GNU/Linux >> Tutoriales Linux >  >> Linux

¿Obtener direcciones de interfaz de red local usando solo proc?

Mi solución para recuperar la configuración de red IPv4, usando /proc solo:

Desafortunadamente, esto es bash (solo bash y sin cualquier bifurcación), no python. Pero espero que esto sea legible:

#!/bin/bash

# ip functions that set variables instead of returning to STDOUT

hexToInt() {
    printf -v $1 "%d\n" 0x${2:6:2}${2:4:2}${2:2:2}${2:0:2}
}
intToIp() {
    local var=$1 iIp
    shift
    for iIp ;do 
        printf -v $var "%s %s.%s.%s.%s" "${!var}" $(($iIp>>24)) \
            $(($iIp>>16&255)) $(($iIp>>8&255)) $(($iIp&255))
    done
}
maskLen() {
    local i
    for ((i=0; i<32 && ( 1 & $2 >> (31-i) ) ;i++));do :;done
    printf -v $1 "%d" $i
}

# The main loop.

while read -a rtLine ;do
    if [ ${rtLine[2]} == "00000000" ] && [ ${rtLine[7]} != "00000000" ] ;then
        hexToInt netInt  ${rtLine[1]}
        hexToInt maskInt ${rtLine[7]}
        if [ $((netInt&maskInt)) == $netInt ] ;then
            for procConnList in /proc/net/{tcp,udp} ;do
                while IFS=': \t\n' read -a conLine ;do
                    if [[ ${conLine[1]} =~ ^[0-9a-fA-F]*$ ]] ;then
                        hexToInt ipInt ${conLine[1]}
                        [ $((ipInt&maskInt)) == $netInt ] && break 3
                    fi
                done < $procConnList
            done
        fi
    fi
done < /proc/net/route 

# And finaly the printout of what's found

maskLen maskBits $maskInt
intToIp addrLine $ipInt $netInt $maskInt
printf -v outForm '%-12s: %%s\\n' Interface Address Network Netmask Masklen
printf "$outForm" $rtLine $addrLine $maskBits\ bits

Hay una muestra de salida:

Interface   : eth0
Address     : 192.168.1.32
Network     : 192.168.1.0
Netmask     : 255.255.255.0
Masklen     : 24 bits

Explicación:

Uso el valor entero de IPV4 para verificar IP & MASK == NETWORK .

Leí primero /proc/net/route para encontrar configuraciones de enrutamiento, buscando rutas accesibles sin ninguna puerta de enlace (gw==000000 ).

Para tal ruta, busco en todas las conexiones (TCP, que UDP si no se encuentra en TCP) la conexión usando esto ruta, el primer punto final es mi dirección de host.

Nota:Esto no funcionará con conexiones PPP

Nota 2:Esto no funcionará en un host totalmente silencioso sin ninguna conexión de red abierta. Podría hacer algo como echo -ne '' | nc -q 0 -w 1 8.8.8.8 80 & sleep .2 && ./retrieveIp.sh para asegurarse de que algo se encuentra en /proc/net/tcp .

Nota3, 2016-09.23:Nueva versión bash usa >(command) sintaxis para multiple inline pipe característica . Esto implica un error en la línea 18:un espacio debe estar presente entre > y ( !!

Nueva versión con puerta de enlace

Hay un pequeño parche:una vez que crea un archivo llamado getIPv4.sh al copiar el script anterior, puede pegar lo siguiente en el comando:patch -p0

--- getIPv4.sh
+++ getIPv4.sh
@@ -35,13 +35,16 @@
                 done < $procConnList
             done
         fi
+    elif [ ${rtLine[1]} == "00000000" ] && [ ${rtLine[7]} == "00000000" ] ;then
+       hexToInt netGw ${rtLine[2]}
     fi
 done < /proc/net/route 

 # And finaly the printout of what's found

 maskLen maskBits $maskInt
-intToIp addrLine $ipInt $netInt $maskInt
-printf -v outForm '%-12s: %%s\\n' Interface Address Network Netmask Masklen
+intToIp addrLine $ipInt $netInt $netGw $maskInt
+printf -v outForm '%-12s: %%s\\n' \
+       Interface Address Network Gateway Netmask Masklen
 printf "$outForm" $rtLine $addrLine $maskBits\ bits

Terminar con Ctrl d , esto puede generar:

patching file getIPv4.sh

Y tal vez

Hunk #1 succeeded at 35 with fuzz 2.

Luego vuelva a ejecutar su secuencia de comandos:

getIPv4.sh
Interface   : eth0
Address     : 192.168.1.32
Network     : 192.168.1.0
Gateway     : 192.168.1.1
Netmask     : 255.255.255.0
Masklen     : 24 bits

Puede encontrar la salida de ip addr show más fácil de analizar que la salida de otras herramientas:

$ ip addr show
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 16436 qdisc noqueue state UNKNOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
    link/ether 00:24:1d:ce:47:05 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.121/24 brd 192.168.0.255 scope global eth0
    inet6 fe80::224:1dff:fece:4705/64 scope link
       valid_lft forever preferred_lft forever
3: eth1: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc pfifo_fast state DOWN qlen 1000
    link/ether 00:24:1d:ce:35:d5 brd ff:ff:ff:ff:ff:ff
4: virbr0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UNKNOWN
    link/ether 92:e3:6c:08:1f:af brd ff:ff:ff:ff:ff:ff
    inet 192.168.122.1/24 brd 192.168.122.255 scope global virbr0
    inet6 fe80::90e3:6cff:fe08:1faf/64 scope link
       valid_lft forever preferred_lft forever

Otra opción es el archivo /proc/net/tcp . Muestra todas las sesiones TCP actualmente abiertas, que es diferente de lo que solicitó, pero podría ser lo suficientemente bueno.

$ cat tcp
  sl  local_address rem_address   st tx_queue rx_queue tr tm->when retrnsmt   uid  timeout inode
   0: 00000000:0050 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 13536 1 ffff88019f0a1380 300 0 0 2 -1
   1: 00000000:1355 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 19877854 1 ffff880016e69380 300 0 0 2 -1
   2: 017AA8C0:0035 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 13633 1 ffff88019f0a1a00 300 0 0 2 -1
   3: 00000000:0016 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 8971 1 ffff88019f0a0000 300 0 0 2 -1
   4: 0100007F:0277 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 12952880 1 ffff880030e30680 300 0 0 2 -1
   5: 00000000:0539 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 14332 1 ffff88019f0a2080 300 0 0 2 -1
   6: 00000000:C000 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 14334 1 ffff88019f0a2700 300 0 0 2 -1
   7: 0100007F:0A44 00000000:0000 0A 00000000:00000000 00:00000000 00000000   119        0 51794804 1 ffff880016e6a700 300 0 0 2 -1
   8: 7900A8C0:B094 53D50E48:01BB 01 00000000:00000000 00:00000000 00000000  1000        0 64877487 1 ffff880100502080 23 4 16 4 -1
   9: 7900A8C0:9576 537F7D4A:01BB 06 00000000:00000000 03:00000E5D 00000000     0        0 0 3 ffff880100c84600
  10: 7900A8C0:CC84 0CC181AE:01BB 01 00000000:00000000 00:00000000 00000000  1000        0 61775908 1 ffff880198715480 35 4 11 4 -1
$ irb
irb(main):001:0> [0x79, 0x00, 0xa8, 0xc0]
=> [121, 0, 168, 192]

Mi IP es 192.168.0.121; tenga en cuenta la aritmética divertida para que salga bien. :)


/proc/net/fib_trie mantiene la topografía de la red

Para imprimir simplemente las direcciones de todos los adaptadores:

$ awk '/32 host/ { print f } {f=$2}' <<< "$(</proc/net/fib_trie)"
127.0.0.1
192.168.0.5
192.168.1.14

Para determinar el adaptador de esas direcciones (a) consulte las redes de destino de los adaptadores desde /proc/net/route , (b) unir esas redes con las de /proc/net/fib_trie y (c) imprimir las direcciones de host /32 correspondientes enumeradas en esas redes.

Nuevamente sin python desafortunadamente, pero un bash bastante extraño enfoque:

#!/bin/bash

ft_local=$(awk '$1=="Local:" {flag=1} flag' <<< "$(</proc/net/fib_trie)")

for IF in $(ls /sys/class/net/); do
    networks=$(awk '$1=="'$IF'" && $3=="00000000" && $8!="FFFFFFFF" {printf $2 $8 "\n"}' <<< "$(</proc/net/route)" )
    for net_hex in $networks; do
            net_dec=$(awk '{gsub(/../, "0x& "); printf "%d.%d.%d.%d\n", $4, $3, $2, $1}' <<< $net_hex)
            mask_dec=$(awk '{gsub(/../, "0x& "); printf "%d.%d.%d.%d\n", $8, $7, $6, $5}' <<< $net_hex)
            awk '/'$net_dec'/{flag=1} /32 host/{flag=0} flag {a=$2} END {print "'$IF':\t" a "\n\t'$mask_dec'\n"}' <<< "$ft_local"
    done
done

exit 0

salida:

eth0:     192.168.0.5
          255.255.255.0

lo:       127.0.0.1
          255.0.0.0

wlan0:    192.168.1.14
          255.255.255.0

Limitación conocida:

Este enfoque no funciona de manera confiable para las direcciones de host que comparten la red con otras direcciones de host. Esta pérdida de singularidad de la red hace que sea imposible determinar la dirección de host correcta de fib_trie ya que el orden de esas direcciones no coincide necesariamente con el orden de las redes de ruta.

Habiendo dicho eso, no estoy seguro de por qué querrías varias direcciones de host pertenecientes a la misma red en primer lugar. Entonces, en la mayoría de los casos de uso, este enfoque debería funcionar bien.


No existe un análogo IPv4 de /proc/net/if_inet6

ifconfig hace:

fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)
ioctl(fd, SIOCGIFCONF, ...)

Obtendrás algo como esto:

ioctl(4, SIOCGIFCONF, {120, {{"lo", {AF_INET, inet_addr("127.0.0.1")}}, {"eth0", {AF_INET, inet_addr("10.6.23.69")}}, {"tun0", {AF_INET, inet_addr("10.253.10.151")}}}})

Linux
  1. Linux:¿el enlace de la interfaz de red parece funcionar solo como root?

  2. ¿Encontrar solo el destino del enlace simbólico?

  3. Ifconfig:7 ejemplos para configurar la interfaz de red

  4. Determinar si una interfaz de red es inalámbrica o cableada

  5. Obtenga direcciones IPv6 en Linux usando ioctl

Cómo bloquear direcciones falsificadas locales usando el firewall de Linux

3 formas de configurar una interfaz de red en Linux

Uso de ifstat para estadísticas de red de Linux

Python:obtenga la puerta de enlace predeterminada para una interfaz local/dirección IP en Linux

Obtener 2 direcciones IP en una tarjeta de red, usando DHCP

Cómo obtener direcciones MAC de dispositivos que no están en la red