- 108
- 15
- CPU
- Ryzen 5 7600x
- Dissipatore
- Noctua
- Scheda Madre
- Asrock B640m riptide
- HDD
- troppi samsung per quanto voglia ammettere
- RAM
- Corsair vengeance kit 32 GB ddr5
- GPU
- Asus 4060 TI
- Monitor
- Samsung odyssey TN
- PSU
- Un corsair decente
- Case
- NZXT H7 Flow
- Periferiche
- Corsair harpoon RGB, Corsair K55 RGB
- Net
- TIM Fttc 100/20 Mbit
- OS
- Windows 11
Salve sono giunto a chiedere consiglio a chi di programmazione e networking ne conosce più di me; sto programmando un progetto di java per un esame di programmazione, in particoalre sto creando la GUI di un router in linguaggio java.
Al momento mi sono arenato su un aspetto del progetto che riguarda l'aspetto logico del seguente problema:
Mi trovo in difficoltà su questo aspetto poichè non riesco a venire a capo del problema di come il pacchetto dati debba avere delle caratteristiche univoche che lo portino alla sua destinazione e non ad una destinazione sbagliata, questa problematica nasce da una situazione limite che schematizzo nella maniera seguente:
Suppongo che Host1 voglia mandare un pacchetto ad Host3, con la classe pacchetto che ho creato io mi crea un problema evidente:
Mettendo come indirizzo di destinazione : 192.168.0.2 l'algoritmo di routing che mi è stato imposto di usare dalle linee guida del progetto(Dijkstra) non manderà correttamente il pacchetto ad Host3 in quanto anche Host2 possiede il medesimo indirizzo, faccio questa affermazione in quanto per come ho pensato di rappresentare la tabella di routing dei vari router presenti nello schema:
Router1
Router2
Router3
Con queste tabelle l'algoritmo nella sua ricerca attraverso i nodi non avrebbe una destinazione univoca e potrebbe indirizzare il pacchetto verso la destinazione sbagliata per il semplice fatto che i due hanno lo stesso indirizzo locale, l'unico fattore discriminante sarebbe la metrica ( il peso degli archi ) a far propendere l'algoritmo per una strada a costo più basso anzichè la destinazione finale in se.
Questo problema nasce dalla mia totale ignoranza su come un host/router possa conoscere a "priori" in maniera univoca a chi mandare il pacchetto nella realtà; ho provato a documentarmi sul funzionamento del sistema TCP/IP , degli indirizzi e delle tabelle di routing su varie fonti come Wikipedia o siti più specializzati ma ho compreso poco o nulla.
Come posso quindi caratterizzare la mia classe pacchetto in maniera tale che una volta generato sia certo che arrivi alla destinazione anche in casi di indirizzi locali uguali su più di una rete? Come viene affrontata nella realtà questa problematica?
Spero di essere stato chiaro nell'esporre il problema, grazie a chi si prenderà la briga anche solo di leggere queste mie 4 righe.
Al momento mi sono arenato su un aspetto del progetto che riguarda l'aspetto logico del seguente problema:
"Smistare un pacchetto dati da un host ad un'altro host controllato da un altro router"
Mi trovo in difficoltà su questo aspetto poichè non riesco a venire a capo del problema di come il pacchetto dati debba avere delle caratteristiche univoche che lo portino alla sua destinazione e non ad una destinazione sbagliata, questa problematica nasce da una situazione limite che schematizzo nella maniera seguente:
Suppongo che Host1 voglia mandare un pacchetto ad Host3, con la classe pacchetto che ho creato io mi crea un problema evidente:
Java:
package AUXCLASSES;
import P3_GUI_APP.COREMODULES.Tipi_pacchetto;
import P3_GUI_APP.COREMODULES.UTILITIES.CheckerMethodsForIPS;
/**
* Classe che rappresenta il pacchetto dati
*
* @author Luca *****
*/
public class Packet implements CheckerMethodsForIPS {
//VARIABILI
/**
* Ip della prossima destizione per raggiunger l'indirizzo del destinatario,
* può coincidere con l'IP del destinatario
*/
private String next_hop;
/**
* Variabile che rappresenta l'ip di destinazione
*/
private final String Dest_IP;
/**
* Varibabile che rappresenta la tipologia di pacchetto
* @see P3_GUI_APP.COREMODULES.Tipi_pacchetto
*/
private final Tipi_pacchetto Packet_type;
/**
* Costruttore dell'oggetto pacchetto parametrizzato e con controlli sugli
* IP
*
* @param next_hopString prossimo salto del pacchetto
* @param Dest_IP destinazione finale
* @param Packet_type tipo di dato
* @see #Dest_IP
* @see #Packet_type
* @see #next_hop
* @see P3_GUI_APP.COREMODULES.UTILITIES.CheckerMethodsForIPS
*/
public Packet(String next_hopString, String Dest_IP, Tipi_pacchetto Packet_type) {
checkField(Dest_IP);
checkNumber(Dest_IP);
checkField(next_hopString);
checkNumber(next_hopString);
this.Dest_IP = Dest_IP;
this.Packet_type = Packet_type;
this.next_hop = next_hopString;
}
public String getNext_hop() {
return next_hop;
}
public String getDest_IP() {
return Dest_IP;
}
public Tipi_pacchetto getPacket_type() {
return Packet_type;
}
public void setNext_hop(String next_hop) {
checkField(next_hop);
checkNumber(next_hop);
this.next_hop = next_hop;
}
}
Mettendo come indirizzo di destinazione : 192.168.0.2 l'algoritmo di routing che mi è stato imposto di usare dalle linee guida del progetto(Dijkstra) non manderà correttamente il pacchetto ad Host3 in quanto anche Host2 possiede il medesimo indirizzo, faccio questa affermazione in quanto per come ho pensato di rappresentare la tabella di routing dei vari router presenti nello schema:
Router1
DESTINATION IP | GATEWAY | METRIC |
192.168.0.2 | 192.168.0.1 | un intero |
10.0.0.3 | 10.0.0.1 | " |
80.9.20.30 | 10.0.0.1 | " |
DESTINATION IP | GATEWAY | METRIC |
192.168.0.2 | 192.168.0.1 | un intero |
10.0.0.1 | 10.0.0.3 | " |
DESTINATION IP | GATEWAY | METRIC |
192.168.0.2 | 192.168.0.1 | un intero |
10.0.0.1 | 80.9.20.30 | " |
Con queste tabelle l'algoritmo nella sua ricerca attraverso i nodi non avrebbe una destinazione univoca e potrebbe indirizzare il pacchetto verso la destinazione sbagliata per il semplice fatto che i due hanno lo stesso indirizzo locale, l'unico fattore discriminante sarebbe la metrica ( il peso degli archi ) a far propendere l'algoritmo per una strada a costo più basso anzichè la destinazione finale in se.
Questo problema nasce dalla mia totale ignoranza su come un host/router possa conoscere a "priori" in maniera univoca a chi mandare il pacchetto nella realtà; ho provato a documentarmi sul funzionamento del sistema TCP/IP , degli indirizzi e delle tabelle di routing su varie fonti come Wikipedia o siti più specializzati ma ho compreso poco o nulla.
Come posso quindi caratterizzare la mia classe pacchetto in maniera tale che una volta generato sia certo che arrivi alla destinazione anche in casi di indirizzi locali uguali su più di una rete? Come viene affrontata nella realtà questa problematica?
Spero di essere stato chiaro nell'esporre il problema, grazie a chi si prenderà la briga anche solo di leggere queste mie 4 righe.