Cómo convertir de manera eficiente de IP larga a cuádruple en punteado en bash

Question

Tengo una gran cantidad de direcciones IP en una gran base de datos MySQL almacenada como int larga. Necesito una forma eficiente/rápida para convertirlos a una IP dentro de un script de shell BASH (o ¿mysql devolver los resultados como una IP?).

Nota: específicamente, no quiero llamar a perl, awk u otro 'idioma'.

Answer 1

Ver la función INET_NTOA, puede usar eso para convertir el número a una IP en el servidor MySQL.

Answer 2

Suponga que tiene un campo llamado ip_addr en una tabla llamada hosts

Entonces

select INET_NTOA(ip_addr) from hosts; 

harían la consulta y devolver IPs de cuaterna en el conjunto de resultados.

Answer 3

Has solicitado que Bash:

INET_NTOA() { 
    local IFS=. num quad ip e 
    num=$1 
    for e in 3 2 1 
    do 
     ((quad = 256 ** e)) 
     ((ip[3-e] = num/quad)) 
     ((num = num % quad)) 
    done 
    ip[3]=$num 
    echo "${ip[*]}" 
} 

INET_ATON() 
{ 
    local IFS=. ip num e 
    ip=($1) 
    for e in 3 2 1 
    do 
     ((num += ip[3-e] * 256 ** e)) 
    done 
    ((num += ip[3])) 
    echo "$num" 
} 

Ejemplos:

$ INET_ATON 10.2.1.255 
167903743 
$ INET_NTOA 167903743 
10.2.1.255 

que aquí hay una versión que funcione en cualquiera de las conchas derivados de Bourne He intentado incluyendo guión, ksh, varias versiones de Bash, BusyBox ash, zsh (con -y) e incluso el Heirloom Bourne Shell.

INET_NTOA() { 
    num=$1 
    ip= 
    for e in 3 2 1 
    do 
     quad=`echo "256^$e" | bc` 
     if [ -n "$ip" ] 
     then 
      ip=$ip. 
     fi 
     ip=$ip`echo "$num/$quad" | bc` 
     num=`echo "$num % $quad" | bc` 
    done 
    ip=$ip.$num 
    echo "$ip" 
} 

INET_ATON() 
{ 
    num=0 
    e=3 
    saveIFS=$IFS 
    IFS=. 
    set -- $1 
    IFS=$saveIFS 
    for ip in "$@" 
    do 
     num=`echo "$num + $ip * 256^$e" | bc` 
     e=`echo "$e - 1" | bc` 
    done 
    echo "$num" 
} 

Answer 4

 
INET_ATON() 
    { 
    local IFS=. ipStr 

    ipStr=($1) 
    echo $(($(($(($(($(($((${ipStr[0]} * 256)) + ${ipStr[1]})) * 256)) + ${ipStr[2]})) * 256)) + ${ipStr[3]})) 
    } 

INET_NTOA() 
    { 
    echo "$(($1/16777216)).$(($(($1 % 16777216))/65536)).$(($(($1 % 65536))/256)).$(($1 % 256))" 
    } 

subnetRange() 
    { 
    local addr=$(INET_ATON "$1") mask=$(INET_ATON "$2") 

    echo "$(INET_NTOA $(($addr & $mask))) $(INET_NTOA $(($addr | $mask^4294967295)))" 
    } 

Answer 5

Teniendo en cuenta que la pregunta original era alrededor de una eficiente manera de hacer esto en bash, creo que estos podrían ser entradas dignas en el concurso:

INET_ATON() 
    { 
    local IFS=. ip 
    ip=($*) 
    echo $(((ip[0] << 24) + (ip[1] << 16) + (ip[2] << 8) + ip[3])) 
    } 

INET_NTOA() 
    { 
    echo $(($1 >> 24)).$((($1 >> 16) % 256)).$((($1 >> 8) % 256)).$(($1 % 256)) 
    } 

Naturalmente, estos han el mismo problema de "envoltura" que las otras soluciones dadas aquí, debido al tratamiento de los enteros según lo expresado en el intérprete de comandos.

Answer 6

soy flojo, y esto ya se ha hecho. Así que desde un shell

$ ping -c1 1199092913 | head -n1 | grep -Eow "[0-9]+[.][0-9]+[.][0-9]+[.][0-9]+" 

estoy seguro de que hay otras maneras inteligentes de hacerlo desde el caparazón también.