Lines Matching refs:self
500 self = _SSLContext.__new__(cls, protocol)
501 return self
503 def _encode_hostname(self, hostname):
511 def wrap_socket(self, sock, server_side=False,
517 return self.sslsocket_class._create(
523 context=self,
527 def wrap_bio(self, incoming, outgoing, server_side=False,
531 return self.sslobject_class._create(
533 server_hostname=self._encode_hostname(server_hostname),
534 session=session, context=self,
537 def set_npn_protocols(self, npn_protocols):
551 self._set_npn_protocols(protos)
553 def set_servername_callback(self, server_name_callback):
555 self.sni_callback = None
561 servername = self._encode_hostname(servername)
564 self.sni_callback = shim_cb
566 def set_alpn_protocols(self, alpn_protocols):
575 self._set_alpn_protocols(protos)
577 def _load_windows_store_certs(self, storename, purpose):
588 self.load_verify_locations(cadata=certs)
591 def load_default_certs(self, purpose=Purpose.SERVER_AUTH):
595 for storename in self._windows_cert_stores:
596 self._load_windows_store_certs(storename, purpose)
597 self.set_default_verify_paths()
601 def minimum_version(self):
605 def minimum_version(self, value):
607 self.options &= ~Options.OP_NO_SSLv3
608 super(SSLContext, SSLContext).minimum_version.__set__(self, value)
611 def maximum_version(self):
615 def maximum_version(self, value):
616 super(SSLContext, SSLContext).maximum_version.__set__(self, value)
619 def options(self):
623 def options(self, value):
624 super(SSLContext, SSLContext).options.__set__(self, value)
628 def hostname_checks_common_name(self):
629 ncs = self._host_flags & _ssl.HOSTFLAG_NEVER_CHECK_SUBJECT
633 def hostname_checks_common_name(self, value):
635 self._host_flags &= ~_ssl.HOSTFLAG_NEVER_CHECK_SUBJECT
637 self._host_flags |= _ssl.HOSTFLAG_NEVER_CHECK_SUBJECT
640 def hostname_checks_common_name(self):
644 def _msg_callback(self):
683 def _msg_callback(self, callback):
685 super(SSLContext, SSLContext)._msg_callback.__set__(self, None)
718 super(SSLContext, SSLContext)._msg_callback.__set__(self, inner)
721 def protocol(self):
725 def verify_flags(self):
729 def verify_flags(self, value):
730 super(SSLContext, SSLContext).verify_flags.__set__(self, value)
733 def verify_mode(self):
741 def verify_mode(self, value):
742 super(SSLContext, SSLContext).verify_mode.__set__(self, value)
860 def __init__(self, *args, **kwargs):
862 f"{self.__class__.__name__} does not have a public "
869 self = cls.__new__(cls)
873 owner=self, session=session
875 self._sslobj = sslobj
876 return self
879 def context(self):
881 return self._sslobj.context
884 def context(self, ctx):
885 self._sslobj.context = ctx
888 def session(self):
890 return self._sslobj.session
893 def session(self, session):
894 self._sslobj.session = session
897 def session_reused(self):
899 return self._sslobj.session_reused
902 def server_side(self):
904 return self._sslobj.server_side
907 def server_hostname(self):
910 return self._sslobj.server_hostname
912 def read(self, len=1024, buffer=None):
919 v = self._sslobj.read(len, buffer)
921 v = self._sslobj.read(len)
924 def write(self, data):
930 return self._sslobj.write(data)
932 def getpeercert(self, binary_form=False):
939 return self._sslobj.getpeercert(binary_form)
941 def selected_npn_protocol(self):
951 def selected_alpn_protocol(self):
955 return self._sslobj.selected_alpn_protocol()
957 def cipher(self):
960 return self._sslobj.cipher()
962 def shared_ciphers(self):
966 return self._sslobj.shared_ciphers()
968 def compression(self):
971 return self._sslobj.compression()
973 def pending(self):
975 return self._sslobj.pending()
977 def do_handshake(self):
979 self._sslobj.do_handshake()
981 def unwrap(self):
983 return self._sslobj.shutdown()
985 def get_channel_binding(self, cb_type="tls-unique"):
989 return self._sslobj.get_channel_binding(cb_type)
991 def version(self):
994 return self._sslobj.version()
996 def verify_client_post_handshake(self):
997 return self._sslobj.verify_client_post_handshake()
1011 def __init__(self, *args, **kwargs):
1013 f"{self.__class__.__name__} does not have a public "
1038 self = cls.__new__(cls, **kwargs)
1039 super(SSLSocket, self).__init__(**kwargs)
1043 self._context = context
1044 self._session = session
1045 self._closed = False
1046 self._sslobj = None
1047 self.server_side = server_side
1048 self.server_hostname = context._encode_hostname(server_hostname)
1049 self.do_handshake_on_connect = do_handshake_on_connect
1050 self.suppress_ragged_eofs = suppress_ragged_eofs
1054 self.getpeername()
1059 blocking = self.getblocking()
1060 self.setblocking(False)
1066 notconn_pre_handshake_data = self.recv(1)
1072 self.setblocking(blocking)
1083 self.close()
1090 self.settimeout(sock_timeout) # Must come after setblocking() calls.
1091 self._connected = connected
1095 self._sslobj = self._context._wrap_socket(
1096 self, server_side, self.server_hostname,
1097 owner=self, session=self._session,
1100 timeout = self.gettimeout()
1104 self.do_handshake()
1106 self.close()
1108 return self
1112 def context(self):
1113 return self._context
1116 def context(self, ctx):
1117 self._context = ctx
1118 self._sslobj.context = ctx
1122 def session(self):
1123 if self._sslobj is not None:
1124 return self._sslobj.session
1127 def session(self, session):
1128 self._session = session
1129 if self._sslobj is not None:
1130 self._sslobj.session = session
1134 def session_reused(self):
1135 if self._sslobj is not None:
1136 return self._sslobj.session_reused
1138 def dup(self):
1140 self.__class__.__name__)
1142 def _checkClosed(self, msg=None):
1146 def _check_connected(self):
1147 if not self._connected:
1152 self.getpeername()
1154 def read(self, len=1024, buffer=None):
1158 self._checkClosed()
1159 if self._sslobj is None:
1163 return self._sslobj.read(len, buffer)
1165 return self._sslobj.read(len)
1167 if x.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs:
1175 def write(self, data):
1179 self._checkClosed()
1180 if self._sslobj is None:
1182 return self._sslobj.write(data)
1185 def getpeercert(self, binary_form=False):
1186 self._checkClosed()
1187 self._check_connected()
1188 return self._sslobj.getpeercert(binary_form)
1191 def selected_npn_protocol(self):
1192 self._checkClosed()
1201 def selected_alpn_protocol(self):
1202 self._checkClosed()
1203 if self._sslobj is None or not _ssl.HAS_ALPN:
1206 return self._sslobj.selected_alpn_protocol()
1209 def cipher(self):
1210 self._checkClosed()
1211 if self._sslobj is None:
1214 return self._sslobj.cipher()
1217 def shared_ciphers(self):
1218 self._checkClosed()
1219 if self._sslobj is None:
1222 return self._sslobj.shared_ciphers()
1225 def compression(self):
1226 self._checkClosed()
1227 if self._sslobj is None:
1230 return self._sslobj.compression()
1232 def send(self, data, flags=0):
1233 self._checkClosed()
1234 if self._sslobj is not None:
1238 self.__class__)
1239 return self._sslobj.write(data)
1243 def sendto(self, data, flags_or_addr, addr=None):
1244 self._checkClosed()
1245 if self._sslobj is not None:
1247 self.__class__)
1253 def sendmsg(self, *args, **kwargs):
1257 self.__class__)
1259 def sendall(self, data, flags=0):
1260 self._checkClosed()
1261 if self._sslobj is not None:
1265 self.__class__)
1270 v = self.send(byte_view[count:])
1275 def sendfile(self, file, offset=0, count=None):
1279 if self._sslobj is not None:
1280 return self._sendfile_use_send(file, offset, count)
1285 def recv(self, buflen=1024, flags=0):
1286 self._checkClosed()
1287 if self._sslobj is not None:
1291 self.__class__)
1292 return self.read(buflen)
1296 def recv_into(self, buffer, nbytes=None, flags=0):
1297 self._checkClosed()
1302 if self._sslobj is not None:
1306 self.__class__)
1307 return self.read(nbytes, buffer)
1311 def recvfrom(self, buflen=1024, flags=0):
1312 self._checkClosed()
1313 if self._sslobj is not None:
1315 self.__class__)
1319 def recvfrom_into(self, buffer, nbytes=None, flags=0):
1320 self._checkClosed()
1321 if self._sslobj is not None:
1323 self.__class__)
1327 def recvmsg(self, *args, **kwargs):
1329 self.__class__)
1331 def recvmsg_into(self, *args, **kwargs):
1333 "%s" % self.__class__)
1336 def pending(self):
1337 self._checkClosed()
1338 if self._sslobj is not None:
1339 return self._sslobj.pending()
1343 def shutdown(self, how):
1344 self._checkClosed()
1345 self._sslobj = None
1349 def unwrap(self):
1350 if self._sslobj:
1351 s = self._sslobj.shutdown()
1352 self._sslobj = None
1355 raise ValueError("No SSL wrapper around " + str(self))
1358 def verify_client_post_handshake(self):
1359 if self._sslobj:
1360 return self._sslobj.verify_client_post_handshake()
1362 raise ValueError("No SSL wrapper around " + str(self))
1364 def _real_close(self):
1365 self._sslobj = None
1369 def do_handshake(self, block=False):
1370 self._check_connected()
1371 timeout = self.gettimeout()
1374 self.settimeout(None)
1375 self._sslobj.do_handshake()
1377 self.settimeout(timeout)
1379 def _real_connect(self, addr, connect_ex):
1380 if self.server_side:
1384 if self._connected or self._sslobj is not None:
1386 self._sslobj = self.context._wrap_socket(
1387 self, False, self.server_hostname,
1388 owner=self, session=self._session
1397 self._connected = True
1398 if self.do_handshake_on_connect:
1399 self.do_handshake()
1402 self._sslobj = None
1405 def connect(self, addr):
1408 self._real_connect(addr, False)
1410 def connect_ex(self, addr):
1413 return self._real_connect(addr, True)
1415 def accept(self):
1421 newsock = self.context.wrap_socket(newsock,
1422 do_handshake_on_connect=self.do_handshake_on_connect,
1423 suppress_ragged_eofs=self.suppress_ragged_eofs,
1428 def get_channel_binding(self, cb_type="tls-unique"):
1429 if self._sslobj is not None:
1430 return self._sslobj.get_channel_binding(cb_type)
1439 def version(self):
1440 if self._sslobj is not None:
1441 return self._sslobj.version()