Server ping in Python

In Python, c'è un modo per eseguire il ping di un server tramite ICMP e restituire VERO se il server risponde o FALSO se non c'è risposta?

Questa funzione è disponibile in qualsiasi sistema operativo (Unix, Linux, macOS e Windows)
Python 2 e Python 3

EDIT:
da @radato è os.system stato sostituito da subprocess.call. Ciò evita la vulnerabilità dell'iniezione di shell nei casi in cui la stringa del nome host potrebbe non essere convalidata.

import platform    # For getting the operating system name
import subprocess  # For executing a shell command

def ping(host):
    """
    Returns True if host (str) responds to a ping request.
    Remember that a host may not respond to a ping (ICMP) request even if the host name is valid.
    """

    # Option for the number of packets as a function of
    param = '-n' if platform.system().lower()=='windows' else '-c'

    # Building the command. Ex: "ping -c 1 google.com"
    command = ['ping', param, '1', host]

    return subprocess.call(command) == 0

Nota che, secondo @ikrase su Windows, questa funzione tornerà comunque in Truecaso di Destination Host Unreachableerrore.

Spiegazione

Il comando è pingin sistemi Windows e Unix.
L'opzione -n(Windows) o -c(Unix) controlla il numero di pacchetti che in questo esempio è stato impostato su 1.

platform.system()restituisce il nome della piattaforma. Ex. 'Darwin'su macOS.
subprocess.call()esegue una chiamata di sistema. Ex. subprocess.call(['ls','-l']).

Se non hai bisogno di supportare Windows, ecco un modo davvero conciso per farlo:

import os
hostname = "google.com" #example
response = os.system("ping -c 1 " + hostname)

#and then check the response...
if response == 0:
  print hostname, 'is up!'
else:
  print hostname, 'is down!'

Ciò funziona perché il ping restituisce un valore diverso da zero se la connessione non riesce. (Il valore di ritorno in realtà differisce a seconda dell'errore di rete.) È inoltre possibile modificare il timeout del ping (in secondi) utilizzando l'opzione '-t'. Nota, questo genererà testo sulla console.

C'è un modulo chiamato pyping che può fare questo. Può essere installato con pip

pip install pyping

È piuttosto semplice da usare, tuttavia, quando si utilizza questo modulo, è necessario l'accesso alla radice poiché sta creando pacchetti grezzi sotto il cofano.

import pyping

r = pyping.ping('google.com')

if r.ret_code == 0:
    print("Success")
else:
    print("Failed with {}".format(r.ret_code))

import subprocess
ping_response = subprocess.Popen(["/bin/ping", "-c1", "-w100", "192.168.0.1"], stdout=subprocess.PIPE).stdout.read()

Per python3 esiste un modulo python ping3 molto semplice e conveniente : ( pip install ping3, necessita dei privilegi di root ).

from ping3 import ping, verbose_ping
ping('example.com')  # Returns delay in seconds.
>>> 0.215697261510079666

Questo modulo consente anche la personalizzazione di alcuni parametri.

Poiché mi piace avere il mio programma Python universale sulla versione 2.7 e 3.xe su piattaforma Linux, Mac OS e Windows, ho dovuto modificare gli esempi esistenti.

# shebang does not work over all platforms
# ping.py  2016-02-25 Rudolf
# subprocess.call() is preferred to os.system()
# works under Python 2.7 and 3.4
# works under Linux, Mac OS, Windows

def ping(host):
    """
    Returns True if host responds to a ping request
    """
    import subprocess, platform

    # Ping parameters as function of OS
    ping_str = "-n 1" if  platform.system().lower()=="windows" else "-c 1"
    args = "ping " + " " + ping_str + " " + host
    need_sh = False if  platform.system().lower()=="windows" else True

    # Ping
    return subprocess.call(args, shell=need_sh) == 0

# test call
print(ping("192.168.17.142"))

Dopo essermi guardato intorno, ho finito per scrivere il mio modulo ping, progettato per monitorare un gran numero di indirizzi, è asincrono e non utilizza molte risorse di sistema. Puoi trovarlo qui: https://github.com/romana/multi-ping/ È concesso in licenza Apache, quindi puoi utilizzarlo nel tuo progetto come preferisci.

I motivi principali per implementare il mio sono le restrizioni degli altri approcci:

• Molte delle soluzioni menzionate qui richiedono l'esecuzione di un'utilità da riga di comando. Questo è abbastanza inefficiente e affamato di risorse se è necessario monitorare un gran numero di indirizzi IP.
• Altri menzionano alcuni vecchi moduli ping di Python. Ho esaminato quelli e alla fine tutti hanno avuto qualche problema o l'altro (come non impostare correttamente gli ID dei pacchetti) e non hanno gestito il ping di un gran numero di indirizzi.

#!/usr/bin/python3

import subprocess as sp

def ipcheck():
    status,result = sp.getstatusoutput("ping -c1 -w2 " + str(pop))
    if status == 0:
        print("System " + str(pop) + " is UP !")
    else:
        print("System " + str(pop) + " is DOWN !")


pop = input("Enter the ip address: ")
ipcheck()

Accertarsi che sia installata la codifica o installarla pip install pyping

#!/usr/bin/python
import pyping

response = pyping.ping('Your IP')

if response.ret_code == 0:
    print("reachable")
else:
    print("unreachable")

Il ping programmatico ICMP è complicato a causa dei privilegi elevati richiesti per inviare pacchetti ICMP non elaborati e la chiamata pingbinaria è brutta. Per il monitoraggio del server, è possibile ottenere lo stesso risultato utilizzando una tecnica chiamata ping TCP :

# pip3 install tcping
>>> from tcping import Ping
# Ping(host, port, timeout)
>>> ping = Ping('212.69.63.54', 22, 60)
>>> ping.ping(3)
Connected to 212.69.63.54[:22]: seq=1 time=23.71 ms
Connected to 212.69.63.54[:22]: seq=2 time=24.38 ms
Connected to 212.69.63.54[:22]: seq=3 time=24.00 ms

Internamente, questo stabilisce semplicemente una connessione TCP al server di destinazione e lo rilascia immediatamente, misurando il tempo trascorso. Questa particolare implementazione è un po 'limitata in quanto non gestisce le porte chiuse ma per i tuoi server funziona abbastanza bene.

#!/usr/bin/python3

import subprocess as sp

ip = "192.168.122.60"
status,result = sp.getstatusoutput("ping -c1 -w2 " + ip)

if status == 0: 
    print("System " + ip + " is UP !")
else:
    print("System " + ip + " is DOWN !")

Lo risolvo con:

def ping(self, host):
    res = False

    ping_param = "-n 1" if system_name().lower() == "windows" else "-c 1"

    resultado = os.popen("ping " + ping_param + " " + host).read()

    if "TTL=" in resultado:
        res = True
    return res

"TTL" è il modo per sapere se il ping è corretto. saludos

La mia riduzione usando le idee delle risposte in questo post ma usando solo il modulo di sottoprocesso consigliato più recente e python3:

import subprocess
import platform

operating_sys = platform.system()
nas = '192.168.0.10'

def ping(ip):
    # ping_command = ['ping', ip, '-n', '1'] instead of ping_command = ['ping', ip, '-n 1'] for Windows
    ping_command = ['ping', ip, '-n', '1'] if operating_sys == 'Windows' else ['ping', ip, '-c 1']
    shell_needed = True if operating_sys == 'Windows' else False

    ping_output = subprocess.run(ping_command,shell=shell_needed,stdout=subprocess.PIPE)
    success = ping_output.returncode
    return True if success == 0 else False

out = ping(nas)
print(out)

Questo script funziona su Windows e dovrebbe funzionare su altri sistemi operativi: funziona su Windows, Debian e macosx, necessita di un test su Solaris.

import os
import platform


def isUp(hostname):

    giveFeedback = False

    if platform.system() == "Windows":
        response = os.system("ping "+hostname+" -n 1")
    else:
        response = os.system("ping -c 1 " + hostname)

    isUpBool = False
    if response == 0:
        if giveFeedback:
            print hostname, 'is up!'
        isUpBool = True
    else:
        if giveFeedback:
            print hostname, 'is down!'

    return isUpBool

print(isUp("example.com")) #Example domain
print(isUp("localhost")) #Your computer
print(isUp("invalid.example.com")) #Unresolvable hostname: https://tools.ietf.org/html/rfc6761
print(isUp("192.168.1.1")) #Pings local router
print(isUp("192.168.1.135")) #Pings a local computer - will differ for your network

Ho finito per trovare questa domanda su uno scenario simile. Ho provato a scrivere codice ma l'esempio fornito da Naveen non ha funzionato per me in Windows con Python 2.7.

Un esempio che ha funzionato per me è:

import pyping

response = pyping.send('Your IP')

if response['ret_code'] == 0:
    print("reachable")
else:
    print("unreachable")

Usando il multi-ping ( pip install multiPing) ho creato questo semplice codice ( semplicemente copia e incolla se vuoi! ):

from multiping import MultiPing

def ping(host,n = 0):
    if(n>0):
        avg = 0
        for i in range (n):
            avg += ping(host)
        avg = avg/n
    # Create a MultiPing object to test hosts / addresses
    mp = MultiPing([host])

    # Send the pings to those addresses
    mp.send()

    # With a 1 second timout, wait for responses (may return sooner if all
    # results are received).
    responses, no_responses = mp.receive(1)


    for addr, rtt in responses.items():
        RTT = rtt


    if no_responses:
        # Sending pings once more, but just to those addresses that have not
        # responded, yet.
        mp.send()
        responses, no_responses = mp.receive(1)
        RTT = -1

    return RTT

Uso:

#Getting the latency average (in seconds) of host '192.168.0.123' using 10 samples
ping('192.168.0.123',10)

Se vuoi un singolo campione, il secondo parametro "10 " può essere ignorato!

Spero che sia d'aiuto!

La mia versione di una funzione ping:

• Funziona su Python 3.5 e versioni successive, su Windows e Linux (dovrebbe funzionare su Mac, ma non è possibile testarlo).
• Su Windows, restituisce False se il comando ping ha esito negativo con "Host di destinazione non raggiungibile".
• E non mostra alcun output, né come finestra pop-up o nella riga di comando.

import platform, subprocess

def ping(host_or_ip, packets=1, timeout=1000):
    ''' Calls system "ping" command, returns True if ping succeeds.
    Required parameter: host_or_ip (str, address of host to ping)
    Optional parameters: packets (int, number of retries), timeout (int, ms to wait for response)
    Does not show any output, either as popup window or in command line.
    Python 3.5+, Windows and Linux compatible (Mac not tested, should work)
    '''
    # The ping command is the same for Windows and Linux, except for the "number of packets" flag.
    if platform.system().lower() == 'windows':
        command = ['ping', '-n', str(packets), '-w', str(timeout), host_or_ip]
        # run parameters: capture output, discard error messages, do not show window
        result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, creationflags=0x08000000)
        # 0x0800000 is a windows-only Popen flag to specify that a new process will not create a window.
        # On Python 3.7+, you can use a subprocess constant:
        #   result = subprocess.run(command, capture_output=True, creationflags=subprocess.CREATE_NO_WINDOW)
        # On windows 7+, ping returns 0 (ok) when host is not reachable; to be sure host is responding,
        # we search the text "TTL=" on the command output. If it's there, the ping really had a response.
        return result.returncode == 0 and b'TTL=' in result.stdout
    else:
        command = ['ping', '-c', str(packets), '-w', str(timeout), host_or_ip]
        # run parameters: discard output and error messages
        result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        return result.returncode == 0

Sentiti libero di usarlo come vuoi.

Sembra abbastanza semplice, ma mi ha dato i giusti. Continuavo a ricevere "operazione con socket aperto icmp non consentita", altrimenti le soluzioni si sarebbero bloccate se il server fosse offline. Se, tuttavia, quello che vuoi sapere è che il server è attivo e stai eseguendo un server Web su quel server, allora curl farà il lavoro. Se hai ssh e certificati, allora basterà ssh e un semplice comando. Ecco il codice:

from easyprocess import EasyProcess # as root: pip install EasyProcess
def ping(ip):
    ping="ssh %s date;exit"%(ip) # test ssh alive or
    ping="curl -IL %s"%(ip)      # test if http alive
    response=len(EasyProcess(ping).call(timeout=2).stdout)
    return response #integer 0 if no response in 2 seconds

Avevo requisiti simili, quindi l'ho implementato come mostrato di seguito. È testato su Windows a 64 bit e Linux.

import subprocess
def systemCommand(Command):
    Output = ""
    Error = ""     
    try:
        Output = subprocess.check_output(Command,stderr = subprocess.STDOUT,shell='True')
    except subprocess.CalledProcessError as e:
        #Invalid command raises this exception
        Error =  e.output 

    if Output:
        Stdout = Output.split("\n")
    else:
        Stdout = []
    if Error:
        Stderr = Error.split("\n")
    else:
        Stderr = []

    return (Stdout,Stderr)

#in main
Host = "ip to ping"
NoOfPackets = 2
Timeout = 5000 #in milliseconds
#Command for windows
Command = 'ping -n {0} -w {1} {2}'.format(NoOfPackets,Timeout,Host)
#Command for linux 
#Command = 'ping -c {0} -w {1} {2}'.format(NoOfPackets,Timeout,Host)
Stdout,Stderr = systemCommand(Command)
if Stdout:
   print("Host [{}] is reachable.".format(Host))
else:
   print("Host [{}] is unreachable.".format(Host))

Quando l'IP non è raggiungibile subprocess.check_output () genera un'eccezione. È possibile effettuare una verifica aggiuntiva estraendo le informazioni dalla riga di output "Pacchetti: inviati = 2, ricevuti = 2, persi = 0 (perdita 0%)".

Ecco una soluzione che utilizza il subprocessmodulo di Python e lo pingstrumento CLI fornito dal sistema operativo sottostante. Testato su Windows e Linux. Supporto per l'impostazione di un timeout di rete. Non ha bisogno dei privilegi di root (almeno su Windows e Linux).

import platform
import subprocess

def ping(host, network_timeout=3):
    """Send a ping packet to the specified host, using the system "ping" command."""
    args = [
        'ping'
    ]

    platform_os = platform.system().lower()

    if platform_os == 'windows':
        args.extend(['-n', '1'])
        args.extend(['-w', str(network_timeout * 1000)])
    elif platform_os in ('linux', 'darwin'):
        args.extend(['-c', '1'])
        args.extend(['-W', str(network_timeout)])
    else:
        raise NotImplemented('Unsupported OS: {}'.format(platform_os))

    args.append(host)

    try:
        if platform_os == 'windows':
            output = subprocess.run(args, check=True, universal_newlines=True).stdout

            if output and 'TTL' not in output:
                return False
        else:
            subprocess.run(args, check=True)

        return True
    except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
        return False

Usa questo è testato su Python 2.7 e funziona bene restituisce il tempo di ping in millisecondi se successo e restituisce False on fail.

import platform,subproccess,re
def Ping(hostname,timeout):
    if platform.system() == "Windows":
        command="ping "+hostname+" -n 1 -w "+str(timeout*1000)
    else:
        command="ping -i "+str(timeout)+" -c 1 " + hostname
    proccess = subprocess.Popen(command, stdout=subprocess.PIPE)
    matches=re.match('.*time=([0-9]+)ms.*', proccess.stdout.read(),re.DOTALL)
    if matches:
        return matches.group(1)
    else: 
        return False

Una cosa che manca molte delle risposte è che (almeno in Windows) il ping comando restituisce 0 (che indica l'esito positivo) se riceve la risposta "Host di destinazione non raggiungibile".

Ecco il mio codice che controlla se b'TTL='è nella risposta, poiché è presente solo quando il ping ha raggiunto l'host. Nota: la maggior parte di questo codice si basa sulle altre risposte qui.

import platform
import subprocess

def ping(ipAddr, timeout=100):
    '''
    Send a ping packet to the specified host, using the system ping command.
    Accepts ipAddr as string for the ping destination.
    Accepts timeout in ms for the ping timeout.
    Returns True if ping succeeds otherwise Returns False.
        Ping succeeds if it returns 0 and the output includes b'TTL='
    '''
    if platform.system().lower() == 'windows':
        numFlag = '-n'
    else:
        numFlag = '-c'
    completedPing = subprocess.run(['ping', numFlag, '1', '-w', str(timeout), ipAddr],
                                   stdout=subprocess.PIPE,    # Capture standard out
                                   stderr=subprocess.STDOUT)  # Capture standard error
    # print(completedPing.stdout)
    return (completedPing.returncode == 0) and (b'TTL=' in completedPing.stdout)

print(ping('google.com'))

Nota: questo cattura l'output invece di stamparlo, quindi se si desidera vedere l'output di ping, è necessario stampare completedPing.stdoutprima di tornare.

SOLO WINDOWS - Non riesco a credere che nessuno abbia aperto Win32_PingStatus Usando una semplice query WMI restituiamo gratuitamente un oggetto pieno di informazioni molto dettagliate

import wmi


# new WMI object
c = wmi.WMI()

# here is where the ping actually is triggered
x = c.Win32_PingStatus(Address='google.com')

# how big is this thing? - 1 element
print 'length x: ' ,len(x)


#lets look at the object 'WMI Object:\n'
print x


#print out the whole returned object
# only x[0] element has values in it
print '\nPrint Whole Object - can directly reference the field names:\n'
for i in x:
    print i



#just a single field in the object - Method 1
print 'Method 1 ( i is actually x[0] ) :'
for i in x:
    print 'Response:\t', i.ResponseTime, 'ms'
    print 'TTL:\t', i.TimeToLive


#or better yet directly access the field you want
print '\npinged ', x[0].ProtocolAddress, ' and got reply in ', x[0].ResponseTime, 'ms'

uscita campione

Prendo in prestito da altre risposte. Tentativo di semplificare e minimizzare le query.

import platform, os

def ping(host):
    result = os.popen(' '.join(("ping", ping.param, host))).read()
    return 'TTL=' in result

ping.param = "-n 1" if platform.system().lower() == "windows" else "-c 1"

Avevo bisogno di una scansione del ping più veloce e non volevo usare alcuna libreria esterna, quindi ho deciso di usare la concorrenza usando il built-in asyncio.

Questo codice richiede python 3.7+ ed è realizzato e testato solo su Linux . Non funzionerà su Windows ma sono sicuro che puoi facilmente cambiarlo per farlo funzionare su Windows.

Non sono un esperto, asyncioma ho usato questo fantastico articolo Accelerare il tuo programma Python con concorrenza e ho inventato queste righe di codice. Ho cercato di renderlo il più semplice possibile, quindi molto probabilmente dovrai aggiungere altro codice per soddisfare le tue esigenze.

Non restituisce vero o falso, ho pensato che sarebbe stato più conveniente solo per farlo stampare l'IP che risponde a una richiesta di ping. Penso che sia abbastanza veloce, eseguendo il ping di 255 ips in quasi 10 secondi.

#!/usr/bin/python3

import asyncio

async def ping(host):
    """
    Prints the hosts that respond to ping request
    """
    ping_process = await asyncio.create_subprocess_shell("ping -c 1 " + host + " > /dev/null 2>&1")
    await ping_process.wait()

    if ping_process.returncode == 0:
        print(host)
    return 


async def ping_all():
    tasks = []

    for i in range(1,255):
        ip = "192.168.1.{}".format(i)
        task = asyncio.ensure_future(ping(ip))
        tasks.append(task)

    await asyncio.gather(*tasks, return_exceptions = True)

asyncio.run(ping_all())

Uscita campione:

192.168.1.1
192.168.1.3
192.168.1.102
192.168.1.106
192.168.1.6

Si noti che gli IP non sono in ordine, poiché l'IP viene stampato non appena risponde, quindi quello che risponde per primo viene stampato per primo.

  1 #!/usr/bin/python
  2
  3 import os
  4 import sys
  5 import time
  6
  7 os.system("clear")
  8 home_network = "172.16.23."
  9 mine = []
 10
 11 for i in range(1, 256):
 12         z =  home_network + str(i)
 13         result = os.system("ping -c 1 "+ str(z))
 14         os.system("clear")
 15         if result == 0:
 16                 mine.append(z)
 17
 18 for j in mine:
 19         print "host ", j ," is up"

Un semplice che ho appena preparato in un minuto..usando icmplib ho bisogno dei privilegi di root il sotto funziona abbastanza bene! HTH