Porting zerobin to python 3

libs/cherrypy/wsgiserver/ssl_builtin.py

@@ -25,31 +25,33 @@ from cherrypy import wsgiserver
 
 
 class BuiltinSSLAdapter(wsgiserver.SSLAdapter):
+
     """A wrapper for integrating Python's builtin ssl module with CherryPy."""
-    
+
     certificate = None
     """The filename of the server SSL certificate."""
-    
+
     private_key = None
     """The filename of the server's private key file."""
-    
+
     def __init__(self, certificate, private_key, certificate_chain=None):
         if ssl is None:
             raise ImportError("You must install the ssl module to use HTTPS.")
         self.certificate = certificate
         self.private_key = private_key
         self.certificate_chain = certificate_chain
-    
+
     def bind(self, sock):
         """Wrap and return the given socket."""
         return sock
-    
+
     def wrap(self, sock):
         """Wrap and return the given socket, plus WSGI environ entries."""
         try:
             s = ssl.wrap_socket(sock, do_handshake_on_connect=True,
-                    server_side=True, certfile=self.certificate,
-                    keyfile=self.private_key, ssl_version=ssl.PROTOCOL_SSLv23)
+                                server_side=True, certfile=self.certificate,
+                                keyfile=self.private_key,
+                                ssl_version=ssl.PROTOCOL_SSLv23)
         except ssl.SSLError:
             e = sys.exc_info()[1]
             if e.errno == ssl.SSL_ERROR_EOF:
@@ -67,7 +69,7 @@ class BuiltinSSLAdapter(wsgiserver.SSLAdapter):
                     return None, {}
             raise
         return s, self.get_environ(s)
-    
+
     # TODO: fill this out more with mod ssl env
     def get_environ(self, sock):
         """Create WSGI environ entries to be merged into each request."""
@@ -77,15 +79,14 @@ class BuiltinSSLAdapter(wsgiserver.SSLAdapter):
             "HTTPS": "on",
             'SSL_PROTOCOL': cipher[1],
             'SSL_CIPHER': cipher[0]
-##            SSL_VERSION_INTERFACE 	string 	The mod_ssl program version
-##            SSL_VERSION_LIBRARY 	string 	The OpenSSL program version
-            }
+            # SSL_VERSION_INTERFACE 	string 	The mod_ssl program version
+            # SSL_VERSION_LIBRARY 	string 	The OpenSSL program version
+        }
         return ssl_environ
-    
+
     if sys.version_info >= (3, 0):
         def makefile(self, sock, mode='r', bufsize=DEFAULT_BUFFER_SIZE):
             return wsgiserver.CP_makefile(sock, mode, bufsize)
     else:
         def makefile(self, sock, mode='r', bufsize=DEFAULT_BUFFER_SIZE):
             return wsgiserver.CP_fileobject(sock, mode, bufsize)
-

libs/cherrypy/wsgiserver/ssl_pyopenssl.py

@@ -1,7 +1,7 @@
 """A library for integrating pyOpenSSL with CherryPy.
 
 The OpenSSL module must be importable for SSL functionality.
-You can obtain it from http://pyopenssl.sourceforge.net/
+You can obtain it from `here <https://launchpad.net/pyopenssl>`_.
 
 To use this module, set CherryPyWSGIServer.ssl_adapter to an instance of
 SSLAdapter. There are two ways to use SSL:
@@ -44,14 +44,15 @@ except ImportError:
 
 
 class SSL_fileobject(wsgiserver.CP_fileobject):
+
     """SSL file object attached to a socket object."""
-    
+
     ssl_timeout = 3
     ssl_retry = .01
-    
+
     def _safe_call(self, is_reader, call, *args, **kwargs):
         """Wrap the given call with SSL error-trapping.
-        
+
         is_reader: if False EOF errors will be raised. If True, EOF errors
         will return "" (to emulate normal sockets).
         """
@@ -70,7 +71,7 @@ class SSL_fileobject(wsgiserver.CP_fileobject):
             except SSL.SysCallError, e:
                 if is_reader and e.args == (-1, 'Unexpected EOF'):
                     return ""
-                
+
                 errnum = e.args[0]
                 if is_reader and errnum in wsgiserver.socket_errors_to_ignore:
                     return ""
@@ -78,34 +79,27 @@ class SSL_fileobject(wsgiserver.CP_fileobject):
             except SSL.Error, e:
                 if is_reader and e.args == (-1, 'Unexpected EOF'):
                     return ""
-                
+
                 thirdarg = None
                 try:
                     thirdarg = e.args[0][0][2]
                 except IndexError:
                     pass
-                
+
                 if thirdarg == 'http request':
                     # The client is talking HTTP to an HTTPS server.
                     raise wsgiserver.NoSSLError()
-                
+
                 raise wsgiserver.FatalSSLAlert(*e.args)
             except:
                 raise
-            
+
             if time.time() - start > self.ssl_timeout:
                 raise socket.timeout("timed out")
-    
-    def recv(self, *args, **kwargs):
-        buf = []
-        r = super(SSL_fileobject, self).recv
-        while True:
-            data = self._safe_call(True, r, *args, **kwargs)
-            buf.append(data)
-            p = self._sock.pending()
-            if not p:
-                return "".join(buf)
-    
+
+    def recv(self, size):
+        return self._safe_call(True, super(SSL_fileobject, self).recv, size)
+
     def sendall(self, *args, **kwargs):
         return self._safe_call(False, super(SSL_fileobject, self).sendall,
                                *args, **kwargs)
@@ -116,15 +110,16 @@ class SSL_fileobject(wsgiserver.CP_fileobject):
 
 
 class SSLConnection:
+
     """A thread-safe wrapper for an SSL.Connection.
-    
+
     ``*args``: the arguments to create the wrapped ``SSL.Connection(*args)``.
     """
-    
+
     def __init__(self, *args):
         self._ssl_conn = SSL.Connection(*args)
         self._lock = threading.RLock()
-    
+
     for f in ('get_context', 'pending', 'send', 'write', 'recv', 'read',
               'renegotiate', 'bind', 'listen', 'connect', 'accept',
               'setblocking', 'fileno', 'close', 'get_cipher_list',
@@ -140,7 +135,7 @@ class SSLConnection:
         finally:
             self._lock.release()
 """ % (f, f))
-    
+
     def shutdown(self, *args):
         self._lock.acquire()
         try:
@@ -151,33 +146,34 @@ class SSLConnection:
 
 
 class pyOpenSSLAdapter(wsgiserver.SSLAdapter):
+
     """A wrapper for integrating pyOpenSSL with CherryPy."""
-    
+
     context = None
     """An instance of SSL.Context."""
-    
+
     certificate = None
     """The filename of the server SSL certificate."""
-    
+
     private_key = None
     """The filename of the server's private key file."""
-    
+
     certificate_chain = None
     """Optional. The filename of CA's intermediate certificate bundle.
-    
+
     This is needed for cheaper "chained root" SSL certificates, and should be
     left as None if not required."""
-    
+
     def __init__(self, certificate, private_key, certificate_chain=None):
         if SSL is None:
             raise ImportError("You must install pyOpenSSL to use HTTPS.")
-        
+
         self.context = None
         self.certificate = certificate
         self.private_key = private_key
         self.certificate_chain = certificate_chain
         self._environ = None
-    
+
     def bind(self, sock):
         """Wrap and return the given socket."""
         if self.context is None:
@@ -185,11 +181,11 @@ class pyOpenSSLAdapter(wsgiserver.SSLAdapter):
         conn = SSLConnection(self.context, sock)
         self._environ = self.get_environ()
         return conn
-    
+
     def wrap(self, sock):
         """Wrap and return the given socket, plus WSGI environ entries."""
         return sock, self._environ.copy()
-    
+
     def get_context(self):
         """Return an SSL.Context from self attributes."""
         # See http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/442473
@@ -199,18 +195,18 @@ class pyOpenSSLAdapter(wsgiserver.SSLAdapter):
             c.load_verify_locations(self.certificate_chain)
         c.use_certificate_file(self.certificate)
         return c
-    
+
     def get_environ(self):
         """Return WSGI environ entries to be merged into each request."""
         ssl_environ = {
             "HTTPS": "on",
             # pyOpenSSL doesn't provide access to any of these AFAICT
-##            'SSL_PROTOCOL': 'SSLv2',
-##            SSL_CIPHER 	string 	The cipher specification name
-##            SSL_VERSION_INTERFACE 	string 	The mod_ssl program version
-##            SSL_VERSION_LIBRARY 	string 	The OpenSSL program version
-            }
-        
+            # 'SSL_PROTOCOL': 'SSLv2',
+            # SSL_CIPHER 	string 	The cipher specification name
+            # SSL_VERSION_INTERFACE 	string 	The mod_ssl program version
+            # SSL_VERSION_LIBRARY 	string 	The OpenSSL program version
+        }
+
         if self.certificate:
             # Server certificate attributes
             cert = open(self.certificate, 'rb').read()
@@ -218,20 +214,22 @@ class pyOpenSSLAdapter(wsgiserver.SSLAdapter):
             ssl_environ.update({
                 'SSL_SERVER_M_VERSION': cert.get_version(),
                 'SSL_SERVER_M_SERIAL': cert.get_serial_number(),
-##                'SSL_SERVER_V_START': Validity of server's certificate (start time),
-##                'SSL_SERVER_V_END': Validity of server's certificate (end time),
-                })
-            
+                # 'SSL_SERVER_V_START':
+                #   Validity of server's certificate (start time),
+                # 'SSL_SERVER_V_END':
+                #   Validity of server's certificate (end time),
+            })
+
             for prefix, dn in [("I", cert.get_issuer()),
                                ("S", cert.get_subject())]:
                 # X509Name objects don't seem to have a way to get the
                 # complete DN string. Use str() and slice it instead,
                 # because str(dn) == "<X509Name object '/C=US/ST=...'>"
                 dnstr = str(dn)[18:-2]
-                
+
                 wsgikey = 'SSL_SERVER_%s_DN' % prefix
                 ssl_environ[wsgikey] = dnstr
-                
+
                 # The DN should be of the form: /k1=v1/k2=v2, but we must allow
                 # for any value to contain slashes itself (in a URL).
                 while dnstr:
@@ -242,9 +240,9 @@ class pyOpenSSLAdapter(wsgiserver.SSLAdapter):
                     if key and value:
                         wsgikey = 'SSL_SERVER_%s_DN_%s' % (prefix, key)
                         ssl_environ[wsgikey] = value
-        
+
         return ssl_environ
-    
+
     def makefile(self, sock, mode='r', bufsize=-1):
         if SSL and isinstance(sock, SSL.ConnectionType):
             timeout = sock.gettimeout()
@@ -253,4 +251,3 @@ class pyOpenSSLAdapter(wsgiserver.SSLAdapter):
             return f
         else:
             return wsgiserver.CP_fileobject(sock, mode, bufsize)
-