स्कैपी कैसे पिंग समय मिलता है?

Question

मैं एक स्कैपी स्क्रिप्ट लिखने की कोशिश कर रहा हूं जो पिंग समय पर औसत बना सकता है, इसलिए मुझे आईसीएमपी गूंज/उत्तर पैकेट भेजा गया और उत्तर पैकेट प्राप्त करने के बीच का समय बीतने की जरूरत है। अभी के लिए, मेरे पास यह है:

#! /usr/bin/env python 
from scapy.all import * 
from time import * 

def QoS_ping(host, count=3): 
    packet = Ether()/IP(dst=host)/ICMP() 
    t=0.0 
    for x in range(count): 
     t1=time() 
     ans=srp(packet,iface="eth0", verbose=0) 
     t2=time() 
     t+=t2-t1 
    return (t/count)*1000 

समस्या यह है कि समय() फ़ंक्शन का उपयोग करने से कोई अच्छा परिणाम नहीं बढ़ता है। उदाहरण के लिए, मुझे एक डोमेन पर 134 एमएस मिलते हैं, और उसी डोमेन पर पिंग सिस्टम फ़ंक्शन के साथ, मुझे 30 एमएस (कोर्स का औसत) मिला है।

मेरा प्रश्न है: क्या भेजा गया पैकेट के बीच में सही समय प्राप्त करने का कोई तरीका है और स्कैपी द्वारा पैकेट प्राप्त किया गया है? मैं popen() फ़ंक्शन या अन्य सिस्टम कॉल का उपयोग नहीं करना चाहता क्योंकि मुझे फ़्यूचर पैकेट प्रबंधन के लिए स्कैपी की आवश्यकता है।

Answer 1

स्कैपी धीमी है क्योंकि यह शुद्ध स्थान है जो उपयोगकर्ता अंतरिक्ष में पूरे पैकेट को पार्स कर रहा है ... it is not all that unusual to hack around scapy's thoughput limitations।

सेब की तुलना में सेब बनाना ... मेरे पास इंटरनेट पर डायरेक्ट गिग ईथरनेट पाइप वाला ज़ीऑन सर्वर है, लेकिन मेरा ट्रैफ़िक बहुत हल्का है। जब मैं सिस्को रूटर इसे करने के लिए, मैं के बारे में 60 माइक्रोसेकंड प्रत्येक औसत रहा हूँ संलग्न है के लिए एक सामान्य पिंग ...

[mpenning@Bucksnort ~]$ ping -W 1 -c 3 192.0.2.1 
PING 192.0.2.1 (192.0.2.6) 56(84) bytes of data. 
64 bytes from 192.0.2.1: icmp_req=1 ttl=64 time=0.078 ms 
64 bytes from 192.0.2.1: icmp_req=2 ttl=64 time=0.062 ms 
64 bytes from 192.0.2.1: icmp_req=3 ttl=64 time=0.062 ms 

--- 192.0.2.1 ping statistics --- 
3 packets transmitted, 3 received, 0% packet loss, time 1998ms 
rtt min/avg/max/mdev = 0.062/0.067/0.078/0.010 ms 
[mpenning@Bucksnort ~]$ 

Scapy ... भी मिलीसेकेंड में मापा जाता में एक ही गंतव्य ... चलाने

[mpenning@Bucksnort ~]$ sudo python new_ping_ip.py 
Ping: 0.285587072372 
Ping: 0.230889797211 
Ping: 0.219928979874 
AVERAGE 245.468616486 
[mpenning@Bucksnort ~]$ 

Scapy के परिणाम बैश शीघ्र (245.469/0.062) ... मैं केबल अपने आप को दौड़ा से एक आधारभूत पिंग की तुलना में लगभग गुना बड़ा है, यह सिस्को रूटर से एक दस फुट केबल से कम है।

बेहतर परिणाम प्राप्त करने के लिए आप क्या कर सकते हैं? जैसा कि टिप्पणियों में उल्लेख किया गया है, sent_time और time देखें ... Packet.time पार्सिंग से पहले पॉप्युलेट किया गया है ... यह अभी भी खोल से एक पिंग से धीमा है, लेकिन स्कैपी में पैकेट को पकड़ने की आपकी इच्छा में मदद कर सकता है।

#! /usr/bin/env python 
from scapy.all import * 

def QoS_ping(host, count=3): 
    packet = Ether()/IP(dst=host)/ICMP() 
    t=0.0 
    for x in range(count): 
     ans,unans=srp(packet,iface="eth0", filter='icmp', verbose=0) 
     rx = ans[0][1] 
     tx = ans[0][0] 
     delta = rx.time-tx.sent_time 
     print "Ping:", delta 
     t+=delta 
    return (t/count)*1000 

if __name__=="__main__": 
    total = QoS_ping('192.0.2.1') 
    print "TOTAL", total 

नमूना रन ...

[mpenning@Bucksnort ~]$ sudo python ping_ip.py 
Ping: 0.000389099121094 
Ping: 0.000531911849976 
Ping: 0.000631093978882 
TOTAL 0.51736831665 
[mpenning@Bucksnort ~]$ 

यहां तक ​​कि का उपयोग कर Packet.time और Packet.sent_time एक खोल कॉल हालांकि की तुलना में धीमी है ...

>>> from subprocess import Popen, PIPE 
>>> import re 
>>> cmd = Popen('ping -q -c 3 192.0.2.1'.split(' '), stdout=PIPE) 
>>> output = cmd.communicate()[0] 
>>> match = re.search('(\d+\.\d+)\/(\d+\.\d+)\/(\d+\.\d+)\/(\d+\.\d+)\s+ms', output) 
>>> if not (match is None): 
...  print "Average %0.3f" % float(match.group(1)) 
... else: 
...  print "Failure" 
... 
Average 0.073 
>>> 

ping -q -c 3 3 पिंग्स का सारांश आउटपुट प्रदान करता है व्यक्तिगत पिंग मुद्रित किए बिना।

आप अपने पिंग पैकेट, बाद में scapy प्रसंस्करण के लिए (एक खोल पिंग कॉल के माध्यम से) पर कब्जा करने के अपने CLI पिंग चलाने से पहले tcpdump -c <num-packets> -w <filename> icmp and host <host-addr> & अंडे चाहते हैं ... तो Scapy के rdpcap() का उपयोग tcpdump से PCAP फ़ाइल को पढ़ने के लिए। अपने पैकेप फ़ाइल में कैप्चर किए जाने वाले पैकेट की संख्या की उचित गणना करना सुनिश्चित करें।

Answer 2

बीटीडब्लू, अनबफर्ड पायथन (पायथन-इसे शुरू करने के लिए) का उपयोग करके समय सटीकता बढ़ जाती है क्योंकि पाइथन बफर को डंप करने का फैसला नहीं कर रहा है। आपकी उपरोक्त लिपि का उपयोग करके, यह मेरे परिणामों को 0.4 एमएस से 0.1-आईएस तक बंद होने से बदल दिया।

Answer 3

माइक, बस आदेश औसत समय, परिवर्तन प्राप्त करने के लिए एक छोटे से ठीक:

print "Average %0.3f" % float(match.group(1)) 

रहे हैं:

print "Average %0.3f" % float(match.group(2)) 

के बाद से (match.group (1)) मिनट समय मिल जाएगा और उल्लेख के रूप में औसत नहीं है।