Discussion :

[Lekno]

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 ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[Lekno]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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.

[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

[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...

[Lekno]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[souviron34]

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...

[Lekno]

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

[souviron34]

Moi je ferais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 );

[Lekno]

Moi je ferais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[souviron34]

Alors en gros en pseudo-code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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

[Lekno]

Je reviens vers vous, j'ai bien avancé

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)



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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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