求一个linux ping脚本

qldb4u

我需要一个linux的ping脚本，记录ping过程中没有ping通的包，输出到指定文件，ping通时不记录，同时记录ping的时间点，先谢谢各位了

qingduo04

路过，学习..........

ljwsy

有个ping.py脚本，我是直接拿来改再利用的：ping.py

1. #!/usr/bin/env python
   
2. 
   
3. """
   
4.     A pure python ping implementation using raw socket.
   
5. 
   
6. 
   
7.     Note that ICMP messages can only be sent from processes running as root.
   
8. 
   
9. 
   
10.     Derived from ping.c distributed in Linux's netkit. That code is
    
11.     copyright (c) 1989 by The Regents of the University of California.
    
12.     That code is in turn derived from code written by Mike Muuss of the
    
13.     US Army Ballistic Research Laboratory in December, 1983 and
    
14.     placed in the public domain. They have my thanks.
    
15. 
    
16.     Bugs are naturally mine. I'd be glad to hear about them. There are
    
17.     certainly word - size dependenceies here.
    
18. 
    
19.     Copyright (c) Matthew Dixon Cowles, <http://www.visi.com/~mdc/>.
    
20.     Distributable under the terms of the GNU General Public License
    
21.     version 2. Provided with no warranties of any sort.
    
22. 
    
23.     Original Version from Matthew Dixon Cowles:
    
24.       -> ftp://ftp.visi.com/users/mdc/ping.py
    
25. 
    
26.     Rewrite by Jens Diemer:
    
27.       -> http://www.python-forum.de/post-69122.html#69122
    
28. 
    
29.     Rewrite by George Notaras:
    
30.       -> http://www.g-loaded.eu/2009/10/30/python-ping/
    
31. 
    
32.     Revision history
    
33.     ~~~~~~~~~~~~~~~~
    
34. 
    
35.     November 8, 2009
    
36.     ----------------
    
37.     Improved compatibility with GNU/Linux systems.
    
38. 
    
39.     Fixes by:
    
40.      * George Notaras -- http://www.g-loaded.eu
    
41.     Reported by:
    
42.      * Chris Hallman -- http://cdhallman.blogspot.com
    
43. 
    
44.     Changes in this release:
    
45.      - Re-use time.time() instead of time.clock(). The 2007 implementation
    
46.        worked only under Microsoft Windows. Failed on GNU/Linux.
    
47.        time.clock() behaves differently under the two OSes[1].
    
48. 
    
49.     [1] http://docs.python.org/library/time.html#time.clock
    
50. 
    
51.     May 30, 2007
    
52.     ------------
    
53.     little rewrite by Jens Diemer:
    
54.      -  change socket asterisk import to a normal import
    
55.      -  replace time.time() with time.clock()
    
56.      -  delete "return None" (or change to "return" only)
    
57.      -  in checksum() rename "str" to "source_string"
    
58. 
    
59.     November 22, 1997
    
60.     -----------------
    
61.     Initial hack. Doesn't do much, but rather than try to guess
    
62.     what features I (or others) will want in the future, I've only
    
63.     put in what I need now.
    
64. 
    
65.     December 16, 1997
    
66.     -----------------
    
67.     For some reason, the checksum bytes are in the wrong order when
    
68.     this is run under Solaris 2.X for SPARC but it works right under
    
69.     Linux x86. Since I don't know just what's wrong, I'll swap the
    
70.     bytes always and then do an htons().
    
71. 
    
72.     December 4, 2000
    
73.     ----------------
    
74.     Changed the struct.pack() calls to pack the checksum and ID as
    
75.     unsigned. My thanks to Jerome Poincheval for the fix.
    
76. 
    
77. 
    
78.     Last commit info:
    
79.     ~~~~~~~~~~~~~~~~~
    
80.     $LastChangedDate: $
    
81.     $Rev: $
    
82.     $Author: $
    
83. """
    
84. 
    
85. 
    
86. import os, sys, socket, struct, select, time
    
87. 
    
88. # From /usr/include/linux/icmp.h; your milage may vary.
    
89. ICMP_ECHO_REQUEST = 8 # Seems to be the same on Solaris.
    
90. 
    
91. 
    
92. def checksum(source_string):
    
93.     """
    
94.     I'm not too confident that this is right but testing seems
    
95.     to suggest that it gives the same answers as in_cksum in ping.c
    
96.     """
    
97.     sum = 0
    
98.     countTo = (len(source_string)/2)*2
    
99.     count = 0
    
100.     while count<countTo:
     
101.         thisVal = ord(source_string[count + 1])*256 + ord(source_string[count])
     
102.         sum = sum + thisVal
     
103.         sum = sum & 0xffffffff # Necessary?
     
104.         count = count + 2
     
105. 
     
106.     if countTo<len(source_string):
     
107.         sum = sum + ord(source_string[len(source_string) - 1])
     
108.         sum = sum & 0xffffffff # Necessary?
     
109. 
     
110.     sum = (sum >> 16)  +  (sum & 0xffff)
     
111.     sum = sum + (sum >> 16)
     
112.     answer = ~sum
     
113.     answer = answer & 0xffff
     
114. 
     
115.     # Swap bytes. Bugger me if I know why.
     
116.     answer = answer >> 8 | (answer << 8 & 0xff00)
     
117. 
     
118.     return answer
     
119. 
     
120. 
     
121. def receive_one_ping(my_socket, ID, timeout):
     
122.     """
     
123.     receive the ping from the socket.
     
124.     """
     
125.     timeLeft = timeout
     
126.     while True:
     
127.         startedSelect = time.time()
     
128.         whatReady = select.select([my_socket], [], [], timeLeft)
     
129.         howLongInSelect = (time.time() - startedSelect)
     
130.         if whatReady[0] == []: # Timeout
     
131.             return
     
132. 
     
133.         timeReceived = time.time()
     
134.         recPacket, addr = my_socket.recvfrom(1024)
     
135.         icmpHeader = recPacket[20:28]
     
136.         type, code, checksum, packetID, sequence = struct.unpack(
     
137.             "bbHHh", icmpHeader
     
138.         )
     
139.         if packetID == ID:
     
140.             bytesInDouble = struct.calcsize("d")
     
141.             timeSent = struct.unpack("d", recPacket[28:28 + bytesInDouble])[0]
     
142.             return timeReceived - timeSent
     
143. 
     
144.         timeLeft = timeLeft - howLongInSelect
     
145.         if timeLeft <= 0:
     
146.             return
     
147. 
     
148. 
     
149. def send_one_ping(my_socket, dest_addr, ID):
     
150.     """
     
151.     Send one ping to the given >dest_addr<.
     
152.     """
     
153.     dest_addr  =  socket.gethostbyname(dest_addr)
     
154. 
     
155.     # Header is type (8), code (8), checksum (16), id (16), sequence (16)
     
156.     my_checksum = 0
     
157. 
     
158.     # Make a dummy heder with a 0 checksum.
     
159.     header = struct.pack("bbHHh", ICMP_ECHO_REQUEST, 0, my_checksum, ID, 1)
     
160.     bytesInDouble = struct.calcsize("d")
     
161.     data = (192 - bytesInDouble) * "Q"
     
162.     data = struct.pack("d", time.time()) + data
     
163. 
     
164.     # Calculate the checksum on the data and the dummy header.
     
165.     my_checksum = checksum(header + data)
     
166. 
     
167.     # Now that we have the right checksum, we put that in. It's just easier
     
168.     # to make up a new header than to stuff it into the dummy.
     
169.     header = struct.pack(
     
170.         "bbHHh", ICMP_ECHO_REQUEST, 0, socket.htons(my_checksum), ID, 1
     
171.     )
     
172.     packet = header + data
     
173.     my_socket.sendto(packet, (dest_addr, 1)) # Don't know about the 1
     
174. 
     
175. 
     
176. def do_one(dest_addr, timeout):
     
177.     """
     
178.     Returns either the delay (in seconds) or none on timeout.
     
179.     """
     
180.     icmp = socket.getprotobyname("icmp")
     
181.     try:
     
182.         my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp)
     
183.     except socket.error, (errno, msg):
     
184.         if errno == 1:
     
185.             # Operation not permitted
     
186.             msg = msg + (
     
187.                 " - Note that ICMP messages can only be sent from processes"
     
188.                 " running as root."
     
189.             )
     
190.             raise socket.error(msg)
     
191.         raise # raise the original error
     
192. 
     
193.     my_ID = os.getpid() & 0xFFFF
     
194. 
     
195.     send_one_ping(my_socket, dest_addr, my_ID)
     
196.     delay = receive_one_ping(my_socket, my_ID, timeout)
     
197. 
     
198.     my_socket.close()
     
199.     return delay
     
200. 
     
201. 
     
202. def verbose_ping(dest_addr, timeout = 2, count = 4):
     
203.     """
     
204.     Send >count< ping to >dest_addr< with the given >timeout< and display
     
205.     the result.
     
206.     """
     
207.     for i in xrange(count):
     
208.         print "ping %s..." % dest_addr,
     
209.         try:
     
210.             delay  =  do_one(dest_addr, timeout)
     
211.         except socket.gaierror, e:
     
212.             print "failed. (socket error: '%s')" % e[1]
     
213.             break
     
214. 
     
215.         if delay  ==  None:
     
216.             print "failed. (timeout within %ssec.)" % timeout
     
217.         else:
     
218.             delay  =  delay * 1000
     
219.             print "get ping in %0.4fms" % delay
     
220.     print
     
221. 
     
222. 
     
223. if __name__ == '__main__':
     
224.     verbose_ping("heise.de")
     
225.     verbose_ping("google.com")
     
226.     verbose_ping("a-test-url-taht-is-not-available.com")
     
227.     verbose_ping("192.168.1.1")

复制代码