Explication de convertisseur de cidr pour le masque de réseau sous linux shell netmask2cdir et cdir2netmask

J'ai trouvé le shell suivante des fonctions à partir de ce sujet

mask2cdr ()
{
   # Assumes there's no "255." after a non-255 byte in the mask
   local x=${1##*255.}
   set -- 0^^^128^192^224^240^248^252^254^ $(( (${#1} - ${#x})*2 )) ${x%%.*}
   x=${1%%$3*}
   echo $(( $2 + (${#x}/4) ))
}


cdr2mask ()
{
   # Number of args to shift, 255..255, first non-255 byte, zeroes
   set -- $(( 5 - ($1 / 8) )) 255 255 255 255 $(( (255 << (8 - ($1 % 8))) & 255 )) 0 0 0
   [ $1 -gt 1 ] && shift $1 || shift
   echo ${1-0}.${2-0}.${3-0}.${4-0}
}

Pourriez-vous expliquer en détails comment ces fonctions convertissent cidr pour le masque de réseau et le masque de réseau pour cidr? Plus précisément, les appels à set, le paramètre d'expansion ${#…}, et l'expansion arithmétique $((…)) sont assez écrasante.

De toute partie, ou avez-vous juste de ne pas comprendre une partie de la création de scripts shell?
l'ensemble du code n'est pas clair pour moi
Je ne sais pas pourquoi vous avez fermé à cette question, mais c'est une bonne question et la réponse est wonerful
Je ne sais pas pourquoi vous avez fermé à cette question, mais c'est une bonne question et la réponse est wonerful
ne sais pas pourquoi vous avez fermé à cette question, mais c'est une bonne question et la réponse est wonerful

OriginalL'auteur MOHAMED | 2013-12-24

bash linux sh shell

27

mask2cdr()

Pour obtenir le CIDR préfixe à partir d'un point-virgule masque de réseau comme celui-ci:
```
255.255.192.0
```
vous devez d'abord convertir les quatre octets en binaire puis de compter les bits les plus significatifs (c'est à dire le nombre de meneurs):
```
11111111.11111111.11000000.00000000  # 18 ones = /18 in CIDR
```
Cette fonction ne fait que plutôt de façon créative. Tout d'abord, nous dépouiller tous les 255 octets (c'est à dire les octets qui sont toutes en binaire) et de stocker les résultats dans une variable x:
```
local x=${1##*255.}
```
Cette étape utilise paramètre d'extension, le script s'appuie sur assez fortement. Si nous continuons avec notre exemple, le masque de réseau de 255.255.192.0, maintenant, nous avons les valeurs suivantes:
```
$1: 255.255.192.0
$x: 192.0
```
Ensuite, nous avons défini trois variables: $1, $2, et $3. Ceux-ci sont appelés les paramètres positionnels; ils sont plus comme de simples variables nommées, mais sont généralement défini lorsque vous passez des arguments d'un script ou d'une fonction. Nous pouvons définir les valeurs directement à l'aide de set --, par exemple:
```
set -- foo bar  # $1 = foo, $2 = bar
```
Je préfère utiliser des variables nommées sur les paramètres positionnels, car cela fait des scripts plus facile à lire et à déboguer, mais le résultat final est le même. Nous avons mis $1:
```
0^^^128^192^224^240^248^252^254^
```
C'est vraiment juste une table pour convertir certaines valeurs décimales en binaire et le nombre de 1 bits. Nous y reviendrons plus tard.

Nous avons mis $2 à
```
$(( (${#1} - ${#x})*2 ))
```
Ce qui est appelé L'Expansion Arithmétique. Il semble complexe, mais il est vraiment juste de compter le nombre de 1 bits que nous enlevée lors de la première commande. Il se décompose à ceci:
```
(number of chars in $1 - number of chars in $x) * 2
```
qui dans notre cas correspond à
```
(13 - 5) * 2 = 16
```
Nous avons dépouillé de deux octets afin d'obtenir 16. Du sens.

Nous avons mis $3:
```
${x%%.*}
```
qui est la valeur de $x avec tout ce qui est après la première . dépouillé. Dans notre cas, c'est 192.

Nous avons besoin de convertir ce nombre en binaire et compter le nombre de 1 bits, donc, revenons à notre "tableau de conversion." Nous pouvons diviser la table en l'égalité des morceaux de quatre caractères:
```
0^^^  128^  192^  224^  240^  248^  252^  254^
```
En binaire, les chiffres ci-dessus sont:
```
00000000 10000000 11000000 11100000 11110000 11111000 11111100 11111110
# 0 ones 1 one    2 ones   3 ones   ...
```
Si on compte à partir de la gauche, de chaque quatre-bloc de caractères dans le tableau correspond à un supplément de 1 bits en binaire. Nous essayons de convertir 192, donc tout d'abord lop off la partie droite de la table, de la 192 sur, et de le stocker dans x:
```
x=${1%%$3*}
```
La valeur de $x est maintenant
```
0^^^128^
```
qui contient de deux à quatre caractères de blocs, ou deux 1 bits en binaire.

Maintenant nous avons juste besoin d'ajouter la 1 bits à partir de nos principaux 255 octets (16 total, stockés dans la variable $2) et le 1 bits à partir de l'étape précédente (2 au total):
```
echo $(( $2 + (${#x}/4) ))
```
où
```
${#x}/4
```
est le nombre de caractères dans $x divisé par quatre, c'est à dire le nombre de quatre caractères blocs dans $x.

De sortie:
```
18
```
cdr2mask()

Nous allons continuer à courir avec notre exemple précédent, qui avait une CIDR préfixe de 18.

Nous utilisons set -- pour définir les paramètres positionnels de $1 à $9:
```
$1: $(( 5 - ($1 / 8) ))  # 5 - (18 /8) = 3 [integer math]
$2: 255
$3: 255
$4: 255
$5: 255
$6: $(( (255 << (8 - ($1 % 8))) & 255 ))  # (255 << (8 - (18 % 8))) & 255 = 192
$7: 0
$8: 0
$9: 0
```
Nous allons examiner les formules utilisées pour définir $1 et $6 d'un peu plus près. $1 est fixé à:
```
$(( 5 - ($1 / 8) ))
```
Le maximum et le minimum des valeurs possibles d'un CIDR préfixe sont 32 pour le masque de réseau
```
11111111.11111111.11111111.11111111
```
et 0 pour le masque de réseau
```
00000000.00000000.00000000.00000000
```
La formule ci-dessus utilise la division entière, de sorte que les résultats possibles vont de 1 à 5:
```
5 - (32 / 8) = 1
5 - ( 0 / 8) = 5
```
$6 est fixé à:
```
$(( (255 << (8 - ($1 % 8))) & 255 ))
```
Analysons tout cela pour notre exemple CIDR préfixe de 18. D'abord nous prenons le module et faire la soustraction:
```
8 - (18 % 8) = 6
```
Ensuite, nous bit à bit shift 255 par cette valeur:
```
255 << 6
```
C'est la même chose que de pousser six 0 de bits sur la fin de 255 en binaire:
```
11111111000000
```
Enfin, nous avons au niveau du bit ET cette valeur avec 255:
```
11111111000000 &
00000011111111  # 255
```
qui donne
```
00000011000000
```
ou tout simplement
```
11000000
```
Semble familière? C'est le troisième octet dans notre masque en binaire:
```
11111111.11111111.11000000.00000000
                  ^------^
```
En décimal, la valeur est de 192.

Ensuite, nous décalage de la position des paramètres basés sur la valeur de $1:
```
[ $1 -gt 1 ] && shift $1 || shift
```
Dans notre cas, la valeur de $1 est 3, donc on décale les paramètres positionnels de 3 à gauche. La valeur précédente de $4 devient la nouvelle valeur de $1, la valeur précédente de $5 devient la valeur de $2, et ainsi de suite:
```
$1: 255
$2: 255
$3: 192
$4: 0
$5: 0
$6: 0
```
Ces valeurs devrait vous être familier: ils sont la virgule octets à partir de notre masque de sous-réseau avec un couple de zéros supplémentaires ajouté à la fin). Pour obtenir le masque de réseau, nous avons tout simplement imprimer les quatre premiers, avec des points entre eux:
```
echo ${1-0}.${2-0}.${3-0}.${4-0}
```
La -0 après chaque paramètre est dit d'utiliser 0 que la valeur par défaut si le paramètre n'est pas défini.

De sortie:
```
255.255.192.0
```
merveilleux. C'est bien expliqué Merci beaucoup
C'est une excellente réponse. Je l'ai utilisé comme base pour la conversion du "code ont joué au golf" formulaire pour un plus verbeux "les noms de variables que de la documentation". Vous pouvez voir que dans ce résumé: gist.github.com/RichardBronosky/...

OriginalL'auteur ThisSuitIsBlackNot

Vous devez vous connecter pour publier un commentaire.

mask2cdr()

De sortie:

cdr2mask()

De sortie: