Cloud with rain
.:G
G:.
0 and 1 serie, black on white
pulled card
myjsp.feelinglinux.com
ver. 1.1.9-4
Hallo, welcome to my world.
Here you can find some stuff about computer science.
<<< Enjoy your visit! >>>
0 and 1 serie, white on black

Strumenti online: IPv4 e Reti (Javascript)

        Scritto: Giansante Gabriele, 26/10/2016     

Strumenti utili per operazioni su IP e su reti (l'utilizzo e' gratuito ed assolutamente anonimo).
Basati sulla conversione in Javascript del codice descritto nell'articolo
Indirizzi IPv4 e maschere. Esempi di calcolo in Java

Conversione maschera di rete

Tramite questi due strumenti e' possibile convertire il valore della maschera di rete dalla notazione intera alla notazione IP e viceversa.
es. 24 => 255.255.255.0
Maschera (int)

es. 24

Maschera (IP)

es. 255.255.255.0


Pubblicita'
Operazioni su Reti

Strumenti che consentono di effettuare operazioni che coinvolgono reti (inclusione di IP in reti, informazioni su una rete, ecc.).
IP (qualsiasi)

es. 192.168.1.55
Maschera (int o IP)
es. 18 oppure 255.255.192.0




IP

es. 192.168.25.13
Rete

es. 192.168.0.0/18 oppure
192.168.0.0/255.255.192.0


Rete 1

Rete 2

es. 192.168.0.0/18 oppure
192.168.0.0/255.255.192.0



Pubblicita'
Operazioni su IPv4

Operazioni su IP (AND, NOT, somma, uguaglianza, confronto). Queste operazioni, prese cosi', singolarmente, potrebbero sembrare poco utili, ma vengono sfruttate dagli altri strumenti, come le conversioni di maschera e le operazioni su reti.
IP 1

es. 192.168.25.13
IP 2

es. 192.168.80.0







IP

es. 192.168.25.13


Codice Javascript di base

Come accennato ad inizio di pagina, gli strumenti presenti in questa pagina sono realizzati sfruttando la conversione in Javascript del codice mostrato nell'articolo
Indirizzi IPv4 e maschere. Esempi di calcolo in Java
Il codice alla base del funzionamento di questi mini-tool e' presente nel file
ipToolsCore.js
Il file contiene solo le funzioni base, ovvero senza i vari controlli sul formato dell'input e senza la gestione della parte grafica dei box.
Di seguito, ne viene mostrato il contenuto


[[[                  ipToolsCore.js                     ]]]
[[[ Codice utilizzabile sotto GNU LGPL 2.1 e successive ]]]

//Effettua l'AND binario fra due IP (byte a byte)
//Input: array di byte
//Output: array di byte
function andIp(ip1, ip2) {
    var result = new Array();
    for (var i = 0; i < 4; i++) {
        result.push(ip1[i] & ip2[i]);
    }
    return result;
}

//Effettua la negazione dell'IP mediante l'operazione (255.255.255.255-IP)
//Input: array di byte
//Output: array di byte
function notIp(ip) {
    var result = new Array();
    var notMask = [255, 255, 255, 255];
    for (var i = 0; i < 4; i++) {
        result.push(notMask[i] - ip[i]);
    }
    return result;
}

//Somma due IP. I byte che superano 255 vengono messi a 255
//Input: array di byte
//Output: array di byte
function addIp(ip1, ip2) {
    var result = new Array();
    for (var i = 0; i < 4; i++) {
        result.push(ip1[i] + ip2[i]);
        if (result[i] > 255)
            result[i] = 255;
    }
    return result;
}

//Verifica l'uguaglianza di due IP
//Input: array di byte
//Output: boolean
function equalsIp(ip1, ip2) {
    var result = true;
    for (var i = 0; i < 4; i++) {
        if (ip1[i] !== ip2[i]) {
            result = false;
            break;
        }
    }
    return result;
}

//Verifica che il primo IP sia inferiore al secondo (confronto byte a byte)
//Input: array di byte
//Output: boolean
function lessThanIp(ip1, ip2) {
    var result = false;
    //Va avanti fino a che i numeri sono uguali. 
    //Si ferma quando sono diversi e verifica quale e' piu' grande.
    for (var i = 0; i < 4; i++) {
        if (ip1[i] < ip2[i]) {
            //sicuramente minore
            result = true;
            break;
        } else if (ip1[i] > ip2[i]) {
            //sicuramente maggiore
            break;
        }
    }
    return result;
}

//Trasforma l'IP passato come stringa in array di byte
//Input: stringa (xxx.xxx.xxx.xxx)
//Output: array di byte
function getIpArray(ip) {
    var result = [0, 0, 0, 0];
    //Il parametro di split non e' un'espressione 
    //regolare come invece e' in Java
    var stringIpArray = ip.split(".");
    for (var i = 0; i < stringIpArray.length; i++) {
        result[i] = parseInt(stringIpArray[i]);
    }
    return result;
}

//Trasforma l'IP passato come array di byte in stringa
//Input: array di byte
//Output: stringa (xxx.xxx.xxx.xxx)
function getIpString(ip) {
    var result =
            ip[0] + "." +
            ip[1] + "." +
            ip[2] + "." +
            ip[3];
    return result;
}

//Trasforma la maschera da notazione intera a notazione IP
//Input: intero
//Output: array di byte
function toIpMask(networkMask) {
    var result = new Array();
    if (networkMask === 0) {
        //Nessun calcolo necessario... 0 e' 0...
        result = [0, 0, 0, 0];
    } else {
        //Inizializzo per comodita' il risultato come 
        //se avessi una maschera "32"
        result = [255, 255, 255, 255];

        //i=0 => resto=0 => ho un numero formato da primi 
        //                  byte a 255 e gli altri a 0
        //i>0 => resto>0 => ho un numero formato da primi 
        //                  byte a 255, uno 1..254, il resto a 0
        var i = networkMask % 8;

        //Se i>0, count mi da la posizione nell'array dove inserire 
        //il byte disparo (diverso da 0 o 255).
        //Se i=0, count mi da, invece, la posizione del primo 0 (ho una 
        //divisione perfetta).
        var count = Math.floor(networkMask / 8);

        //conterra', alla fine, il limite per 
        //l'inserimento dei byte "0".
        var zeroLimit = count;
        if (i > 0) {
            //Calcolo numero "centrale",
            //trasformazione binario/byte
            var temp = 0;
            //Ciclo sul numero di bit a 1
            for (var j = 0; j < i; j++) {
                //Shift j volte dell'1, metto il risultato in 
                //OR col valore temporaneo
                temp |= (1 << j);
            }
            //Ho i bit spostati a "destra", shift a "sinistra"
            //per avere prima gli 1 e poi gli 0
            result[count] = (temp << (8 - i));
        } else {
            if (count > 0) {
                zeroLimit = count - 1;
            }
        }

        //uso la variabile "zeroLimit" perche' a seconda 
        //del caso con "resto=0" o "resto>0" devo usare 
        //"count" o "count-1"
        //Metto a "0" i restanti byte
        for (var j = 3; j > zeroLimit; j--) {
            result[j] = 0;
        }
    }
    return result;
}

//Trasforma la maschera da notazione IP a notazione intera
//Input: array di byte
//Output: intero
function toIntMask(networkMask) {
    var result = 0;
    // Ciclo sui 4 compoenti della maschera/IP
    for (var i = 0; i < 4; i++) {
        if (networkMask[i] === 255) {
            // 255 sono tutti 1 (8 bit a 1). Comincio a contarli
            result += 8;
        } else if (networkMask[i] === 0) {
            // Se la cifra e' uno zero, esco ed interrompo la 
            // "conta" perche' saranno tutti 0 anche i successivi
            break;
        } else {
            //Caso in cui il numero e' compreso fra 1 e 254.
            //Devo trovare la prima posizione dello 0 o l'ultima dell'1 
            //all'interno della sua rappresentazione binaria.
            //L'idea e' di usare le potenze di 2 (numeri con un unico bit a 1).
            //Per ottenere queste potenze di due uso il trucco di shiftare N volte 
            //verso sinistra (bit meno significativo a destra) il valore "00000001".
            //Comincio con N=4 in modo da ottimizzare potenzialmente la ricerca 
            //(binaria come primo passo, sequenziale per la rimanente meta' dei bit).
            //La potenza di 2 a cui sono arrivato con lo shift e' indicativa della 
            //posizione del bit (indice) all'interno del byte (8 bit).
            //Metto in AND il numero con la potenza del 2 ed ottengo 1 o 0 a seconda che 
            //il corrispondente bit sia settato (1) o no (0). A seconda che sia "0" o "1" 
            //capisco la direzione in cui procedere. Vado avanti nella direzione 
            //individuata, fino a contare tutti gli 1.
            var shift = 4;
            //Variabile di comodo che conterra', alla fine,
            //il numero di uno consecutivi trovati all'inizio di mask[i]
            var numberOfOne = 0;
            var goRight = (networkMask[i] & (1 << shift)) > 0;
            // Unico codice per entrambe le direzioni, ci pensa "goRight" a selezionare
            // indirettamente il ramo su cui continuare
            while ((goRight && ((shift--) > 0)) || (!goRight && ((shift++) < 7))) {
                var testValue = networkMask[i] & (1 << shift);
                if (goRight && testValue === 0) {
                    numberOfOne = 8 - shift - 1;
                    break;
                } else if (!goRight && testValue > 0) {
                    numberOfOne = 8 - shift;
                    break;
                }
            }
            result += numberOfOne;
        }
    }
    return result;
}

//Restituisce l'indirizzo di rete (base) dato un IP qualsiasi e la maschera della rete a cui appartiene
//Input: array di byte, intero
//Output: array di byte
function getNetworkBaseIp(ip, networkMask) {
    var result = new Array();
    var maskArray = toIpMask(networkMask);
    result = andIp(ip, maskArray);
    return result;
}

//Verifica che l'ip sia all'interno della rete indicata
//Input: array di byte, array di byte, intero
//Output: boolean
function isIpInsideNetwork(ip, networkBaseIp, networkMask) {
    var result;
    //Se la base della rete passata e' identica a quella ottenuta 
    //applicando la maschera della rete all'IP, 
    //allora l'IP e' nella rete
    result = equalsIp(networkBaseIp, getNetworkBaseIp(ip, networkMask));
    return result;
}

//Verifica che la rete sia inclusa nell'altra rete indicata
//Input: array di byte, intero, array di byte, intero
//Output: boolean
function isNetworkInsideNetwork(networkIp1, networkMask1, networkIp2, networkMask2) {
    var networkMaskIp1 = toIpMask(networkMask1);
    var broadcastIp1 = addIp(notIp(networkMaskIp1), networkIp1);
    var networkMaskIp2 = toIpMask(networkMask2);
    var broadcastIp2 = addIp(notIp(networkMaskIp2), networkIp2);
    //L'ip base della prima rete deve essere maggiore o 
    //uguale a quello della seconda, l'ultimo ip della seconda rete 
    //dev'essere maggiore o uguale all'ultimo della prima
    var result = !lessThanIp(networkIp1, networkIp2) && !lessThanIp(broadcastIp2, broadcastIp1);
    return result;
}

//Restituisce informazioni sulla rete a cui appartiene l'IP passato (ip base, maschera, broadcast, numero di ip)
//Input: array di byte, intero
//Output: istanza di NetworkStatistics
function getNetworkStatistics(ip, networkMask) {
    var result = new NetworkStatistics();
    if (networkMask > 0) {
        var networkIp = getNetworkBaseIp(ip, networkMask);
        //calcolo la maschera che "aggiunta" all'IP di base 
        //della rete mi determina l'ampiezza della rete stessa
        var networkRangeMask = notIp(toIpMask(networkMask));
        //L'IP di broadcast e' l'ultimo della rete e lo ottengo aggiungendo 
        //l'inversione della maschera all'IP base
        result.setBroadcastIp(addIp(networkIp, networkRangeMask));
        result.setNetworkIp(networkIp);
        result.setMask(networkMask);
        //Il numero di IP possibili si calcola come 
        //numero di combinazioni al variare delle singole parti 
        //della inversione della maschera
        if (networkMask === 32) {
            result.setCount(1);
        } else {
            var count = 0;
            for (var i = 0; i < 4; i++) {
                var value = networkRangeMask[i];
                if (value > 0) {
                    if (count === 0)
                        count += ++value;
                    else
                        count *= ++value;
                }
            }
            result.setCount(count);
        }
    }
    return result;
}

//################################################
// Class NetworkStatistics 
//################################################
var NetworkStatistics = function () {
    this.networkIp = [0, 0, 0, 0];
    this.broadcastIp = [0, 0, 0, 0];
    this.mask = 0;
    this.count = 0;

    //Output: array di byte
    this.getNetworkIp = function () {
        return this.networkIp;
    };

    //Input: array di byte
    this.setNetworkIp = function (networkIp) {
        this.networkIp = networkIp;
    };
    //Output: array di byte
    this.getBroadcastIp = function () {
        return this.broadcastIp;
    };
    //Input: array di byte
    this.setBroadcastIp = function (broadcastIp) {
        this.broadcastIp = broadcastIp;
    };
    //Maschera di rete
    //Output: intero
    this.getMask = function () {
        return this.mask;
    };
    //Maschera di rete
    //Input: intero
    this.setMask = function (mask) {
        this.mask = mask;
    };

    //Numero di IP nella rete
    //Output: intero
    this.getCount = function () {
        return this.count;
    };
    
    //Numero di IP nella rete
    //Input: intero
    this.setCount = function (count) {
        this.count = count;
    };

};
//################################################

//Espressione regolare che valida un indirizzo IP (accettati 1,01,001,000,00,ecc...)
var ipToolsJsRegExpr_Ip = /^(((25[0-5])|(2[0-4]\d)|(1(\d){2})|(0?\d{2})|(0{0,2}\d))\.){3}((25[0-5])|(2[0-4]\d)|(1(\d){2})|(0?\d{2})|(0{0,2}\d))$/;
//Espressione regolare che valida una rete (IP/int, IP/IP, con IP che accetta anche 0x e 00x). 
//Inoltre controlla anche che la maschera sia un intero fra 0 e 32 oppure, se in formato IP, che abbia solo 
//i valori ammissibili (e non valori casuali)
var ipToolsJsRegExpr_Network = /^(((25[0-5])|(2[0-4]\d)|(1(\d){2})|(0?\d{2})|(0{0,2}\d))\.){3}((25[0-5])|(2[0-4]\d)|(1(\d){2})|(0?\d{2})|(0{0,2}\d))\/((\d|[0-2]\d|3[0,1,2])|(((0{1,3}|1(28|92)|2(24|4[0,8]|(5[2,4,5])))\.(0{1,3}\.){2}0{1,3})|(255\.(0{1,3}|1(28|92)|2(24|4[0,8]|(5[2,4,5])))(\.0{1,3}){2})|((255\.){2}(0{1,3}|1(28|92)|2(24|4[0,8]|(5[2,4,5])))\.0{1,3})|(255\.){3}(0{1,3}|1(28|92)|2(24|4[0,8]|(5[2,4,5])))))$/;
//Espressione regolare che valida una maschera in formato intero (da 0 a 32). Accetta anche valori "01, 02, ..."
var ipToolsJsRegExpr_IntMask = /^(\d|[0-2]\d|3[0,1,2])$/;
//Espressione regolare che valida una maschera in formato IP. Accetta solo valori di maschera validi, non accetta tutti gli IP. Accetta anche valori "0, 00, 000"
var ipToolsJsRegExpr_IpMask = /^(((0{1,3}|1(28|92)|2(24|4[0,8]|(5[2,4,5])))\.(0{1,3}\.){2}0{1,3})|(255\.(0{1,3}|1(28|92)|2(24|4[0,8]|(5[2,4,5])))(\.0{1,3}){2})|((255\.){2}(0{1,3}|1(28|92)|2(24|4[0,8]|(5[2,4,5])))\.0{1,3})|(255\.){3}(0{1,3}|1(28|92)|2(24|4[0,8]|(5[2,4,5]))))$/;

//Controlla la validita' di una stringa rappresentante una maschera intera
//Input: string 
//Output: boolean
function isValidIntMask(mask) {
    return ipToolsJsRegExpr_IntMask.test(mask);
}

//Controlla la validita' di una stringa rappresentante una maschera in forma IP
//Input: string 
//Output: boolean
function isValidIpMask(mask) {
    return ipToolsJsRegExpr_IpMask.test(mask);
}

//Controlla la validita' di una stringa rappresentante un IP
//Input: string 
//Output: boolean
function isValidIp(ip) {
    return ipToolsJsRegExpr_Ip.test(ip);
}

//Controlla la validita' di una stringa rappresentante una rete
//Input: string
//Output: boolean
function isValidNetwork(network) {
    return ipToolsJsRegExpr_Network.test(network);
}


Hai trovato utile questo articolo?
Aiutami a condividerlo o metti un "mi piace".
Grazie mille!


Gli strumenti di condivisione (Google+, Facebook) sono visibili in alto a destra solo dopo aver accettato la policy di utilizzo dei cookie per questo sito.
FAQ - Come faccio a cambiare la mia scelta?

 

Strumenti (myjsp.feelinglinux.com)
Gioco: allenamento con la tastiera Strumenti di codifica/decodifica URI (%-encoding) e Base64 Strumenti di calcolo online per IP e Reti
QUIZ GAME
Quiz game

Cerca @myjsp.feelinglinux.com

Pubblicita'