def _real_connect(self, addr, return_errno):
        if self._connected:
            raise ValueError('attempt to connect already-connected SSLSocket!')
        self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile, self.certfile, self.cert_reqs, self.ssl_version, self.ca_certs, self.ciphers)
        try:
            if return_errno:
                rc = socket.connect_ex(self, addr)
            else:
                rc = None
                socket.connect(self, addr)
            if not rc:
                if self.do_handshake_on_connect:
                    self.do_handshake()
                self._connected = True
            return rc
        except socket_error:
            self._sslobj = None
            raise

        return

 def _real_connect(self, addr, connect_ex):
     if self.server_side:
         raise ValueError("can't connect in server-side mode")
     if self._connected:
         raise ValueError('attempt to connect already-connected SSLSocket!')
     self._sslobj = self.context._wrap_socket(self, False, self.server_hostname)
     try:
         if connect_ex:
             rc = socket.connect_ex(self, addr)
         else:
             rc = None
             socket.connect(self, addr)
         if not rc:
             if self.do_handshake_on_connect:
                 self.do_handshake()
             self._connected = True
         return rc
     except socket_error:
         self._sslobj = None
         raise

    def _real_connect(self, addr, connect_ex):
        if self.server_side:
            raise ValueError("can't connect in server-side mode")

        # Here we assume that the socket is client-side, and not
        # connected at the time of the call.  We connect it, then wrap it.
        if self._connected:
            raise ValueError("attempt to connect already-connected SSLSocket!")

        if connect_ex:
            err = socket.connect_ex(self, addr)
        else:
            err = 0
            socket.connect(self, addr)

        if err == 0:
            self._connected = True
            if self.do_handshake_on_connect:
                self.do_handshake()

        return err

 def _real_connect(self, addr, return_errno):
     # Here we assume that the socket is client-side, and not
     # connected at the time of the call.  We connect it, then wrap it.
     if self._connected:
         raise ValueError("attempt to connect already-connected SSLSocket!")
     self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile, self.certfile,
                                 self.cert_reqs, self.ssl_version,
                                 self.ca_certs, self.ciphers)
     try:
         if return_errno:
             rc = socket.connect_ex(self, addr)
         else:
             rc = None
             socket.connect(self, addr)
         if not rc:
             if self.do_handshake_on_connect:
                 self.do_handshake()
             self._connected = True
         return rc
     except socket_error:
         self._sslobj = None
         raise