Expression régulière pour le masquage de sous-réseau ?

Question

J'utilise une expression régulière pour vérifier le masquage du sous-réseau. J'utilise une boîte de texte ajax avec une valeur de masquage, mais cela ne fonctionne pas, puis je suis passé à une boîte de texte et à l'application d'une expression régulière pour cela. Malheureusement, cela ne fonctionne pas non plus.

Pouvez-vous m'aider à donner un RE pour le masquage de sous-réseau 255.255.255.255

Ou une meilleure façon de le faire ?

Solution :

J'ai utilisé une zone de texte masquée et je ne sais pas comment mettre l'expression de validation.

Finalement, j'ai trouvé une propriété de la zone de texte masquée comme expression de validation, et là j'ai mis le RE et changé la propriété validate en true.

Il n'est pas nécessaire d'utiliser explicitement l'expression du validateur.

Gracias

Answer 1

Pour y parvenir à l'aide d'une expression régulière, il faut s'assurer que l'ensemble du quadrant pointé IPv4 représente un nombre de 32 bits avec uniquement des uns en tête. Il ne suffit pas de s'assurer que chaque chiffre du quadrant ne comporte que des uns en tête. Par exemple, 255.192.255.0 n'est pas un sous-masque valide, même si chaque chiffre du quadrant ne comporte que des uns en tête. En s'appuyant sur la solution proposée par @xanatos,

var leadingOnes = new Regex("255|254|252|248|240|224|192|128|0+");

définit une expression régulière qui correspondra à n'importe quel nombre de 8 bits (décimal) avec uniquement des uns en tête. J'ai utilisé "0+" pour tenir compte de .000, qui est parfois utilisé dans les quads. Évidemment, si vous voulez forcer un seul zéro, utilisez "0" à la place.

Vous devez ensuite construire une expression régulière qui correspond à l'un des quatre motifs suivants, que je représente sous forme de pseudo-expressions régulières pour faciliter la compréhension :

• 255.255.255. leadingOnes
• 255.255. leadingOnes *.0
• 255. leadingOnes .0.0
• leadingOnes .0.0.0

Vous pouvez soit l'écrire sous forme de chaîne unique, soit la construire par concaténation. Voici la construction :

var leadingOnes = "(255|254|252|248|240|224|192|128|0+);"
var allOnes = @"(255\.)"; 
var re = new Regex("^((" + allOnes + "{3}" + leadingOnes + ")|" +
                     "(" + allOnes + "{2}" + leadingOnes + @"\.0+)|" +
                     "(" + allOnes +         leadingOnes + @"(\.0+){2})|" +
                     "(" +                   leadingOnes + @"(\.0+){3}))$");

Et voici la chaîne entière, si on ignore les sauts de ligne.

var re = new Regex(@"^(((255\.){3}(255|254|252|248|240|224|192|128|0+))|((255\.){2}(255|254|252|248|240|224|192|128|0+)\.0)|((255\.)(255|254|252|248|240|224|192|128|0+)(\.0+){2})|((255|254|252|248|240|224|192|128|0+)(\.0+){3}))$");

En suivant la suggestion de @Keith, vous pourriez commencer par une simple expression régulière telle que

Regex("([0-9]{1,3}\.){3}[0-9]{1,3}" pour obtenir quatre nombres à trois chiffres séparés par des points, puis écrivez une fonction qui extrait et évalue les quatre morceaux dans un entier de 32 bits que vous vérifiez ensuite pour vous assurer qu'il ne contient que des uns de tête. Il existe plusieurs façons de le faire, mais toutes nécessitent jusqu'à 31 opérations de comparaison pour compléter la validation.

Answer 2

Si vous voulez accepter toute adresse IP comme un masque de sous-réseau :

var num = @"(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})";
var rx = new Regex("^" + num + @"\." + num + @"\." + num + @"\." + num + "$");

J'ai jugé plus facile de répartir la correspondance "répétitive" pour un seul groupe de chiffres dans une variable distincte.

À titre d'exercice pour le lecteur, je vais donner une autre variante de l'expression. Celle-ci capturera tous les nombres du même groupe mais avec des captures différentes :

var rx = new Regex("^(?:" + num + @"(?:\.(?!$)|$)){4}$");

MAIS c'est faux, vous devriez utiliser ceci

var num = @"(255|254|252|248|240|224|192|128|0+)";
var rx = new Regex("^" + num + @"\." + num + @"\." +num + @"\." +num + "$");

ou

var rx = new Regex("^(?:" + num + @"(?:\.(?!$)|$)){4}$");

http://www.freesoft.org/CIE/Course/Subnet/6.htm

Answer 3

Je sais que la question portait sur une expression Regex, mais pour tous ceux que cela intéresse, voici deux solutions itératives au problème. La deuxième fonction est un peu plus rapide que la première.

private bool IsValidSubnet(IPAddress ip) {
    byte[] validOctets = new byte[] { 255, 254, 252, 248, 240, 224, 192, 128, 0 };
    byte[] ipOctets = ip.GetAddressBytes();
    bool restAreZeros = false;
    for (int i = 0; i < 4; i++) {
        if (!validOctets.Contains(ipOctets[i]))
            return false;
        if (restAreZeros && ipOctets[i] != 0)
            return false;
        if (ipOctets[i] < 255)
            restAreZeros = true;
    }
    return true;
}

// checks if the address is all leading ones followed by only zeroes
private bool IsValidSubnet2(IPAddress ip) {
    byte[] ipOctets = ip.GetAddressBytes();
    bool restAreOnes = false;
    for (int i = 3; i >= 0; i--) {
        for (int j = 0; j < 8; j++) {
            bool bitValue = (ipOctets[i] >> j & 1) == 1;
            if (restAreOnes && !bitValue)
                return false;
            restAreOnes = bitValue;
        }
    }
    return true;
}

Answer 4

Desde http://pastebin.com/wTEKjKpP

var subnetRegex = /^((128|192|224|240|248|252|254)\.0\.0\.0)|(255\.(((0|128|192|224|240|248|252|254)\.0\.0)|(255\.(((0|128|192|224|240|248|252|254)\.0)|255\.(0|128|192|224|240|248|252|254)))))$/

Bien sûr, c'est pour javascript, mais cela devrait aider.

Answer 5

Vous pouvez utiliser cette regex pour valider le sous-réseau

^(((255\.){3}(255|254|252|248|240|224|192|128+))|((255\.){2}(255|254|252|248|240|224|192|128|0+)\.0)|((255\.)(255|254|252|248|240|224|192|128|0+)(\.0+){2})|((255|254|252|248|240|224|192|128|0+)(\.0+){3}))$