Generar dirección IP aleatoria

Question

Quiero generar alguna dirección IP aleatoria. Pero a la vez, esta función generateIPAddress devuelve 0.0.0.0 string como ipAddress. Pero debería devolver alguna ipAddress aleatoria distinta de 0.0.0.0 cada vez. Alguna sugerencia de por qué está sucediendo?

private void callingGeoService() { 
     int p1 = 255; 
     int p2 = 0; 
     int p3 = 0; 
     int inc = 5; 

     String ipAddress = generateIPAddress(p1, p2, p3); 

     p3 += inc; 
     if (p3 > 255) { 
      p3 = 0; 
      p2 += inc; 
      if (p2 > 255) { 
       p2 = 0; 
       p1--; 
       if (p1 <= 0) { 
        p1 = 0; 
       } 
      } 
     } 
    } 

// Este es el método generateIPAddress

private String generateIPAddress(int p1, int p2, int p3) { 

    StringBuilder sb = null; 

    int b1 = (p1 >> 24) & 0xff; 
    int b2 = (p2 >> 16) & 0xff; 
    int b3 = (p3 >> 8) & 0xff; 
    int b4 = 0; 

    String ip1 = Integer.toString(b1); 
    String ip2 = Integer.toString(b2); 
    String ip3 = Integer.toString(b3); 
    String ip4 = Integer.toString(b4); 

    //Now the IP is b1.b2.b3.b4 
    sb = new StringBuilder(); 
    sb.append(ip1).append(".").append(ip2).append(".").append(ip3).append(".").append(ip4); 
    // System.out.println(sb); 

    return sb.toString(); 

} 

Quiero un poco al azar ipAddress básicamente por lo que he hardcoded partir bits de IPADDRESS en forma de p1, p2, p3 y el último bit debe ser 0.

Answer 1

Random r = new Random(); 
return r.nextInt(256) + "." + r.nextInt(256) + "." + r.nextInt(256) + "." + r.nextInt(256); 

Answer 2

Usando Google Guava:

import com.google.common.net.InetAddresses; 
... 
String ipString = InetAddresses.fromInteger(random.nextInt()).getHostAddress(); 

, por supuesto, puede validar la dirección resultante no ser multidifusión etc.

Answer 3

Suponiendo que en realidad no se preocupan por la dirección IP resultante siendo válida en cualquier forma que sea, tiene un problema sencillo.

El código para generar las direcciones establece los parámetros p3 y p2 a algo menos de 255. p1 está atrapado entre 255 y 0.

El problema real es que el código que convierte esto en una dirección cambia estos valores. p1 por 24, p2 por 16 y p3 por 8. Entender la limitación aplicada en el método de llamada, puede saber que p1, p2 y p3 nunca excederán 255, por lo que en este caso sabiendo que un cambio de 8 o más dará como resultado 0, ninguno de los elementos individuales de la dirección dará como resultado en un valor distinto de 0, y el último octeto siempre será 0, por lo que la dirección resultante será 0.0.0.0

Si desea evitar que sea 0.0.0.0, lo primero que debe hacer es quitar las operaciones de cambio. Esto mantendrá el último campo como 0, porque nunca se establece, pero debería generar direcciones.

De nuevo, esto no se preocupa por el estado de las direcciones, terminará con las direcciones de difusión, multidifusión y solo local utilizando este método.

Answer 4

Cuando se invoca generateIPAddress(p1, p2, p3), p1 es 255, p2 y p3 son 0.

Esta línea

int b1 = (p1 >> 24) & 0xff; 

turnos p1 24 bits a la derecha. Antes del cambio p1 era 11111111. Los resultados del cambio con 0. En realidad también se podría utilizar

int b1 = p1 >> 8; 

como p1 tiene sólo sus 8 bits menos significativos encendidos.El uso de & 0xff es redundante ya que la operación se realiza entre dos operandos int. Entonces b1 es 0.

p2 y p3 se pasan con el valor 0 lo que el cambio (ya sea por 16 o 8) no cambia ni un poco, lo que resulta con b2 y b3 siendo también 0.

b4 se establece explícitamente en 0.

Así que todo b1, b2, b3 y b4 son 0, a partir del cual se crea ip1-ip4. Entonces el método generateIPAddress(p1, p2, p3) siempre devuelve 0.0.0.0.

Luego p3 += inc; agrega 5 a 0. Reuslt en p3 ahora es 5.

La condición if (p3 > 255) siempre fallará en p3 es 5 que es < 255 ...

Answer 5

he desarrollado recientemente un small library que puede generar direcciones IPv4 al azar utilizando diferentes restricciones de tipo:

MockNeat mock = MockNeat.threadLocal(); 

    String ipv4 = mock.ipv4s().val(); 
    System.out.println(ipv4); 

    String ipClassA = mock.ipv4s().type(CLASS_A).val(); 
    System.out.println(ipClassA); 

    String classAorB = mock.ipv4s().types(CLASS_A, CLASS_B).val(); 
    System.out.println(classAorB); 

    List<String> ip4s = mock.ipv4s().list(10).val(); 
    System.out.println(ip4s); 

salida :

192.112.222.183 
120.178.110.193 
143.68.176.47 
[112.246.76.178, 29.201.72.151, 67.105.2.128, 102.189.109.206, 157.146.176.212, 59.220.145.35, 47.171.185.233, 162.245.163.124, 19.203.21.194, 114.177.238.50]