Découper en octet une adresse ip

Version imprimable

Bonjour à tous,

je souhaite mettre en place une fonction qui doit me découper à chaque octet mon adresse de façon à me retrouver avec ceci

IP = 192.168.1.0

tableau[0] => 192
tableau[1] => 168
tableau[2] => 0
tableau[3] => 1

Actuellement j'ai fais ceci, sauriez vous me dire si mon algo est correct ?:ccool:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Fonction decoupage_chaine ( ip_reseau : Chaîne ) : Entier Variable longeur_chaine , i , j , compteur_nombres : Entier Variable tableau_bloc_octet : Chaîne [ 12 ] Variable caractere_courant : Chaîne Début | j <- 0 | longeur_chaine <- LgChaîne ( ip_reseau ) | Pour i <- 1 à longeur_chaine Faire | | caractere_courant <- SousChaîne ( ip_reseau , i , 1 ) | | Si caractere_courant <> "." | | | j <- j + 1 | | FinSi | | Si caractere_courant = "." | | | tableau_bloc_octet [ i ] <- SousChaîne ( ip_reseau , j , i ) | | | Afficher ( tableau_bloc_octet [ i ] ) | | FinSi | | | FinPour Fin
Si non, que ferriez vous pour l'améliorer ?
Merci par avance ! ;)

J'ai modifié mon algo afin de sortir convenablement mes blocs d'octets, mon seul soucis est que la fonction DébutChaine me tronque mon premier bloc d'octets

Sauriez vous m'indiquer une potentielle solution à ce problème ?:?

Avec l'algo ci-dessous j'obtiens en sortie, j'ai mon deuxième bloc d'octets qui est tronqué :

Code:

1
2
3
 
Debut chaine :4 ->192
FinChaine N :4 ->1.0

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
Variable ip_reseau : Chaîne
Variable rez : Entier
 
Début
  |  ip_reseau <- "192.168.1.0"
  |  rez <- decoupage_chaine ( ip_reseau )
Fin
 
 
Fonction decoupage_chaine ( ip_reseau : Chaîne ) : Entier
Variable longeur_chaine , i , compteur : Entier
Variable caractere_courant , debut_chaine , fin_chaine , octet : Chaîne
Variable tableau_octets : Chaîne [ 99 ]
Début
  |  compteur <- 0
  |  longeur_chaine <- LgChaîne ( ip_reseau )
  |  Pour i <- 1 à longeur_chaine Faire
  |    |  caractere_courant <- SousChaîne ( ip_reseau , i , 1 )
  |    |  Si caractere_courant <> "."
  |    |    |  compteur <- compteur + 1
  |    |  FinSi
  |    |  Si caractere_courant = "."
  |    |    |  octet <- DébutChaîne ( ip_reseau , compteur )
  |    |    |  Afficher ( "Debut chaine :" & i & " ->" & octet )
  |    |    |  ip_reseau <- FinChaîne ( ip_reseau , compteur )
  |    |    |  Afficher ( "FinChaine N :" & i & " ->" & ip_reseau )
  |    |    |  compteur <- 0
  |    |  FinSi
  |  FinPour
Fin

08/01/2014, 14h36
bertry

Salut,

Ne peux-tu pas tout simplement utiliser les fonctions sur les chaine déjà présentes dans de nombreux languages? Queque chose comme: maChaine.split(".")
Si tu souhaite coder ta propre fonction decoupage_chaine, alors utilise split pour vérifier que les retours de ta fonction sont corrects.
10/01/2014, 10h57
Lekno

Il n'existe pas à ma connaissance de fonction split en algorithmique, je dois faire cette algo en langage algorithmique c'est pour ca que j'ai quelques difficultées :(
11/01/2014, 15h24
souviron34

Alors tu fais une fonction "Cherche-Caractère".

Tu chercheras soit le point soit la fin de chaine. Tu stockeras l'adresse où tu es au départ, et celle du caractère (-1). Et tu auras une fonction "Lit-Chaine" qui ressortira un entier..

En C, l'équivalent est via strtok et sscanf...

J'ai essayé d'appliquer l'idée que tu m'as donné. Le problème est que je ne peux retourner qu'un seul argument dans une fonction algoritmique :?

Je retourne donc bien mon octet, mais comment mettre à jour mon adresse ip pour signifier que le premier bloc d'octets est traité ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
 
Variable ip_reseau , ip_octet1 : Chaîne
Variable rez : Entier
 
Début
  |  ip_reseau <- "188.168.10.0"
  |  ip_octet1 <- octet_1 ( ip_reseau )
  |  Afficher ( ip_octet1 )
Fin
 
 
Fonction octet_1 ( ip_reseau : Chaîne ) : Chaîne
Variable longeur_chaine , i , compteur , longeur_octet : Entier
Variable caractere_courant , octet : Chaîne
Début
  |  compteur <- 0
  |  longeur_chaine <- LgChaîne ( ip_reseau )
  |  i <- 0
  |  TantQue i < longeur_chaine Faire
  |    |  caractere_courant <- SousChaîne ( ip_reseau , i , 1 )
  |    |  Si caractere_courant = "."
  |    |    |  octet <- DébutChaîne ( ip_reseau , i - 1 )
  |    |    |  longeur_octet <- LgChaîne ( octet )
  |    |    |  ip_reseau <- FinChaîne ( ip_reseau , longeur_chaine - longeur_octet )
  |    |    |  i <- longeur_chaine
  |    |  FinSi
  |    |  i <- i + 1
  |  FinTantQue
  |  Retourner ( octet )
Fin

13/01/2014, 11h23
souviron34

Citation:

Envoyé par Lekno

mais comment mettre à jour mon adresse ip pour signifier que le premier bloc d'octets est traité ?

En passant l'adresse de la chaine et non pas le pointeur ;)

Donc un pointeur modifiable (et modifié) dans ta fonction...
13/01/2014, 11h45
Lekno

Citation:

Envoyé par souviron34

En passant l'adresse de la chaine et non pas le pointeur ;)

Donc un pointeur modifiable (et modifié) dans ta fonction...

Je n'ai pas compris ta réponse :?
13/01/2014, 11h55
souviron34
Moi je ferais :

Code:

Fonction octet ( ip_reseau : pointeur sur Chaîne ) : entier

Au départ, l'adresse de la chaine est l'adresse du buffer dans lequel tu as stocké ton adresse en caractères.

Tu cherches le caractère de fin, tu lis l'entier, et tu ressorts la position du caractère de fin + 1 (et tu renvoies la valeur décimale de ce que tu as lu) ..

ça donnerais en code :
Code:

1 2 3 4 5 6 7 8 9 10 char chaine[16], *p ; int ip[4], i ; ..... /* on lit la chaine */ p = chaine ; for ( i = 0 ; i < 4 ; i++ ) ip[i] = octet ( &p );
13/01/2014, 12h04
Lekno
Citation:
Envoyé par souviron34

Moi je ferais :

Code:

Fonction octet ( ip_reseau : pointeur sur Chaîne ) : entier

Au départ, l'adresse de la chaine est l'adresse du buffer dans lequel tu as stocké ton adresse en caractères.

Tu cherches le caractère de fin, tu lis l'entier, et tu ressorts la position du caractère de fin + 1 (et tu renvoies la valeur décimale de ce que tu as lu) ..

ça donnerais en code :

Code:

1 2 3 4 5 6 7 8 9 10 char chaine[16], *p ; int ip[4], i ; ..... /* on lit la chaine */ p = chaine ; for ( i = 0 ; i < 4 ; i++ ) ip[i] = octet ( &p );
Il doit me manquer quelques bases, je ne connais pas "*p", "&p". Je suis verrouillé par un proxy (pas d'accès google) je ne peux donc pas faire de recherche

Alors en gros en pseudo-code :

Code:

Fonction octet ( ip_reseau : adresse de Chaîne ) : Chaîne (modifiable)

Code:

1
2
3
4
5
6
7
  |    |  Si caractere_courant = "."
  |    |    |  octet <- DébutChaîne ( ip_reseau , i - 1 )
  |    |    |  longeur_octet <- LgChaîne ( octet )
  |    |    |  ip_reseau <- FinChaîne ( ip_reseau , longeur_chaine - longeur_octet )
  |    |    |  i <- longeur_chaine
  |    |    |  adresse de chaine <- adresse de chaine - i
  |    |  FinSi

13/01/2014, 15h48
Lekno

Je te remercie pour ton explication pour être plus pratique je vais passer par 4 demandes de bloc d'octets, cela me complique beaucoup moins la tâche.

J'ai bien essayé d'adapter ton code mais je bloque sur le traitement par la suite :lol:

Je reviens vers vous, j'ai bien avancé :ccool:

J'ai cependant un soucis sur ma dernière étape de calcul, je dois lister les sous-réseau obtenu.

A ce stade dans mon algorithme je retourne le nombres de bits sur lequel on va calculer nos sous réseau ainsi que le nouveaux masque, ainsi que le nombres d'hôtes par sous réseau.

helas je ne trouve pas de solution pour ressortir, la liste de mes sous réseau comme présenté sur le screen ci-dessous (ceci doit être mon résultat en sortie)

http://s21.postimg.org/45wbmaeqv/algo_sous_reseau.jpg

J'ai tenté via cette fonction, elle ne fonctione pas dans tout les cas (suivant la classe d'adresse)

Merci par avance à ceux qui sauront m'indiquer une piste :ccool:

EDIT

J'ai mis à jour mon algo, cela fonctionne je retourne bien mon nouveau masque de sous réseau, mais je sèche sur la façon de retourner mes sous réseau :roll:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 ' calcul des sous reseau Fonction calcul_ss_reseaux ( classe : Chaîne ; NbReseau : Entier ) : Chaîne Variable puissance , i , j , octets , octets_totale : Entier i <- 0 puissance <- 0 Début | Afficher ( classe & NbReseau ) | TantQue puissance < NbReseau Faire | | puissance <- 2 ^ i | | i <- i + 1 | FinTantQue | Afficher ( "************************************************************************" ) | Afficher ( "Le coefficient vaut " & puissance & " (Nb d'hôtes par sous réseau)" ) | Afficher ( "On va travailler sur " & i & " bits" ) | | j <- 1 | octets <- 0 | octets_totale <- 0 | Si classe = "C" Alors | | octets <- 255 | | TantQue j < i Faire | | | octets <- octets / 2 | | | octets_totale <- octets_totale + octets | | | j <- j + 1 | | FinTantQue | | Afficher ( "Le nouveau masque vaut :255.255.255." & octets_totale ) | FinSi | | Si classe = "B" Alors | | octets <- 255 | | TantQue j < i Faire | | | octets <- octets / 2 | | | octets_totale <- octets_totale + octets | | | j <- j + 1 | | FinTantQue | | Afficher ( "Le nouveau masque vaut : 255.255." & octets_totale & ".0" ) | FinSi | | Si classe = "A" Alors | | octets <- 255 | | TantQue j < i Faire | | | octets <- octets / 2 | | | octets_totale <- octets_totale + octets | | | j <- j + 1 | | FinTantQue | | Afficher ( "Le nouveau masque vaut : 255." & octets_totale & ".0.0" ) | FinSi | Afficher ( "************************************************************************" ) Fin