sslutil: abort when ssl module is needed but not found

It is apparently possible to compile Python without SSL support or leave it out
when installing precompiled binaries.

Mercurial on such Pythons would crash if the user tried to use https. Now it
will be reported as "abort: Python SSL support not found" instead.

mercurial/sslutil.py

@@ -1,128 +1,130 b''
 # sslutil.py - SSL handling for mercurial
 #
 # Copyright 2005, 2006, 2007, 2008 Matt Mackall <[e-mail]>
 # Copyright 2006, 2007 Alexis S. L. Carvalho <[e-mail]>
 # Copyright 2006 Vadim Gelfer <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 import os
 
 from mercurial import util
 from mercurial.i18n import _
 try:
     # avoid using deprecated/broken FakeSocket in python 2.6
     import ssl
     ssl_wrap_socket = ssl.wrap_socket
     CERT_REQUIRED = ssl.CERT_REQUIRED
 except ImportError:
     CERT_REQUIRED = 2
 
     import socket, httplib
 
     def ssl_wrap_socket(sock, key_file, cert_file,
                         cert_reqs=CERT_REQUIRED, ca_certs=None):
+        if not util.safehasattr(socket, 'ssl'):
+            raise util.Abort(_('Python SSL support not found'))
         if ca_certs:
             raise util.Abort(_(
                 'certificate checking requires Python 2.6'))
 
         ssl = socket.ssl(sock, key_file, cert_file)
         return httplib.FakeSocket(sock, ssl)
 
 def _verifycert(cert, hostname):
     '''Verify that cert (in socket.getpeercert() format) matches hostname.
     CRLs is not handled.
 
     Returns error message if any problems are found and None on success.
     '''
     if not cert:
         return _('no certificate received')
     dnsname = hostname.lower()
     def matchdnsname(certname):
         return (certname == dnsname or
                 '.' in dnsname and certname == '*.' + dnsname.split('.', 1)[1])
 
     san = cert.get('subjectAltName', [])
     if san:
         certnames = [value.lower() for key, value in san if key == 'DNS']
         for name in certnames:
             if matchdnsname(name):
                 return None
         if certnames:
             return _('certificate is for %s') % ', '.join(certnames)
 
     # subject is only checked when subjectAltName is empty
     for s in cert.get('subject', []):
         key, value = s[0]
         if key == 'commonName':
             try:
                 # 'subject' entries are unicode
                 certname = value.lower().encode('ascii')
             except UnicodeEncodeError:
                 return _('IDN in certificate not supported')
             if matchdnsname(certname):
                 return None
             return _('certificate is for %s') % certname
     return _('no commonName or subjectAltName found in certificate')
 
 
 # CERT_REQUIRED means fetch the cert from the server all the time AND
 # validate it against the CA store provided in web.cacerts.
 #
 # We COMPLETELY ignore CERT_REQUIRED on Python <= 2.5, as it's totally
 # busted on those versions.
 
 def sslkwargs(ui, host):
     cacerts = ui.config('web', 'cacerts')
     hostfingerprint = ui.config('hostfingerprints', host)
     if cacerts and not hostfingerprint:
         cacerts = util.expandpath(cacerts)
         if not os.path.exists(cacerts):
             raise util.Abort(_('could not find web.cacerts: %s') % cacerts)
         return {'ca_certs': cacerts,
                 'cert_reqs': CERT_REQUIRED,
                 }
     return {}
 
 class validator(object):
     def __init__(self, ui, host):
         self.ui = ui
         self.host = host
 
     def __call__(self, sock):
         host = self.host
         cacerts = self.ui.config('web', 'cacerts')
         hostfingerprint = self.ui.config('hostfingerprints', host)
         if cacerts and not hostfingerprint:
             msg = _verifycert(sock.getpeercert(), host)
             if msg:
                 raise util.Abort(_('%s certificate error: %s '
                                    '(use --insecure to connect '
                                    'insecurely)') % (host, msg))
             self.ui.debug('%s certificate successfully verified\n' % host)
         else:
             if getattr(sock, 'getpeercert', False):
                 peercert = sock.getpeercert(True)
                 peerfingerprint = util.sha1(peercert).hexdigest()
                 nicefingerprint = ":".join([peerfingerprint[x:x + 2]
                     for x in xrange(0, len(peerfingerprint), 2)])
                 if hostfingerprint:
                     if peerfingerprint.lower() != \
                             hostfingerprint.replace(':', '').lower():
                         raise util.Abort(_('invalid certificate for %s '
                                            'with fingerprint %s') %
                                          (host, nicefingerprint))
                     self.ui.debug('%s certificate matched fingerprint %s\n' %
                                   (host, nicefingerprint))
                 else:
                     self.ui.warn(_('warning: %s certificate '
                                    'with fingerprint %s not verified '
                                    '(check hostfingerprints or web.cacerts '
                                    'config setting)\n') %
                                  (host, nicefingerprint))
             else: # python 2.5 ?
                 if hostfingerprint:
                     raise util.Abort(_("host fingerprint for %s can't be "
                                        "verified (Python too old)") % host)
                 self.ui.warn(_("warning: certificate for %s can't be "
                                "verified (Python too old)\n") % host)