Wie kann ich ein Linux-Bash-Skript schreiben, das mir sagt, welche Computer in meinem LAN eingeschaltet sind?

Wie kann ich schreiben Sie eine linux-bash-Skript, das mir sagt, welche Computer in meinem LAN ?

Würde es helfen, wenn ich könnte geben Sie als Eingabe einen IP-Bereich.

InformationsquelleAutor der Frage Dumb Questioner | 2009-04-09

75

Ich würde vorschlagen, mit nmap - ping-scan-flag,
```
$ nmap -sn 192.168.1.60-70

Starting Nmap 4.11 ( http://www.insecure.org/nmap/ ) at 2009-04-09 20:13 BST
Host machine1.home (192.168.1.64) appears to be up.
Host machine2.home (192.168.1.65) appears to be up.
Nmap finished: 11 IP addresses (2 hosts up) scanned in 0.235 seconds
```
Sagte, dass, wenn Sie wollen, um es selbst schreiben (das ist fair genug), das ist, wie ich es tun würde:
```
for ip in 192.168.1.{1..10}; do ping -c 1 -t 1 $ip > /dev/null && echo "${ip} is up"; done
```
..und eine Erklärung jedes bit des obigen Befehls:

Generieren Liste von IP-Adressen

Können Sie die {1..10} syntax zum erzeugen einer Liste von zahlen, zum Beispiel..
```
$ echo {1..10}
1 2 3 4 5 6 7 8 9 10
```
(es ist auch nützlich für Dinge wie mkdir {dir1,dir2}/{sub1,sub2} - das macht dir1 und dir2 jeweils sub1 und sub2)

So, um eine Liste von IP ' s, wir würden etwas tun, wie
```
$ echo 192.168.1.{1..10}
192.168.1.1 192.168.1.2 [...] 192.168.1.10
```
Schleifen

Schleife über etwas in bash, verwenden Sie for:
```
$ for thingy in 1 2 3; do echo $thingy; done
1
2
3
```
Ping

Weiter, um ping.. ping-Befehl variiert ein wenig mit verschiedenen Betriebssystemen, unterschiedlichen Distributionen/Versionen (ich verwende OS X derzeit)

Standardmäßig (auch auf der OS X-version von ping) es wird der ping unterbrochen, bis, das wird nicht funktionieren, so ping -c 1 nur versuchen, das senden eines Paketes, das sollte genug sein, um festzustellen, ob eine Maschine ist.

Ein weiteres problem ist das Zeitlimit, das scheint zu sein, 11 Sekunden auf dieser version von ping.. Es verändert mit der -t Flagge. Eine Sekunde sollte reichen um zu sehen, wenn eine Maschine im lokalen Netz lebendig ist oder nicht.

So, den ping-Befehl, den wir verwenden werden ist..
```
$ ping -c 1 -t 1 192.168.1.1
PING 192.168.1.1 (192.168.1.1): 56 data bytes

--- 192.168.1.1 ping statistics ---
1 packets transmitted, 0 packets received, 100% packet loss
```
Überprüfung ping-Ergebnis

Als Nächstes müssen wir wissen, ob die Maschine antwortete oder nicht..

Können wir die && - operator, um einen Befehl auszuführen, wenn der erste erfolgreich ist, zum Beispiel:
```
$ echo && echo "It works"

It works
$ nonexistantcommand && echo "This should not echo"
-bash: nonexistantcommand: command not found
```
Gut, so dass wir tun können..

ping -c 1 -I 1 192.168.1.1 && echo "192.168.1.1 ist!"

Die andere Möglichkeit wäre die Verwendung der exit-code von ping.. ping-Befehl wird beendet mit exit-code 0 (Erfolg) zurück, wenn es funktionierte, und ein nicht-null-code, wenn ein Fehler aufgetreten ist. In der bash erhalten Sie die letzten Befehle exit-code mit der variable $?

So, um zu überprüfen, ob der Befehl funktionierte, würden wir das tun..
```
ping -c 1 -t 1 192.168.1.1;
if [ $? -eq 0 ]; then
    echo "192.168.1.1 is up";
else 
    echo "ip is down";
fi
```
Versteckt ping-Ausgabe

Letzte Sache, die wir nicht brauchen, um zu sehen, der ping-Ausgabe, so können wir umleiten stdout zu /dev/null mit der > Umleitung, zum Beispiel:
```
$ ping -c 1 -t 1 192.168.1.1 > /dev/null && echo "IP is up"
IP is up
```
Und umleiten stderr (verwerfen der ping: sendto: Host is down Nachrichten), die Sie verwenden 2> - zum Beispiel:
```
$ errorcausingcommand
-bash: errorcausingcommand: command not found
$ errorcausingcommand 2> /dev/null
$
```
Das Skript

So zu kombinieren, dass..
```
for ip in 192.168.1.{1..10}; do  # for loop and the {} operator
    ping -c 1 -t 1 192.168.1.1 > /dev/null 2> /dev/null  # ping and discard output
    if [ $? -eq 0 ]; then  # check the exit code
        echo "${ip} is up" # display the output
        # you could send this to a log file by using the >>pinglog.txt redirect
    else
        echo "${ip} is down"
    fi
done
```
Oder mit den && Methode, in einem one-liner:
```
for ip in 192.168.1.{1..10}; do ping -c 1 -t 1 $ip > /dev/null && echo "${ip} is up"; done
```
Problem

Ist es langsam.. Jeder Befehl ping dauert etwa 1 Sekunde (da wir aber die-t-timeout-flag auf 1 Sekunde). Es kann nur führen Sie einen ping-Befehl an eine Zeit.. Die offensichtliche Weg, um dieses ist die Verwendung von threads, also Sie können Befehle gleichzeitig auszuführen, aber das ist jenseits dessen, was Sie verwenden sollten, bash..

"Python-threads - ein erstes Beispiel" wird erläutert, wie die Python threading-Modul zum schreiben von multi-threaded-ping ' er.. Obwohl an diesem Punkt, ich würde mal wieder vorschlagen, mit nmap -sn..

InformationsquelleAutor der Antwort dbr
14

In der realen Welt, Sie könnte verwenden nmap zu bekommen, was Sie wollen.
```
nmap -sn 10.1.1.1-255
```
Diese wird ping alle Adressen im Bereich von 10.1.1.1 bis 10.1.1.255 und lassen Sie Sie wissen, welche Antwort.

Natürlich, wenn Sie tatsächlich wollen, dies zu tun als ein bash-übung könnte führen Sie ping für jede Adresse und analysieren Sie die Ausgabe, aber das ist eine ganz andere Geschichte.

InformationsquelleAutor der Antwort Tiberiu Ana
10

Vorausgesetzt mein Netzwerk 10.10.0.0/24, wenn ich einen ping auf die broadcast-Adresse wie
```
ping -b 10.10.0.255
```
Ich eine Antwort bekommen von allen Computern in diesem Netzwerk nicht blockieren, Ihre ICMP-ping-port.
```
64 bytes from 10.10.0.6: icmp_seq=1 ttl=64 time=0.000 ms
64 bytes from 10.10.0.12: icmp_seq=1 ttl=64 time=0.000 ms 
64 bytes from 10.10.0.71: icmp_seq=1 ttl=255 time=0.000 ms 
```
So dass Sie nur noch extrahieren Sie die 4. Spalte mit awk zum Beispiel:
```
ping -b 10.10.0.255 | grep 'bytes from' | awk '{ print $4 }'

10.10.0.12:
10.10.0.6:
10.10.0.71:
10.10.0.95:
```
Gut, erhalten Sie duplizieren, und Sie müssen möglicherweise zu entfernen ':'.

BEARBEITEN von Kommentaren :
die -c-option schränkt die Anzahl der pings
da das Skript endet, können wir uns auch beschränken, uns auf einzigartige IPs
```
ping -c 5 -b 10.10.0.255 | grep 'bytes from' | awk '{ print $4 }' | sort | uniq
```
InformationsquelleAutor der Antwort chburd
8

Gibt es auch fping:
```
fping -g 192.168.1.0/24
```
oder:
```
fping -g 192.168.1.0 192.168.1.255
```
oder zeigt nur hosts, die lebendig sind:
```
fping -ag 192.168.1.0/24
```
Es pings hosts in parallel so dass der scan ist sehr schnell. Ich weiß nicht, eine distribution, welche umfasst fping in der Standard-installation aber in den meisten Distributionen können Sie es über den Paket-manager.

InformationsquelleAutor der Antwort d0k
2

Auch mit dem "ping an die broadcast-Adresse" - Methode hingewiesen hat, chburd, das Rohr sollte den trick für Sie:
```
ping -c 5 -b 10.11.255.255 | sed -n 's/.* $[0-9]\+\.[0-9]\+\.[0-9]\+\.[0-9]\+$.*/\1/p' | sort | uniq
```
Natürlich müssten Sie ändern die broadcast-Adresse des Netzwerks.

InformationsquelleAutor der Antwort Can Berk Güder

Nur zum Spaß, hier ist eine Alternative


     #!/bin/bash
     nmap -sP 192.168.1.0/24 > /dev/null 2>&1 && arp -an | grep -v incomplete | awk '{print$2}' | sed -e s,\(,, | sed -e s,\),,

InformationsquelleAutor der Antwort Eddy

1

Wenn Sie selbst die Beschränkung auf, nur das Letzte Oktett ändern, das script sollte es tun. Es sollte ziemlich offensichtlich, wie eine Verlängerung von einem bis zu mehreren Bytes.
```
#! /bin/bash 
BASE=$1 
START=$2 
ENDE=$3 

counter=$START 

while [ $counter -le $ENDE ] 
tun 
ip=$BASE.$Zähler 
wenn ping -qc-2 $ip 
dann 
echo "$ip antwortet" 
fi 
counter=$(( $counter + 1 )) 
getan 
```
InformationsquelleAutor der Antwort Vatine
1
InformationsquelleAutor der Antwort raspi
1

Als andere Poster darauf hingewiesen, nmap ist der Weg zu gehen, aber hier ist, wie zu tun, das äquivalent von einem ping-scan in der bash. Ich würde nicht verwenden die broadcast-ping, wie viele Systeme sind so konfiguriert, nicht zu reagieren, um broadcast ICMP heute.
```
for i in $(seq 1 254); do
    host="192.168.100.$i"
    ping -c 1 -W 1 $host &> /dev/null
    echo -n "Host $host is "
    test $? -eq 0 && echo "up" || echo "down"
done
```
InformationsquelleAutor der Antwort Don Werve

#!/bin/bash
#Get the ip address for the range
ip=$(/sbin/ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}' | cut -d"." -f1,2,3)

# ping test and list the hosts and echo the info

for range in $ip ; do  [ $? -eq 0 ] && ping -c 1 -w 1 $range > /dev/null 2> /dev/null && echo "Node $range is up" 
done

InformationsquelleAutor der Antwort hemanth.hm

Zwar eine alte Frage, scheint es immer noch wichtig zu sein (zumindest wichtig genug für mich um damit umzugehen). Mein script basiert auf nmap zu, also nichts besonderes hier, außer, dass IE können festlegen, welche Schnittstelle Sie Scannen möchten, und die IP-Range erstellt automatisch (zumindest eine Art).

Dies ist, was ich kam mit

#!/bin/bash
#Script for scanning the (local) network for other computers 

command -v nmap >/dev/null 2>&1 || { echo "I require nmap but it's not installed. Aborting." >&2; exit 1; }

if [ -n ""$@"" ];  then
    ip=$(/sbin/ifconfig $1 | grep 'inet '  | awk '{ print $2}' | cut -d"." -f1,2,3 )
    nmap -sP $ip.1-255
else
    echo -e "\nThis is a script for scanning the (local) network for other computers.\n"
    echo "Enter Interface as parameter like this:"
    echo -e "\t./scannetwork.sh $(ifconfig -lu | awk '{print $2}')\n"

    echo "Possible interfaces which are up are: "   
    for i in $(ifconfig -lu)
    do
        echo -e "\033[32m \t $i \033[39;49m"
    done

    echo "Interfaces which could be used but are down at the moment: "
    for i in $(ifconfig -ld)
    do
        echo -e "\033[31m \t $i \033[39;49m"
    done
    echo
fi

Eine Bemerkung: Dieses Skript ist erstellt auf OSX, so dass es möglicherweise einige änderungen in linux-Umgebungen.

InformationsquelleAutor der Antwort d3v3l

1

Wenn Sie möchten, um eine Liste der hosts, auf denen es getan werden kann, mit nmap, grep und awk.

Installieren Sie nmap:
```
$ sudo apt-get install nmap
```
Datei erstellen hostcheck.sh wie diese:

hostcheck.sh
```
#!/bin/bash

nmap -sP -iL hostlist -oG pingscan > /dev/null
grep Up pingscan | awk '{print $2}' > uplist
grep Down pingscan | awk '{print $2}' > downlist
```
-sP: Ping Scan - go no weiter, als die Bestimmung, wenn der host online ist

-iL : - Eingang aus der Liste der hosts/Netzwerke

-oG : Ausgabe der scan-Ergebnisse in Grepable-format, zu dem angegebenen Dateinamen.

/dev/null : Verwirft Ausgabe

Ändern Sie die Zugriffsrechte:
```
$ chmod 775 hostcheck.sh
```
Erstellen Sie die Datei hostlist mit der Liste der hosts überprüft werden (hostname oder IP):

hostlist (Beispiel)
```
192.168.1.1-5
192.168.1.101
192.168.1.123
```
192.168.1.1-5 ist ein Bereich von IP Adressen

Führen Sie das Skript:

./hostcheck.sh hostfile

Werden die generierten Dateien pingscan mit allen Informationen, uplist mit der hosts-online (Bis) und downlist mit der hosts offline (Down).

uplist (Beispiel)
```
192.168.1.1
192.168.1.2
192.168.1.3
192.168.1.4
192.168.1.101
```
downlist (Beispiel)
```
192.168.1.5
192.168.1.123
```
InformationsquelleAutor der Antwort viniciusfcosta
1

Einige Maschinen keine Antwort auf pings (z.B. firewalls).

Wenn Sie möchten, dass nur das lokale Netzwerk Sie können mit diesem Befehl:
```
(for n in $(seq 1 254);do sudo arping -c1 10.0.0.$n &  done ; wait) | grep reply | grep --color -E '([0-9]+\.){3}[0-9]+'
```
Erläuterungen Teil !
1. arping ist ein Befehl, sendet ARP-Anfragen. Es ist auf den meisten linux.
Beispiel:
```
sudo arping -c1 10.0.0.14
```
dem sudo ist nicht notwendig, wenn Sie das root-ofc.
- 10.0.0.14 : die ip, die Sie testen möchten
- -c1 : senden Sie nur eine Anfrage.
1. &: der 'ich-nicht-want-to-wait" - Zeichen
Dies ist ein wirklich nützliches Zeichen, das Ihnen die Möglichkeit zum starten eines Befehls in einem sub-Prozess, ohne zu warten, ihn zu beenden (wie ein Faden)
1. die for - Schleife ist hier, um arping emerged werden alle 255 ip-Adressen. Es verwendet die seq Befehl, um eine Liste aller Nummern.
1. wait: nachdem wir gestartet unsere Anfragen, die wir wollen, um zu sehen, wenn es einige Antworten. Zu tun, so dass wir erst wait nach der Schleife.
  wait sieht aus wie die Funktion join() in anderen Sprachen.
1. (): Klammern sind hier zu interpretieren sind alle Ausgänge als text, damit wir geben können, es zu grep
1. grep: wir wollen nur, um zu sehen, Antworten. der zweite grep ist nur hier, um zu markieren IPs.
hth

Bearbeiten 20150417: Maxi Aktualisieren !

Den schlechten Teil meiner Lösung ist, dass es druckt alle Ergebnisse am Ende. Es ist, weil grep ist groß genug Puffer, um einige Linien im inneren.
die Lösung ist das hinzufügen --line-buffered dem ersten grep.
etwa so:
```
(for n in $(seq 1 254);do sudo arping -c1 10.0.0.$n &  done ; wait) | grep --line-buffered reply | grep --color -E '([0-9]+\.){3}[0-9]+'
```
InformationsquelleAutor der Antwort Boop

#!/bin/bash

for ((n=0 ; n < 30 ; n+=1))
do
    ip=10.1.1.$n
    if ping -c 1 -w 1 $ip > /dev/null 2> /dev/null >> /etc/logping.txt; then  
        echo "${ip} is up" # output up
        # sintax >> /etc/logping.txt log with .txt format
    else
        echo "${ip} is down" # output down
    fi
done

InformationsquelleAutor der Antwort erik

0

Folgende (schlechte) code läuft mehr als DOPPELT so schnell wie der nmap-Methode
```
for i in {1..254} ;do (ping 192.168.1.$i -c 1 -w 5  >/dev/null && echo "192.168.1.$i" &) ;done
```
dauert etwa 10 Sekunden, wo der standard nmap
```
nmap -sP 192.168.1.1-254
```
dauert 25 Sekunden...

InformationsquelleAutor der Antwort Mike Redrobe

Gut, das ist ein Teil von einem script von mir.

ship.sh ? Ein einfaches, handliches Netzwerk-Adressierung ? multitool mit vielen Funktionen ?

Pings Netzwerk, zeigt der online-hosts in diesem Netzwerk mit Ihren lokalen IP-und MAC-Adresse

Ist es nicht erforderlich, alle zu Bearbeiten. Braucht root-Berechtigung ausführen.

GOOGLE_DNS="8.8.8.8"
ONLINE_INTERFACE=$(ip route get "${GOOGLE_DNS}" | awk -F 'dev ' 'NR == 1 {split($2, a, " "); print a[1]}')
NETWORK_IP=$(ip route | awk "/${ONLINE_INTERFACE}/&& /src/{print \$1}" | cut --fields=1 --delimiter="/")
NETWORK_IP_CIDR=$(ip route | awk "/${ONLINE_INTERFACE}/&& /src/{print \$1}")
FILTERED_IP=$(echo "${NETWORK_IP}" | awk 'BEGIN{FS=OFS="."} NF--')

ip -statistics neighbour flush all &>/dev/null

echo -ne "Pinging ${NETWORK_IP_CIDR}, please wait ..."
for HOST in {1..254}; do
  ping "${FILTERED_IP}.${HOST}" -c 1 -w 10 &>/dev/null &
done

for JOB in $(jobs -p); do wait "${JOB}"; done

ip neighbour | \
    awk 'tolower($0) ~ /reachable|stale|delay|probe/{printf ("%5s\t%s\n", $1, $5)}' | \
      sort --version-sort --unique

InformationsquelleAutor der Antwort xtonousou

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Generieren Liste von IP-Adressen

Schleifen

Ping

Überprüfung ping-Ergebnis

Versteckt ping-Ausgabe

Das Skript

Problem

Erläuterungen Teil !

Bearbeiten 20150417: Maxi Aktualisieren !