Adresses IP – Bac théorique – Section informatique – 2013

Bac Info 31-12-25

154 0

Sujet (Algo et programmation - Bac 2013)

Etant donné un fichier texte nommé "F_IPV4.txt" contenant dans chaque ligne une adresse IPV4.

On se propose de vérifier la validité des adresses IPV4 stockées dans ce fichier, de déterminer la classe à laquelle appartient chacune des adresses valides, de les faire migrer vers le système IPV6 et de stocker dans un fichier d'enregistrements nommé "F JPV6.dat" chaque adresse IPV4 valide ainsi que la classe à laquelle elle appartient et son équivalent en IPV6.

Pour ce faire, on dispose des informations suivantes :

1- Une adresse IPV4 valide est codée sur quatre octets (32 bits) et représentée sous la forme W.X.Y.Z avec W, X, Y et Z sont quatre entiers naturels appartenant chacun à l'intervalle [0, 255] et séparés par le caractère "."

2- Pour vérifier la validité d'une adresse IPV4, le candidat est appelé uniquement à vérifier si W, X, Y et Z sont dans l'intervalle [0, 255].

3- Chaque adresse IPV4 valide appartient à une classe :

- Classe A, si la valeur du premier bit à gauche de la représentation en binaire de W est

- Classe B, si la valeur des deux premiers bits à gauche de la représentation en binaire de W est 10.

- Classe C, si la valeur des trois premiers bits à gauche de la représentation en binaire de W est 110.

- Classe D, si la valeur des quatre premiers bits à gauche de la représentation en binaire de W est 1110.

- Classe E, si la valeur des quatre premiers bits à gauche de la représentation en binaire de W est 1111.

4- Une adresse IPV6 est codée sur 16 octets (128 bits). Pour faire migrer une adresse IPV4 valide vers le système IPV6, on va s'intéresser uniquement au bloc de 32 bits dans l'adresse IPV6 qui représente la conversion en hexadécimal de l'adresse IPV4.

Pour ce faire, on convertit chacun des nombres W, X, Y et Z en hexadécimal, puis, les concaténer en insérant le caractère ":" au milieu du résultat obtenu.

Exemple

L'adresse 155.105.50.68 est valide et elle appartient à la classe B car la valeur des deux premiers bits à gauche de la représentation en binaire de 155 qui est 10011011 est 10.

L'équivalent du nombre décimal 155 en hexadécimal est 9B

L'équivalent du nombre décimal 105 en hexadécimal est 69

L'équivalent du nombre décimal 50 en hexadécimal est 32

L'équivalent du nombre décimal 69 en hexadécimal est 45

Donc, le bloc de 32 bits dans l'adresse IPV6 qui représente la conversion en hexadécimal de l'adresse IPV4 est 9B69:3245

Travail demandé

1. Analyser le problème en le décomposant en modules.

2. Analyser chacun des modules envisagés.

Solution Algorithmique

Dans cet algorithme, On va utiliser six fonctions et quatre procédures:

- la fonction saisie_nbr_adresses()

- la fonction verif_nombre()

- la procédure verif_adresse()

- la procédure saisie_adresse()

- la procédure remplir_fichier_ipv4()

- la fonction conversion_binaire()

- la fonction classe_ip()

- la fonction conversion_hexadecimal()

- la fonction conversion_ipv6()

- la procédure remplir_fichier_ipv6

Algorithme du programme Principal

Algorithme adresses_ip
Debut 
     n <- saisie_nbr_adresses()
     remplir_fichier_ipv4(n)
     remplir_fichier_ipv6(n)
Fin

Algorithme adresses_ip

Debut

n <- saisie_nbr_adresses()

remplir_fichier_ipv4(n)

remplir_fichier_ipv6(n)

Fin

Déclaration des objets

Objet	Type / Nature
n	entier

La fonction saisie_nbr_adresses

La fonction saisie_nbr_adresses() permet à l’utilisateur de saisir un entier strictement positif, tout en vérifiant la validité de la saisie.

Le programme demande à l’utilisateur d’entrer un nombre entier n.

Si n est inférieur ou égal à 0, la saisie est refusée.

Le programme redemande la saisie autant de fois que nécessaire jusqu’à ce que l’utilisateur fournisse un entier strictement positif.

Une fois la valeur correcte saisie, elle est retournée par la fonction.

Fonction saisie_anbr_adresses():entier   
    # Demande à l'utilisateur de saisir un entier n
    Ecrire('donner n tel que n > 0: ') 
    Lire(n)

    # Tant que n est inférieur ou égal à 0, on redemande la saisie
    # on redemande la saisie
    Tant que (n <= 0) faire
        Ecrire('donner n tel que n > 0:') 
        Lire(n)
    Fin tant que
    # Retourne la valeur correcte saisie
    retourner n 
Fin

Fonction saisie_anbr_adresses():entier

# Demande à l'utilisateur de saisir un entier n

Ecrire('donner n tel que n > 0: ')

Lire(n)

# Tant que n est inférieur ou égal à 0, on redemande la saisie

# on redemande la saisie

Tant que (n <= 0) faire

Ecrire('donner n tel que n > 0:')

Lire(n)

Fin tant que

# Retourne la valeur correcte saisie

retourner n

Fin

Déclaration des objets

Objet	Type / Nature
n	entier

La fonction verif_nombre

Ce programme définit une fonction verif_nombre(ch) qui vérifie si une chaîne de caractères ch représente un nombre entier valide compris entre 0 et 255.

Plus précisément, la fonction :

Vérifie la longueur de la chaîne
→ Elle doit contenir entre 1 et 3 caractères, ce qui correspond aux nombres de 0 à 255.

Vérifie que tous les caractères sont des chiffres ('0' à '9')
→ La boucle while parcourt la chaîne caractère par caractère pour s’assurer qu’il n’y a que des chiffres.

Convertit la chaîne en entier
→ Si tous les caractères sont numériques, la chaîne est transformée en entier avec int(ch).

Teste l’intervalle de validité
→ Le nombre doit être compris entre 0 et 255 inclus.

Valeur retournée :

Vrai → si ch est une chaîne numérique représentant un entier entre 0 et 255

Faux → dans tous les autres cas (lettres, symbole, nombre trop grand, chaîne vide, etc.)

Fonction verif_nombre(ch:chaine):booleen   
    # La longueur doit être entre 1 et 3 caractères
    Si 1 <= long(ch) <= 3 alors
        i <- 0
        # Vérification que tous les caractères sont des chiffres
        Tant que (i < long(ch) - 1) et ('0' <= ch[i] <= '9') faire
            i <- i + 1
        Fin tant que
        Si '0' <= ch[i] <= '9' alors
            # Conversion en entier et test de l'intervalle
            retourner 0 <= int(ch) <= 255
        Sinon
            retourner Faux
        Fin si
    Sinon
        retourner False
    Fin si 
Fin

Fonction verif_nombre(ch:chaine):booleen

# La longueur doit être entre 1 et 3 caractères

Si 1 <= long(ch) <= 3 alors

i <- 0

# Vérification que tous les caractères sont des chiffres

Tant que (i < long(ch) - 1) et ('0' <= ch[i] <= '9') faire

i <- i + 1

Fin tant que

Si '0' <= ch[i] <= '9' alors

# Conversion en entier et test de l'intervalle

retourner 0 <= int(ch) <= 255

Sinon

retourner Faux

Fin si

Sinon

retourner False

Fin si

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

La fonction verif_adresse

Ce programme commence la définition d’une fonction qui a pour objectif de vérifier la validité d’une adresse IPv4, c’est-à-dire une adresse du type : a.b.c.d où a, b, c et d sont des nombres compris entre 0 et 255.

Ce que fait précisément cette fonction :

1- vérifie que l’adresse contient 3 points

2- extrait les 4 octets

3- vérifie que chaque partie est un nombre entre 0 et 255, à l’aide d’une fonction comme verif_nombre

Fonction verif_adresse(ip:chaine):booleen   
    nbr_points <- 0

    # Comptage du nombre de points dans l'adresse
    Pour i de 0 à long(ip)-1 faire
        Si ip[i] == '.':
            nbr_points <- nbr_points + 1
        Fin si
    Fin pour
    # Une adresse IPv4 valide doit contenir exactement 3 points
    Si nbr_points = 3 alors
        # Extraction des quatre parties de l'adresse
        w <- Sous_chaine(ip , 0, Pos(ip,'.')
        ip <- Effacer(ip, 0 , Pos(ip,'.'))

        x <- Sous_chaine(ip, 0 , Pos(ip,'.'))
        ip <- Effacer (ip , 0 , Pos(ip,'.') )

        y <- Sous_chaine(ip , 0 , Pos(ip,'.'))
        z <- Effacer (ip , 0 , Pos(ip, '.'))

        # Vérification de chaque partie
        retourner (verif_nombre(w) et verif_nombre(x) et verif_nombre(y) et verif_nombre(z))
    Sinon
        retourner Faux
    Finsi
Fin

Fonction verif_adresse(ip:chaine):booleen

nbr_points <- 0

# Comptage du nombre de points dans l'adresse

Pour i de 0 à long(ip)-1 faire

Si ip[i] == '.':

nbr_points <- nbr_points + 1

Fin si

Fin pour

# Une adresse IPv4 valide doit contenir exactement 3 points

Si nbr_points = 3 alors

# Extraction des quatre parties de l'adresse

w <- Sous_chaine(ip , 0, Pos(ip,'.')

ip <- Effacer(ip, 0 , Pos(ip,'.'))

x <- Sous_chaine(ip, 0 , Pos(ip,'.'))

ip <- Effacer (ip , 0 , Pos(ip,'.') )

y <- Sous_chaine(ip , 0 , Pos(ip,'.'))

z <- Effacer (ip , 0 , Pos(ip, '.'))

# Vérification de chaque partie

retourner (verif_nombre(w) et verif_nombre(x) et verif_nombre(y) et verif_nombre(z))

Sinon

retourner Faux

Finsi

Fin

Déclaration des objets

Objet	Type / Nature
w	chaîne
x	chaîne
y	chaîne
z	chaîne

La fonction saisie_adresse

Ce programme définit la fonction saisie_adresse() qui permet à l’utilisateur de saisir une adresse IPv4 valide, en contrôlant la saisie jusqu’à ce qu’elle soit correcte.

Cette fonction :

- demande une première saisie

- vérifie la validité de l’adresse

- redemande la saisie tant que l’adresse est invalide

- retourne l’adresse valide

Fonction saisie_adresse():chaine  
    # Première saisie de l'adresse IP
    Ecrire('donner une adresse IPV4: ')
    Lire(ip)

    # Tant que l'adresse n'est pas valide, on redemande la saisie
    Tant que verif_adresse(ip) = Faux faire
        Ecrire('donner une adresse IPV4: ') 
        Lire(ip) 
    Fin tant que
    # Retourne l'adresse IPv4 valide
    retourner ip 
Fin

Fonction saisie_adresse():chaine

# Première saisie de l'adresse IP

Ecrire('donner une adresse IPV4: ')

Lire(ip)

# Tant que l'adresse n'est pas valide, on redemande la saisie

Tant que verif_adresse(ip) = Faux faire

Ecrire('donner une adresse IPV4: ')

Lire(ip)

Fin tant que

# Retourne l'adresse IPv4 valide

retourner ip

Fin

Déclaration des objets

Objet	Type / Nature
ip	chaîne

La procédure remplir_fichier_ipv4

Ce programme définit la procédure remplir_fichier_ipv4(n) dont le rôle est de créer (ou écraser) le fichier texte F_IP4.txt et d’y enregistrer n adresses IPv4 valides, saisies par l’utilisateur.

Cette procédure ouvre le fichier en mode écriture, saisit et écrit n adresses IPv4 valides.

Pour chaque itération :

1- l’utilisateur saisit une adresse IPv4

2- la fonction saisie_adresse() garantit qu’elle est valide

3- l’adresse est écrite dans le fichier, une par ligne

Enfin elle ferme le fichier

Procedure remplir_fichier_ipv4(n:entier)
    Ecrire('*** Remplir le fichier F_IP4.txt ***')
    # Ouverture du fichier en mode écriture
    Ouvrir( f , "F_IP4.txt" , "w")
    # Saisie et écriture de n adresses IPv4
    Pour i de 0 à n-1 faire
        ip <- saisie_adresse()
        Ecrire(f, ip , '\n')
    Fin tant que
    # Fermeture du fichier
    Fermer(f)
Fin

Procedure remplir_fichier_ipv4(n:entier)

Ecrire('*** Remplir le fichier F_IP4.txt ***')

# Ouverture du fichier en mode écriture

Ouvrir( f , "F_IP4.txt" , "w")

# Saisie et écriture de n adresses IPv4

Pour i de 0 à n-1 faire

ip <- saisie_adresse()

Ecrire(f, ip , '\n')

Fin tant que

# Fermeture du fichier

Fermer(f)

Fin

Déclaration des objets

Objet	Type / Nature
f	fichier
i	entier
ip	chaîne

La fonction conversion_binaire

Cette fonction a pour rôle de transformer un nombre entier décimal en sa représentation binaire sur 8 bits (un octet).

Elle prend en entrée un nombre entier décimal.

Elle calcule sa forme binaire en effectuant des divisions successives par 2.

Elle ajoute des zéros à gauche si nécessaire afin d’obtenir exactement 8 bits.

Elle retourne le résultat sous forme de chaîne de caractères binaire.

Fonction conversion_binaire(n:entier): chaine
    binaire <- ""
    # Conversion par divisions successives par 2
    Tant que n > 0 faire
        binaire <- Convch(n mod 2) + binaire
        n = n div 2
    Fin tant que
    # Compléter à 8 bits
    Tant que long(binaire) < 8 faire
       binaire <- "0" + binaire
    Fin tant que
    retourner binaire
Fin

Fonction conversion_binaire(n:entier): chaine

binaire <- ""

# Conversion par divisions successives par 2

Tant que n > 0 faire

binaire <- Convch(n mod 2) + binaire

n = n div 2

Fin tant que

# Compléter à 8 bits

Tant que long(binaire) < 8 faire

binaire <- "0" + binaire

Fin tant que

retourner binaire

Fin

Déclaration des objets

Objet	Type / Nature
binaire	chaîne

La fonction classe_ip

Cette fonction classe_ip(ip) a pour rôle de déterminer la classe d’une adresse IPv4 (A, B, C, D ou E) à partir de son premier octet.

Elle extrait le premier nombre de l’adresse IPv4.

Elle convertit ce nombre en binaire sur 8 bits.

Elle analyse les bits de poids fort (les premiers bits à gauche).

Selon le motif binaire obtenu, elle identifie la classe de l’adresse IPv4.

Fonction classe_ip(ip:chaine):chaine
    # Extraction du premier octet
    w <- Sous_chaine(ip, 0 , Pos(ip,'.')]

    # Conversion en binaire
    binaire < conversion_binaire(Valeur(w))

    # Détermination de la classe selon les bits de poids fort
    Si Pos(binaire,'1111') = 0 alors
        retourner 'Classe E'
    Sinon Si Pos(binaire,'1110') = 0 alors
        retourner 'Classe D'
    Sinon Si Pos(binaire,'110') = 0 alors
        retourner 'Classe C'
    Sinon Si Pos(binaire,'10') = 0 alors
        retourner 'Classe B'
    Sinon Si Pos(binaire,'0') = 0 alors
        retourner 'Classe A'
    Fin si
Fin

Fonction classe_ip(ip:chaine):chaine

# Extraction du premier octet

w <- Sous_chaine(ip, 0 , Pos(ip,'.')]

# Conversion en binaire

binaire < conversion_binaire(Valeur(w))

# Détermination de la classe selon les bits de poids fort

Si Pos(binaire,'1111') = 0 alors

retourner 'Classe E'

Sinon Si Pos(binaire,'1110') = 0 alors

retourner 'Classe D'

Sinon Si Pos(binaire,'110') = 0 alors

retourner 'Classe C'

Sinon Si Pos(binaire,'10') = 0 alors

retourner 'Classe B'

Sinon Si Pos(binaire,'0') = 0 alors

retourner 'Classe A'

Fin si

Fin

Déclaration des objets

Objet	Type / Nature
w	chaîne
binaire	chaîne

La fonction onversion_hexadecimal

Cette fonction a pour rôle de convertir un nombre entier décimal en sa représentation hexadécimale.

Elle reçoit en entrée un nombre entier en base 10.

Elle effectue des divisions successives par 16.

À chaque étape, elle récupère le reste et l’associe au chiffre hexadécimal correspondant (de 0 à 9 puis de A à F).

Elle construit progressivement le nombre en base 16.

Elle retourne le résultat sous forme de chaîne de caractères hexadécimale.

Fonction onversion_hexadecimal(n:entier):chaine
    hexa <- ""
    chiffres <- "0123456789ABCDEF"

    Tant que n > 0 faire
        reste <- n mod 16
        hexa <- chiffres[reste] + hexa
        n <- n div 16
    Fin tant que
    retourner hexa 
Fin

Fonction onversion_hexadecimal(n:entier):chaine

hexa <- ""

chiffres <- "0123456789ABCDEF"

Tant que n > 0 faire

reste <- n mod 16

hexa <- chiffres[reste] + hexa

n <- n div 16

Fin tant que

retourner hexa

Fin

Déclaration des objets

Objet	Type / Nature
hexa	chaîne
reste	chaîne
chiffres	chaîne

La fonction conversion_ipv6

Cette fonction a pour rôle de convertir une adresse IPv4 en une forme IPv6 simplifiée, en utilisant une représentation hexadécimale des octets.

Elle prend en entrée une adresse IPv4 sous la forme a.b.c.d.

Elle sépare l’adresse en quatre octets décimaux.

Chaque octet est converti en hexadécimal.

Les octets sont regroupés deux par deux pour former deux blocs hexadécimaux.

Les deux blocs sont séparés par le caractère :.

Fonction conversion_ipv6(ip:chaine):chaine
    w <- conversion_hexadecimal(Valeur(Sous_chaine(ip , 0, Pos(ip,'.')) 
    ip <- Effacer(ip, 0 , Pos(ip,'.')] 
    x <- conversion_hexadecimal(Valeur(Sous_chaine(ip, 0 , Pos(ip,'.')))
    ip <- Effacer (ip , 0 , Pos(ip,'.') ] 
    y <- conversion_hexadecimal(Valeur(Sous_chaine(ip , 0 , Pos(ip,'.')))
    z <- conversion_hexadecimal(Valeur(Effacer (ip , 0 , Pos(ip, '.')))
    retourner w + x + ':' + y + z
Fin

Fonction conversion_ipv6(ip:chaine):chaine

w <- conversion_hexadecimal(Valeur(Sous_chaine(ip , 0, Pos(ip,'.'))

ip <- Effacer(ip, 0 , Pos(ip,'.')]

x <- conversion_hexadecimal(Valeur(Sous_chaine(ip, 0 , Pos(ip,'.')))

ip <- Effacer (ip , 0 , Pos(ip,'.') ]

y <- conversion_hexadecimal(Valeur(Sous_chaine(ip , 0 , Pos(ip,'.')))

z <- conversion_hexadecimal(Valeur(Effacer (ip , 0 , Pos(ip, '.')))

retourner w + x + ':' + y + z

Fin

Déclaration des objets

Objet	Type / Nature
w	chaîne
x	chaîne
y	chaîne
z	chaîne

La procédure remplir_fichier_ipv6

Cette procédure ouvre le fichier en mode écriture, saisit et écrit n adresses IPv4 valides.

Pour chaque itération :

1- l’utilisateur saisit une adresse IPv4

2- la fonction saisie_adresse() garantit qu’elle est valide

3- l’adresse est écrite dans le fichier, une par ligne

Enfin elle ferme le fichier

Procedure remplir_fichier_ipv6()
    Ecrire('*** Contenu du fichier F_IP6.txt ***')

    # Dictionnaire pour stocker un enregistrement
    enregistrement = Enregistrement(
        ipv4=chaine,
        classe_ip=chaine,
        ipv6=chaine
    )

    # Ouverture des fichiers
    Ouvrir(f_ipv4 , "F_IP4.txt", "r")
    Ouvrir(f_ipv6 , "F_IPV6.dat", "wb")
    # Lecture de toutes les adresses IPv4
    liste_ipv4 <- Lire_lignes(f_ipv4)
    Pour ipv4 dans liste_ipv4 faire
        ipv4 <- ipv4.strip('\n')
        # Remplissage de l'enregistrement
        enregistrement['ipv4'] <- ipv4
        enregistrement['classe_ip'] <- classe_ip(ipv4)
        enregistrement['ipv6'] <- conversion_ipv6(ipv4)
        # Affichage
        Ecrire(ipv4, enregistrement['classe_ip'], enregistrement['ipv6'])
        # Sauvegarde dans le fichier binaire
        Ecrire(f_ipv6,enregistrement)
Fin

Procedure remplir_fichier_ipv6()

Ecrire('*** Contenu du fichier F_IP6.txt ***')

# Dictionnaire pour stocker un enregistrement

enregistrement = Enregistrement(

ipv4=chaine,

classe_ip=chaine,

ipv6=chaine

)

# Ouverture des fichiers

Ouvrir(f_ipv4 , "F_IP4.txt", "r")

Ouvrir(f_ipv6 , "F_IPV6.dat", "wb")

# Lecture de toutes les adresses IPv4

liste_ipv4 <- Lire_lignes(f_ipv4)

Pour ipv4 dans liste_ipv4 faire

ipv4 <- ipv4.strip('\n')

# Remplissage de l'enregistrement

enregistrement['ipv4'] <- ipv4

enregistrement['classe_ip'] <- classe_ip(ipv4)

enregistrement['ipv6'] <- conversion_ipv6(ipv4)

# Affichage

Ecrire(ipv4, enregistrement['classe_ip'], enregistrement['ipv6'])

# Sauvegarde dans le fichier binaire

Ecrire(f_ipv6,enregistrement)

Fin

Déclaration des objets

Objet	Type / Nature
enregistrement	Enregistrement
f_ipv4	fichier
f_ipv6	fichier
liste_ipv4	entier
ipv4	entier

Solution en Python

import pickle
from pickle import load, dump

# --------------------------------------------------
# Fonction qui permet de saisir un entier strictement positif
# (nombre d'adresses IPv4 à enregistrer)
# --------------------------------------------------
def saisie_nbr_adresses():
    # Première saisie de l'entier n
    n = int(input('donner n tel que n > 0: '))

    # Tant que n est inférieur ou égal à 0, on redemande la saisie
    while n <= 0:
        n = int(input('donner n tel que n > 0: '))

    # Retourne la valeur valide de n
    return n


# --------------------------------------------------
# Fonction qui vérifie si une chaîne représente
# un nombre compris entre 0 et 255
# --------------------------------------------------
def verif_nombre(ch):
    # La longueur doit être entre 1 et 3 caractères
    if 1 <= len(ch) <= 3:
        i = 0

        # Vérification que tous les caractères sont des chiffres
        while (i < len(ch) - 1) and ('0' <= ch[i] <= '9'):
            i = i + 1

        if '0' <= ch[i] <= '9':
            # Conversion en entier et test de l'intervalle
            return 0 <= int(ch) <= 255
        else:
            return False
    else:
        return False


# --------------------------------------------------
# Fonction qui vérifie la validité d'une adresse IPv4
# --------------------------------------------------
def verif_adresse(ip):
    nbr_points = 0

    # Comptage du nombre de points dans l'adresse
    for i in range(len(ip)):
        if ip[i] == '.':
            nbr_points = nbr_points + 1

    # Une adresse IPv4 valide doit contenir exactement 3 points
    if nbr_points == 3:
        # Extraction des quatre parties de l'adresse
        w = ip[0:ip.find('.')]
        ip = ip[ip.find('.') + 1:]

        x = ip[0:ip.find('.')]
        ip = ip[ip.find('.') + 1:]

        y = ip[0:ip.find('.')]
        z = ip[ip.find('.') + 1:]

        # Vérification de chaque partie
        return (verif_nombre(w) and verif_nombre(x)
                and verif_nombre(y) and verif_nombre(z))
    else:
        return False


# --------------------------------------------------
# Fonction qui permet de saisir une adresse IPv4 valide
# --------------------------------------------------
def saisie_adresse():
    # Première saisie de l'adresse IP
    ip = input('donner une adresse IPV4: ')

    # Tant que l'adresse n'est pas valide, on redemande la saisie
    while verif_adresse(ip) == False:
        ip = input('donner une adresse IPV4: ')

    # Retourne l'adresse IPv4 valide
    return ip


# --------------------------------------------------
# Procédure qui remplit le fichier texte F_IP4.txt
# avec n adresses IPv4 valides
# --------------------------------------------------
def remplir_fichier_ipv4(n):
    print('*** Remplir le fichier F_IP4.txt ***')

    # Ouverture du fichier en mode écriture
    f = open("F_IP4.txt", "w")

    # Saisie et écriture de n adresses IPv4
    for i in range(n):
        ip = saisie_adresse()
        f.write(ip + '\n')

    # Fermeture du fichier
    f.close()


# --------------------------------------------------
# Fonction qui convertit un nombre décimal en binaire
# sur 8 bits (octet)
# --------------------------------------------------
def conversion_binaire(n):
    binaire = ""

    # Conversion décimale → binaire
    while n > 0:
        binaire = str(n % 2) + binaire
        n = n // 2

    # Compléter à 8 bits
    while len(binaire) < 8:
        binaire = "0" + binaire

    return binaire


# --------------------------------------------------
# Fonction qui détermine la classe d'une adresse IPv4
# (A, B, C, D ou E)
# --------------------------------------------------
def classe_ip(ip):
    # Extraction du premier octet
    w = ip[0:ip.find('.')]

    # Conversion en binaire
    binaire = conversion_binaire(int(w))

    # Détermination de la classe selon les bits de poids fort
    if binaire.find('1111') == 0:
        return 'Classe E'
    elif binaire.find('1110') == 0:
        return 'Classe D'
    elif binaire.find('110') == 0:
        return 'Classe C'
    elif binaire.find('10') == 0:
        return 'Classe B'
    elif binaire.find('0') == 0:
        return 'Classe A'


# --------------------------------------------------
# Fonction qui convertit un nombre décimal en hexadécimal
# --------------------------------------------------
def conversion_hexadecimal(n):
    hexa = ""
    chiffres = "0123456789ABCDEF"

    while n > 0:
        reste = n % 16
        hexa = chiffres[reste] + hexa
        n = n // 16

    return hexa


# --------------------------------------------------
# Fonction qui convertit une adresse IPv4 en IPv6 simplifiée
# --------------------------------------------------
def conversion_ipv6(ip):
    w = conversion_hexadecimal(int(ip[0:ip.find('.')]))
    ip = ip[ip.find('.') + 1:]

    x = conversion_hexadecimal(int(ip[0:ip.find('.')]))
    ip = ip[ip.find('.') + 1:]

    y = conversion_hexadecimal(int(ip[0:ip.find('.')]))
    z = conversion_hexadecimal(int(ip[ip.find('.') + 1:]))

    return w + x + ':' + y + z


# --------------------------------------------------
# Procédure qui crée le fichier binaire F_IPV6.dat
# contenant les informations IPv4, classe et IPv6
# --------------------------------------------------
def remplir_fichier_ipv6(n):
    print('*** Contenu du fichier F_IP6.txt ***')

    # Dictionnaire pour stocker un enregistrement
    enregistrement = dict(
        ipv4=str(),
        classe_ip=str(),
        ipv6=str()
    )

    # Ouverture des fichiers
    f_ipv4 = open("F_IP4.txt", "r")
    f_ipv6 = open("F_IPV6.dat", "wb")

    # Lecture de toutes les adresses IPv4
    liste_ipv4 = f_ipv4.readlines()

    for ipv4 in liste_ipv4:
        ipv4 = ipv4.strip('\n')

        # Remplissage de l'enregistrement
        enregistrement['ipv4'] = ipv4
        enregistrement['classe_ip'] = classe_ip(ipv4)
        enregistrement['ipv6'] = conversion_ipv6(ipv4)

        # Affichage
        print(ipv4, enregistrement['classe_ip'], enregistrement['ipv6'])

        # Sauvegarde dans le fichier binaire
        dump(enregistrement, f_ipv6)


# --------------------------------------------------
# Programme principal
# --------------------------------------------------
n = saisie_nbr_adresses()
remplir_fichier_ipv4(n)
remplir_fichier_ipv6(n)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

import pickle

from pickle import load, dump

# --------------------------------------------------

# Fonction qui permet de saisir un entier strictement positif

# (nombre d'adresses IPv4 à enregistrer)

# --------------------------------------------------

def saisie_nbr_adresses():

# Première saisie de l'entier n

n = int(input('donner n tel que n > 0: '))

# Tant que n est inférieur ou égal à 0, on redemande la saisie

while n <= 0:

n = int(input('donner n tel que n > 0: '))

# Retourne la valeur valide de n

return n

# --------------------------------------------------

# Fonction qui vérifie si une chaîne représente

# un nombre compris entre 0 et 255

# --------------------------------------------------

def verif_nombre(ch):

# La longueur doit être entre 1 et 3 caractères

if 1 <= len(ch) <= 3:

i = 0

# Vérification que tous les caractères sont des chiffres

while (i < len(ch) - 1) and ('0' <= ch[i] <= '9'):

i = i + 1

if '0' <= ch[i] <= '9':

# Conversion en entier et test de l'intervalle

return 0 <= int(ch) <= 255

else:

return False

else:

return False

# --------------------------------------------------

# Fonction qui vérifie la validité d'une adresse IPv4

# --------------------------------------------------

def verif_adresse(ip):

nbr_points = 0

# Comptage du nombre de points dans l'adresse

for i in range(len(ip)):

if ip[i] == '.':

nbr_points = nbr_points + 1

# Une adresse IPv4 valide doit contenir exactement 3 points

if nbr_points == 3:

# Extraction des quatre parties de l'adresse

w = ip[0:ip.find('.')]

ip = ip[ip.find('.') + 1:]

x = ip[0:ip.find('.')]

ip = ip[ip.find('.') + 1:]

y = ip[0:ip.find('.')]

z = ip[ip.find('.') + 1:]

# Vérification de chaque partie

return (verif_nombre(w) and verif_nombre(x)

and verif_nombre(y) and verif_nombre(z))

else:

return False

# --------------------------------------------------

# Fonction qui permet de saisir une adresse IPv4 valide

# --------------------------------------------------

def saisie_adresse():

# Première saisie de l'adresse IP

ip = input('donner une adresse IPV4: ')

# Tant que l'adresse n'est pas valide, on redemande la saisie

while verif_adresse(ip) == False:

ip = input('donner une adresse IPV4: ')

# Retourne l'adresse IPv4 valide

return ip

# --------------------------------------------------

# Procédure qui remplit le fichier texte F_IP4.txt

# avec n adresses IPv4 valides

# --------------------------------------------------

def remplir_fichier_ipv4(n):

print('*** Remplir le fichier F_IP4.txt ***')

# Ouverture du fichier en mode écriture

f = open("F_IP4.txt", "w")

# Saisie et écriture de n adresses IPv4

for i in range(n):

ip = saisie_adresse()

f.write(ip + '\n')

# Fermeture du fichier

f.close()

# --------------------------------------------------

# Fonction qui convertit un nombre décimal en binaire

# sur 8 bits (octet)

# --------------------------------------------------

def conversion_binaire(n):

binaire = ""

# Conversion décimale → binaire

while n > 0:

binaire = str(n % 2) + binaire

n = n // 2

# Compléter à 8 bits

while len(binaire) < 8:

binaire = "0" + binaire

return binaire

# --------------------------------------------------

# Fonction qui détermine la classe d'une adresse IPv4

# (A, B, C, D ou E)

# --------------------------------------------------

def classe_ip(ip):

# Extraction du premier octet

w = ip[0:ip.find('.')]

# Conversion en binaire

binaire = conversion_binaire(int(w))

# Détermination de la classe selon les bits de poids fort

if binaire.find('1111') == 0:

return 'Classe E'

elif binaire.find('1110') == 0:

return 'Classe D'

elif binaire.find('110') == 0:

return 'Classe C'

elif binaire.find('10') == 0:

return 'Classe B'

elif binaire.find('0') == 0:

return 'Classe A'

# --------------------------------------------------

# Fonction qui convertit un nombre décimal en hexadécimal

# --------------------------------------------------

def conversion_hexadecimal(n):

hexa = ""

chiffres = "0123456789ABCDEF"

while n > 0:

reste = n % 16

hexa = chiffres[reste] + hexa

n = n // 16

return hexa

# --------------------------------------------------

# Fonction qui convertit une adresse IPv4 en IPv6 simplifiée

# --------------------------------------------------

def conversion_ipv6(ip):

w = conversion_hexadecimal(int(ip[0:ip.find('.')]))

ip = ip[ip.find('.') + 1:]

x = conversion_hexadecimal(int(ip[0:ip.find('.')]))

ip = ip[ip.find('.') + 1:]

y = conversion_hexadecimal(int(ip[0:ip.find('.')]))

z = conversion_hexadecimal(int(ip[ip.find('.') + 1:]))

return w + x + ':' + y + z

# --------------------------------------------------

# Procédure qui crée le fichier binaire F_IPV6.dat

# contenant les informations IPv4, classe et IPv6

# --------------------------------------------------

def remplir_fichier_ipv6(n):

print('*** Contenu du fichier F_IP6.txt ***')

# Dictionnaire pour stocker un enregistrement

enregistrement = dict(

ipv4=str(),

classe_ip=str(),

ipv6=str()

)

# Ouverture des fichiers

f_ipv4 = open("F_IP4.txt", "r")

f_ipv6 = open("F_IPV6.dat", "wb")

# Lecture de toutes les adresses IPv4

liste_ipv4 = f_ipv4.readlines()

for ipv4 in liste_ipv4:

ipv4 = ipv4.strip('\n')

# Remplissage de l'enregistrement

enregistrement['ipv4'] = ipv4

enregistrement['classe_ip'] = classe_ip(ipv4)

enregistrement['ipv6'] = conversion_ipv6(ipv4)

# Affichage

print(ipv4, enregistrement['classe_ip'], enregistrement['ipv6'])

# Sauvegarde dans le fichier binaire

dump(enregistrement, f_ipv6)

# --------------------------------------------------

# Programme principal

# --------------------------------------------------

n = saisie_nbr_adresses()

remplir_fichier_ipv4(n)

remplir_fichier_ipv6(n)

Exécution du programme

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Créer une horloge numérique avec la carte ESP32 et le module RTC DS1302

ESP32 17-02-26

Réaliser une horloge numérique avec Micro:bit et RTC DS1302

Micro:bit 15-02-26

Calculatrice commandée par la carte Arduino UNO

Arduino 14-02-26

Calculatrice commandée par la carte ESP32

ESP32 12-02-26

Réaliser une calculatrice commandée par la carte Micro:bit

Micro:bit 10-02-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 11396vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 10991vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 9655vues

Allumer une LED par la carte ESP32

ESP32 9269vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino 9262vues

Construction des robots

Tutoriels plus commentés

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 28 commentaires

Premiers pas avec Micro:bit et MakeCode

Micro:bit 26 commentaires

Présentation du module capteur de lumière à LDR

Composants 20 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino 17 commentaires

Echange des messages entre deux cartes Micro:bit via radio

Micro:bit 14 commentaires

Adresses IP – Bac théorique – Section informatique – 2013

Sujet (Algo et programmation - Bac 2013)

Solution Algorithmique

Algorithme du programme Principal

La fonction saisie_nbr_adresses

La fonction verif_nombre

La fonction verif_adresse

La fonction saisie_adresse

La procédure remplir_fichier_ipv4

La fonction conversion_binaire

La fonction classe_ip

La fonction onversion_hexadecimal

La fonction conversion_ipv6

La procédure remplir_fichier_ipv6

Solution en Python

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles