Calcular la emisión en dirección de IP y la máscara de subred

Question

quiero para calcular la dirección de difusión para:

IP:  192.168.3.1 
Subnet: 255.255.255.0 
=  192.168.3.255 

en C.

Conozco el camino (haciendo bit a bit de lujo o de entre el Inversed IP y subred) , pero mi problema es que vengo de los campos verdes de la programación MacOSX Cocoa.

Miré en el origen de ipcal, pero no pude integrarlo en mi base de código. Debe haber un simple diez líneas de código en algún lugar de Internet, simplemente no puedo encontrarlo. ¿Podría alguien señalarme un ejemplo de código corto de cómo hacerlo en C?

Answer 1

Sólo calcular:

broadcast = ip | (~ subnet) 

(Broadcast = ip-addr o la máscara de subred-invertida)

La dirección de difusión tiene un poco 1 donde la máscara de subred tiene un poco 0.

Answer 2

¿Podría ser?

unsigned broadcast(unsigned ip,unsigned subnet){ 
    unsigned int bits = subnet^0xffffffff; 
    unsigned int bcast = ip | bits; 

    return bcast; 
} 

Editar: Considero que tanto el ip como la subred son sin "."

Answer 3

Aquí se muestra cómo hacerlo en C#. por ejemplo, usar ip 10.28.40.149 con la máscara de red 255.255.252.0 devuelve 10.28.43.255, que es la dirección de difusión correcta. gracias a un código de here

private static string GetBroadcastAddress(string ipAddress, string subnetMask) { 
     //determines a broadcast address from an ip and subnet 
     var ip = IPAddress.Parse(ipAddress); 
     var mask = IPAddress.Parse(subnetMask); 

     byte[] ipAdressBytes = ip.GetAddressBytes(); 
     byte[] subnetMaskBytes = mask.GetAddressBytes(); 

     if (ipAdressBytes.Length != subnetMaskBytes.Length) 
      throw new ArgumentException("Lengths of IP address and subnet mask do not match."); 

     byte[] broadcastAddress = new byte[ipAdressBytes.Length]; 
     for (int i = 0; i < broadcastAddress.Length; i++) { 
      broadcastAddress[i] = (byte)(ipAdressBytes[i] | (subnetMaskBytes[i]^255)); 
     } 
     return new IPAddress(broadcastAddress).ToString(); 
    } 

Answer 4

entiendo que el PO tenía al menos una vaga idea de la aritmética a nivel de bits, pero se perdió en la conversión de las cadenas en números y su inversa. aquí hay un ejemplo de trabajo (con pruebas mínimas de todos modos), usando el cálculo de froh42.

jcomeau@aspire:~/rentacoder/jcomeau/freifunk$ cat inet.c; make inet; ./inet 192.168.3.1 255.255.255.0 
#include <arpa/inet.h> 
#include <stdio.h> 
int main(int argc, char **argv) { 
    char *host_ip = argc > 1 ? argv[1] : "127.0.0.1"; 
    char *netmask = argc > 2 ? argv[2] : "255.255.255.255"; 
    struct in_addr host, mask, broadcast; 
    char broadcast_address[INET_ADDRSTRLEN]; 
    if (inet_pton(AF_INET, host_ip, &host) == 1 && 
     inet_pton(AF_INET, netmask, &mask) == 1) 
     broadcast.s_addr = host.s_addr | ~mask.s_addr; 
    else { 
     fprintf(stderr, "Failed converting strings to numbers\n"); 
     return 1; 
    } 
    if (inet_ntop(AF_INET, &broadcast, broadcast_address, INET_ADDRSTRLEN) != NULL) 
     printf("Broadcast address of %s with netmask %s is %s\n", 
      host_ip, netmask, broadcast_address); 
    else { 
     fprintf(stderr, "Failed converting number to string\n"); 
     return 1; 
    } 
    return 0; 
} 
cc  inet.c -o inet 
Broadcast address of 192.168.3.1 with netmask 255.255.255.0 is 192.168.3.255 

Answer 5

bien quién buscará este código en el futuro. A veces he gastado hoy cuando lo necesitaba, aquí está el código completo y funciona :) simplemente cópielo y péguelo y luego importe los dlls necesarios.

private IPAddress CalculateBroadCastAddress(IPAddress currentIP, IPAddress ipNetMask) 
    { 
     string[] strCurrentIP = currentIP.ToString().Split('.'); 
     string[] strIPNetMask = ipNetMask.ToString().Split('.'); 

     ArrayList arBroadCast = new ArrayList(); 

     for (int i = 0; i < 4; i++) 
     { 
      int nrBCOct = int.Parse(strCurrentIP[i]) | (int.Parse(strIPNetMask[i])^255); 
      arBroadCast.Add(nrBCOct.ToString()); 
     } 
     return IPAddress.Parse(arBroadCast[0] + "." + arBroadCast[1] + 
       "." + arBroadCast[2] + "." + arBroadCast[3]); 
    } 


    private IPAddress getIP() 
    { 
     IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName()); 
     foreach (IPAddress ip in host.AddressList) 
     { 
      if (ip.AddressFamily == AddressFamily.InterNetwork) 
      { 
       return ip; 

      } 
     } 
     return null; 
    } 

    private IPAddress getSubnetMask() 
    { 
     NetworkInterface[] Interfaces = NetworkInterface.GetAllNetworkInterfaces(); 
     IPAddress ip = getIP(); 
     foreach (NetworkInterface interf in Interfaces) 
     { 

      UnicastIPAddressInformationCollection UnicastIPInfoCol = interf.GetIPProperties().UnicastAddresses; 

      foreach (UnicastIPAddressInformation UnicatIPInfo in UnicastIPInfoCol) 
      { 
       if (UnicatIPInfo.Address.Equals(ip)) 
        return UnicatIPInfo.IPv4Mask; 
      } 

     } 

     return null; 

    } 

A continuación, sólo llamar así:

IPAddress broadcastip = CalculateBroadCastAddress(getIP(), getSubnetMask()); 

feliz de codificación :)