Quelle est la meilleure façon de convertir du bitcount réseau au masque de réseau?

Question

Par exemple, si j'ai une spécification de réseau comme 172.20.10.0/24, "24" est le bitcount. Quelle est la meilleure façon de convertir cela en un masque de réseau comme 0xffffff00?

Answer 1

Ce n'est pas une question de programmation, mais dans Linux, vous pouvez utiliser quel masque.

whatmask 72.20.10.0/24 

retours

IP Entered = ..................: 72.20.10.0 
CIDR = ........................: /24 
Netmask = .....................: 255.255.255.0 
Netmask (hex) = ...............: 0xffffff00 
Wildcard Bits = ...............: 0.0.0.255 
------------------------------------------------ 
Network Address = .............: 72.20.10.0 
Broadcast Address = ...........: 72.20.10.255 
Usable IP Addresses = .........: 254 
First Usable IP Address = .....: 72.20.10.1 
Last Usable IP Address = ......: 72.20.10.254 

Answer 2

Vous pouvez essayer quelque chose de simple, comme prendre la Bitcount et en divisant par 4. Ce serait vous donner de leader F dans le masque. Et puis prenez le reste et passez de 0 bits à 3 bits.

Answer 3

En supposant un masque de 32 bits et un int de 32 bits

int keepBits = 24; /* actually get it from somewhere else? */ 

int mask = (0xffffffff >> (32 - keepBits)) << (32 - keepBits); 

Note: ce n'est pas nécessairement la réponse à la question « Quelle est la meilleure façon d'obtenir le masque de réseau pour une interface? »

Answer 4

int keepbits = 24; 
int mask = keepbits > 0 ? 0x00 - (1<<(32 - keepbits)) : 0xFFFFFFFF; 

Answer 5

je fais toujours comme ça (dans votre cas cidr = 24):

uint32_t ipv4Netmask; 

ipv4Netmask = 0xFFFFFFFF; 
ipv4Netmask <<= 32 - cidr; 
ipv4Netmask = ntohl(ipv4Netmask); 

Cela ne fonctionnera avec ipv4Netmask pour être réellement uint32_t, ne font pas int, int doesn Pas besoin d'être 32 bits sur chaque système. Le résultat est converti en ordre d'octets réseau, car c'est ce que la plupart des fonctions système attendent.

Answer 6

est ici une solution dans VBScript, FWIW

option explicit 

'whatmask 72.20.10.0/24 
If WScript.Arguments.Unnamed.Count < 1 Then 
    WScript.Echo "WhatMask xxx.xxx.xxx.xxx/xx" 
    Wscript.Quit 
End If 

Dim sToFind 
Dim aParts 
Dim nSubnet 

sToFind = WScript.Arguments(0) 
aParts = Split(sToFind, "/", 2) 
nSubnet = aParts(1) 

if nSubnet < 1 or nSubnet > 32 then 
    WScript.echo "Subnet out of range [1..32]" 
    Wscript.quit 
end if 

Dim sBinary 
sBinary = String(nSubnet, "1") 
sBinary = sBinary & String(32 - nSubnet, "0") 

wscript.echo "0x" & lcase(binary2hexadecimal(sBinary)) 

function binary2hexadecimal(sBin) 
    dim sSlice 
    dim sResult 
    dim i 
    for i = 1 to len(sBin) step 4 
    sSlice = mid(sBin, i, 4) 
    sResult = sResult & hex(binary2decimal(sSlice)) 
    next 
    binary2hexadecimal = sResult 
end function 

function binary2decimal(sFourbits) 
    dim i 
    dim bit 
    dim nResult 
    nResult = 0 
    for i = 4 to 1 step -1 
    bit = mid(sFourbits, i, 1) 
    nResult = nResult * 2 + bit 
    next 
    binary2decimal = nResult 
end function 

A partir de la ligne de commande

>whatmask.vbs 123.12.123.17/23 
0xfffff700 

Answer 7

Pourquoi perdre du temps avec soustraction ou déclarations ternaires?

int suffix = 24; 
int mask = 0xffffffff^0xffffffff >> suffix; 

Si vous connaissez votre entier est exactement 32 bits de long alors il vous suffit de taper 0xffffffff fois.

int32_t mask = ~(0xffffffff >> suffix); 

Les deux compilent exactement le même code d'assemblage.

Answer 8

/* C# version merging some of the other contributions and corrected for byte order. */ 

int cidr = 24; 

var ipv4Netmask = 0xFFFFFFFF; 

ipv4Netmask <<= 32 - cidr; 

byte[] bytes = BitConverter.GetBytes(ipv4Netmask); 

Array.Reverse(bytes); 

ipv4Netmask = BitConverter.ToUInt32(bytes, 0);  

// mask is now ready for use such as: 

var netmask = new IPAddress(ipv4Netmask); 

Answer 9

Soyez prudent lorsque vous utilisez les réponses précédentes avec le code comme:

0xFFFFFFFF << 32 - cidr 

ou

-1 << 32 - cidr 

En C# au moins, il va masquer le décalage compte avec 0x1F premier. Ainsi, pour un cidr avec préfixe 0 (l'ensemble de la plage d'adresses IPv4):

int cidr=0; 
0xFFFFFFFF << (32 - cidr) == 0xFFFFFFFF 

qui n'est pas ce que vous voulez. Au lieu de cela, vous devez utiliser:

int cidr=0; 
(int)(0xFFFFFFFFL << (32 - cidr)) == 0