Python'daki ping sunucuları

Python'da, sunucuya ICMP üzerinden ping atmanın ve sunucu yanıt verirse TRUE, yanıt yoksa FALSE döndürmenin bir yolu var mı?

Bu işlev herhangi bir işletim sisteminde (Unix, Linux, macOS ve Windows)
Python 2 ve Python 3'te çalışır

EDITS :
By @radato os.system ile değiştirildi subprocess.call. Bu , ana makine adı dizenizin doğrulanamayacağı durumlarda kabuk enjeksiyon güvenlik açığını önler .

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

Windows'ta @ikrase'a göre, Truebir Destination Host Unreachablehata alırsanız bu işlevin yine de döneceğini unutmayın .

açıklama

Komut pinghem Windows hem de Unix benzeri sistemlerde bulunur. (Windows) veya (Unix)
seçeneği , bu örnekte 1 olarak ayarlanan paket sayısını kontrol eder.-n-c

platform.system()platform adını döndürür. Ör. 'Darwin'macOS'ta.
subprocess.call()bir sistem çağrısı gerçekleştirir. Ör. subprocess.call(['ls','-l']).

Windows'u desteklemeniz gerekmiyorsa, bunu yapmanın gerçekten kısa bir yolu var:

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!'

Bağlantı başarısız olursa ping sıfır olmayan bir değer döndürdüğü için bu çalışır. (Dönüş değeri aslında ağ hatasına bağlı olarak değişir.) '-T' seçeneğini kullanarak ping zaman aşımını da (saniye cinsinden) değiştirebilirsiniz. Not, bu konsola metin çıktısı verecektir.

Bunu yapabilen pyping adlı bir modül var . Pip ile kurulabilir

pip install pyping

Kullanımı oldukça basittir, ancak bu modülü kullanırken, kaputun altında ham paketleri hazırladığı için kök erişimine ihtiyacınız vardır.

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()

Python3 için çok basit ve kullanışlı bir python modülü ping3 vardır : ( pip install ping3, kök ayrıcalıklarına ihtiyaç duyar ).

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

Bu modül bazı parametrelerin de özelleştirilmesine izin verir.

Python programımın 2.7 ve 3.x sürümlerinde ve platform Linux, Mac OS ve Windows'da evrensel olmasını sevdiğim için, mevcut örnekleri değiştirmek zorunda kaldım.

# 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"))

Etrafa baktıktan sonra, çok sayıda adresi izlemek için tasarlanmış, eşzamansız ve çok fazla sistem kaynağı kullanmayan kendi ping modülümü yazdım. Burada bulabilirsiniz: https://github.com/romana/multi-ping/ Apache lisanslıdır, böylece projenizde uygun gördüğünüz herhangi bir şekilde kullanabilirsiniz.

Benimkini uygulamanın ana nedenleri diğer yaklaşımların kısıtlamalarıdır:

• Burada bahsedilen çözümlerin çoğu bir komut satırı yardımcı programına bir yürütme gerektirir. Çok sayıda IP adresini izlemeniz gerekiyorsa, bu oldukça verimsizdir ve kaynak açtır.
• Diğerleri bazı eski python ping modüllerinden bahseder. Ben bunlara baktım ve sonunda, hepsi bir sorun ya da diğer (paket kimliklerini doğru ayarlamıyor gibi) vardı ve çok sayıda adresin ping-up işlemedi.

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

Emin olun pyping yüklü veya yüklemek pip kurulum pyping

#!/usr/bin/python
import pyping

response = pyping.ping('Your IP')

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

Ham ICMP paketlerini göndermek için gereken yüksek ayrıcalıklar nedeniyle programlı ICMP ping karmaşıktır ve pingikili çağırma çirkindir. Sunucu izleme için, TCP ping adı verilen bir tekniği kullanarak aynı sonucu elde edebilirsiniz :

# 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

Dahili olarak, bu sadece hedef sunucuya bir TCP bağlantısı kurar ve geçen süreyi ölçerek hemen bırakır. Bu özel uygulama, kapalı bağlantı noktalarını işlememesi nedeniyle biraz sınırlıdır, ancak kendi sunucularınız için oldukça iyi çalışır.

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

Bunu şu şekilde çözerim:

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" , ping'in doğru olup olmadığını bilmenin yoludur. saludos

Bu yayındaki yanıtlardan fikirler kullanarak ancak yalnızca daha yeni önerilen alt işlem modülü ve python3 kullanarak azaltımım:

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)

Bu komut dosyası Windows üzerinde çalışır ve diğer işletim sistemlerinde çalışmalıdır: Windows, Debian ve macosx üzerinde çalışır, solaris üzerinde bir teste ihtiyaç duyar.

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

Benzer bir senaryo ile ilgili bu soruyu buldum. Pyping denedim ama Naveen tarafından verilen örnek Python 2.7 altında Windows'ta benim için çalışmadı.

Benim için çalışan bir örnek:

import pyping

response = pyping.send('Your IP')

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

Multi-ping ( pip install multiPing) kullanarak bu basit kodu yaptım ( sadece kopyalayıp yapıştırın! ):

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

Kullanımı:

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

Tek bir örnek istiyorsanız, ikinci parametre " 10" yok sayılabilir!

Umarım yardımcı olur!

Ping işlevimin sürümü:

• Python 3.5 ve sonraki sürümlerinde, Windows ve Linux'ta çalışır (Mac'te çalışmalıdır, ancak test edemez).
• Windows'ta ping komutu "Hedef Ana Bilgisayara Ulaşılamıyor" ile başarısız olursa False değerini döndürür.
• Açılır pencere olarak veya komut satırında herhangi bir çıktı göstermez.

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

İstediğiniz gibi kullanmaktan çekinmeyin.

Yeterince basit görünüyor, ama bana uyuyor. Ben "icmp açık soket işlemine izin verilmiyor" almaya devam etti, aksi takdirde çözümler sunucu kapalı olsaydı çözümler asmak. Bununla birlikte, bilmek istediğiniz şey sunucunun canlı olması ve bu sunucuda bir web sunucusu çalıştırıyorsanız, curl işi yapacaktır. Ssh ve sertifikalarınız varsa, ssh ve basit bir komut yeterli olacaktır. İşte kod:

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

Benzer bir gereksinim vardı, bu yüzden aşağıda gösterildiği gibi uyguladım. Windows 64 bit ve Linux üzerinde test edilmiştir.

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))

IP'ye erişilemediğinde subprocess.check_output () bir istisna oluşturur. 'Paket: Gönderilen = 2, Alındı ​​= 2, Kayıp = 0 (% 0 kayıp)' çıkış satırından bilgi çıkarılarak ek doğrulama yapılabilir.

İşte Python'un subprocessmodülünü ve pingtemel OS tarafından sağlanan CLI aracını kullanarak bir çözüm . Windows ve Linux üzerinde test edilmiştir. Ağ zaman aşımı ayarlamayı destekleyin. Kök ayrıcalıklarına gerek yoktur (en azından Windows ve Linux'ta).

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

Bunu python 2.7 üzerinde test edilmiştir ve başarılı çalışır ve False on dönüş başarısız olursa milisaniye içinde ping süresi döndürür.

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

Bir çok cevapsız şeylerden biri ping, "Hedef ana bilgisayara erişilemiyor" yanıtını alırsa (en azından Windows'ta) komutun 0 (başarılı olduğunu gösterir) döndürmesidir.

İşte b'TTL='yanıtta olup olmadığını kontrol eden kodum , çünkü bu sadece ping ana bilgisayara ulaştığında mevcuttur. Not: Bu kodun çoğu buradaki diğer cevaplara dayanmaktadır.

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'))

Not: Bu, çıktıyı yazdırmak yerine yakalar, bu nedenle çıktısını görmek istiyorsanız ping, completedPing.stdoutgeri dönmeden önce yazdırmanız gerekir .

SADECE WINDOWS - Kimsenin açık kırık inanamıyorum Win32_PingStatus Basit bir WMI sorgusu kullanarak gerçekten ayrıntılı bilgilerle dolu bir nesneyi ücretsiz olarak döndürüyoruz

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'

örnek çıktı

Diğer cevaplardan borç almam. Sorguları basitleştirmeye ve en aza indirmeye çalışın.

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"

Daha hızlı bir ping taramasına ihtiyacım vardı ve herhangi bir harici kütüphane kullanmak istemedim, bu yüzden yerleşik kullanarak eşzamanlılık kullanmaya karar verdim asyncio.

Bu kod python 3.7+ gerektirir ve sadece Linux üzerinde yapılır ve test edilir . Windows'da çalışmaz, ancak eminim Windows üzerinde çalışmak için kolayca değiştirebilirsiniz.

Ben bir uzman değilim asyncioama ben bu harika makaleyi kullandık PIETON Programı ile Eşzamanlılık ve ben bu kod satırları ile geldi. Mümkün olduğunca basit hale getirmeye çalıştım, bu yüzden büyük olasılıkla ihtiyaçlarınıza uyacak daha fazla kod eklemeniz gerekecek.

Doğru veya yanlış döndürmez, sadece bir ping isteğine yanıt veren IP'yi yazdırmanın daha uygun olacağını düşündüm. Sanırım oldukça hızlı, yaklaşık 10 saniyede 255 ips ping yapıyor .

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

Örnek çıktı:

192.168.1.1
192.168.1.3
192.168.1.102
192.168.1.106
192.168.1.6

IP yanıt verir verilmez yazdırıldığı için IP'lerin sıralı olmadığına dikkat edin, böylece ilk yanıt veren önce yazdırılır.

  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"

Ben sadece bir dakika içinde pişmiş basit bir ... icmplib kullanarak kök privs ihtiyacı aşağıdaki oldukça iyi çalışıyor! HTH