# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT

""" Implementation module for SSL socket operations.  See the socket module
for documentation. """

CERT_NONE = 0
CERT_OPTIONAL = 1
CERT_REQUIRED = 2
HAS_ECDH = True
HAS_NPN = False
HAS_SNI = True
HAS_TLS_UNIQUE = True
OPENSSL_VERSION = 'OpenSSL 0.9.8zh 14 Jan 2016'
OPENSSL_VERSION_INFO = ()
OPENSSL_VERSION_NUMBER = 9470431
OP_ALL = 2047
OP_CIPHER_SERVER_PREFERENCE = 4194304
OP_NO_SSLv2 = 16777216
OP_NO_SSLv3 = 33554432
OP_NO_TLSv1 = 67108864
OP_SINGLE_DH_USE = 1048576
OP_SINGLE_ECDH_USE = 524288
PROTOCOL_SSLv2 = 0
PROTOCOL_SSLv23 = 2
PROTOCOL_SSLv3 = 1
PROTOCOL_TLSv1 = 3

def RAND_add(string, entropy):
  """ RAND_add(string, entropy)
  
  Mix string into the OpenSSL PRNG state.  entropy (a float) is a lower
  bound on the entropy contained in string.  See RFC 1750. """
  pass

def RAND_bytes(n):
  """ RAND_bytes(n) -> bytes
  
  Generate n cryptographically strong pseudo-random bytes. """
  return None

def RAND_egd(path):
  """ RAND_egd(path) -> bytes
  
  Queries the entropy gather daemon (EGD) on the socket named by 'path'.
  Returns number of bytes read.  Raises SSLError if connection to EGD
  fails or if it does not provide enough data to seed PRNG. """
  return None

def RAND_pseudo_bytes(n):
  """ RAND_pseudo_bytes(n) -> (bytes, is_cryptographic)
  
  Generate n pseudo-random bytes. is_cryptographic is True if the bytesgenerated are cryptographically strong. """
  return (None, None)

def RAND_status():
  """ RAND_status() -> 0 or 1
  
  Returns 1 if the OpenSSL PRNG has been seeded with enough data and 0 if not.
  It is necessary to seed the PRNG with RAND_add() on some platforms before
  using the ssl() function. """
  return None

class SSLEOFError(SSLError):
  """ SSL/TLS connection terminated abruptly. """

  pass

class SSLError(OSError):
  """ An error occurred in the SSL implementation. """

  pass

class SSLSyscallError(SSLError):
  """ System error when attempting SSL operation. """

  pass

class SSLWantReadError(SSLError):
  """ Non-blocking SSL socket needs to read more data
  before the requested operation can be completed. """

  pass

class SSLWantWriteError(SSLError):
  """ Non-blocking SSL socket needs to write more data
  before the requested operation can be completed. """

  pass

class SSLZeroReturnError(SSLError):
  """ SSL/TLS session closed cleanly. """

  pass

SSL_ERROR_EOF = 8
SSL_ERROR_INVALID_ERROR_CODE = 10
SSL_ERROR_SSL = 1
SSL_ERROR_SYSCALL = 5
SSL_ERROR_WANT_CONNECT = 7
SSL_ERROR_WANT_READ = 2
SSL_ERROR_WANT_WRITE = 3
SSL_ERROR_WANT_X509_LOOKUP = 4
SSL_ERROR_ZERO_RETURN = 6
_OPENSSL_API_VERSION = ()

class _SSLContext(object):

  def _set_npn_protocols(self):
    pass

  def _wrap_socket(self):
    pass

  def load_cert_chain(self):
    pass

  def load_dh_params(self):
    pass

  def load_verify_locations(self):
    pass

  options = property(None, None, None,
                     )


  def session_stats(self):
    pass

  def set_ciphers(self):
    pass

  def set_default_verify_paths(self):
    pass

  def set_ecdh_curve(self):
    pass

  verify_mode = property(None, None, None,
                         )


class _SSLSocket(object):

  def cipher(self):
    pass

  def compression(self):
    pass

  def do_handshake(self):
    pass

  def peer_certificate(self, der=False):
    """ peer_certificate([der=False]) -> certificate
    
    Returns the certificate for the peer.  If no certificate was provided,
    returns None.  If a certificate was provided, but not validated, returns
    an empty dictionary.  Otherwise returns a dict containing information
    about the peer certificate.
    
    If the optional argument is True, returns a DER-encoded copy of the
    peer certificate, or None if no certificate was provided.  This will
    return the certificate even if it wasn't validated. """
    return None

  def pending(self):
    """ pending() -> count
    
    Returns the number of already decrypted bytes available for read,
    pending on the connection.
     """
    return None

  def read(self, len=None):
    """ read([len]) -> string
    
    Read up to len bytes from the SSL socket. """
    return ""

  def shutdown(self, s):
    """ shutdown(s) -> socket
    
    Does the SSL shutdown handshake with the remote end, and returns
    the underlying socket object. """
    return SocketType()

  def tls_unique_cb(self):
    """ tls_unique_cb() -> bytes
    
    Returns the 'tls-unique' channel binding data, as defined by RFC 5929.
    
    If the TLS handshake is not yet complete, None is returned """
    return None

  def write(self, s):
    """ write(s) -> len
    
    Writes the string s into the SSL object.  Returns the number
    of bytes written. """
    return None

__doc__ = """Implementation module for SSL socket operations.  See the socket module
for documentation."""
__file__ = '/Users/Shared/src/ide/build-files/build-temp/runtimes-release/__os__/osx/runtime-python3.3/lib/Python.framework/Versions/Current/lib/python3.3/lib-dynload/_ssl.so'
__loader__ = None
__name__ = '_ssl'
__package__ = ''

def _test_decode_cert():
  pass

err_codes_to_names = {}
err_names_to_codes = {}
lib_codes_to_names = {}