[C] Calculs réseau.

[Kiwazaru]

Yop, bon alors ce soir je me faisais un peu chier alors j'ai voulu faire un petit programme qui calcul automatiquement certaines informations via un masque de sous-réseau.
Bon trêve de bavardage, place au code

Code C :

#include <stdio.h>
#include <stdlib.h>

void returnMask(unsigned char *mask);
int maskBit(unsigned char *mask);
int pow(int x, int y);

int main(){
    unsigned char addr[] = {192, 168, 1, 12}, sAddr[5] = {0}, bAddr[5] = {0};
    unsigned char mask[] = {255, 255, 255, 0}, _rMask[] = {255, 255, 255, 0};
    int maxHost, i;
    returnMask(_rMask);
    printf("Ip: %d.%d.%d.%d\n", addr[0], addr[1], addr[2], addr[3]);
    printf("Masque de sous-réseau: %d.%d.%d.%d\n", mask[0], mask[1], mask[2], mask[3]);
    printf("Masque de sous-réseau inversé: %d.%d.%d.%d\n", _rMask[0], _rMask[1], _rMask[2], _rMask[3]);
    for (i=0; i <= 3; i++){
        sAddr[i] = addr[i] & mask[i]; /* On &(AND) notre adresse ip par le masque */
    }
    printf("Adresse de sous-réseau: %d.%d.%d.%d\n", sAddr[0], sAddr[1], sAddr[2], sAddr[3]);
    for (i=0; i <= 3; i++){
        bAddr[i] = sAddr[i] | _rMask[i]; /* On |(OR) notre adresse de sous-réseau par le masque inversé pour obtenir l'adresse de broadcast */
    }
    printf("Adresse de broadcast: %d.%d.%d.%d\n", bAddr[0], bAddr[1], bAddr[2], bAddr[3]);
    maxHost = pow(2, 32-maskBit(mask)) - 2; /* On calcule le nombre maximal d'host */
    printf("Le nombre d'hôte(s) possible du réseau: %d", maxHost);
    return 0;
}

void returnMask(unsigned char *mask){
    int i;
    for (i=0; i <= 3; i++){
        mask[i] = ~mask[i]; /* On ~(NOT) les bits, on se retrouve donc avec le masque inversé */
    }
}

int maskBit(unsigned char *mask){
    int i, y, c = 0;
    for(i=0; i <= 3; i++){ /* Pour chaque octet */
        for(y=0; y <= 7; y++){ /* On parcours chaque bit */
            c += (mask[i] >> y) & 1; /* 00001100 & 00000001 = 0, avec le SHR on obtient la valeur de chaque bit. */
        }
    }
    return c;
}

int pow(int x, int y){
    int i, p = x;
    for(i=0; i < y - 1; i++){
        p *= x; /* On multiplie le nombre précédent par 2 */
    }
    return p;
}

Output:

Ip: 192.168.1.12
Masque de sous-réseau: 255.255.255.0
Masque de sous-réseau inversé: 0.0.0.255
Adresse de sous-réseau: 192.168.1.0
Adresse de broadcast: 192.168.1.255
Le nombre d'hôte(s) possible du réseau: 254

NOUVEAU CODE:

Code C :

#include <stdio.h>
#include <stdlib.h>
     
void returnMask(unsigned char *mask);
int maskBit(unsigned char *mask);
int pow(int x, int y);
int validMask(unsigned char *mask);
char getBit(unsigned char *ip);

int main(){
    unsigned char addr[] = {192, 168, 1, 12}, sAddr[5] = {0}, bAddr[5] = {0};
    unsigned char mask[] = {255, 255, 255, 0}, _rMask[] = {255, 255, 255, 0};
    int maxHost, i;
    returnMask(_rMask);
    if (validMask(mask)){
        printf("Masque invalide.");
        return 0;
    }
    printf("Ip: %d.%d.%d.%d", addr[0], addr[1], addr[2], addr[3]);
    getBit(addr);
    printf("Masque de sous-réseau: %d.%d.%d.%d", mask[0], mask[1], mask[2], mask[3]);
    getBit(mask);    
    printf("Masque de sous-réseau inversé: %d.%d.%d.%d", _rMask[0], _rMask[1], _rMask[2], _rMask[3]);
    getBit(_rMask);    
    for (i=0; i <= 3; i++){
        sAddr[i] = addr[i] & mask[i]; /* On &(AND) notre adresse ip par le masque */
    }
    printf("Adresse de sous-réseau: %d.%d.%d.%d", sAddr[0], sAddr[1], sAddr[2], sAddr[3]);
    getBit(sAddr);
    printf("Notation CIDR: %d.%d.%d.%d/%d\n", sAddr[0], sAddr[1], sAddr[2], sAddr[3], maskBit(mask));
    for (i=0; i <= 3; i++){
        bAddr[i] = sAddr[i] | _rMask[i]; /* On |(OR) notre adresse de sous-réseau par le masque inversé pour obtenir l'adresse de broadcast */
    }
    printf("Adresse de broadcast: %d.%d.%d.%d", bAddr[0], bAddr[1], bAddr[2], bAddr[3]);
    getBit(bAddr);    
    maxHost = pow(2, 32-maskBit(mask)) - 2; /* On calcule le nombre maximal d'host */
    printf("Le nombre d'hôte(s) possible du réseau: %d\n", maxHost);
    printf("Première machine: %d.%d.%d.%d / Dernière machine: %d.%d.%d.%d\n", sAddr[0], sAddr[1], sAddr[2], sAddr[3],bAddr[0], bAddr[1], bAddr[2], bAddr[3]);
    return 0;
}
     
void returnMask(unsigned char *mask){
    int i;
    for (i=0; i <= 3; i++){
        mask[i] = ~mask[i]; /* On ~(NOT) les bits, on se retrouve donc avec le masque inversé */
    }
}
     
int maskBit(unsigned char *mask){
    int i, y, c = 0;
    for(i=0; i <= 3; i++){ /* Pour chaque octet */
        for(y=0; y <= 7; y++){ /* On parcours chaque bit */
            c += (mask[i] >> y) & 1; /* 00001100 & 00000001 = 0, avec le SHR on obtient la valeur de chaque bit. */
        }
    }
    return c;
}
     
int pow(int x, int y){
    int i, p = x;
    for(i=0; i < y - 1; i++){
        p *= x; /* On multiplie le nombre précédent par 2 */
    }
    return p; /* -2 pour l'adresse de sous-réseau réservée et l'adresse de broadcast */
}

int validMask(unsigned char *mask){
    int i, y, a = 0, c = 0, t = 0;
    for (i=0; i <= 3; i++){
        for (y=7; y >= 0; y--){
            c += (mask[i] >> y) & 1;
            if(((mask[i] >> y) & 1) && t == 0){ a += (mask[i] >> y) & 1; }
            else { t = 1; }
        }
    }
    if (c != a){ return 1; }
    else { return 0; }
   
}

char getBit(unsigned char *ip){
    int i, y, a = 0;
    printf(" (");
    for (i=0; i <= 3; i++){
        for (y=7; y >= 0; y--){
            printf("%d", (ip[i] >> y) & 1);
        }
        if (i < 3) { printf("."); }
    }
    printf(")\n");
}

Output:

Ip: 192.168.1.12 (11000000.10101000.00000001.00001100)
Masque de sous-réseau: 255.255.255.0 (11111111.11111111.11111111.00000000)
Masque de sous-réseau inversé: 0.0.0.255 (00000000.00000000.00000000.11111111)
Adresse de sous-réseau: 192.168.1.0 (11000000.10101000.00000001.00000000)
Notation CIDR: 192.168.1.0/24
Adresse de broadcast: 192.168.1.255 (11000000.10101000.00000001.11111111)
Le nombre d'hôte(s) possible du réseau: 254
Première machine: 192.168.1.0 / Dernière machine: 192.168.1.255

UPDATE:

Code C :

#include <stdio.h>
#include <stdlib.h>
     
void returnMask(unsigned char *mask);
int maskBit(unsigned char *mask);
int pow(int x, int y);
int validMask(unsigned char *mask);
char getBit(unsigned char *ip);

int main(){
    unsigned char addr[] = {192, 168, 1, 12}, sAddr[5] = {0}, bAddr[5] = {0};
    unsigned char mask[] = {255, 255, 255, 192}, _rMask[] = {255, 255, 255, 192};
    int maxHost, i;
    returnMask(_rMask);
    if (validMask(mask)){
        printf("Masque invalide.");
        return 0;
    }
    printf("Ip: %d.%d.%d.%d", addr[0], addr[1], addr[2], addr[3]);
    getBit(addr);
    printf("Masque de sous-réseau: %d.%d.%d.%d", mask[0], mask[1], mask[2], mask[3]);
    getBit(mask);    
    printf("Masque de sous-réseau inversé: %d.%d.%d.%d", _rMask[0], _rMask[1], _rMask[2], _rMask[3]);
    getBit(_rMask);    
    for (i=0; i <= 3; i++){
        sAddr[i] = addr[i] & mask[i]; /* On &(AND) notre adresse ip par le masque */
    }
    printf("Adresse de sous-réseau: %d.%d.%d.%d", sAddr[0], sAddr[1], sAddr[2], sAddr[3]);
    getBit(sAddr);
    printf("Notation CIDR: %d.%d.%d.%d/%d\n", sAddr[0], sAddr[1], sAddr[2], sAddr[3], maskBit(mask));
    for (i=0; i <= 3; i++){
        bAddr[i] = sAddr[i] | _rMask[i]; /* On |(OR) notre adresse de sous-réseau par le masque inversé pour obtenir l'adresse de broadcast */
    }
    printf("Adresse de broadcast: %d.%d.%d.%d", bAddr[0], bAddr[1], bAddr[2], bAddr[3]);
    getBit(bAddr);    
    maxHost = pow(2, 32-maskBit(mask)) - 2; /* On calcule le nombre maximal d'host */
    printf("Le nombre d'hôte(s) possible du réseau: %d\n", maxHost);
    printf("Première machine: %d.%d.%d.%d / Dernière machine: %d.%d.%d.%d\n", sAddr[0], sAddr[1], sAddr[2], sAddr[3],bAddr[0], bAddr[1], bAddr[2], bAddr[3]);
        printf("OU\n");
        printf("Première machine: %d.%d.%d.%d / Dernière machine: %d.%d.%d.%d\n", sAddr[0] & mask[0], sAddr[1] & mask[1], sAddr[2] & mask[2], (sAddr[3] & mask[3]) + 1, bAddr[0], bAddr[1], bAddr[2], bAddr[3] - 1);
    return 0;
}
     
void returnMask(unsigned char *mask){
    int i;
    for (i=0; i <= 3; i++){
        mask[i] = ~mask[i]; /* On ~(NOT) les bits, on se retrouve donc avec le masque inversé */
    }
}
     
int maskBit(unsigned char *mask){
    int i, y, c = 0;
    for(i=0; i <= 3; i++){ /* Pour chaque octet */
        for(y=7; y >= 0; y--){ /* On parcours chaque bit */
            c += (mask[i] >> y) & 1; /* 00001100 & 00000001 = 0, avec le SHR on obtient la valeur de chaque bit. */
        }
    }
    return c;
}
     
int pow(int x, int y){
    int i, p = x;
    for(i=0; i < y - 1; i++){
        p *= x; /* On multiplie le nombre précédent par 2 */
    }
    return p; /* -2 pour l'adresse de sous-réseau réservée et l'adresse de broadcast */
}

int validMask(unsigned char *mask){
    int i, y, a = 0, c = 0, t = 0;
    for (i=0; i <= 3; i++){
        for (y=7; y >= 0; y--){
            c += (mask[i] >> y) & 1;
            if(((mask[i] >> y) & 1) && t == 0){ a += (mask[i] >> y) & 1; }
            else { t = 1; }
        }
    }
    if (c != a){ return 1; }
    else { return 0; }
   
}

char getBit(unsigned char *ip){
    int i, y, a = 0;
    printf(" (");
    for (i=0; i <= 3; i++){
        for (y=7; y >= 0; y--){
            printf("%d", (ip[i] >> y) & 1);
        }
        if (i < 3) { printf("."); }
    }
    printf(")\n");
}

Output:

Ip: 192.168.1.12 (11000000.10101000.00000001.00001100)
Masque de sous-réseau: 255.255.255.0 (11111111.11111111.11111111.00000000)
Masque de sous-réseau inversé: 0.0.0.255 (00000000.00000000.00000000.11111111)
Adresse de sous-réseau: 192.168.1.0 (11000000.10101000.00000001.00000000)
Notation CIDR: 192.168.1.0/24
Adresse de broadcast: 192.168.1.255 (11000000.10101000.00000001.11111111)
Le nombre d'hôte(s) possible du réseau: 254
Première machine: 192.168.1.0 / Dernière machine: 192.168.1.255
OU
Première machine: 192.168.1.1 / Dernière machine: 192.168.1.254

N'hésitez pas à donner votre avis as usual

PS: J'ai codé sur http://codepad.org/ d'où la fonction pow() que j'ai recodé, mais vous pouvez l'importer directement en foutant le préprocesseur #include <math.h> pour avoir la lib mathématique

EDIT:
- Ajout d'une fonction de vérification de la validité du masque.
- Ajout notation CIDR
- Ajout de la visualisation en binaire des IP affichés
- Ajout "Première machine:ernière machine"
- Ajout de la seconde notation de "Première machine:ernière machine"

[Loup]

Juste une question,
J'ai pas à compris à quoi servait

Code :

returnMask(_rMask);

Pourquoi donner l'inverse du masque sous-réseau?

[b0fh]

Chouettos.

Petite remarque: c'est extrêmement traitre de faire le -2 a l'intérieur de la fonction pow(). Quand on lit le code, on se dit que ça calcule la puissance et c'est tout... si un jour un mec doit maintenir du code écrit comme ça, il risque bien de te maudire

[crown]

Juste une question,
J'ai pas à compris à quoi servait

Code :

returnMask(_rMask);

Pourquoi donner l'inverse du masque sous-réseau?

Pour ensuite faire un OR logique entre l'adresse de sous-réseau et le masque inversé ce qui donnera l'addr de broadcast, enfin ce qui est expliqué par Reverse :

Code C :


bAddr[i] = sAddr[i] | _rMask[i]; /* On |(OR) notre adresse de sous-réseau par le masque inversé pour obtenir l'adresse de broadcast */
 

Après c'est sûr que l'afficher à l'écran n'a pas beaucoup de pertinence imo

@Reverse
Pas mal ce petit bout de code

[Kiwazaru]

On veut obtenir l'adresse de broadcast avec le retour de cette fonction, et l'adresse de broadcast c'est (désolé j'ai pas réussi à faire le barre du haut pour inverse le nombre en LaTeX, si quelqu'un sait comment faire ça serait cool de me le dire :p) :
Adresse de Broadcast = B + ~M
B étant l'adresse de sous-réseau et ~M l'inverse de notre masque de sous-réseau de base.
Au final on fait ça pour faire un OR logique qui modifiera les bits non inclus dans le masque qui couvre les valeurs de l'adresse fixes.
Par exemple t'auras:
0000 0000 . 0000 0000 . 0000 0000 . 1111 1111 = ~M
1100 0000 . 1010 1000 . 0000 0000 . 0000 0000 = Adresse de sous-réseau

Les caractéristiques d'un OR logique c'est:
0 | 0 = 0
0 | 1 = 1
1 | 0 = 1
1 | 1 = 1

En ayant que des 0 dans le début du masque, on va donc éviter de modifier le début de l'adresse, et avec la fin du masque inversé, on va avoir une suite de 0 | 1 qui va nous renvoyer un 1. Avec ça on aura notre adresse de broadcast réservée (D'où notre calcul max d'hôtes 2^(32 - n) - 2 qui réserve une place pour notre adresse de broadcast étant l'adresse max, et notre adresse pour le sous-réseau étant normalement 0)
Voilà, en espérant avoir été assez clair :p

[Loup]

Merci pour tes explications ReVerSe

[0pc0deFR]

Le nombre d'hôte(s) possible du réseau: 254

Je dirais plutôt 253 car l'adresse 192.168.0.0 et l'adresse 192.168.0.255 ne sont pas utilisable.

[gruik]

ça tombe bien sur 8bits on peut coder 256 valeurs, moins les deux que tu cites 254 on est bon

edit: @ReVeRse j'en profite pour rajouter qu'une notation qu'on voit souvent c'est <IP>/<MASK> genre 192.168.53.18/24, 24 étant donc le nombre de bits du masque

[levur]

Pour le nombre de fois ou j'ai essayer de faire un tel programme bravo ReVeRse.
Manque plus que la classe, une partie ou tu saisie toi même l'@ip et tant qu'a faire le nombre de sous réseaux possible avec leur @ip ^^

[Kiwazaru]

J'ai fais ce code à la va vite, je vais sûrement ajouter des options oui, notamment la range d'ip possible genre: 192.168.x.x et la classe c'est une bonne idée aussi ouais thanks :p

[levur]

[ReVeRse]
J'ai fais ce code à la va vite
[ReVeRse]
me fais pas rager

Mais j'essaye également de mon coté (même si sa risque de prendre du tps )

[ark]

Pas mal ce petit bout de code :)
Petite suggestion, en plus des bonnes idées des autres, faire un prompt pour ask des ips avec netmask, et garder une listes de toutes les entrées pour ensuite définir lesquelles peuvent communiquer entre elles.

[Kiwazaru]

Updated

[notfound]

Première machine: 192.168.1.0 / Dernière machine: 192.168.1.255

Edit:

Après discussion avec l'autre gusse, on peut prétendre que .0 = 1ere @ et .255 = dernière.
C'est une "notation" à choisir ...
Au temps pour moi.

[Kiwazaru]

Après quelques recherches, certains calculateur incluent le .0 et le maximum, et d'autre non.
Je ne confirme donc pas que cette notation soit correcte !