Le masque de réseau pour CIDR en ruby

J'ai été en utilisant l'adresse ip de gem et il ne semble pas avoir la capacité de convertir un masque de la forme

255.255.255.0

dans le CIDR forme

/24

Quelqu'un a une idées sur la façon de convertir rapidement la première à la seconde ?

Une solution est probablement d'utiliser le ipadmin gem au lieu qui semble beaucoup plus complet. Je suis toujours intéressé de voir ce qu'une solution à ce à partir d'une perspective de code est bien.

OriginalL'auteur Dean Smith | 2009-12-01

ip ruby

12

Ici est la façon rapide et sale
```
require 'ipaddr'
puts IPAddr.new("255.255.255.0").to_i.to_s(2).count("1")
```
Il faudrait fonction de cela, je ne pouvais pas trouver que, donc, je viens de compter "1"

Si vous allez être en utilisant la fonction dans un certain nombre de lieux et de ne pas l'esprit monkeypatching, ce qui pourrait aider:
```
IPAddr.class_eval
  def to_cidr
    "/" + self.to_i.to_s(2).count("1")
  end
end
```
Puis vous obtenez des
```
IPAddr.new('255.255.255.0').to_cidr
# => "/24"
```
Je ne suis pas sûr qu'il y a quelque chose de plus approprié que d'utiliser count("1"). Peut-être quelque chose comme cela? 32 - (2**32 - 1 - IPAddr.new("255.255.255.0").to_i).to_s(2).length
En C, je vais probablement le faire passer à droite, et de tester avec & 1 jusqu'à ce que sa portée 1, par exemple, bits=32;unsigned int ipaddr=0xFFFFFF00;while(ipaddr&1==0){ipaddr=ipaddr>>1;bits--;} pour le cas ci-dessus, seulement le besoin de décalage à droite 8 fois je crois.

OriginalL'auteur YOU

Comme un FYI, et de garder l'information facilement accessible pour ceux qui sont à la recherche...

Voici un moyen simple de convertir de CIDR pour masque format:

def cidr_to_netmask(cidr)
  IPAddr.new('255.255.255.255').mask(cidr).to_s
end

Par exemple:

cidr_to_netmask(24) #=> "255.255.255.0"
cidr_to_netmask(32) #=> "255.255.255.255"
cidr_to_netmask(16) #=> "255.255.0.0"
cidr_to_netmask(22) #=> "255.255.252.0"

OriginalL'auteur the Tin Man

5

Ici est une approche mathématique, en évitant les chaînes à tout prix:
```
def cidr_mask
    Integer(32-Math.log2((IPAddr.new(mask,Socket::AF_INET).to_i^0xffffffff)+1))
end
```
avec "masque" étant une chaîne comme 255.255.255.0. Vous pouvez les modifier et de modifier le premier argument juste "masque" si "masque" est déjà une représentation entière d'une adresse IP.

Ainsi, par exemple, si le masque était "255.255.255.0", IPAddr.nouveau(masque,Socket::AF_INET).to_i deviendrait 0xffffff00, qui est ensuite xor souhaitez avec 0xffffffff, qui est égal à 255.

Nous ajouter 1, que pour en faire une gamme complète de 256 hôtes, puis de trouver le logarithme de base 2 de 256, qui est égal à 8 (les bits utilisés pour l'adresse de l'hôte), puis soustrayez-8 de 32, ce qui équivaut à 24 (les bits utilisés pour l'adresse réseau).

Nous avons alors jeté à l'entier, car les Mathématiques.log2 renvoie un float.

OriginalL'auteur bluefear
5

Rapide et sale de conversion:

"255.255.255.0".split(".").map { |e| e.to_i.to_s(2).rjust(8, "0") }.join.count("1").split(".")

=> j'ai divisé masque dans un Tableau

.map { |e| e.to_i.to_s(2).rjust(8, "0") }

=> Pour chaque élément de Tableau:

.to_i

=> Convertir en entier

.to_s(2)

=> Convertir en entier en binaire

.rjust(8, "0")

=> Ajouter un rembourrage

=> Carte de retourner un Tableau avec la même cardinalité

.join

=> Convertir le Tableau en une chaîne de caractères complète

.count("1")

=> Count "1" caractères => Donner masque CIDR
```
    def mask_2_ciddr mask
      "/" + mask.split(".").map { |e| e.to_i.to_s(2).rjust(8, "0") }.join.count("1").to_s
    end

    mask_2_ciddr "255.255.255.0"
    => "/24"
    mask_2_ciddr "255.255.255.128"
    => "/25"
```
OriginalL'auteur Nicolas Ledez

Si vous n'avez pas besoin d'utiliser l'adresse ip gem, vous pouvez le faire avec le netaddr gem

require 'netaddr'

def to_cidr_mask(dotted_mask)
  NetAddr::CIDR.create('0.0.0.0/'+dotted_mask).netmask
end

to_cidr_mask("255.224.0.0") # => "/11"

OriginalL'auteur Claudio Floreani

1
```
require 'ipaddr'

def serialize_ipaddr(address)
  mask = address.instance_variable_get(:@mask_addr).to_s(2).count('1')
  "#{address}/#{mask}"
end

serialize_ipaddr(IPAddr.new('192.168.0.1/24')) # => "192.168.0.0/24"
```
Le code permet d'atteindre le masquage en accès privé variable d'instance *@mask_addr) de l'adresse Ip de l'instance (adresse, passé dans serialize_ipaddr). Ce n'est pas recommandé (comme les variables d'instance ne font pas partie des classes de l'API publique, mais ici c'est mieux que de l'analyse de la chaîne de #inspecter à mon avis.

De sorte que le processus est comme suit:
1. Obtenir la variable d'instance @mask_addr que représente le masque de réseau
2. Obtenir sa représentation binaire par exemple 255.255.255.0 -> 4294967040 -> 11111111111111111111111100000000
3. Compter du 1-s dans la base-2 nombre pour obtenir le masque CIDR (24)
4. Faire une chaîne de caractères composée de l'adresse & masque
EDIT: Ajout de l'explication de la mise en œuvre, comme demandé par NathanOliver

Alors que cet extrait de code, peut-être de résoudre la question, y compris une explication aide vraiment à améliorer la qualité de votre post. Rappelez-vous que vous répondez à la question pour les lecteurs dans l'avenir, et ces personnes pourraient ne pas connaître les raisons de votre code suggestion.

OriginalL'auteur Madis Nõmme
0

Ici est une façon de le faire sans la IPAddr gem
```
(('1'*cidr)+('0'*(32-cidr))).scan(/.{8}/m).map{|e|e.to_i(2)}.join('.')
```
OriginalL'auteur ewatt

Vous devez vous connecter pour publier un commentaire.