GNU/Linux >> Tutoriels Linux >  >> Linux

Obtenir des adresses d'interface réseau local en utilisant uniquement proc ?

Ma solution pour récupérer la configuration réseau IPv4, en utilisant /proc uniquement :

Malheureusement, c'est bash (bash uniquement et sans n'importe quel fork), pas python. Mais j'espère que ce sera lisible :

#!/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

Voici un exemple de sortie :

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

Explication :

J'utilise la valeur entière d'IPV4 afin de vérifier IP & MASK == NETWORK .

J'ai lu en premier /proc/net/route pour trouver des configurations de routage, rechercher des routes accessibles sans aucune passerelle (gw==000000 ).

Pour un tel itinéraire, je recherche dans toutes les connexions (TCP, puis UDP si non trouvé dans TCP) une connexion utilisant ceci route, le premier point final est mon adresse hôte.

Remarque :Cela ne fonctionnera pas avec les connexions PPP

Nota2 :Cela ne fonctionnera pas sur un hôte totalement silencieux sans aucune connexion réseau ouverte. Vous pouvez faire quelque chose comme echo -ne '' | nc -q 0 -w 1 8.8.8.8 80 & sleep .2 && ./retrieveIp.sh pour s'assurer que quelque chose a été trouvé dans /proc/net/tcp .

Nota3, 2016-09.23 :La nouvelle version de bash utilise >(command) syntaxe pour multiple inline pipe fonctionnalité . Cela implique un bug à la ligne 18 :un espace doit être présent entre > et ( !!

Nouvelle version avec passerelle

Il y a un petit patch :une fois que vous avez créé un fichier appelé getIPv4.sh en copiant le script précédent, vous pouvez coller ce qui suit dans la commande :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

Terminer avec Ctrl d , cela peut afficher :

patching file getIPv4.sh

Et peut-être

Hunk #1 succeeded at 35 with fuzz 2.

Puis relancez votre script :

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

Vous pouvez trouver la sortie de ip addr show plus facile à analyser que la sortie d'autres outils :

$ 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

Une autre option est le fichier /proc/net/tcp . Il affiche toutes les sessions TCP actuellement ouvertes, ce qui est différent de ce que vous avez demandé, mais peut être suffisant.

$ 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]

Mon IP est 192.168.0.121; notez l'arithmétique drôle pour le faire sortir correctement. :)


/proc/net/fib_trie contient la topographie du réseau

Pour imprimer simplement les adresses de tous les adaptateurs :

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

Pour déterminer l'adaptateur de ces adresses (a) consultez les réseaux de destination des adaptateurs à partir de /proc/net/route , (b) faire correspondre ces réseaux avec ceux de /proc/net/fib_trie et (c) imprimer les adresses d'hôte /32 correspondantes répertoriées sous ces réseaux.

Encore une fois pas de python malheureusement, mais un bash assez maladroit approche :

#!/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

sortie :

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

Limitation connue :

Cette approche ne fonctionne pas de manière fiable pour les adresses hôtes qui partagent le réseau avec d'autres adresses hôtes. Cette perte d'unicité du réseau rend impossible la détermination de l'adresse hôte correcte à partir de fib_trie car l'ordre de ces adresses ne correspond pas nécessairement à l'ordre des réseaux de route.

Cela dit, je ne sais pas pourquoi vous voudriez plusieurs adresses hôtes appartenant au même réseau en premier lieu. Donc, dans la plupart des cas d'utilisation, cette approche devrait fonctionner correctement.


Il n'y a pas d'analogue IPv4 de /proc/net/if_inet6

ifconfig fait :

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

Vous obtiendrez quelque chose comme ceci :

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. Utilisation de l'outil SS pour le dépannage du réseau

  2. Ssh - Nécessite uniquement l'authentificateur Google depuis l'extérieur du réseau local ?

  3. Ifconfig :7 exemples pour configurer l'interface réseau

  4. CentOS / RHEL 6 :Comment ajouter/supprimer des adresses IP supplémentaires à une interface réseau

  5. Obtenir 2 adresses IP sur une carte réseau, en utilisant DHCP

Comment bloquer les adresses usurpées locales à l'aide du pare-feu Linux

3 façons de configurer une interface réseau sous Linux

Utilisation d'ifstat pour les statistiques réseau Linux

Déterminer si une interface réseau est sans fil ou câblée

Obtenir des adresses IPv6 sous Linux en utilisant ioctl

Obtenir l'adresse MAC à l'aide du script shell