local import

dtls/__init__.py

@@ -48,7 +48,7 @@ def _prep_bins():
     prebuilt_path = path.join(package_root, "prebuilt", platform + bit_suffix)
     config = {"MANIFEST_DIR": prebuilt_path}
     try:
-        execfile(path.join(prebuilt_path, "manifest.pycfg"), config)
+        exec(compile(open(path.join(prebuilt_path, "manifest.pycfg"), "rb").read()), config)
     except IOError:
         return  # there are no prebuilts for this platform - nothing to do
     files = map(lambda x: path.join(prebuilt_path, x), config["FILES"])
@@ -60,6 +60,6 @@ def _prep_bins():
 
 _prep_bins()  # prepare before module imports
 
-from patch import do_patch
+from .patch import do_patch
-from sslconnection import SSLContext, SSL, SSLConnection
+from .sslconnection import SSLContext, SSL, SSLConnection
-from demux import force_routing_demux, reset_default_demux
+from .demux import force_routing_demux, reset_default_demux

dtls/openssl.py

@@ -38,9 +38,9 @@ import socket
 from logging import getLogger
 from os import path
 from datetime import timedelta
-from err import openssl_error
+from .err import openssl_error
-from err import SSL_ERROR_NONE
+from .err import SSL_ERROR_NONE
-from util import _EC_KEY, _BIO
+from .util import _EC_KEY, _BIO
 import ctypes
 from ctypes import CDLL
 from ctypes import CFUNCTYPE
@@ -65,8 +65,8 @@ if sys.platform.startswith('win'):
     libcrypto = CDLL(cryptodll_path)
     libssl = CDLL(ssldll_path)
 else:
-    libcrypto = CDLL("libcrypto.so.1.0.0")
+    libcrypto = CDLL("libcrypto.so.1.0.2")
-    libssl = CDLL("libssl.so.1.0.0")
+    libssl = CDLL("libssl.so.1.0.2")
 
 #
 # Integer constants - exported

dtls/patch.py

@@ -34,18 +34,19 @@ has the following effects:
       PROTOCOL_DTLSv1 for the parameter ssl_version is supported
 """
 
-from socket import socket, getaddrinfo, _delegate_methods, error as socket_error
+# from socket import socket, getaddrinfo, _delegate_methods, error as socket_error
+from socket import socket, getaddrinfo, error as socket_error
 from socket import AF_INET, SOCK_STREAM, SOCK_DGRAM
 from ssl import PROTOCOL_SSLv23, CERT_NONE
 from types import MethodType
 from weakref import proxy
 import errno
 
-from sslconnection import SSLConnection, PROTOCOL_DTLS, PROTOCOL_DTLSv1, PROTOCOL_DTLSv1_2
+from .sslconnection import SSLConnection, PROTOCOL_DTLS, PROTOCOL_DTLSv1, PROTOCOL_DTLSv1_2
-from sslconnection import DTLS_OPENSSL_VERSION_NUMBER, DTLS_OPENSSL_VERSION, DTLS_OPENSSL_VERSION_INFO
+from .sslconnection import DTLS_OPENSSL_VERSION_NUMBER, DTLS_OPENSSL_VERSION, DTLS_OPENSSL_VERSION_INFO
-from sslconnection import SSL_BUILD_CHAIN_FLAG_NONE, SSL_BUILD_CHAIN_FLAG_UNTRUSTED, \
+from .sslconnection import SSL_BUILD_CHAIN_FLAG_NONE, SSL_BUILD_CHAIN_FLAG_UNTRUSTED, \
     SSL_BUILD_CHAIN_FLAG_NO_ROOT, SSL_BUILD_CHAIN_FLAG_CHECK, SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR, SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR
-from err import raise_as_ssl_module_error, patch_ssl_errors
+from .err import raise_as_ssl_module_error, patch_ssl_errors
 
 
 def do_patch():
@@ -158,11 +159,11 @@ def _SSLSocket_init(self, sock=None, keyfile=None, certfile=None,
     else:
         socket.__init__(self, _sock=sock.get_socket(True)._sock)
     # Copy instance initialization from SSLSocket class
-    for attr in _delegate_methods:
+    #for attr in _delegate_methods:
-        try:
+    #    try:
-            delattr(self, attr)
+    #        delattr(self, attr)
-        except AttributeError:
+    #    except AttributeError:
-            pass
+    #        pass
 
     if certfile and not keyfile:
         keyfile = certfile
@@ -170,7 +171,7 @@ def _SSLSocket_init(self, sock=None, keyfile=None, certfile=None,
         # see if it's connected
         try:
             socket.getpeername(self)
-        except socket_error, e:
+        except socket_error as e:
             if e.errno != errno.ENOTCONN:
                 raise
             # no, no connection yet

dtls/sslconnection.py

@@ -50,17 +50,17 @@ from os import urandom
 from select import select
 from weakref import proxy
 
-from err import openssl_error, InvalidSocketError
+from .err import openssl_error, InvalidSocketError
-from err import raise_ssl_error
+from .err import raise_ssl_error
-from err import SSL_ERROR_WANT_READ, SSL_ERROR_SYSCALL
+from .err import SSL_ERROR_WANT_READ, SSL_ERROR_SYSCALL
-from err import ERR_WRONG_VERSION_NUMBER, ERR_COOKIE_MISMATCH, ERR_NO_SHARED_CIPHER
+from .err import ERR_WRONG_VERSION_NUMBER, ERR_COOKIE_MISMATCH, ERR_NO_SHARED_CIPHER
-from err import ERR_NO_CIPHER, ERR_HANDSHAKE_TIMEOUT, ERR_PORT_UNREACHABLE
+from .err import ERR_NO_CIPHER, ERR_HANDSHAKE_TIMEOUT, ERR_PORT_UNREACHABLE
-from err import ERR_READ_TIMEOUT, ERR_WRITE_TIMEOUT
+from .err import ERR_READ_TIMEOUT, ERR_WRITE_TIMEOUT
-from err import ERR_BOTH_KEY_CERT_FILES, ERR_BOTH_KEY_CERT_FILES_SVR, ERR_NO_CERTS
+from .err import ERR_BOTH_KEY_CERT_FILES, ERR_BOTH_KEY_CERT_FILES_SVR, ERR_NO_CERTS
-from x509 import _X509, decode_cert
+from .x509 import _X509, decode_cert
-from tlock import tlock_init
+from .tlock import tlock_init
-from openssl import *
+from .openssl import *
-from util import _Rsrc, _BIO
+from .util import _Rsrc, _BIO
 
 _logger = getLogger(__name__)
 

dtls/test/echo_seq.py

@@ -56,13 +56,13 @@ def main():
 
     while True:
         cnt += 1
-        print "Listen invocation: %d" % cnt
+        print("Listen invocation: %d" % cnt)
         peer_address = scn.listen()
         if peer_address:
-            print "Completed listening for peer: %s" % str(peer_address)
+            print("Completed listening for peer: %s" % str(peer_address))
             break
 
-    print "Accepting..."
+    print("Accepting...")
     conn = scn.accept()[0]
     sck.settimeout(5)
     conn.get_socket(True).settimeout(5)
@@ -70,26 +70,26 @@ def main():
     cnt = 0
     while True:
         cnt += 1
-        print "Listen invocation: %d" % cnt
+        print("Listen invocation: %d" % cnt)
         peer_address = scn.listen()
         assert not peer_address
-        print "Handshake invocation: %d" % cnt
+        print("Handshake invocation: %d" % cnt)
         try:
             conn.do_handshake()
         except SSLError as err:
             if err.errno == 504:
                 continue
             raise
-        print "Completed handshaking with peer"
+        print("Completed handshaking with peer")
         break
 
     cnt = 0
     while True:
         cnt += 1
-        print "Listen invocation: %d" % cnt
+        print("Listen invocation: %d" % cnt)
         peer_address = scn.listen()
         assert not peer_address
-        print "Read invocation: %d" % cnt
+        print("Read invocation: %d" % cnt)
         try:
             message = conn.read()
         except SSLError as err:
@@ -98,16 +98,16 @@ def main():
             if err.args[0] == SSL_ERROR_ZERO_RETURN:
                 break
             raise
-        print message
+        print(message)
         conn.write("Back to you: " + message)
 
     cnt = 0
     while True:
         cnt += 1
-        print "Listen invocation: %d" % cnt
+        print("Listen invocation: %d" % cnt)
         peer_address = scn.listen()
         assert not peer_address
-        print "Shutdown invocation: %d" % cnt
+        print("Shutdown invocation: %d" % cnt)
         try:
             s = conn.shutdown()
             s.shutdown(socket.SHUT_RDWR)

dtls/test/simple_client.py

@@ -10,6 +10,6 @@ cert_path = path.join(path.abspath(path.dirname(__file__)), "certs")
 sock = ssl.wrap_socket(socket(AF_INET, SOCK_DGRAM), cert_reqs=ssl.CERT_REQUIRED, ca_certs=path.join(cert_path, "ca-cert.pem"))
 sock.connect(('localhost', 28000))
 sock.send('Hi there')
-print sock.recv()
+print(sock.recv())
 sock.unwrap()
 sock.shutdown(SHUT_RDWR)

dtls/test/test_perf.py

@@ -84,7 +84,7 @@ fill = urandom(CHUNK_SIZE)
 def transfer_out(sock, listen_sock=None, marker=False):
     max_i_len = 10
     start_char = "t" if marker else "s"
-    for i in xrange(CHUNKS):
+    for i in range(CHUNKS):
         prefix = start_char + str(i) + ":"
         pad_prefix = prefix + "b" * (max_i_len - len(prefix))
         message = pad_prefix + fill[:CHUNK_SIZE - max_i_len - 1] + "e"
@@ -106,7 +106,7 @@ def transfer_out(sock, listen_sock=None, marker=False):
         if not i % CHUNKS_PER_DOT:
             sys.stdout.write('.')
             sys.stdout.flush()
-    print
+    print()
 
 def transfer_in(sock, listen_sock=None):
     drops = 0
@@ -168,7 +168,7 @@ def transfer_in(sock, listen_sock=None):
             sys.stdout.flush()
         i += 1
     drops += CHUNKS - 1 - pack_seq
-    print
+    print()
     return drops
 
 #
@@ -260,7 +260,7 @@ def make_client_manager():
     # Create the global client manager class in servers configured as client
     # managers
     class ClientManager(object):
-        from Queue import Queue
+        from queue import Queue
 
         queue = Queue()
         clients = -1  # creator does not count
@@ -324,16 +324,16 @@ def remote_client(manager_address):
     manager = Manager(manager_address, COMM_KEY)
     manager.connect()
     queue = manager.get_queue()
-    print "Client connected; waiting for job..."
+    print("Client connected; waiting for job...")
     while True:
         command = queue.get()
         if command == "STOP":
             break
         command = command[:-1] + [(manager_address[0], command[-1][1])]
-        print "Starting job: " + str(command)
+        print("Starting job: " + str(command))
         drops = client(*command)
-        print "%d drops" % drops
+        print("%d drops" % drops)
-        print "Job completed; waiting for next job..."
+        print("Job completed; waiting for next job...")
 
 #
 # Test runner
@@ -349,7 +349,7 @@ def run_test(server_args, client_args, port):
         # bind to loopback only, for local clients
         listen_addr = 'localhost', port
     svr = iter(server(*server_args, listen_addr=listen_addr))
-    listen_addr = svr.next()
+    listen_addr = next(svr)
     listen_addr = 'localhost', listen_addr[1]
     client_args = list(client_args)
     client_args.append(listen_addr)
@@ -360,19 +360,19 @@ def run_test(server_args, client_args, port):
         proc.start()
     in_size = CHUNK_SIZE * CHUNKS / 2**20
     out_size = CHUNK_SIZE * CHUNKS / 2**20
-    print "Starting inbound: %dMiB" % in_size
+    print("Starting inbound: %dMiB" % in_size)
-    svr_in_time, drops = svr.next()
+    svr_in_time, drops = next(svr)
-    print "Inbound: %.3f seconds, %dMiB/s, %d drops" % (
+    print("Inbound: %.3f seconds, %dMiB/s, %d drops" % (
-        svr_in_time, in_size / svr_in_time, drops)
+        svr_in_time, in_size / svr_in_time, drops))
-    print "Starting outbound: %dMiB" % out_size
+    print("Starting outbound: %dMiB" % out_size)
-    svr_out_time = svr.next()
+    svr_out_time = next(svr)
-    print "Outbound: %.3f seconds, %dMiB/s" % (
+    print("Outbound: %.3f seconds, %dMiB/s" % (
-        svr_out_time, out_size / svr_out_time)
+        svr_out_time, out_size / svr_out_time))
     if not QUEUE:
         proc.join()
-    print "Combined: %.3f seconds, %dMiB/s" % (
+    print("Combined: %.3f seconds, %dMiB/s" % (
         svr_out_time + svr_in_time,
-        (in_size + out_size) / (svr_in_time + svr_out_time))
+        (in_size + out_size) / (svr_in_time + svr_out_time)))
 
 #
 # Main entry point
@@ -419,16 +419,16 @@ if __name__ == "__main__":
         }
     do_patch()
     while True:
-        print "\nSelect protocol:\n"
+        print("\nSelect protocol:\n")
         for key in sorted(selector):
-            print "\t" + str(key) + ": " + selector[key]
+            print("\t" + str(key) + ": " + selector[key])
         try:
-            choice = raw_input("\nProtocol: ")
+            choice = input("\nProtocol: ")
             choice = int(choice)
             if choice < 0 or choice >= len(selector):
                 raise ValueError("Invalid selection input")
         except (ValueError, OverflowError):
-            print "Invalid selection input"
+            print("Invalid selection input")
             continue
         except EOFError:
             break

dtls/test/unit.py

@@ -59,7 +59,7 @@ class BasicTests(unittest.TestCase):
         # A crude test for the legacy API
         try:
             ssl.sslwrap_simple(socket.socket(AF_INET4_6, socket.SOCK_DGRAM))
-        except IOError, e:
+        except IOError as e:
             if e.errno == 32: # broken pipe when ssl_sock.do_handshake(), this test doesn't care about that
                 pass
             else:
@@ -67,7 +67,7 @@ class BasicTests(unittest.TestCase):
         try:
             ssl.sslwrap_simple(socket.socket(AF_INET4_6,
                                              socket.SOCK_DGRAM)._sock)
-        except IOError, e:
+        except IOError as e:
             if e.errno == 32: # broken pipe when ssl_sock.do_handshake(), this test doesn't care about that
                 pass
             else:
@@ -281,7 +281,7 @@ class NetworkedTests(unittest.TestCase):
                     count += 1
                     s.do_handshake()
                     break
-                except ssl.SSLError, err:
+                except ssl.SSLError as err:
                     if err.args[0] == ssl.SSL_ERROR_WANT_READ:
                         while True:
                             to = s.get_timeout()
@@ -601,7 +601,7 @@ class AsyncoreEchoServer(threading.Thread):
             def _do_ssl_handshake(self):
                 try:
                     self.socket.do_handshake()
-                except ssl.SSLError, err:
+                except ssl.SSLError as err:
                     if err.args[0] in (ssl.SSL_ERROR_WANT_READ,
                                        ssl.SSL_ERROR_WANT_WRITE,
                                        ssl.SSL_ERROR_SSL):
@@ -609,7 +609,7 @@ class AsyncoreEchoServer(threading.Thread):
                     elif err.args[0] == ssl.SSL_ERROR_EOF:
                         return self.handle_close()
                     raise
-                except socket.error, err:
+                except socket.error as err:
                     if err.args[0] == errno.ECONNABORTED:
                         return self.handle_close()
                 else:
@@ -861,10 +861,10 @@ def bad_cert_test(certfile):
                                 certfile=certfile,
                                 ssl_version=ssl.PROTOCOL_DTLSv1)
             s.connect((HOST, server.port))
-        except ssl.SSLError, x:
+        except ssl.SSLError as x:
             if test_support.verbose:
                 sys.stdout.write("\nSSLError is %s\n" % x[1])
-        except socket.error, x:
+        except socket.error as x:
             if test_support.verbose:
                 sys.stdout.write("\nsocket.error is %s\n" % x[1])
         else:

dtls/tlock.py

@@ -25,7 +25,7 @@ threading support. It does not have client-visible components.
 """
 
 from logging import getLogger
-from openssl import *
+from .openssl import *
 
 try:
     import threading

dtls/wrapper.py

@@ -35,10 +35,10 @@ from logging import getLogger
 
 import ssl
 import socket
-from patch import do_patch
+from .patch import do_patch
 do_patch()
-from sslconnection import SSLContext, SSL
+from .sslconnection import SSLContext, SSL
-import err as err_codes
+import .err as err_codes
 
 _logger = getLogger(__name__)
 

dtls/x509.py

@@ -31,8 +31,8 @@ interpreter.
 """
 
 from logging import getLogger
-from openssl import *
+from .openssl import *
-from util import _Rsrc, _BIO
+from .util import _Rsrc, _BIO
 
 _logger = getLogger(__name__)
 

setup.py

@@ -49,10 +49,10 @@ if __name__ == "__main__":
         from pypandoc import convert
         long_description = convert("README.md", "rst")\
                            .translate({ord("\r"): None})
-        with open("README.rst", "wb") as readme:
+        with open("README.rst", "w") as readme:
             readme.write(long_description)
     else:
-        long_description = open("README.rst").read()
+        long_description = open("README.md").read()
     top_package_plat_files_file = "dtls_package_files"
     if dist:
         if plat_dist: