Added support for python 3+

ping.py

@@ -1,103 +1,29 @@
-#!/usr/bin/env python
-
-"""
-    A pure python ping implementation using raw socket.
-
-
-    Note that ICMP messages can only be sent from processes running as root.
-
-
-    Derived from ping.c distributed in Linux's netkit. That code is
-    copyright (c) 1989 by The Regents of the University of California.
-    That code is in turn derived from code written by Mike Muuss of the
-    US Army Ballistic Research Laboratory in December, 1983 and
-    placed in the public domain. They have my thanks.
-
-    Bugs are naturally mine. I'd be glad to hear about them. There are
-    certainly word - size dependenceies here.
-
-    Copyright (c) Matthew Dixon Cowles, <http://www.visi.com/~mdc/>.
-    Distributable under the terms of the GNU General Public License
-    version 2. Provided with no warranties of any sort.
-
-    Original Version from Matthew Dixon Cowles:
-      -> ftp://ftp.visi.com/users/mdc/ping.py
-
-    Rewrite by Jens Diemer:
-      -> http://www.python-forum.de/post-69122.html#69122
-
-
-    Revision history
-    ~~~~~~~~~~~~~~~~
-
-    March 11, 2010
-    changes by Samuel Stauffer:
-    - replaced time.clock with default_timer which is set to
-      time.clock on windows and time.time on other systems.
-
-    May 30, 2007
-    little rewrite by Jens Diemer:
-     -  change socket asterisk import to a normal import
-     -  replace time.time() with time.clock()
-     -  delete "return None" (or change to "return" only)
-     -  in checksum() rename "str" to "source_string"
-
-    November 22, 1997
-    Initial hack. Doesn't do much, but rather than try to guess
-    what features I (or others) will want in the future, I've only
-    put in what I need now.
-
-    December 16, 1997
-    For some reason, the checksum bytes are in the wrong order when
-    this is run under Solaris 2.X for SPARC but it works right under
-    Linux x86. Since I don't know just what's wrong, I'll swap the
-    bytes always and then do an htons().
-
-    December 4, 2000
-    Changed the struct.pack() calls to pack the checksum and ID as
-    unsigned. My thanks to Jerome Poincheval for the fix.
-
-    Januari 27, 2015
-    Changed receive response to not accept ICMP request messages.
-    It was possible to receive the very request that was sent.
-
-    Last commit info:
-    ~~~~~~~~~~~~~~~~~
-    $LastChangedDate: $
-    $Rev: $
-    $Author: $
-"""
-
-
-import os, sys, socket, struct, select, time
-
-if sys.platform == "win32":
-    # On Windows, the best timer is time.clock()
-    default_timer = time.clock
+import os, sys, socket, struct, select, time, base64
+
+if sys.platform.startswith('win'):
+    default_timer = time.perf_counter()
+elif sys.platform.startswith('linux'):
+    default_timer = time.perf_counter()
+if sys.platform.startswith('darwin'):
+    #default_timer = time.clock()
+    default_timer = time.perf_counter()
 else:
-    # On most other platforms the best timer is time.time()
-    default_timer = time.time
+    default_timer = time.perf_counter()
 
-# From /usr/include/linux/icmp.h; your milage may vary.
 ICMP_ECHO_REQUEST = 8 # Seems to be the same on Solaris.
 
-
 def checksum(source_string):
-    """
-    I'm not too confident that this is right but testing seems
-    to suggest that it gives the same answers as in_cksum in ping.c
-    """
     sum = 0
-    countTo = (len(source_string)/2)*2
+    count_to = (len(source_string)//2)*2
     count = 0
-    while count<countTo:
-        thisVal = ord(source_string[count + 1])*256 + ord(source_string[count])
-        sum = sum + thisVal
+    while count < count_to:
+        this_val = source_string[count+1]*256 + source_string[count]
+        sum = sum + this_val
         sum = sum & 0xffffffff # Necessary?
         count = count + 2
 
-    if countTo<len(source_string):
-        sum = sum + ord(source_string[len(source_string) - 1])
+    if count_to < len(source_string):
+        sum = sum + source_string[len(source_string) - 1]# removed ord()
         sum = sum & 0xffffffff # Necessary?
 
     sum = (sum >> 16)  +  (sum & 0xffff)
@@ -110,54 +36,58 @@ def checksum(source_string):
 
     return answer
 
-
-def receive_one_ping(my_socket, ID, timeout):
+def recieve_one_ping(my_socket, ID, timeout):
     """
     receive the ping from the socket.
     """
-    timeLeft = timeout
+    time_left = timeout
     while True:
-        startedSelect = default_timer()
-        whatReady = select.select([my_socket], [], [], timeLeft)
-        howLongInSelect = (default_timer() - startedSelect)
-        if whatReady[0] == []: # Timeout
+        started_select = default_timer
+        what_ready = select.select([my_socket], [], [], time_left)
+        how_long_in_select = (default_timer - started_select) # removed default_timer()
+        if what_ready[0] == []:
             return
 
-        timeReceived = default_timer()
-        recPacket, addr = my_socket.recvfrom(1024)
-        icmpHeader = recPacket[20:28]
-        type, code, checksum, packetID, sequence = struct.unpack(
-            "bbHHh", icmpHeader
+        time_recieved = default_timer
+        rec_packet, addr = my_socket.recvfrom(1024) # changed recv_from to recvfrom
+        icmp_header = rec_packet[20:28]
+        type, code, checksum, packet_id, sequence = struct.unpack(
+            'bbHHh', icmp_header
         )
-        # Filters out the echo request itself. 
-        # This can be tested by pinging 127.0.0.1 
+        # Filters out the echo request itself.
+        # This can be tested by pinging 127.0.0.1
         # You'll see your own request
-        if type != 8 and packetID == ID:
-            bytesInDouble = struct.calcsize("d")
-            timeSent = struct.unpack("d", recPacket[28:28 + bytesInDouble])[0]
-            return timeReceived - timeSent
+        if type != 8 and packet_id == ID:
+            bytes_in_double = struct.calcsize('d')
+            time_sent = struct.unpack('d', rec_packet[28:28 + bytes_in_double])[0]
+            return time_recieved - time_sent
 
-        timeLeft = timeLeft - howLongInSelect
-        if timeLeft <= 0:
+        time_left = time_left - how_long_in_select
+        if time_left <= 0:
             return
 
-
 def send_one_ping(my_socket, dest_addr, ID):
     """
     Send one ping to the given >dest_addr<.
     """
-    dest_addr  =  socket.gethostbyname(dest_addr)
+    dest_addr = socket.gethostbyname(dest_addr)
 
     # Header is type (8), code (8), checksum (16), id (16), sequence (16)
     my_checksum = 0
 
     # Make a dummy heder with a 0 checksum.
     header = struct.pack("bbHHh", ICMP_ECHO_REQUEST, 0, my_checksum, ID, 1)
-    bytesInDouble = struct.calcsize("d")
-    data = (192 - bytesInDouble) * "Q"
-    data = struct.pack("d", default_timer()) + data
+    bytes_in_double = struct.calcsize('d')
+    data = (192 - bytes_in_double) * 'Q'
 
+    data = struct.pack('d', default_timer) + bytes(data.encode('utf-8'))
+    # base64.b64encode(bytes(data.encode('utf-8')))
     # Calculate the checksum on the data and the dummy header.
+
+    # data = base64.b64decode(data) works half the time or fails with incorrect padding
+    #
+
+    data = decode_base64(data)
     my_checksum = checksum(header + data)
 
     # Now that we have the right checksum, we put that in. It's just easier
@@ -168,15 +98,14 @@ def send_one_ping(my_socket, dest_addr, ID):
     packet = header + data
     my_socket.sendto(packet, (dest_addr, 1)) # Don't know about the 1
 
-
 def do_one(dest_addr, timeout):
     """
     Returns either the delay (in seconds) or none on timeout.
     """
     icmp = socket.getprotobyname("icmp")
     try:
         my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp)
-    except socket.error, (errno, msg):
+    except socket.error (errno, msg): # removed ',' from excep, socket.error, (errno, msg)
         if errno == 1:
             # Operation not permitted
             msg = msg + (
@@ -189,32 +118,38 @@ def do_one(dest_addr, timeout):
     my_ID = os.getpid() & 0xFFFF
 
     send_one_ping(my_socket, dest_addr, my_ID)
-    delay = receive_one_ping(my_socket, my_ID, timeout)
-
+    delay = recieve_one_ping(my_socket, my_ID, timeout)
     my_socket.close()
     return delay
 
-
 def verbose_ping(dest_addr, timeout = 2, count = 4):
     """
     Send >count< ping to >dest_addr< with the given >timeout< and display
     the result.
     """
-    for i in xrange(count):
-        print "ping %s..." % dest_addr,
+
+    for i in range(count): # changed xrange() to range()
+        print("ping %s..." % dest_addr,) # removed , maybe take out end=''
         try:
             delay  =  do_one(dest_addr, timeout)
-        except socket.gaierror, e:
-            print "failed. (socket error: '%s')" % e[1]
+
+        except socket.gaierror as e:
+            print("failed. (socket error: '%s')" % e) # e[1]
             break
 
+
         if delay  ==  None:
-            print "failed. (timeout within %ssec.)" % timeout
+            print("failed. (timeout within %ssec.)" % timeout)
         else:
             delay  =  delay * 1000
-            print "get ping in %0.4fms" % delay
+            print("get ping in %0.4fms" % delay)
     print
 
+def decode_base64(your_data):
+    padding = len(your_data) % 4
+    if padding != 0:
+        your_data += b'='* (4 - padding)
+    return base64.b64decode(your_data)
 
 if __name__ == '__main__':
     verbose_ping("heise.de")

ping_py_changes.txt

@@ -0,0 +1,35 @@
+Added the following changes:
+
+changed if sys.platform() to sys.platform.startswith() at lines 3, 6, and 9
+
+Added two extra if statements line 6, and 9 for detecting linux and mac
+
+removed () from default_timer at lines 46, 48, 52 and 82
+
+Changes time.clock() which is depreciated to time.perf_counter() as lines 3 , 6
+9, and 14
+
+Changed count_to = (len(source_string) / 2) * 2 to
+count_to = (len(source_string) // 2) * 2 at line 20
+
+Changed ord(ord(source_string[count + 1]) * 256 + ord(source_string[count])) to
+(source_string[count + 1]) * 256 + source_string[count] at line 23
+
+
+Renamed variables into more readable format.
+
+
+Changed except socket.error, (errno, msg): to except socket.error (errno, msg)
+at line 104
+
+Changed  except socket.gaierror, e: to except socket.gaierror as e: at line 130
+
+Changed xrange() to range at line 125 because xrange was changed to range in
+python 3+
+
+Changed print("ping %s..." % dest_addr,) to print("ping %s..." % dest_addr)
+at line 126
+
+added padding function
+
+added encoding at line 83 and decoding at line 90