

				    Netsukuku
			
			- Close the world, txEn eht nepO -



--								

 -1. Preface

  0. The old wired

  1. The Pure Wired
  
  2. The Netsukuku wired
  
  	2.1  No name, no identity
	2.2  Gandhi
	2.3  Self Control
	2.4  So, WTF is it?
	2.5  Other implementations
  	2.6  The born
  
  3. Netukuku Protocol v7: the seventh son of Ipv7

	3.1  #define Npv7
	
  4. Npv7_II: Laser Broadcast
  
  5. Npv7 Hybrid Theory: the final way
  
  	5.1  QSPN: Quantum Shortest Path Netsukuku
  		5.1.1  QSPN screenshot
	  	5.1.2  Continual qspn starters
		5.1.3  The Qspn sickness: RequestForRoute
		5.1.4  Qspn round
		
	5.2  Npv7_HT Hook & Unhook
		5.2.1  Qspn Hook & Unhook
		
	5.3  The truly Gnode^n for n<=INFINITE
		5.3.1  Groupnode: one entity
		5.3.2  Gnode fusion
	
  6. Broadcast: There can be only one!
  
	6.1  Tracer pkt: one flood, one route
	
  7. ANDNA: Abnormal Netsukuku Domain Name Anarchy
 
 	7.1  ANDNA Metalloid elements: registration recipe
  		7.1.1  ANDNA hook
		7.1.2  Don't rob my hostname!
		7.1.3  Count again
		7.1.4  Registration step by step
		7.1.5  Endless rest and rebirth
		7.1.6  Hash_gnodes mutation
		7.1.7  Yaq: Yet another queue
		
  	7.8  Hostname resolution
		7.8.1  Distributed cache for hostname resolution
		7.8.2  noituloser emantsoh esreveR
		
	7.9  dns wrapper
	  
  8. Heavy Load: flood your ass!
  
  9. Spoof the Wired: happy kiddies
  
  10. /dev/Accessibility
  
  11. Internet compatibility
  
  12. Implementation: let's code
  
  13. What to do
  
  14. The smoked ones who made Netsukuku
  
--

 -1.  Preface

  Questo documento ed il codice sorgente relativo sono disponibili su:
  http://netsukuku.freaknet.org


  0.  The old wired
  
  Internet e' una rete gerarchica gestita da multinazionali ed enti che vengono
  supportati dai governi. Ogni bit di traffico dati passa attraverso le loro
  backbone e i loro router. 
  I benemeriti Internet Service Provider offrono la connettivita' a tutti i
  poveri umani che si trovano nelle parti piu' basse di questa scala
  gerarchica garantendo, cosi', che Internet sia di tutti e per tutti,
  ovviamente, secondo il giusto e saggio principio dell'uguaglianza. Essi
  chiedono, in cambio, una "piccola"  somma di denaro per poter accedere a
  questa rete. D'altronde l'informazione, il sapere e la comunicazione non
  sono di certo frutti che crescono sugli alberi, gratuitamente e liberamente.
  Grazie al loro generoso servizio, circa 600 milioni di persone possono 
  connettersi alla grande, libera, ed anonima rete. 
  Ai restanti 5 miliardi e 400 milioni di persone, che non possono permettersi 
  questo lusso, viene detto di riprovare piu' tardi, quando nel mondo non ci
  saranno piu' guerre e regnera' la pace.
  
  Ritornando al discorso delle multinazionali, che cosa accade se una di esse
  o un ISP decide di non fornire piu' il suo servizio? E' semplice: intere
  nazioni saranno tagliate immediatamente fuori da Internet. Paradossalmente
  Internet e' nato proprio per garantire una comunicazione sicura ed
  inattaccabile tra i vari nodi della rete.
  E che cosa avviene se una di queste multinazionali stipula accordi segreti o
  non con i governi per sorvegliare il traffico dati e rintracciare veri o
  presunti "terroristi"? Il traffico viene intercettato, analizzato e i
  potenziali "terroristi" sottoposti, senza alcun vincolo, ad illimitati
  controlli.

  La struttura gerarchica e centralizzata di Internet crea, di conseguenza,
  altri sistemi identici che poggiano su di essa, come ad esempio il DNS.
  I server del Domain Name System vengono anch'essi gestiti dai vari ISP, i
  domini vengono letteralmente venduti e le maglie di un sistema centralizzato 
  rimangono immutate.
  Questo tipo di struttura permette, in modo semplice ed efficace, di
  localizzare fisicamente qualsiasi computer connesso ad Internet in
  pochissimo tempo e senza alcuno sforzo.
  In Cina, l'intera rete e' sorvegliata continuamente da numerosi computer che
  filtrano il traffico Internet: un cinese non potra' mai vedere e in ogni
  caso venire a conoscenza di un sito che contiene delle parole chiavi
  censurate dallo Stato. Se, poi, egli osasse esprimere sulla rete un pensiero
  contrario alla dottrina politica del governo, rischierebbe perfino la pena
  di morte.

  Internet e' nato per soddisfare le esigenze di sicurezza militare
  dell'amministrazione della difesa degli USA, e nel corso del tempo, la
  sua struttura originaria non e' cambiata, ne' mai potra' mutare.
  La liberta' di comunicazione e d'informazione su Internet saranno sempre
  negate: per comunicare saremo sempre costretti a chiedere il preventivo
  beneplacito di autorita' statali e mendicare il supporto di gigantesche
  multinazionali che, in tal modo, continueranno ad espandere il proprio
  dominio.
  Se, di fatto, i tentativi di rendere Internet il mezzo di comunicazione
  libero per eccellenza, sono destinati a fallire, allora non ci resta altro
  da fare che sostituirlo.
  Come?
  Con una rete distribuita, decentralizzata e pienamente efficiente, una rete
  che non possa essere sottoposta a nessun tipo di governo.
 
  1.   The Pure Wired
  
  Una rete neurale, una ragnatela, una rete sociale, una rete da pesca sono
  delle reti pure. La natura stessa e, infine, l'universo nel suo insieme,
  dall'infinitamente piccolo all'infinitamente grande, sono delle reti
  pure.
  
  In tutte le reti esistenti in natura non esistono centri di "smistamento del
  traffico" della rete, perche' non sono di alcuna utilita'.
  Queste reti raggiungono una potenza ed efficacia incredibile perche' sono
  semplici, non esiste alcuna complicazione.

  In una rete pura ogni nodo svolge la funzione di un router e quindi non
  esistono i router dedicati, indispensabili, invece, alle reti gerarchiche.
  
  La condizione necessaria e sufficiente perche' un nodo appartenga alla rete
  pura e' quella di essere connesso ad almeno un altro nodo.
  In questo modo tutti i nodi della rete possono mettersi in comunicazione.
  Se, per esempio, il nodo (A) (vedi figura) deve mandare un messaggio al nodo
  (Y), prima lo inviera' a (C),  il nodo (C) lo inviera' ad (E), poi passera' a
  (F) ed infine arrivera' a (Y).
  Riassumendo abbiamo (A)-->(C)-->(E)-->(F)-->(Y).


				         (L)
				          |
				          |
			(A)----(B)-------(H)
			 |			     (T)
			 |			      |
	  (G)----(E)----(C)----(D)-------------------(S)
	          |		|
   	          |		|				  (L1)
	         (F)---(Y)--(1)	|				   |	
		 		|				   |
				|				   |
		       (R)-----(M)---------(Q)		  (Z)----(76)	
			      / | \			   |	
			    /	|   \			   |	
		       (P)/	|     \(O)----------------(U)----(V)
			  	|	|			  |
     (5)---------------------- (N)	|			  |
      |					|			  |
      |		       (9)     		|			 (X)
      |			|	       (20)
     (3)---------------(4)-----(8)
     
 				-| Una possibile porzione di una rete pura |-


  2.   The Netsukuku wired
  
  Netsukuku e' una rete pura che sfrutta il caos, si crea e si mantiene
  autonomamente assumendo la forma di un frattale.
  La fusione di una rete pura con i frattali e il caos e' la caratterestica
  che permette a Netsukuku di essere un rete diffusa e distribuita, non
  centralizzata, anonima, anarchica, non controllata ed autonoma.

  2.1  No name, no identity
  
  In Netsukuku chiunque, in qualunque luogo e in qualsiasi momento puo'
  agganciarsi immediatamente alla rete senza dover passare attraverso
  adempimenti burocratici o contrattuali, tuttora ineluttabili.
  Inoltre, ogni elemento della rete e' estremamente dinamico e non rimane mai
  uguale a se' stesso. L'indirizzo IP che identifica un computer e' scelto
  casualmente, quindi e' impossibile associarlo ad una localita' fisica
  precisa, e le stesse rotte, essendo formate da un numero innumerevole di
  nodi, tendono ad avere una complessita' e densita' talmente elevata da
  rendere il tracciamento di un nodo un'impresa epica.
  Poiche' non esiste alcun contratto con alcuna societa', la velocita' del 
  trasferimento dei dati e' limitata unicamente dalla tecnologia attuale delle
  schede di rete.

  2.2  Gandhi

  Netsukuku e' anarchico. Si crea e si gestisce da se'.
  Un nodo si aggancia a Netsukuku, la rete si auto-riscrive e tutti gli altri 
  nodi conoscono quali sono le strade piu' veloci ed efficienti per comunicare 
  con il nuovo arrivato.
  I nodi non hanno privilegi o limitazioni rispetto ad altri nodi, fanno parte
  della rete e contribuiscono alla sua espansione ed efficienza.
  Con l'aumentare del loro numero, la rete cresce e si perfeziona.
  In Netsukuku non vi e' alcuna differenza tra reti private e pubbliche e non
  ha piu' alcun significato parlare di LAN.
	
  2.3  Self Control

  Netsukuku non puo' essere controllato ne' distrutto poiche' e' totalmente
  decentralizzato e distribuito. L'unico modo per sorvegliare o smantellare
  Netsukuku e' abbattere fisicamente ogni singolo nodo che lo compone.

  Su Netsukuku, essendo una rete distribuita, e non centralizzata, si possono
  implementare effettivi sistemi distribuiti, come ad esempio l'Abnormal
  Netsukuku Domain Name Anarchy (ANDNA), che sostituira' l'attuale sistema
  gerarchico e centralizzato dei DNS.

  2.4  So, WTF is it?
  
  Netsukuku e' una mesh network o rete p2p composta da un protocollo di rete
  per il routing dinamico, chiamato Npv7_HT.
  Attualmente esistono molti protocolli ed algoritmi per il routing dinamico,
  ma a differenza dell'Npv7_HT, vengono utilizzati solo per creare piccole e
  medie reti. Anche i router di Internet sono gestisti da vari protocoli come
  l'OSPF, il RIP od il BGP, che usano diversi algoritmi classici per trovare
  il percorso migliore per raggiungere un nodo in una rete.
  Questi protocolli richiedono un consumo di cpu e memoria elevatissimo, ed e'
  per questo motivo che i router di Internet sono dei computer appositamente
  dedicati. Sarebbe impossibile adottare uno di questi protocolli per creare
  e mantenere una rete come Netsukuku, dove ogni nodo e' a sua volta un
  router, perche' la mappa di tutte le rotte richiederebbe uno spazio, su
  ciascun pc connesso alla rete, di circa un centinaio di Gb.
  
  L'Npv7 struttura l'intera rete come un frattale, ed usa un particolare
  algoritmo chiamato Quantum Shortest Path Netsukuku (QSPN) per calcolare
  tutte le rotte necessarie a collegare un nodo ad ogni altro nodo. 
  Un frattale e' una struttura matematica che si puo' comprimere all'infinito,
  proprio perche', al suo interno, ogni sua parte e' formata dal frattale
  stesso. Si ha quindi una compressione elevata di una struttura che
  puo' espandersi infinitamente. Questo significa che bastano pochi Kb per
  mantenere l'intera mappa di Netsukuku.
  Il QSPN, invece, e' un meta-algoritmo perche' non esegue una sequenza di
  istruzioni matematiche definite ma sfrutta il caso e il caos, che non
  richiedono nessun calcolo. In altre parole, anche una semplice calcolatrice
  puo' usare il QSPN per stare connessa in Netsukuku.

  2.5  Other implementations

  Netsukuku non e' limitato alla creazione di una rete di soli computer, e' un
  protocollo che implementa una rete pura, e cosi' come ogni protocollo di rete
  puo' essere usato in tutte le situazioni in cui si ha bisogno di collegare
  piu' nodi fra loro.
  Prendiamo in esame il caso dei cellulari. Anche la rete dei cellulari e' una
  rete gerarchica e centralizzata. Migliaia di nodi si appoggiano ad una
  stessa cella, che poi smistera' il traffico alle altre celle, che, infine,
  consegneranno i dati ai nodi destinatari. Bene, Netsukuku puo' essere
  adottato anche dai cellulari, rendendo superflua l'esistenza degli attuali
  gestori di telefonia mobile.
  Questo ragionamento puo' essere applicato a tutti i sistemi di comunicazione
  che esistono attualmente.
  
  2.6  The born

  La storia di come si sia arrivati a Netsukuku e' lunga e travagliata.
  Nel lontano 2003, un gruppo di pazzi deliranti concepisce l'idea
  dell'Ipv7: una rete in cui tutti i pacchetti venivano mandati in broadcast,
  compressi con le zlib7, un algoritmo che comprimeva l'attuale Internet in
  32 byte. In Ipv7 nessun nodo aveva un indirizzo IP. Tutto il sistema era
  gestito da programmi che si autoscrivevano usando il compilatore nocoder.
  Ecco che si aveva una rete estremamente decentralizzata e libera.
  Quelle persone erano felici, e dopo la stesura del primo RFC, un sorriso
  sereno e una luce angelica avvolgeva le loro figure.
  Un anno trascorre, il progetto si perde tra le infinite diramazioni del
  tempo, ma dopo non molto la polvere viene scrollata dal grande libro
  dell'Ipv7. Si incomincia a delirare sull'implementazione di una rete pura.
  I mesi passano. La rete viene definita sempre di piu', diventa quasi 
  tangibile...
  <<Ma deve anche supportare una qualche forma di antiflood e antispoofing>>. 
  <<Gia'! E si deve fare in modo che le rotte non siano mai uguali tra loro>>.
  <<Si, si, e perche' non facciamo che non esistano piu' in assoluto dei server
  centrali?>>.
  Tre mesi dopo, a seguito di numerosissime peregrinazioni mistiche, il cuore 
  teorico e' pronto. Gli algoritmi sono definiti. 
  Si incomincia a codare. La maledizione dei coder di protocolli di rete del
  sacro faraone Mortedelprimogenito si riversa sul codice di Netsukuku. La 
  pazzia e il delirio sono la giusta ricompensa a tutti coloro i quali
  osano addentrarsi nella creazione di protocolli di reti pure.
  Nonostante tutto, esattamente dopo un anno e 14 mila righe di codice,
  Netsukuku e' pronto e diventa Beta.
  Due mesi dopo la presentazione di Netsukuku all'Hackmeeting 2005, il
  protocollo dell'ANDNA, cosi' come il suo codice, e' completamente
  definito e documentato.
  Il resto giace in potenza e deve ancora divenire.
  
  
  3.   Netsukukuku protocol v7

  Netsukuku, usa l'Npv7 (Netsukuku protocol version 7), il suo protocollo, che
  deriva da tre precedenti versioni.
  La prima era strutturata in maniera simile agli attuali protocolli di rete 
  utilizzati per il routing dinamico: la rete era divisa in gruppi di nodi,
  ogni nodo possedeva la mappa dell'intera rete. 
  Questo sistema, non ottimale, non e' adottato da Netsukuku poiche' prevede
  l'aggiornamento continuo della mappa, ed ogni aggiornamento crea un overload
  nella rete. Inoltre, ogni volta che la mappa cambia bisogna ricalcolarsi tutte
  le rotte.

  3.1  #define Npv7

  Le definizioni basilari utilizzate per Netsukuku sono state e, tuttora sono:

  src_node: Il Source node e' il nodo che manda un pacchetto al dst_node.
  dst_node: Destination node, il node the riceve il pacchetto mandato dal
	    src_node.

  r_node: Considerando un nodo X, un remote node (r_node) e' un qualsiasi
	  nodo direttamente collegato ad X.
  g_node: Group node, un gruppo di nodi, o un gruppo di gruppi di nodi, e
	  cosi' via.
  b_node: Border node, un nodo che ha rnodes di diversi gnode.
  h_node: Hooking node, un nodo che si sta agganciando a netsukuku.
  
  int_map: Internal map, mappa interna. La mappa interna del nodo X e' la mappa 
  	   che contiene le informazioni sui nodi che appartengono al gnode a cui
	   appartiene X.
  ext_map: External map, mappa esterna. La mappa che contiene le informzioni sui
  	   gnode.
  bmap / bnode_map: Border node map. E' la mappa che tiene la lista dei
                    border node.

  quadro_group: Un nodo, o un groupnode di qualsiasi livello, scomposto nelle 
  		sue parti essenziali.

   
  4.   Npv7_II: Laser Broadcast

  Npv7_II e' la seconda versione dell'Npv7. 
  Netsukuku viene suddiviso in tanti piccoli groupnode che contengono al
  massimo 600 nodi. Ogni nodo di Netsukuku possiedera' solamente la mappa
  esterna, quella dei groupnode.
  Gli stessi groupnode vengono raggruppati in multi-groupnode, chiamati quadro
  groupnode. 
  Per creare una rotta e raggiungere un determinato dst_node, il src_node,
  usando la mappa esterna, calcola il percorso migliore per raggiungere il
  gnode di destinazione a cui appartiene il dst_node.
  La rotta cosi' trovata viene memorizzata nel pacchetto che viene spedito in
  broadcast all'interno del gnode a cui appartiene l'src_node.
  I border_node del gnode del src_node ricevono il pkt e controllano se il
  prossimo gnode a cui deve essere mandato in broadcast il pkt e' proprio un
  gnode con cui confinano. Se la condizione viene rispettata, i border_node
  mandano in broadcast il pkt in quel gnode. In caso contrario il pkt viene
  ignorato.
  E cosi' via...
  In questo modo il pacchetto arrivera' al gnode di destinazione.
  Quando il dst_node riceve il pkt non deve far altro che settare una
  rotta inversa usando la rotta memorizzata nel pkt.
  L'Npv7_II e la sua versione precedente non vengono usate, ma sono alla base
  dell'Npv7_HT, l'attuale versione del protocollo Netsukuku.
  
  5.   Npv7 Hybrid Theory: the final way

  Dall'unione di Npv7 e Npv7_II e' derivato Npv7 Hybrid Theory. 
  Questa nuova versione, sfrutta i vantaggi della mappa interna e del laser 
  broadcast e cosi' facendo supera le loro imperfezioni.
  In Npv7_HT il numero massimo di nodi presenti in un group node (MAXGROUPNODE)
  e' pari a 2^8, i groupnode sono quindi relativamente piccoli.
  In Npv7_HT il cambiamento principale riguarda la sua stessa essenza, infatti,
  si basa su un algoritmo creato appositamente per Netsukuku, chiamato
  Quantum Shortest Path Netsukuku, che permette di ottenere in un solo colpo la
  situazione completa del g_node, tutte le rotte migliori, la riduzione del
  carico del g_node, un'efficace gestione dei gnode molto dinamici,
  l'abolizione del bisogno di autenticazione tra i nodi. 
  
  5.1   QSPN: Quantum Shortest Path Netsukuku

  In Netsukuku, come in natura, non vi e' alcun bisogno di usare schemi
  matematici creati dalla limitata logica umana. Netsukuku sfrutta il caos. 
  L'uso di una mappa, in un protocollo di reti dinamiche, crea troppi
  problemi, dovendo tenerla sempre aggiornata. La soluzione e' semplice: non
  usare affatto una mappa e far diventare ogni richiesta mandata in broadcast
  un tracer_pkt (Vedi 6.1 Tracer pkt).
  In questo modo ogni nodo che ricevera' il pkt sapra' qual e' la rotta
  migliore per raggiungere il src_node e tutti i nodi che stanno
  in mezzo alla rotta, si memorizzera' queste info nella  sua mappa interna,
  aggiungera' la sua entry nel tracer_pkt e fara' continuare il broadcast del
  pkt.
  Rimane un grosso problema: per avere tutte le rotte per tutti i nodi
  bisogna che tutti i nodi mandino in broadcast un tracer_pkt. In realta' questo
  problema e' del tutto inconsistente. Infatti, con il tracer_pkt possiamo
  ricavare anche le rotte per i nodi intermedi; questo vuol dire che abbiamo
  bisogno di un numero < di n pacchetti, dove n e' il numero dei nodi.
  Se ogni nodo rimanda indietro un tracer_pkt ogni volta che ne riceve uno,
  siamo sicuri che tutti i nodi ricevono tutte le rotte possibili, cosi'
  facendo ricaviamo lo stesso risultato raggiunto dal far mandare un
  tracer_pkt da tutti i nodi.

  Per chi ha presente la fisica delle onde, il funzionamento del qspn puo'
  essere facilmente compreso. Se lanciamo un sassolino in uno specchio d'acqua,
  contenuto in una bacinella, dal punto di impatto incominciano a propagarsi
  delle onde circolari. Ogni onda genera un'onda figlia che continua ad
  espandersi ed a generare figli che generano figli e cosi' via...
  Quando un'onda colpisce i bordi della bacinella, viene riflessa e ritorna
  verso il punto d'origine; lo stesso avviene se l'onda incontra un ostacolo.
  Il qspn_starter e' il sassolino gettato nel groupnode ed ogni onda e' un
  tracerpkt. Ogni onda figlia porta con se' l'informazione dell'onda padre.
  Quando l'onda arriva in un extreme_node (un ostacolo, un vicolo cieco) parte
  il qspn_open (l'onda riflessa).
  
  Il QSPN si basa su questo principio. Per iniziare il tracciamento del g_node,
  un qualsiasi nodo manda un qspn_pkt (chiamato qspn_close), questo nodo diventa
  quindi un qspn_starter.
  Un qspn_pkt e' un normale tracer_pkt, ma il modo in cui si diffonde in
  broadcast e' leggermente diverso dal normale. 
  Ogni nodo che riceve il qspn_pkt "chiude" il link da cui ha ricevuto il pkt,
  e spedisce il pkt a tutti gli altri link. Tutti i successivi pacchetti
  qspn_close che arriveranno al nodo saranno mandati a tutti i link ancora non
  chiusi.  
  Una volta che il qspn_close e' diffuso, alcuni nodi si troveranno con tutti i
  link chiusi. Questi nodi saranno gli extreme_node che invieranno un altro
  qspn_pkt di risposta (chiamato qspn_open), che contiene l'informazione gia'
  accumulata, a tutti i link, tranne a quello da cui hanno ricevuto l'ultimo
  qspn_close che li ha completamente chiusi a cui invieranno un qspn_open
  vuoto.
  Il qspn_open e' un normale qspn_pkt, quindi "apre" tutti i link alla stessa
  maniera del qspn_close. I nodi che si troveranno con tutti i link aperti non
  faranno assolutamente nulla, questo garantisce la fine del qspn_open.
  Un qspn_open possiede anche un sub_id, un numero che indentifica nella mappa
  interna l'extreme_node che l'ha creato. Il sub_id, che rimane inalterato per
  tutti i pacchetti qspn_open figli generati dal primo pacchetto, viene usato
  per gestire piu' qspn_pkt simultaneamente, poiche' ogni extreme_node genera
  un qspn_open ed ognuno dovra' essere indipendente dall'altro.
  Tutti i nodi con un solo link sono gli e_node per eccellenza, infatti non
  appena ricevono un qspn_close sono gia' chiusi.
  
  Una  volta che un nodo ha mandato un qspn_open non rispondera' piu' a
  qualsiasi qspn_pkt che gli arrivera' (sempre relativamente alla sessione
  corrente), quindi non mandera' piu' qspn_close ne' qspn_open. 
  Il qspn_starter, il nodo che ha innescato il qspn, si comporta come un
  normale nodo pero' non puo' mandare qspn_open perche' ha gia' mandato il
  primo qspn_close in assoluto, inoltre tutti i qspn_close che riceve li usa
  per aggiornare la sua mappa, ma se hanno gia' percorso piu' hop o se sono
  stati spediti da lui stesso, vengono ignorati; questo accorgimento garantisce
  la stabilita' nel caso ci siano piu' qspn_starter simultanei. La descrizione
  approfondita del qspn_starter e' nella sezione successiva 5.1.1.
  
  Alla fine i pacchetti di broadcast che vengono generati con qspn sono pari al
  numero degli e_node, ovvero 2 per ogni segmento di rete ciclico e 1 per un
  segmento singolo non ciclico.
  
  L'informazione per le rotte viene in ogni caso accumulata ogni volta che
  qualche tracer_pkt gira per la rete.  Un nodo ricevera' molto probabilmente
  diverse rotte per raggiungere uno stesso nodo, ma memorizzera' solamente le
  prime MAXROUTES (10) rotte migliori.
  
  Il pkt_id dei qspn_pkt inizia da 1 e viene incrementato di 1 ogni volta che
  un nodo ne spedisce uno nuovo.
  Quindi, tutti i nodi conoscono il pkt_id corrente. Ogni qualvolta un nodo
  deve far aggiornare la mappa interna o esterna manda un qspn_close, solamente
  se non ha ricevuto entro i precedenti QSPN_WAIT secondi un altro qspn_close.
  Se due nodi mandano nello stesso momento un qspn_close, useranno lo stesso
  pkt_id, perche' nessuno dei due sa che ne e' stato gia' spedito un altro; in
  questo caso il funzionamento  del qspn non cambia, anzi se i due qspn_pkt
  sono partiti da due luogi molto distanti allora il qspn_pkt si diffondera'
  molto rapidamente.

  Quando un nodo prende la mappa interna da un altro nodo, non deve
  far altro che aggiungere l'r_node, da cui ha preso la mappa, all'inizio
  di tutte le rotte. Se scarica la mappa da piu' r_node, dovra' confrontare
  tutte le rotte e scegliere la piu' breve. La mappa risultante avra' tutte
  le rotte migliori.

  Le rotte della mappa interna ed esterna verranno sempre ricopiate nella
  tabella di routing del kernel. In questo modo non ci sara' alcun bisogno di
  creare ogni volta la rotta necessaria per raggiungere il nodo di
  destinazione.

  5.1.1  QSPN screenshot
    
        (A)-----(B)
      /  | \     |  \
   (E)   |   \   |  (F)
      \  |     \ |  /
        (C)-----(D)
  
  Ricapitolando, tutti i nodi estremi dovrebbero inviare un tracer_pkt, ma non
  si puo' sapere quali essi siano. In questo disegnino e' facile individuarli,
  perche', appunto, la mappa e' disegnata, me nella realta' (nel codice di
  Netsukuku) non esiste una mappa topologica, quindi non si puo' sapere dove
  inizia un gruppo di nodi e dove finisce.

  Ecco cosa succede, in uno scenario immaginario, se il nodo E manda un
  qspn_close:
  E ha mandato il primo qspn_close del nuovo qspn_round, quindi e' diventato
  un qspn_starter.
  Consideriamo il caso in cui il nodo A riceve prima di C il qspn_close.
  A chiude il link E, manda il pkt a B, C, e D.
  C riceve il pkt, chiude il link E, lo manda ad A ed a D.
  C riceve da A, chiude il link.

  B e D hanno ricevuto, e chiudono i rispettivi link.
  Consideriamo il caso in cui il nodo B manda per primo il pkt ad F.
  D lo manda ad F subito dopo, ma nello stesso momento F lo manda a D.
  D ha ricevuto il pkt anche da B.
  D ed F hanno tutti i link chiusi.
  Mandano un qspn_open.
  Tutto avviene nel senso opposto.
  Finisce il qspn_open.
  Tutti hanno le rotte per raggiungere tutti.

  In genere, la topologia base a cui si riconduce il qspn e' un rombo con i
  nodi ai vertici, per renderla piu' complessa e' possibile aggiungere altri
  rombi uniti tra di loro con i vertici.
  Tutte le altre situazioni derivano piu' o meno da questa.

  5.1.2  Continual qspn starters

  Se piu' qspn_starter che lanciano un qspn sono contigui fra loro allora
  il funzionamento del qspn varia leggermente. Un gruppo di nodi qspn_starter 
  e' contiguo quando tutti i suoi nodi sono collegati a nodi che sono a
  loro volta dei qspn_starter. In questo scenario i qspn_starter continuano a
  inoltrare tra di loro solo i qspn_close mandati dai qspn_starter; si
  comportano quindi come dei normali nodi, infatti non appena ricevono dei
  pacchetti provenienti dall'esterno del gruppo contiguo di qspn_starters
  ritornano a seguire le loro istruzioni originarie. Quindi se A manda un
  qspn_close e B ha mandato pure un qspn_close, quando B riceve il qspn_close
  di A lo inoltra come un normale tracer_pkt con la flag BCAST_TRACER_STARTERS
  che si diffonde solo tra gli altri starter.
  Il motivo di tutto questo deriva dal fatto che in quel gruppo contiguo di 
  nodi, ogni singolo nodi manda un tracer_pkt, quindi, i qspn_pkt vengono
  declassati a normali tracer_pkt.
     
  5.1.3  The Qspn sickness: RequestForRoute
  
  /* Da codare, e non realmente necessario */
  L'unico grande difetto di qspn e' l'impossibilita' di avere molte piu' rotte
  per raggiungere uno stesso nodo. Con il qspn si e' sicuri di avere solamente
  le rotte migliori, e basta. In realta' il qspn puo' anche generare infinite
  rotte, basta che si lasci circolare il broadcast all'infinito (^_-).
  Ovviamente e' impensabile aspettare un'intera eternita' o due, quindi si usa
  il RequestForRoute! Il RFR verra' usato ogni volta che un nodo si connette
  ad un altro.
  Ecco cosa succede:
  il nodo manda a tutti i suoi rnode una richiesta RFR per una determinata
  rotta, questa richiesta contiene anche il numero di sub richieste
  (total_routes) che gli rnode devono mandare ai loro rnode. In pratica il
  nodo decide quante rotte ricevere e si calcola il numero di sub richieste
  che dovranno mandare i suoi rnode:
  subrfr = (total_routes - r_node.links) / r_node.links
  Dopo invia il RFR.
  I suoi rnode, dopo avergli mandato la rotta che loro usano per raggiungere il
  dst_node specificato nel rfr_pkt, mandano allo stesso modo un RFR che pero'
  ha total_routes pari a subrfr. Gli rnode degli rnode eseguiranno la stessa
  procedura e risponderanno direttamente al nodo interessato.

  5.1.4  Qspn round

  Se un nodo riscontra un cambiamento attorno a se', ad esempio un suo
  rnode e' morto oppure l'rtt che lo distanzia dal suo rnode e' cambiato
  considerevolmente, allora mandera' un QSPN. Per evitare che vengano creati
  dei QSPN continuamente, il nodo deve prima verificare che il QSPN_WAIT_ROUND
  (60 secondi) sia scaduto. Il QSPN_WAIT_ROUND scade nello stesso momento per
  tutti i nodi appartenenti allo stesso gnode. Per far si' che i nodi che si
  agganciano al gnode siano sincronizzati ai nodi del gnode stesso, gli viene
  dato il numero di secondi che sono passati dal precedente QSPN, in questo
  modo tutti i nodi sapranno quando si verifichera' la prossima scadenza,
  ovvero avverra' dopo (current_time - prev_qspn_round) + QSPN_WAIT_ROUND 
  secondi.
  Quando un qspn_starter manda un nuovo qspn_pkt, incrementa l'id del
  qspn_round di 1. 
  Se il nodo che riceve un qspn_pkt, vede che il suo id e' maggiore del
  qspn_round id precedente che ha memorizzato, allora vuol dire che ha ricevuto
  un nuovo qspn_round; in questo caso aggiornera' il suo id locale e il suo
  qspn_time (la variabile che indica quando e' stato ricevuto/mandato l'ultimo
  qspn).
  Per aggiornare il qspn_time, dovra' settarlo a 
  current_time - somma_degli_rtt_contenuti_nel_tracer_pkt.
  
  5.2  Npv7_HT Hook & Unhook
  
  Un nodo, per entrare a far parte di Netsukuku, deve agganciarsi ai suoi
  rnode.
  L'hook in Netsukuku non si riferisce ad un aggancio alla rete "fisico",
  poiche' si presuppone gia' che un nodo sia linkato ad altri (r)_node.
  Quando un nodo si aggancia significa che comunica con un il suo rnode piu'
  vicino, se non gli risponde ne sceglie un altro. In pratica durante l'hook,
  il nodo si prende la mappa interna, quella esterna, la mappa dei border
  node, e si sceglie un IP libero. A questo punto fa ufficialmente parte della
  rete, quindi manda un normale tracer_pkt. I suoi rnode manderanno in seguito,
  un qspn.
  
  Ecco cosa avviene piu' in dettaglio:
  Il nodo si prende un IP compreso tra 10.0.0.1 <= x <= 10.0.0.1+256,
  rimuove le reti di loopback dalla tabella locale di routing e setta come
  default gateway l'IP scelto.
  Il primo passo e' quello di lanciare il primo radar per vedere quali sono i
  suoi r_nodes. Se non ci sono rnodes, crea un nuovo gnode e l'hook termina qui.
  Poi chiede all'rnode piu' vicino la lista di nodi liberi (free_nodes)
  presenti nel gnode dell'rnode. Se l'rnode non accetta la richiesta (il gnode
  potrebbe essere pieno), il nodo chiede la lista ad un altro rnode.
  Dai free_nodes ricevuti sceglie un IP e lo setta all'interfaccia di rete,
  modificando il default gw.
  A questo punto richiede la mappa esterna allo stesso rnode da cui ha preso la
  list di nodi liberi. Usando la lista di free_nodes vede se deve creare un
  nuovo gnode. Se non deve, prende l'int_map da ogni r_node.
  Unisce tutte le int_map ricevute in un unica mappa, in questo modo ha gia'
  tutte le rotte. Infine, si prende la bnode_map.
  Se tutto e' andato a buon fine, rilancia un secondo radar, manda un semplice
  tracer_pkt e aggiorna la sua tabella di routing. Fin.
  
  5.2.1  Qspn Hook & Unhook

  Un nodo, dopo essersi agganciato al gnode, non deve far altro che mandare
  un tracer_pkt. In questo modo tutti i nodi avranno gia' la rotta esatta
  per raggiungerlo, aggiorneranno qualche rotta e saranno felici. Poi per
  quanto riguarda le rotte secondarie ci pensera' il round successivo di QSPN.
  Quando un nodo muore o si sgancia, non dice nulla a nessuno. I suoi rnode si
  accorgeranno della sua morte e manderanno un nuovo qspn_round.

  5.3  The truly Gnode^n for n<=INFINITE

  Nel mondo ci sono 6*10^9 di persone, se andremo a colonizzare
  altri pianeti arriveremo a circa (6*10^9)^n, dove n e' un numero random > 0.
  E' anche vero che ci estingueremo molto prima in una delle solite stupide
  guerre. In sostanza netsukuku deve provvedere a un numero ENORME di nodi,
  per questo, come gia' sai, si usano i gnode. 
  Ma questo non basta, perche' anche cosi' ci vorrebbero 300Mb circa per 
  tenere l'intera extern map! Come si fa quindi? 
  Si dividono i gnode in ulteriori gruppi, stavolta pero' questi gruppi non
  contengono nodi normali ma degli interi gnode, che vengono considerati dei
  nodi a tutti gli effetti...  Procedendo recursivamente netsukuku puo'
  contenere all'incirca INFINITI nodi.
  Tutto rimane invariato.  
  Per implementare questi gnode frattali e' necessario usare piu' di una mappa
  esterna che conterranno l'informazione su questi gruppi di gruppi. Questi
  "gruppi di gruppi" li continuiamo a chiamare groupnode.
  Ogni mappa di groupnode appartiene ad un determinato livello. Quindi il
  groupnode normale, che racchiude singoli nodi si trova a livello 0, la mappa
  del primo groupnode di gruppi di nodi si trova al primo livello, e la mappa
  di groupnode di groupnode di groupnode e' al secondo, e cosi' via.
  Un nodo per poter contattare qualsiasi altro nodo in qualsiasi parte del
  globo deve avere solamente la sua mappa interna, che non e' nient'altro
  che la mappa a livello 0 e poi le mappe di tutti i livelli superiori in
  cui lui e' presente.  Facendo qualche calcolo con l'ipv4, per usare tutti
  gli IP, si devono usare solamente 3 livelli di mappe. Il che significa che
  prima c'e' il normale groupnode, poi ci sono MAXGROUPNODE di groupnode,
  e infine ci sono MAXGROUPNODE di questi ultimi. Nell'IPv6 invece, abbiamo
  una quantita' abnorme di IP, percio' i livelli ammontano a 16.  Facendo una
  stima approssimativa, tutte le mappe esterne dei groups nell'IPv4 occupano
  144K di memoria e nell'IPv6 1996K. Questo significa che nessuno si deve
  preoccupare di usare lo swap!  

  Per trovare le rotte che connettono i vari gruppi verra' usato il QSPN, 
  avevi dubbi -_^ ?  Il qspn verra' ristretto e lanciato per ogni livello, in
  questo modo, ad esempio, trovera' tutte le rotte che legano i nodi
  appartenenti al secondo livello...
  Questo sistema dei livelli in relta' non e' complesso, basta tenere
  presente il funzionamento della mappa interna in unione a quello della
  mappa esterna ed applicare recursivamente ad ogni grouppo lo stesso concetto.
  Basta considerare ogni grouppo un singolo nodo.  
  La rotta usata per raggiungere un groupnode, nella routing table, e' formata
  da range di IP (da IP x ad IP y) invece di un singolo IP.
  In questo modo, per poter raggiungere tutti i nodi presenti in netsukuku
  bisogna tenere nella routing table MAXGROUPNODE*(levels+1) rotte. 
  Consideriamo il caso dell'IPv4 che ha 3 livelli. 
  Intanto un nodo deve avere tutte le rotte per raggiungere tutti
  i nodi all'interno del suo groupnode, percio' gia' abbiamo MAXGROUPNODE
  di rotte, poi dobbiamo aggiungere tutte le rotte per raggiungere gli
  altri groupnode del suo livello superiore, percio' aggiungiamo altri
  MAXGROUPNODE di rotte. Proseguendo arriviamo all'ultimo livello ed abbiamo
  MAXGROUPNODE*(3+1). Con l'IPv4 abbiamo 1024 rotte, con l'IPv6 4352.
  Tutte queste rotte risiederanno direttamente nel kernel.

  5.3.1 Groupnode: one entity
  
  Per avere il qspn effettivo dei groupnode la storia cambia un po'.
  La differenza tra un groupnode ed un nodo singolo risiede nel fatto che il
  nodo e' un'unica entita' che gestisce i suoi link direttamente da se', il
  groupnode, invece, e' un nodo composto da piu' nodi e i suoi link sono
  gestisti da altri nodi che sono i border node. Per rendere il groupnode
  un'unica entita' che si comporti esattamente come un nodo singolo basta che
  tutti i bnode del groupnode comunichino tra loro. Quindi, quando un bnode
  riceve un qspn_close da un altro groupnode, chiudera' il suo link e quando
  avra' tutti i suoi link con gli altri gnode chiusi, lo comunichera' agli
  altri bnode del suo groupnode. Lo stesso faranno gli altri. In questo modo 
  il qspn_open sara' mandato solamente quando tutti i bnode avranno tutti i 
  loro link esterni chiusi.
  Quando parliamo di groupnode di alti livelli allora un bnode non e' piu' un
  singolo nodo, ma e' a sua volta un gnode. Il procedimento resta invariato:
  questo bnode-gnode e' rappresentato da tutti i suoi bnodes interni.
  Ma come fanno i bnode a comunicare fra loro?
  Ovviamente in modo passivo: quando un bnode chiude tutti i suoi link esterni
  dopo aver ricevuto un qspn_close, setta nel tracer_pkt che sta per
  forwardare la flag BNODE_CLOSED, in questo modo gli altri bnode, vedendo
  questa flag, incrementeranno il loro contatore di bnodes chiusi. Quando i
  numero di bnode chiusi e' pari a quello dei bnode presenti nel gnode, allora
  verra' mandato il qspn_open.
  Un ultimo accorgimento: quando un bnode riceve un qspn_close mandato da un
  bnode del suo stesso gnode, allora, anche lui si considerera' un
  QSPN_STARTER e forwardera' il pkt senza aggiungere la sua entry, questo 
  perche' il gnode deve essere come un unico nodo; inoltre, i bnode chiudono
  ed aprono solo i link esterni, cioe' quelli che li collegano ai bnode dei
  gnode confinanti.
  Tutto questo discorso vale anche per il qspn_open.

  5.3.2  Gnode fusion

  Quando un nodo crea un nuovo group_node, ne sceglie uno completamente random,
  usando quindi un IP random. Se due gnode, dapprima isolati, per disgrazia
  hanno lo stesso groupnode id (e quindi lo stesso intervallo di IP), uno
  di loro due deve cambiare; questo significa cambiare l'IP di tutti i nodi
  del gnode. Se il gnode e' di un livello superiore, e' davvero un disastro.
  Per evitare tutto cio', basta che l'IP random sia unico in tutto il globo!
  La soluzione e' semplice: usiamo un hash di tempo che diventera' il
  nostro IP "random". Visto che consideriamo anche i micro secondi, non ci
  saranno due IP uguali in tutto il globo.
  Tutti i nodi devono pero' mantenere i loro orologi sincronizzati.
  
  6.   Broadcast: There can be only one!
  
  Quando vengono mandati dei pkt in broadcast si deve fare in modo che non
  vaghino in eterno in Netsukuku.  Ogni nodo mantiene una cache composta
  da un numero di slot pari a MAXGROUPNODE. (La cache e' all'interno della
  mappa interna). Ogni slot corrisponde ad un nodo del g_node. Questo slot
  contiene il pkt_id dell'ultimo pkt broadcast mandato da quel nodo. 
  Quindi:
	u_int brdcast; /*Pkt_id of the last brdcast_pkt sent by this node*/
	
  Un nodo quando riceve un pkt broadcast lo analizza: 
  se vede che il pkt_id e' <= a quello memorizzato nella cache lo rigetta,
  perche' e' sicuramente un pkt vecchio che non deve piu' diffondersi.
  Ovviamente i pkt_id vengono incrementati ogni volta dal src_node.  
  Se il pkt supera questo check allora il nodo esegue l'azione che il pkt
  richiede e forwarda il pkt a tutti i suoi r_node, escludendo quelli che gli
  hanno spedito il pkt.	Se si vuole che il broadcast sia delimitato entro
  un'area di raggio prefissato, basta settare il ttl al numero di hop di questo
  raggio.

  6.1  Tracer pkt: one flood, one route

  Il tracer pkt non e' altro che il modo per trovare la rotta migliore
  con il broadcast. Se il pkt che viene mandato in broadcast avra' la flag
  "tracer_pkt" settata allora ogni nodo che attraversera', aggiungera' in coda
  al pkt il suo IP. Quindi l'intera rotta che il pkt compie viene memorizzata
  nel pacchetto stesso. Il primo pacchetto che arrivera' a destinazione sara'
  sicuramente quello che avra' percorso la rotta migliore, percio' il dst_node
  non fara' altro che settare la rotta memorizzata nel pacchetto ed avviare
  la connessione.  Il tracer_pkt introduce anche un altro subdolo  vantaggio,
  infatti, il tracer_pkt non solo trasporta la rotta migliore per il src_node,
  ma anche quella per i nodi che fanno parte della rotta perche' se questo pkt
  ha davvero percorso la rotta migliore significa che ha anche percorso _TUTTE_
  le rotte migliori per gli hop intermediari. 
  Concludendo, con un tracer pkt possiamo conoscere la rotta migliore per 
  raggiungere il src_node (il nodo che ha spedito il pkt), e conseguentemente 
  le rotte per raggiungere tutti i nodi intermediari.  
  I border_node quando aggiungono la loro entry in un tracer_pkt settano la 
  flag b_node ed aggiungono in coda l'id del gnode con cui confinano, ma
  solamente se quel gnode appartiene al livello superiore a quello in cui il
  tracer_pkt si sta propagando.
  Con questo sistema tutti riceveranno tutte le rotte migliori per raggiungere 
  tutti i nodi del g_node e tutti i g_node confinanti.

  Per ottimizzare al massimo lo spazio utilizzato in un tracer_pkt, 
  gli IP vengono scritti nel formato IP2MAP, che corrisponde all'id dei nodi
  nel gnode di livello zero. Con questo formato e' richiesto solamente un
  u_char (1 byte invece di 20).

  7.   ANDNA: Abnormal Netsukuku Domain Name Anarchy

  ANDNA e' il sistema distribuito, non gerarchico e decentralizzato, di
  gestione di hostname in Netsukuku. Sostituisce il DNS.
  Il database dell'ANDNA e' sparso in tutto Netsukuku e nel peggiore dei casi
  ogni nodo dovra' usare circa 355Kb di memoria. 
  
  Il funzionamento base di ANDNA si articola nel seguente modo:
  per risolvere un hostname basta calcolarsi il suo hash. 
  L'hash non e' nient'altro che un numero e questo numero noi lo consideriamo
  come un IP. Il nodo che corrisponde a questo IP lo chiamiamo
  andna_hash_node. In pratica l'hash_node manterra' un piccolo database che
  associa gli hostname, che corrispondono a lui, con l'IP del nodo che ha
  registrato quello stesso hostname.

  
            Nodo X
      IP: 123.123.123.123
      hash( hostname: "andna.acus" ) == 11.22.33.44
					   ||
					   ||
					 Nodo Y
				     IP: 11.22.33.44
			   {	[ Database andna del nodo Y ]	 }
			   {hash_11.22.33.44 ---> 123.123.123.123}


  Le richieste di revoca non esistono, l'hostname viene cancellato
  automaticamente se non viene aggiornato.
 
  7.1  ANDNA Metalloid elements: registration recipe
  
  In realta', non e' detto che l'hash_node esista nella rete, perche' puo'
  essere un IP a caso tra i 2^32 IP disponibili, ed ammesso che esista puo'
  sempre morire e uscire dalla rete. Quindi, per garantire la funzionalita'
  effettiva di ANDNA, ed anche un minimo di backup, gli hostname non vengono
  gestiti da singoli nodi, ma da interi gnode. Il gnode che corrisponde
  all'hash e' l'hash_gnode, all'interno ci sara' anche l'hash_node.
  
  Poiche' gli hash_gnode possono anche non esistere al momento, viene adottata
  una strategia di approsimazione: viene usato il gnode che piu' si avvicina
  all'hash_gnode, che viene chiamato, rounded_hash_gnode, o in forma breve
  rounded_gnode. Ad esempio, se l'hash gnode e' il 210, il piu' vicino a lui
  sara' il 211 e il 209.
  In generale, quando si considera solamente il gnode che ha accettato una
  registrazione, non si fa differenza tra i due tipi e il gnode si chiama
  sempre hash_gnode.
  
  Per consentire un pronto recupero degli hostname quando un intero hash_gnode
  viene tagliato fuori da Netsukuku perdendo tutti i suoi link, o quando tutti
  i nodi che lo compongono muoiono, si usano dei rounded_gnode di backup.
  Un backup_gnode e' sempre un gnode rounded_gnode, ma mette  a disposizione
  solo alcuni dei suoi nodi per mantenere l'informazione dell'hostname
  registrato.
  Il numero dei nodi che fanno da backup in un backup_gnode e' proporzionale
  al suo numero totale di nodi (seeds):
 	 if(seeds > 8) { backup_nodes = (seeds * 32) / MAXGROUPNODE ); }
  		else    { backup_nodes = seeds; }
  Il numero di backup_gnodes utilizzati per ogni hash_gnode e' pari a
  MAX_ANDNA_BACKUP_GNODES (2).

  7.1.1	 ANDNA hook

  Quando un nodo si aggancia a Netsukuku diventando parte di un hash_gnode,
  dovra' anche preoccuparsi di agganciarsi ad ANDNA con l'andna_hook.
  Con l'andna_hook si prendera' dai suoi rnode tutte le cache ed i database
  che i nodi di quel gnode posseggono. Ovviamente e' prima necessario che il
  nodo si agganci a Netsukuku.

  7.1.2  Don't rob my hostname!
  
  Un nodo, prima di fare una richiesta ad ANDNA, genera una coppia di chiavi
  RSA, una pubblica (pub_key) ed una privata (priv_key). La dimensione della 
  pub_key sara' limitata, per questioni di spazio.
  La richiesta di un hostname fatta ad ANDNA verra' firmata con la chiave
  privata e nella richiesta stessa sara' allegata la chiave pubblica.
  In questo modo il nodo potra' far certificare l'originalita' delle sue future
  richieste.

  7.1.3  Count again

  Il numero massimo di hostnames che un nodo puo' registrare e' pari a 256,
  per prevenire la registrazione massiccia di hostnames formati da parole
  comuni da parte di spammer.
  L'unico problema in andna sarebbe quello di  contare. Il sistema e'
  totalmente distribuito e, quindi, non si puo' tenere il conto di quanti
  hostname ha registrato un nodo. Esiste pero' una soluzione: introdurre un
  nuovo elemento, gli andna_counter_nodes.
  Un counter_node e' un nodo che ha un IP uguale all'hash della public key
  del nodo che registra gli hostname. Quindi esiste un counter_node per ogni
  register_node. Il counter_node si occupa di memorizzare il numero di
  hostname che ha registrato il register_node che gli corrisponde. Quindi,
  quando un hash_gnode riceve una richiesta di registrazione, prima di tutto
  contatta il relativo counter_node, che gli comunica quanti hostname sono
  gia' stati registrati dal register_node: se il nodo non ha sforato il
  proprio limite, allora il counter node incrementa il contatore e
  l'hash_gnode registra effettivamente l'hostname.
  L'attivazione di un counter_node avviene con la richiesta di controllo da
  parte dell'hash_gnode e viene mantenuta dalle successive richieste.
  Il meccanismo e' identico a quello dell'andna, e pertanto il register_node si
  deve anche preoccupare di mantenere il suo counter_node attivo seguendo le
  stesse regole dell'ibernazione (vedi sotto).
  In pratica, se il counter_node non riceve piu' richieste di controllo da
  parte degli hash_gnode, si disattiva, e tutti gli hostname registrati non
  sono piu' validi (non si possono piu' aggiornare).
  La stessa regola degli hash_gnode viene applicata anche al counter_node: non
  esistera' piu' un singolo counter_node, ma un intero gnode di counter_node,
  chiamato appunto counter_gnode.
  
  7.1.4  Registration step by step
  
  Il nodo x,  che vuole registrare il suo hostname, trova il gnode piu' vicino
  all'hash_gnode (o l'hash_gnode stesso), contatta un nodo a caso (il nodo y)
  di quel gnode e gli manda la richiesta.
  La richiesta include una public key della sua coppia di chiavi RSA che
  rimane valida per tutte le future richieste. Il pkt viene anche firmato con
  la priv_key.
  Il nodo y controlla di essere effettivamente nel gnode piu' vicino
  all'hash_node, in caso contrario rigetta la richiesta. Viene controllata
  anche la validita' della firma apposta nella richiesta.
  Il nodo y contatta il counter_gnode e gli manda l'IP, l'hostname del
  register_node e la copia della richiesta. 
  Il counter verifica i dati e controlla che la firma apposta sulla richiesta
  sia valida, e da' l'ok.
  Il nodo y, dopo l'ok, accetta la richiesta, crea l'entry nel suo db
  annotando la data di registrazione, e manda in broadcast, all'interno del
  gnode, la richiesta.
  Gli altri nodi dell'hash_gnode che ricevono la richiesta controllano la sua
  validita' e la memorizzano in un'entry del loro db. 
  A questo punto il nodo x deve solo preoccuparsi di mandare la richiesta ai 
  backup_gnode. Quando i nodi dei backup_gnode ricevono la richiesta,
  controllano di essere nel range dei gnode piu' vicini, e riapplicano la
  stessa procedura.
  
  7.1.5  Endless rest and rebirth

  Gli hash_gnode mantengono gli hostname in uno stato di ibernazione per circa
  3 giorni dal momento della loro registrazione od aggiornamento.
  Il tempo di decadimento e' volutamente molto alto per mantenere i domini 
  stabili. In questo modo, anche se qualcuno attacca un nodo per appropriarsi
  del suo dominio, dovra' aspettare 3 giorni.
  Quando il tempo di ibernazione si e' esaurito allora tutti gli hostname
  scaduti vengono cancellati e vengono sostituiti dagli altri hostname in
  coda.
  Un nodo deve mandare una richiesta di aggiornamento dei suoi hostname ogni 
  qualvolta il suo IP cambia e in ogni caso prima dello scadere del tempo di
  ibernazione, in questo modo il suo hostname non sara' cancellato.
  Il pacchetto della richiesta di aggiornamento ha un id che indica il numero
  di aggiornamenti gia' mandati. Il pacchetto viene anche firmato con la
  chiave privata del nodo, per garantire l'autenticita' della richiesta.
  Il pkt viene mandato ad un nodo qualsiasi dell'hash_gnode. Quest'ultimo nodo
  contattera' il counter_node, mandando anche una copia della richiesta, per
  aggiornare le sue entry e per verificare che sia ancora attivo e che l'entry
  relativa all'hostname da aggiornare sia presente. In caso contrario, la
  richiesta di aggiornamento viene rigettata.
  Se tutto va bene, il nodo dell'hash_gnode manda in broadcast la richiesta
  di aggiornamento all'interno del suo gnode.
  Il register_node deve poi mandare la richiesta di aggiornamento anche ai
  backup_gnode.
  Se la richiesta di aggiornamento viene mandata troppo presto (nel primo
  giorno) verra' considerata invalida e sara' ignorata.

  7.1.6  Hash_gnodes mutation
  
  Se un generico rounded_gnode viene scavalcato da un nuovo gnode che e' piu'
  vicino all'hash_gnode deve lasciargli il posto, quindi avviene un
  trasferimento dal vecchio rounded_gnode al nuovo.
  La transizione, pero', avviene in maniera semi-passiva: quando il
  register_node fara' l'aggiornamento dell'hostname, si rivolgera'
  direttamente al nuovo rounded_gnode. L'hostname presente nel vecchio
  rounded_gnode, non essendo piu' aggiornato, decadera'.
  Nel frattempo, quando ancora l'hostname non e' stato aggiornato, tutti i
  nodi che vogliono risolverlo troveranno il nuovo rounded_gnode come gnode
  piu' vicino all'hash_gnode, quindi manderanno le richieste al nuovo gnode.
  Il nuovo rounded_gnode, non avendo ancora il db, chiedera' al vecchio
  hash_gnode di dargli la sua andna_cache relativa all'hostname da risolvere.
  Una volta ricevuta, rispondera' al nodo che ha chiesto la risoluzione
  dell'hname e nel frattempo mandera' in broadcast, all'intero del suo gnode,
  l'andna_cache appena ottenuta. In questo modo la registrazione di
  quell'hostname viene automaticamente trasferita nel nuovo gnode.
  Per evitare che un nodo sottragga l'hostname al leggittimo proprietario
  prima che il trasferimento dell'andna_cache avvenga, tutti i nodi del nuovo
  hash_gnode, per accettare una richiesta di registrazione, controllano se
  quell'hostname esiste gia' in un hash_gnode vecchio: se questa condizione
  e' verificata avvieranno il trasferimento dell'andna_cache ed aggiungeranno
  il nodo che vuole registrare l'hostname nella coda.
 
  7.1.7  Yaq: Yet another queue
  
  Ogni nodo ha la liberta' di scegliersi un qualsiasi nome host, ed anche se
  l'hostname e' gia' stato preso da un altro nodo, puo' sempre decidere di
  proseguire nella registrazione. Proseguendo, il nodo manda una richiesta al
  gnode che conservera' l'hostname, la richiesta viene accettata, e
  viene aggiunta in coda, dove massimo possono esserci MAX_ANDNA_QUEUE (5)
  hostname. Nell'hash_gnode il nodo viene associato al nome host che ha
  richiesto e viene memorizzata anche la data di richiesta.
  Quando un nodo deve risolvere un hostname, consulta l'hash_gnode.
  Il nodo puo' anche scegliere di usare gli altri IP nella coda che sono
  associati allo stesso hostname.
  
  7.8	Hostname resolution

  Per risolvere un hostname il nodo X deve semplicemente trovare l'hash_gnode
  relativo all'hostname e mandare ad un nodo a caso di quel gnode la richiesta
  di risoluzione.
   
  7.8.1  Distributed cache for hostname resolution

  Per incrementare l'efficienza di risoluzione di hostname, si adotta una
  piccola strategia: un nodo, ogni volta che risolve un hostname, memorizza
  il risultato in una cache. Per ogni risoluzione successiva dello stesso
  hostname, il nodo avra' gia' il risultato nella sua cache.
  Poiche' nei pacchetti di risoluzione degli hostname e' indicato il tempo
  dell'ultima volta in cui sono stati registrati o aggiornati, un'entry nella
  cache scade esattamente quando l'hostname non e' piu' valido in ANDNA e deve
  essere aggiornato.
  La resolved_hnames cache e' accessibile a qualunque nodo.
  Un nodo X, sfruttando questa proprieta', se non ha l'hostname da risolvere
  nella sua cache, puo' decidere di chiedere ad un qualsiasi bnode Y scelto a
  caso del suo stesso gnode di risolvere per lui l'hostname desiderato.
  Il bnode Y, cerchera' nella sua resolved cache l'hostname e in caso di esito
  negativo, risolvera' l'hostname in modo standard facendo mandare la risposta
  al nodo X.
  Questo sistema previene l'overload degli hash_gnode che mantengono hostname
  molto famosi.
  
  7.8.2  noituloser emantsoh esreveR

  Se un nodo vuole conoscere gli hostname associati a un IP, contatta
  direttamente il nodo che ha quell'IP.

  7.9  dns wrapper

  Un wrapper di richieste DNS si occupera' di mandare al demone di ANDNA gli
  hostname da risolvere e di restituire gli IP associati ad essi.
  Grazie al wrapper sara' possibile usare ANDNA senza modificare alcun
  programma esistente: bastera' usare come server DNS il proprio computer.

  8.   Heavy Load: flood your ass!

  Le rotte settate da Netsukuku sono create col supporto nexthop, che permette
  ad un nodo di raggiungere un altro nodo usando piu' rotte simultaneamente
  (multipath), garantendo uno smistamento equo del traffico dei pkts.
  Lo scudo anti-flood e' una conseguenza dell'avere delle rotte 
  multipath, ed essere collegati a piu' rnodes. Infatti, anche quando un
  nodo e'  bombardato da un flusso di dati continuo e sostenuto, riceve
  quel flusso diviso in differenti rotte e differenti link, e quindi puo'
  sempre comunicare con altri nodi.

  9.   Spoof the Wired: happy kiddies

  Se un nodo si aggancia a Netsukuku falsificando un IP, non concludera' nulla
  semplicemente perche' nessun nodo sapra' come raggiungerlo, avendo gia' la
  rotta esatta per raggiungere il nodo originale.
  In secondo luogo, gli rnode non permettono un aggancio di un IP che e' gia'
  presente nelle mappe.

  10.  /dev/accessibility
  
  Il mezzo ideale per connettere i nodi tra loro e', ovviamente, il wifi, ma
  qualunque tipo di link che connette due nodi serve allo scopo.
  I cellulari sono un ottimo dispositivo, su cui far girare Netsukuku.
  Alcuni dei nuovi modelli usano Linux come kernel. 
  
  11.  Internet compatibility

  Netsukuku non puo' diffondersi instantaneamente, ed e' impossibile pensare
  di poter migrare da Internet a Netsukuku immediatamente.
  Bisogna, quindi, che durante la sua iniziale diffusione, rimanga compatibile
  con il vecchio Internet e l'unico modo e' quello di limitare temporaneamente
  l'espandibilita' di Netsukuku.
  
  Un nodo che usa Netsukuku non puo' uscire su Internet perche', quando
  netsukuku_d viene avviato, come default gw viene settato lo stesso indirizzo
  IP assegnato all'interfaccia di rete, in questo modo le classi di IP non
  esistono piu', e qualsiasi nodo puo' prendersi qualsiasi IP random; inoltre,
  dato che gli IP vengono scelti in maniera random, possono accadere molte
  collisioni con gli attuali IP di Internet.
  
  Per mantenere la compabilita' con Internet, Netsukuku deve essere ristretto
  ad una sotto classe di IP, in modo da non interferire con il default gw che
  esce su Internet. Allora, per non interferire in nessun modo con Internet,
  usiamo la classe A degli indirizzi privati per l'IPv4, e la classe
  Site-Local per l'IPv6.
  
  Il passaggio dal Netsukuku ristretto al Netsukuku completo e' semplice: 
  nel momento stesso in cui un utente decide di abbandonare Internet, riavvia
  NetsukukuD senza l'opzione di restrizione.

  Ovviamente le altre classi private di IP non vengono toccate, per lasciare la
  possibilita' di creare una LAN con un solo gw/nodo netsukuku.
  
  12.  Implementation: let's code
  
  Il protocollo di Netsukuku non e' low-level, perche' tutto quello che deve
  fare e' settare le rotte nella tabella di routing del kernel, percio' il
  demone NetsukukuD gira in userspace.
  Tutto il sistema viene quindi gestito dal demone che gira su ogni nodo. 
  NetsukukuD comunica con gli altri nodi attraverso l'udp e il tcp e setta le 
  rotte nella tabella del kernel.

  Tutto il codice e' scritto in C ed e' commentato, quindi non dovrebbe essere
  difficile seguire il flusso del programma, in ogni caso, prima di leggere un
  .c e' consigliato sbirciare il relativo .h .
  
  Netsukuku.c si occupa di lanciare i thread principali.
  Ogni porta su cui ascolta NetsukukuD e' gestita da un demone che viene 
  lanciato come un singolo thread. Le porte usate sono le 269-udp, 269-tcp,
  271-udp, 277-udp e 277-tcp.
  Tutti i pacchetti ricevuti dai demoni vengono filtrati da accept.c e da
  request.c che grazie ad una piccola tabella prevengono eventuali attacchi
  di flood (accept.c e' lo stesso codice usato per patchare la vulnerabita'
  user-level-denial-of-service di OpenSSH). In secondo luogo vengono passati
  a pkts.c/pkt_exec().
  Quando tutti i demoni sono attivi, viene lanciato hook.c/netsukuku_hook(),
  il codice che gestisce l'hook alla rete.

  Hook.c avviera' per la prima volta il primo radar scan con
  radar.c/radar_scan(). Tutti i pacchetti ricevuti relativi al radar sono
  gestiti da radar.c/radard() e da radar.c/radar_recv_reply().
  Dopo l'aggancio alla rete, verra' avviato il radar_scan thread che non fara'
  altro che eseguire in eterno la funzione radar.c/radar_daemon(), la quale
  lancia un radar_scan() ogni MAX_RADAR_WAIT secondi. Quando il
  radar_update_map() si accorge di un cambiamento nei suoi rnode spedisce un
  nuovo qspn_close con qspn.c/qspn_send().
  Tutto il codice relativo al qspn e ai tracer_pkt si trova in qspn.c e in
  tracer.c.

  Il codice di ANDNA e' diviso in andna_cache.c, che contiene tutte le
  funzioni usate per gestire le relative cache e in andna.c dove risiede il
  codice che si occupa dei pkt del protocollo ANDNA.
  
  I socket, sockaddr, le connect, i recv(), i send, etc... sono tutte in
  inet.c, e vengono utilizzate da pkts.c.
  pkts.c si occupa di ricevere le richieste con pkt_exec() e mandarne con
  send_rq(), un front-end utilizzato per impacchettare e spedire la grande
  maggioranza delle richieste.
  ipv6-gmp.c usa la libreria GMP (GNU multiple precision arithmetic library)
  per poter manipolare i 16 byte di un IPv6 come se fossero un unico grande
  numero, questo e' essenziale per alcune formule che agiscono direttamente
  sull'IP per poter ricavare molte informazioni, infatti, in Netsukuku un IP
  e' un numero a tutti gli effetti.

  Il codice che si interfaccia al kernel per settare le rotte nella route
  table e per configurare un'interfaccia di rete si trova in:
  krnl_route.c, if.c, ll_map.c, krnl_rule.c, libnetlink.c.
  Route.c fa da intermediario tra il codice che gestisce il protocollo di
  netsukuku e tra le funzioni che comunicano con il kernel.

  Per quanto riguarda le mappe tutto si basa su map.c, il sorgente che
  si occupa di prendersi cura della mappa interna. Tutte le altre mappe si
  appogiano su map.c, e sono:
  bmap.c per la border node map, gmap.c per le mappe esterne.
  
  Per compilare il codice di Netsukuku non e' necessario usare autoconf,
  automake e famiglia, ma basta usare il comodo scons (http://www.scons.org).

  L'ultima versione del codice e' sempre disponibile sul cvs degli
  hinezumilabs: 

  cvs -d :pserver:anoncvs@hinezumilabs.org:/home/cvsroot login
  
  oppure date un'occhiata da qui:
  
  http://hinezumilabs.org/cgi-bin/viewcvs.cgi/netsukuku/
  

  13.  What to do

  - Testare su larga scala Netsukuku ed ANDNA.
  - Completare i src/TODO.
  - Codare, codare, codare.
  - Varie ed eventuali.

  Chi vuole imbarcarsi faccia un fischio.
  

  14.  The smoked ones who made Netsukuku

  Andrea Lo Pumo   aka   AlpT				<alpt@freaknet.org>
 
  
  Special thanks to:
  
  Valvoline the non-existent entity for the implementation advices,
  Newmark, the hibernated guy who helped in some ANDNA problems,
  Crash aka "il nipponico bionico" who takes BSD, breathes the 2.4Ghz and
        worship the great Disagio,
  Tomak aka "il magnanimo" who watches everything with his crypto eyes and
        talks in the unrandomish slang,
  Asbesto aka "l'iniziatore" who lives to destroy the old to build the new,
  Nirvana who exists everywhere to bring peace in your data,
  Ram aka "il maledetto poeta" who builds streams of null filled with the
	infinite,
  Quest who taught me to look in the Code,
  Martin, the immortal coder and our beloved father,
  Elibus, the eternal packet present in your lines,
  Pallotron, the biatomic super AI used to build stream of consciousness,
  Entropika, the Great Mother of Enea,
  Uscinziatu, the attentive,
  Shezzan, the holy bard of the two worlds,
  Katolaz,
  Gamel,
  ...
  the list goes on...
  V C G R A N Q E M P N E T S U K

  and finally thanks to all the
  
  Freaknet  Medialab      <www.freaknet.org>
  
  whose we are all part, and the poetry

  Poetry Hacklab          <poetry.freaknet.org - poetry.homelinux.org>
  
  
--
This file is part of Netsukuku.
This text is free documentation; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option) any
later version. For more information read the COPYING file.
