text: """The match_hostname() function from Python 3.3.3, essential when using SSL."""
  
  # Note: This file is under the PSF license as the code comes from the python
  # stdlib.   http://docs.python.org/3/license.html
  
  import re
  import sys
  
  # ipaddress has been backported to 2.6+ in pypi.  If it is installed on the
  # system, use it to handle IPAddress ServerAltnames (this was added in
  # python-3.5) otherwise only do DNS matching.  This allows
  # backports.ssl_match_hostname to continue to be used all the way back to
  # python-2.4.
  try:
      import ipaddress
  except ImportError:
      ipaddress = None
  
  __version__ = "3.5.0.1"
  
  
  class CertificateError(ValueError):
      pass
  
  
  def _dnsname_match(dn, hostname, max_wildcards=1):
      """Matching according to RFC 6125, section 6.4.3
  
      http://tools.ietf.org/html/rfc6125#section-6.4.3
      """
      pats = []
      if not dn:
          return False
  
      # Ported from python3-syntax:
      # leftmost, *remainder = dn.split(r'.')
      parts = dn.split(r".")
      leftmost = parts[0]
      remainder = parts[1:]
  
      wildcards = leftmost.count("*")
      if wildcards > max_wildcards:
          # Issue #17980: avoid denials of service by refusing more
          # than one wildcard per fragment.  A survey of established
          # policy among SSL implementations showed it to be a
          # reasonable choice.
          raise CertificateError(
              "too many wildcards in certificate DNS name: " + repr(dn)
          )
  
      # speed up common case w/o wildcards
      if not wildcards:
          return dn.lower() == hostname.lower()
  
      # RFC 6125, section 6.4.3, subitem 1.
      # The client SHOULD NOT attempt to match a presented identifier in which
      # the wildcard character comprises a label other than the left-most label.
      if leftmost == "*":
          # When '*' is a fragment by itself, it matches a non-empty dotless
          # fragment.
          pats.append("[^.]+")
      elif leftmost.startswith("xn--") or hostname.startswith("xn--"):
          # RFC 6125, section 6.4.3, subitem 3.
          # The client SHOULD NOT attempt to match a presented identifier
          # where the wildcard character is embedded within an A-label or
          # U-label of an internationalized domain name.
          pats.append(re.escape(leftmost))
      else:
          # Otherwise, '*' matches any dotless string, e.g. www*
          pats.append(re.escape(leftmost).replace(r"\*", "[^.]*"))
  
      # add the remaining fragments, ignore any wildcards
      for frag in remainder:
          pats.append(re.escape(frag))
  
      pat = re.compile(r"\A" + r"\.".join(pats) + r"\Z", re.IGNORECASE)
      return pat.match(hostname)
  
  
  def _to_unicode(obj):
      if isinstance(obj, str) and sys.version_info < (3,):
          obj = unicode(obj, encoding="ascii", errors="strict")
      return obj
  
  
  def _ipaddress_match(ipname, host_ip):
      """Exact matching of IP addresses.
  
      RFC 6125 explicitly doesn't define an algorithm for this
      (section 1.7.2 - "Out of Scope").
      """
      # OpenSSL may add a trailing newline to a subjectAltName's IP address
      # Divergence from upstream: ipaddress can't handle byte str
      ip = ipaddress.ip_address(_to_unicode(ipname).rstrip())
      return ip == host_ip
  
  
  def match_hostname(cert, hostname):
      """Verify that *cert* (in decoded format as returned by
      SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
      rules are followed, but IP addresses are not accepted for *hostname*.
  
      CertificateError is raised on failure. On success, the function
      returns nothing.
      """
      if not cert:
          raise ValueError(
              "empty or no certificate, match_hostname needs a "
              "SSL socket or SSL context with either "
              "CERT_OPTIONAL or CERT_REQUIRED"
          )
      try:
          # Divergence from upstream: ipaddress can't handle byte str
          host_ip = ipaddress.ip_address(_to_unicode(hostname))
      except ValueError:
          # Not an IP address (common case)
          host_ip = None
      except UnicodeError:
          # Divergence from upstream: Have to deal with ipaddress not taking
          # byte strings.  addresses should be all ascii, so we consider it not
          # an ipaddress in this case
          host_ip = None
      except AttributeError:
          # Divergence from upstream: Make ipaddress library optional
          if ipaddress is None:
              host_ip = None
          else:
              raise
      dnsnames = []
      san = cert.get("subjectAltName", ())
      for key, value in san:
          if key == "DNS":
              if host_ip is None and _dnsname_match(value, hostname):
                  return
              dnsnames.append(value)
          elif key == "IP Address":
              if host_ip is not None and _ipaddress_match(value, host_ip):
                  return
              dnsnames.append(value)
      if not dnsnames:
          # The subject is only checked when there is no dNSName entry
          # in subjectAltName
          for sub in cert.get("subject", ()):
              for key, value in sub:
                  # XXX according to RFC 2818, the most specific Common Name
                  # must be used.
                  if key == "commonName":
                      if _dnsname_match(value, hostname):
                          return
                      dnsnames.append(value)
      if len(dnsnames) > 1:
          raise CertificateError(
              "hostname %r "
              "doesn't match either of %s" % (hostname, ", ".join(map(repr, dnsnames)))
          )
      elif len(dnsnames) == 1:
          raise CertificateError(
              "hostname %r " "doesn't match %r" % (hostname, dnsnames[0])
          )
      else:
          raise CertificateError(
              "no appropriate commonName or " "subjectAltName fields were found"
          )
  