Mehrere Ping-Skripts in Python

Versuchen Sie subprocess.call. Es speichert den Rückgabewert des verwendeten Programms.

Gemäß meinem Ping-Handbuch gibt es 0 bei Erfolg zurück, 2, wenn Pings gesendet wurden, aber keine Antwort empfangen wurde und jeder andere Wert einen Fehler anzeigt.

# typo error in import
import subprocess

for ping in range(1,10):
    address = "127.0.0." + str(ping)
    res = subprocess.call(['ping', '-c', '3', address])
    if res == 0:
        print "ping to", address, "OK"
    Elif res == 2:
        print "no response from", address
    else:
        print "ping to", address, "failed!"

Dieses Skript:

import subprocess
import os
with open(os.devnull, "wb") as limbo:
        for n in xrange(1, 10):
                ip="192.168.0.{0}".format(n)
                result=subprocess.Popen(["ping", "-c", "1", "-n", "-W", "2", ip],
                        stdout=limbo, stderr=limbo).wait()
                if result:
                        print ip, "inactive"
                else:
                        print ip, "active"

erzeugt etwas wie diese Ausgabe:

192.168.0.1 active
192.168.0.2 active
192.168.0.3 inactive
192.168.0.4 inactive
192.168.0.5 inactive
192.168.0.6 inactive
192.168.0.7 active
192.168.0.8 inactive
192.168.0.9 inactive

Sie können die Ausgabe erfassen, wenn Sie limbo durch subprocess.PIPE ersetzen und communicate() für das Popen-Objekt verwenden:

p=Popen( ... )
output=p.communicate()
result=p.wait()

Auf diese Weise erhalten Sie den Rückgabewert des Befehls und können den Text erfassen. Befolgen Sie das manual dies ist der bevorzugte Weg, um einen Unterprozess zu betreiben, wenn Sie Flexibilität benötigen:

Die zugrunde liegende Prozesserstellung und -verwaltung in diesem Modul ist wird von der Popen-Klasse behandelt. Es bietet viel Flexibilität, so dass Entwickler sind in der Lage, die weniger häufig vorkommenden Fälle zu behandeln, die nicht von .__ abgedeckt werden. Komfortfunktionen.

Vielen Dank dafür. Ich habe es geändert, um mit Windows zu arbeiten. Ich habe auch ein niedriges Timeout gesetzt, also werden die IPs, die keine Rückkehr haben, nicht warten und jeweils 5 Sekunden warten. Dies ist aus dem Quellcode von hochl.

import subprocess
import os
with open(os.devnull, "wb") as limbo:
        for n in xrange(200, 240):
                ip="10.2.7.{0}".format(n)
                result=subprocess.Popen(["ping", "-n", "1", "-w", "200", ip],
                        stdout=limbo, stderr=limbo).wait()
                if result:
                        print ip, "inactive"
                else:
                        print ip, "active"

Ändern Sie einfach das ip = für Ihr Schema und den Xrange für die Hosts.

Ich bin ein Anfänger und habe ein Skript geschrieben, mit dem Sie mehrere Hosts pingen können. 

import ipaddress
from subprocess import Popen, PIPE

net4 = ipaddress.ip_network('192.168.2.0/24')
for x in net4.hosts():
    x = str(x)
    hostup = Popen(["ping", "-c1", x], stdout=PIPE)
    output = hostup.communicate()[0]
    val1 = hostup.returncode
 if val1 == 0:
    print(x, "is pinging")
 else:
    print(x, "is not responding")

Um mehrere Hosts gleichzeitig zu pingen, können Sie subprocess.Popen() verwenden:

#!/usr/bin/env python3
import os
import time
from subprocess import Popen, DEVNULL

p = {} # ip -> process
for n in range(1, 100): # start ping processes
    ip = "127.0.0.%d" % n
    p[ip] = Popen(['ping', '-n', '-w5', '-c3', ip], stdout=DEVNULL)
    #NOTE: you could set stderr=subprocess.STDOUT to ignore stderr also

while p:
    for ip, proc in p.items():
        if proc.poll() is not None: # ping finished
            del p[ip] # remove from the process list
            if proc.returncode == 0:
                print('%s active' % ip)
            Elif proc.returncode == 1:
                print('%s no response' % ip)
            else:
                print('%s error' % ip)
            break

Wenn Sie als Root laufen können, können Sie ein pure Python-Ping-Skript verwenden oder scapy :

from scapy.all import sr, ICMP, IP, L3RawSocket, conf

conf.L3socket = L3RawSocket # for loopback interface
ans, unans = sr(IP(dst="127.0.0.1-99")/ICMP(), verbose=0) # make requests
ans.summary(lambda (s,r): r.sprintf("%IP.src% is alive"))

import subprocess
import os
'''
servers.txt contains ip address in following format
192.168.1.1
192.168.1.2
'''
    with open('servers.txt', 'r') as f:
        for ip in f:
            result=subprocess.Popen(["ping", "-c", "1", "-n", "-W", "2",    ip],stdout=f, stderr=f).wait()
            if result:
                print(ip, "inactive")
            else:
                print(ip, "active")

Python hat tatsächlich ein wirklich süßes method , das einen Iterator über die verwendbaren Hosts im Netzwerk zurückgibt. (Wenn Strikt auf Falsch gesetzt wird, werden alle IPs durchlaufen.)

Zum Beispiel:

import subprocess
import ipaddress

subnet = ipaddress.ip_network('192.168.1.0/24', strict=False)
for i in subnet.hosts():
    i = str(i)
    subprocess.call(["ping", "-c1", "-n", "-i0.1", "-W1", i])

Das Warteintervall (-i0.1) kann für Automatisierungen wichtig sein, selbst ein Timeout von einer Sekunde (-t1) kann über einen Wert von 0,0/24 ewig dauern

EDIT: Um ICMP-Anforderungen (Ping-Anfragen) zu verfolgen, können wir beispielsweise Folgendes tun:

#!/usr/bin/env python

import subprocess
import ipaddress

alive = []
subnet = ipaddress.ip_network('192.168.1.0/23', strict=False)
for i in subnet.hosts():
    i = str(i)
    retval = subprocess.call(["ping", "-c1", "-n", "-i0.1", "-W1", i])
    if retval == 0:
        alive.append(i)
for ip in alive:
    print(ip + " is alive") 

Was wird so etwas zurückgeben:

192.168.0.1 is alive
192.168.0.2 is alive
192.168.1.1 is alive
192.168.1.246 is alive

alle IPs, die auf ICMP reagieren, erstrecken sich über eine ganze/23 - Ziemlich cool!