def __init__(self,db): self._ipcPath=db.getSettingPath() SocketlikeIPC.__init__(self, self._ipcPath) # super(type(self),self).__init__(self._ipcPath) # if super(type(self),self)._connect(): if SocketlikeIPC._connect(self): print('IPC connect succeed. Welcome back, administrator.') return print('IPC failed. proceeding with TCP.') super(type(self)) #unbound socket.__init__(self) try: socket.connect(self,('racu.idea.sh', PortEnum.MAIN_SERVER.value)) lastPin = db.getConfig() print('lastPin =', lastPin, len(lastPin)) pinmsg = int.to_bytes(SocketEnum.PIN.value, 1, 'big') + int.to_bytes(lastPin[0]) if 10**3<=lastPin['lastPIN']<10**4 else b'' msg = '' # while not msg: socket.sendall(self,pinmsg) msg = socket.recv(self) if not msg: print('main server connect error') return except: print('main server connect error')
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True): socket.__init__(self, _sock=sock._sock) # The initializer for socket overrides the methods send(), recv(), etc. # in the instancce, which we don't need -- but we want to provide the # methods defined in SSLSocket. for attr in _delegate_methods: try: delattr(self, attr) except AttributeError: pass if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except socket_error, e: if e.errno != errno.ENOTCONN: raise # no, no connection yet self._sslobj = None
def __init__(self, sock, keyfile = None, certfile = None, server_side = False, cert_reqs = CERT_NONE, ssl_version = PROTOCOL_SSLv23, ca_certs = None, do_handshake_on_connect = True, suppress_ragged_eofs = True, ciphers = None): socket.__init__(self, _sock=sock._sock) for attr in _delegate_methods: try: delattr(self, attr) except AttributeError: pass if certfile and not keyfile: keyfile = certfile try: socket.getpeername(self) except socket_error as e: if e.errno != errno.ENOTCONN: raise self._sslobj = None else: self._sslobj = _ssl.sslwrap(self._sock, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs, ciphers) if do_handshake_on_connect: self.do_handshake() self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs self._makefile_refs = 0
def __init__(self,ip,port): self.port = port self.ip = ip self.host = (ip,port) socket.__init__(self, AF_INET, SOCK_DGRAM) self.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) self.tx_en = 0 self.rx_en = 0 self.tx_s = 0 self.rx_s = 0 self.tx_thread = threading.Thread(target = self.tx, name = 'tx') self.rx_thread = threading.Thread(target = self.rx, name = 'rx') self.rx_cnt = 0 self.tx_cnt = 0 self.rx_time = 0 self.rx_offset = 0 self.tx_time = 0 self.tx_offset = 0 self.data = (c_uint*0x100)() memset(byref(self.data),0,0x400) self.length = 1920000 self.rd = (c_uint*self.length)() self.mutex = threading.Lock()
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None): socket.__init__(self, _sock=sock._sock) # "close" the original socket: it is not usable any more. # this only calls _drop(), which should not actually call # the operating system's close() because the reference # counter is greater than 1 (we hold one too). sock.close() if ciphers is None and ssl_version != _SSLv2_IF_EXISTS: ciphers = _DEFAULT_CIPHERS if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except socket_error, e: if e.errno != errno.ENOTCONN: raise # no, no connection yet self._connected = False self._sslobj = None
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None): socket.__init__(self, _sock=sock._sock) if ciphers is None and ssl_version != _SSLv2_IF_EXISTS: ciphers = _DEFAULT_CIPHERS if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except socket_error, e: if e.errno != errno.ENOTCONN: raise # no, no connection yet self._connected = False self._sslobj = None
def __init__(self, db): self._ipcPath = db.getSettingPath() SocketlikeIPC.__init__(self, self._ipcPath) # super(type(self),self).__init__(self._ipcPath) # if super(type(self),self)._connect(): if SocketlikeIPC._connect(self): print('IPC connect succeed. Welcome back, administrator.') return print('IPC failed. proceeding with TCP.') super(type(self)) #unbound socket.__init__(self) try: socket.connect(self, ('racu.idea.sh', PortEnum.MAIN_SERVER.value)) lastPin = db.getConfig() print('lastPin =', lastPin, len(lastPin)) pinmsg = int.to_bytes( SocketEnum.PIN.value, 1, 'big') + int.to_bytes( lastPin[0]) if 10**3 <= lastPin['lastPIN'] < 10**4 else b'' msg = '' # while not msg: socket.sendall(self, pinmsg) msg = socket.recv(self) if not msg: print('main server connect error') return except: print('main server connect error')
def __init__(self, sock, keyfile=None, certfile=None): socket.__init__(self, _sock=sock._sock) # the initializer for socket trashes the methods (tsk, tsk), so... self.send = lambda data, flags=0: SSLSocket.send(self, data, flags) self.sendto = lambda data, addr, flags=0: SSLSocket.sendto(self, data, addr, flags) self.recv = lambda buflen=1024, flags=0: SSLSocket.recv(self, buflen, flags) self.recvfrom = lambda addr, buflen=1024, flags=0: SSLSocket.recvfrom(self, addr, buflen, flags) self.recv_into = lambda buffer, nbytes=None, flags=0: SSLSocket.recv_into(self, buffer, nbytes, flags) self.recvfrom_into = lambda buffer, nbytes=None, flags=0: SSLSocket.recvfrom_into(self, buffer, nbytes, flags) if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except socket_error: # no, no connection yet self._sslobj = None else: # yes, create the SSL object self._sslobj = _ssl.ssl(self._sock, keyfile, certfile) timeout = self.gettimeout() try: self.settimeout(None) self.do_handshake() finally: self.settimeout(timeout) self.keyfile = keyfile self.certfile = certfile self._makefile_refs = 0
def __init__( self, addr, port, destination, listen = 2 ): self.__addr = addr self.__port = port self.__dest = destination if self.destination.useSslTls: filename = self.destination.sslTls.certificate if filename is not None and not os.path.isfile( filename ): raise Exception( "Missing SSL/TLS certificate file" ) filename = self.destination.sslTls.key if filename is not None and not os.path.isfile( filename ): raise Exception( "Missing SSL/TLS key file" ) filename = self.destination.sslTls.caBundle if filename is not None and not os.path.isfile( filename ): raise Exception( "Missing SSL/TLS ca-bundle file" ) socket.__init__( self, AF_INET, SOCK_STREAM ) # Avoid "OSError: [Errno 98] Address already in use" when shutting down and restarting self.setsockopt( SOL_SOCKET, SO_REUSEADDR, 1 ) self.bind( ( self.addr, self.port ) ) self.listen( listen ) if self.destination.proxy: API.logger.info( 'TCP listening on {}:{} as a raw proxy'.format( self.addr, self.port ) ) else: API.logger.info( 'TCP listening on {}:{} forward to {}:{} = "{}"'.format( self.addr, self.port, self.destination.addr, self.destination.port, self.destination.portInfo.description ) ) self.setblocking( False ) return
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None): # Can't use sock.type as other flags (such as SOCK_NONBLOCK) get # mixed in. if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError("only stream sockets are supported") socket.__init__(self, _sock=sock._sock) # "close" the original socket: it is not usable any more. which should # not actually call the operating system's close() because the # reference counter is greater than 1 (we hold one too). sock._sock._drop() if ciphers is None and ssl_version != _SSLv2_IF_EXISTS: ciphers = _DEFAULT_CIPHERS if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except socket_error, e: if e.errno != errno.ENOTCONN: raise # no, no connection yet self._connected = False self._sslobj = None
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None): # Can't use sock.type as other flags (such as SOCK_NONBLOCK) get # mixed in. if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError("only stream sockets are supported") socket.__init__(self, _sock=sock._sock) # The initializer for socket overrides the methods send(), recv(), etc. # in the instancce, which we don't need -- but we want to provide the # methods defined in SSLSocket. for attr in _delegate_methods: try: delattr(self, attr) except AttributeError: pass if ciphers is None and ssl_version != _SSLv2_IF_EXISTS: ciphers = _DEFAULT_CIPHERS if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except socket_error, e: if e.errno != errno.ENOTCONN: raise # no, no connection yet self._connected = False self._sslobj = None
def __init__(self, ip, port): self.port = port self.ip = ip self.host = (ip, port) socket.__init__(self, AF_INET, SOCK_DGRAM) self.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.tx_en = 0 self.rx_en = 0 self.tx_s = 0 self.rx_s = 0 self.tx_thread = threading.Thread(target=self.tx, name='tx') self.rx_thread = threading.Thread(target=self.rx, name='rx') self.rx_cnt = 0 self.tx_cnt = 0 self.rx_time = 0 self.rx_offset = 0 self.tx_time = 0 self.tx_offset = 0 self.data = (c_uint * 0x100)() memset(byref(self.data), 0, 0x400) self.length = 1920000 self.rd = (c_uint * self.length)() self.mutex = threading.Lock()
def __init__(self, ip=None, port=None): Thread.__init__(self, name='Snake Server thread') socket.__init__(self, type=SOCK_DGRAM) self.server = socket(AF_INET, SOCK_STREAM) self.port = DEFAULT_PORT if port is None else port self.ip = DEFAULT_IP_SERVER if ip is None else ip self.bind((self.ip, self.port)) self.server_manager = ServerManager()
def __init__(self, host, port): socket.__init__(self, AF_INET, SOCK_STREAM) self.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.bind((host, port)) self.Clients = {} self.run()
def __init__(self, buffer_size=2048, timeout=2.0): """Class constructor. Set attributes, inheritance and logger.""" # Initializes parent class Socket.__init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM) # Connection parameters for the client device self.ip = '' self.port = None self.buffer_size = buffer_size # Call parent method for setting the timeout self.settimeout(timeout)
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None, server_hostname=None): socket.__init__(self, _sock=sock._sock) # The initializer for socket overrides the methods send(), recv(), etc. # in the instancce, which we don't need -- but we want to provide the # methods defined in SSLSocket. for attr in _delegate_methods: try: delattr(self, attr) except AttributeError: pass if ciphers is None and ssl_version != _SSLv2_IF_EXISTS: ciphers = _DEFAULT_CIPHERS if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except socket_error as e: if e.errno != errno.ENOTCONN: raise # no, no connection yet self._connected = False self._sslobj = None else: # yes, create the SSL object self._connected = True self._sslobj = _ssl.sslwrap(self._sock, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs, ciphers, server_hostname) if do_handshake_on_connect: self.do_handshake() self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers self.server_hostname = server_hostname self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs self._makefile_refs = 0
def __init__(self, ip, port, client_ip_address, player_number, server_manager): socket.__init__(self, type=SOCK_DGRAM) Thread.__init__(self, name=f'Client Handler {player_number}') self.settimeout(DEFAULT_TIMEOUT) self.bind((ip, port + player_number)) self.setDaemon(True) self.player_number = player_number self.client_ip_address = client_ip_address self.server_manager = server_manager # send the player number when whe create the server client handler self._send_player_number()
def __init__(self, sock, server_hostname=None, client_certificate=None, context=None, **kwargs): server_side = False do_handshake_on_connect = True self._client_certificate = client_certificate self._sslobj = context connected = False if sock is not None: socket.__init__(self, family=sock.family, type=sock.type, proto=sock.proto, fileno=sock.fileno()) self.settimeout(sock.gettimeout()) # see if it's connected try: sock.getpeername() except socket_error as e: if e.errno != errno.ENOTCONN: raise else: connected = True sock.detach() self._connected = connected if connected: try: if self._sslobj is None: self._sslobj = SSLContext() self._sslobj._wrap_socket( self, server_side, server_hostname=server_hostname, client_certificate=self._client_certificate) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError( "do_handshake_on_connect should not be specified for non-blocking sockets" ) self.do_handshake() except socket_error as x: self.close() raise x
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True): socket.__init__(self, _sock=sock._sock) # the initializer for socket trashes the methods (tsk, tsk), so... self.send = lambda data, flags=0: SSLSocket.send(self, data, flags) self.sendto = lambda data, addr, flags=0: SSLSocket.sendto( self, data, addr, flags) self.recv = lambda buflen=1024, flags=0: SSLSocket.recv( self, buflen, flags) self.recvfrom = lambda addr, buflen=1024, flags=0: SSLSocket.recvfrom( self, addr, buflen, flags) self.recv_into = lambda buffer, nbytes=None, flags=0: SSLSocket.recv_into( self, buffer, nbytes, flags) self.recvfrom_into = lambda buffer, nbytes=None, flags=0: SSLSocket.recvfrom_into( self, buffer, nbytes, flags) if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except: # no, no connection yet self._sslobj = None else: # yes, create the SSL object self._sslobj = _ssl.sslwrap(self._sock, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs) if do_handshake_on_connect: timeout = self.gettimeout() try: self.settimeout(None) self.do_handshake() finally: self.settimeout(timeout) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs self._makefile_refs = 0
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None): if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError('only stream sockets are supported') socket.__init__(self, _sock=sock._sock) for attr in _delegate_methods: try: delattr(self, attr) except AttributeError: pass if ciphers is None and ssl_version != _SSLv2_IF_EXISTS: ciphers = _DEFAULT_CIPHERS if certfile and not keyfile: keyfile = certfile try: socket.getpeername(self) except socket_error as e: if e.errno != errno.ENOTCONN: raise self._connected = False self._sslobj = None else: self._connected = True self._sslobj = _ssl.sslwrap(self._sock, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs, ciphers) if do_handshake_on_connect: self.do_handshake() self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs self._makefile_refs = 0 return
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True): socket.__init__(self, _sock=sock._sock) # the initializer for socket trashes the methods (tsk, tsk), so... self.send = lambda x, flags=0: SSLSocket.send(self, x, flags) self.recv = lambda x, flags=0: SSLSocket.recv(self, x, flags) self.sendto = lambda data, addr, flags=0: SSLSocket.sendto( self, data, addr, flags) self.recvfrom = lambda addr, buflen, flags: SSLSocket.recvfrom( self, addr, buflen, flags) if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except: # no, no connection yet self._sslobj = None else: # yes, create the SSL object self._sslobj = _ssl2.sslwrap(self._sock, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError( "do_handshake_on_connect should not be specified for non-blocking sockets" ) self.do_handshake() self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs self._makefile_refs = 0
def __init__(self): socket.__init__(self, AF_INET, SOCK_DGRAM) self.__pacotes_recebidos_lk = thread.allocate_lock() self.__pacotes_recebidos = [] self.__pacotes_confirmar_lk = thread.allocate_lock() self.__pacotes_confirmar = {} self.__vusuarios_lk = thread.allocate_lock() self.__vusuarios = {} self.ALLOWED = 0 self.DENIED = 1 self.PASSED = 2
def __init__(self, ifname, bpf=None): self.ifname = ifname # lookup the interface details with IPRoute() as ip: for link in ip.get_links(): if link.get_attr('IFLA_IFNAME') == ifname: break else: raise IOError(2, 'Link not found') self.l2addr = link.get_attr('IFLA_ADDRESS') self.ifindex = link['index'] # bring up the socket socket.__init__(self, AF_PACKET, SOCK_RAW, htons(ETH_P_ALL)) socket.bind(self, (self.ifname, ETH_P_ALL)) if bpf: fstring, self.fprog = compile_bpf(bpf) socket.setsockopt(self, SOL_SOCKET, SO_ATTACH_FILTER, fstring)
def __init__(self, ifname, bpf=None): self.ifname = ifname # lookup the interface details with IPRoute() as ip: for link in ip.get_links(): if link.get_attr("IFLA_IFNAME") == ifname: break else: raise IOError(2, "Link not found") self.l2addr = link.get_attr("IFLA_ADDRESS") self.ifindex = link["index"] # bring up the socket socket.__init__(self, AF_PACKET, SOCK_RAW, htons(ETH_P_ALL)) socket.bind(self, (self.ifname, ETH_P_ALL)) if bpf: fstring, self.fprog = compile_bpf(bpf) socket.setsockopt(self, SOL_SOCKET, SO_ATTACH_FILTER, fstring)
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None): socket.__init__(self, _sock=sock._sock) if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except socket_error, e: if e.errno != errno.ENOTCONN: raise # no, no connection yet self._sslobj = None
def __init__(self, sock, server_hostname=None, client_certificate=None, context=None, **kwargs): server_side = False do_handshake_on_connect = True self._client_certificate = client_certificate self._sslobj = context connected = False if sock is not None: socket.__init__(self, family=sock.family, type=sock.type, proto=sock.proto, fileno=sock.fileno()) self.settimeout(sock.gettimeout()) # see if it's connected try: sock.getpeername() except socket_error as e: if e.errno != errno.ENOTCONN: raise else: connected = True sock.detach() self._connected = connected if connected: try: if self._sslobj is None: self._sslobj = SSLContext() self._sslobj._wrap_socket(self, server_side, server_hostname=server_hostname, client_certificate=self._client_certificate) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets") self.do_handshake() except socket_error as x: self.close() raise x
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True): socket.__init__(self, _sock=sock._sock) # the initializer for socket trashes the methods (tsk, tsk), so... self.send = lambda data, flags=0: SSLSocket.send(self, data, flags) self.sendto = lambda data, addr, flags=0: SSLSocket.sendto(self, data, addr, flags) self.recv = lambda buflen=1024, flags=0: SSLSocket.recv(self, buflen, flags) self.recvfrom = lambda addr, buflen=1024, flags=0: SSLSocket.recvfrom(self, addr, buflen, flags) self.recv_into = lambda buffer, nbytes=None, flags=0: SSLSocket.recv_into(self, buffer, nbytes, flags) self.recvfrom_into = lambda buffer, nbytes=None, flags=0: SSLSocket.recvfrom_into(self, buffer, nbytes, flags) if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except: # no, no connection yet self._sslobj = None else: # yes, create the SSL object self._sslobj = _ssl.sslwrap(self._sock, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs) if do_handshake_on_connect: timeout = self.gettimeout() try: if timeout == 0: self.settimeout(None) self.do_handshake() finally: self.settimeout(timeout) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs self._makefile_refs = 0
def __init__(self, ifname, bpf=None): self.ifname = ifname # lookup the interface details with IPRoute() as ip: for link in ip.get_links(): if link.get_attr('IFLA_IFNAME') == ifname: break else: raise IOError(2, 'Link not found') self.l2addr = link.get_attr('IFLA_ADDRESS') self.ifindex = link['index'] # bring up the socket socket.__init__(self, AF_PACKET, SOCK_RAW, htons(ETH_P_ALL)) socket.bind(self, (self.ifname, ETH_P_ALL)) if bpf: self.clear_buffer() fstring, self.fprog = compile_bpf(bpf) socket.setsockopt(self, SOL_SOCKET, SO_ATTACH_FILTER, fstring) else: self.clear_buffer(remove_total_filter=True)
def __init__(self, family=NETLINK_GENERIC, port=None, pid=None): socket.__init__(self, AF_NETLINK, SOCK_DGRAM, family) global sockets self.recv_plugin = self.recv # 8<----------------------------------------- # PID init is here only for compatibility, # later it will be completely moved to bind() self.addr_pool = AddrPool(minaddr=0xff) self.epid = None self.port = 0 self.fixed = True self.backlog = {0: []} self.monitor = False self.callbacks = [] # [(predicate, callback, args), ...] self.pthread = None self.backlog_lock = threading.Lock() self.read_lock = threading.Lock() self.change_master = threading.Event() self.lock = LockFactory() self.buffer_queue = Queue() self.qsize = 0 self.log = [] self.get_timeout = 3 self.get_timeout_exception = None if pid is None: self.pid = os.getpid() & 0x3fffff self.port = port self.fixed = self.port is not None elif pid == 0: self.pid = os.getpid() else: self.pid = pid # 8<----------------------------------------- self.groups = 0 self.marshal = Marshal() # 8<----------------------------------------- # Set default sockopts self.setsockopt(SOL_SOCKET, SO_SNDBUF, 32768) self.setsockopt(SOL_SOCKET, SO_RCVBUF, 1024 * 1024)
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True): socket.__init__(self, _sock=sock._sock) # the initializer for socket trashes the methods (tsk, tsk), so... self.send = lambda x, flags=0: SSLSocket.send(self, x, flags) self.recv = lambda x, flags=0: SSLSocket.recv(self, x, flags) self.sendto = lambda data, addr, flags=0: SSLSocket.sendto(self, data, addr, flags) self.recvfrom = lambda addr, buflen, flags: SSLSocket.recvfrom(self, addr, buflen, flags) if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except: # no, no connection yet self._sslobj = None else: # yes, create the SSL object self._sslobj = _ssl2.sslwrap(self._sock, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets") self.do_handshake() self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs self._makefile_refs = 0
def __init__(self, sock, keyfile = None, certfile = None, server_side = False, cert_reqs = CERT_NONE, ssl_version = PROTOCOL_SSLv23, ca_certs = None, do_handshake_on_connect = True, suppress_ragged_eofs = True, ciphers = None): if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError('only stream sockets are supported') socket.__init__(self, _sock=sock._sock) for attr in _delegate_methods: try: delattr(self, attr) except AttributeError: pass if ciphers is None and ssl_version != _SSLv2_IF_EXISTS: ciphers = _DEFAULT_CIPHERS if certfile and not keyfile: keyfile = certfile try: socket.getpeername(self) except socket_error as e: if e.errno != errno.ENOTCONN: raise self._connected = False self._sslobj = None else: self._connected = True self._sslobj = _ssl.sslwrap(self._sock, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs, ciphers) if do_handshake_on_connect: self.do_handshake() self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs self._makefile_refs = 0 return
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, npn_protocols=None, do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None): socket.__init__(self, _sock=sock._sock) # The initializer for socket overrides the methods send(), recv(), etc. # in the instancce, which we don't need -- but we want to provide the # methods defined in SSLSocket. for attr in _delegate_methods: try: delattr(self, attr) except AttributeError: pass if ciphers is None and ssl_version != _SSLv2_IF_EXISTS: ciphers = _DEFAULT_CIPHERS if certfile and not keyfile: keyfile = certfile if npn_protocols: npn_protocols = ''.join( [struct.pack('b'+'c'*len(p), len(p), *p) for p in npn_protocols] ) # see if it's connected try: socket.getpeername(self) except socket_error, e: if e.errno != errno.ENOTCONN: raise # no, no connection yet self._connected = False self._sslobj = None
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True): if sock is not None: socket.__init__(self, family=sock.family, type=sock.type, proto=sock.proto, fileno=_dup(sock.fileno())) sock.close() elif fileno is not None: socket.__init__(self, fileno=fileno) else: socket.__init__(self, family=family, type=type, proto=proto) self._closed = False if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except socket_error: # no, no connection yet self._sslobj = None else: # yes, create the SSL object try: self._sslobj = _ssl.sslwrap(self, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets") self.do_handshake() except socket_error as x: self.close() raise x self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs
def __init__(self): socket.__init__(self, AF_INET, SOCK_STREAM)
def __init__(self, game): socket.__init__(self) self.game = game self.reader = PacketReader(self) self.writer = PacketWriter(self) self.connect('',7777)
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_TLS, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, sock_type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True, ciphers=None, _context=None): # set options self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs self.server_side = server_side # set context if _context: self._context = _context else: if server_side and not certfile: raise ValueError("certfile must be specified for server-side " "operations") if keyfile and not certfile: raise ValueError("certfile must be specified") if certfile and not keyfile: keyfile = certfile self._context = SSLContext(ssl_version, server_side) self._context.verify_mode = cert_reqs if ca_certs: self._context.load_verify_locations(ca_certs) if certfile: self._context.load_cert_chain(certfile, keyfile) if ciphers: self._context.set_ciphers(ciphers) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers # preparing socket if sock is not None: # Can't use sock.type as other flags (such as SOCK_NONBLOCK) get # mixed in. if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError("only stream sockets are supported") if _PY3: socket.__init__(self, family=sock.family, type=sock.type, proto=sock.proto, fileno=sock.fileno()) else: socket.__init__(self, _sock=sock._sock) self.settimeout(sock.gettimeout()) if _PY3: sock.detach() elif fileno is not None: socket.__init__(self, fileno=fileno) else: socket.__init__(self, family=family, type=sock_type, proto=proto) # see if we are connected try: self.getpeername() except socket_error as exception: if exception.errno != errno.ENOTCONN: raise connected = False else: connected = True self._closed = False self._connected = connected # create the SSL object self.native_object = _lib.wolfSSL_new(self.context.native_object) if self.native_object == _ffi.NULL: raise MemoryError("Unnable to allocate ssl object") ret = _lib.wolfSSL_set_fd(self.native_object, self.fileno()) if ret != _SSL_SUCCESS: self._release_native_object() raise ValueError("Unnable to set fd to ssl object") if connected: try: if do_handshake_on_connect: self.do_handshake() except: self._release_native_object() self.close() raise
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True): if sock is not None: socket.__init__(self, family=sock.family, type=sock.type, proto=sock.proto, fileno=_dup(sock.fileno())) sock.close() elif fileno is not None: socket.__init__(self, fileno=fileno) else: socket.__init__(self, family=family, type=type, proto=proto) self._closed = False if certfile and not keyfile: keyfile = certfile # see if it's connected try: socket.getpeername(self) except socket_error: # no, no connection yet self._sslobj = None else: # yes, create the SSL object try: self._sslobj = _ssl.sslwrap(self, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError( "do_handshake_on_connect should not be specified for non-blocking sockets" ) self.do_handshake() except socket_error as x: self.close() raise x self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_TLS, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True, npn_protocols=None, ciphers=None, server_hostname=None, _context=None): self._makefile_refs = 0 if _context: self._context = _context else: if server_side and not certfile: raise ValueError("certfile must be specified for server-side " "operations") if keyfile and not certfile: raise ValueError("certfile must be specified") if certfile and not keyfile: keyfile = certfile self._context = SSLContext(ssl_version) self._context.verify_mode = cert_reqs if ca_certs: self._context.load_verify_locations(ca_certs) if certfile: self._context.load_cert_chain(certfile, keyfile) if npn_protocols: self._context.set_npn_protocols(npn_protocols) if ciphers: self._context.set_ciphers(ciphers) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers # Can't use sock.type as other flags (such as SOCK_NONBLOCK) get # mixed in. if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError("only stream sockets are supported") socket.__init__(self, _sock=sock._sock) # "close" the original socket: it is not usable any more. which should # not actually call the operating system's close() because the # reference counter is greater than 1 (we hold one too). sock._sock._drop() if server_side and server_hostname: raise ValueError("server_hostname can only be specified " "in client mode") if self._context.check_hostname and not server_hostname: raise ValueError("check_hostname requires server_hostname") self.server_side = server_side self.server_hostname = server_hostname self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs # See if we are connected try: self.getpeername() except socket_error as e: if e.errno != errno.ENOTCONN: raise connected = False else: connected = True self._closed = False self._sslobj = None self._connected = connected if connected: # create the SSL object try: self._sslobj = self._context._wrap_socket(self._sock, server_side, server_hostname, ssl_sock=self) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError( "do_handshake_on_connect should not be specified for non-blocking sockets" ) self.do_handshake() except (OSError, ValueError): self.close() raise
def __init__(self, ip: str): socket.__init__(self, AF_INET, SOCK_STREAM) socket.connect(self, (ip, 19))
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_TLS, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True, npn_protocols=None, ciphers=None, server_hostname=None, _context=None, _session=None): if _context: self._context = _context else: if server_side and not certfile: raise ValueError("certfile must be specified for server-side " "operations") if keyfile and not certfile: raise ValueError("certfile must be specified") if certfile and not keyfile: keyfile = certfile self._context = SSLContext(ssl_version) self._context.verify_mode = cert_reqs if ca_certs: self._context.load_verify_locations(ca_certs) if certfile: self._context.load_cert_chain(certfile, keyfile) if npn_protocols: self._context.set_npn_protocols(npn_protocols) if ciphers: self._context.set_ciphers(ciphers) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers # Can't use sock.type as other flags (such as SOCK_NONBLOCK) get # mixed in. if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError("only stream sockets are supported") if server_side: if server_hostname: raise ValueError("server_hostname can only be specified " "in client mode") if _session is not None: raise ValueError("session can only be specified in " "client mode") if self._context.check_hostname and not server_hostname: raise ValueError("check_hostname requires server_hostname") self._session = _session self.server_side = server_side self.server_hostname = server_hostname self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs if sock is not None: socket.__init__(self, family=sock.family, type=sock.type, proto=sock.proto, fileno=sock.fileno()) self.settimeout(sock.gettimeout()) sock.detach() elif fileno is not None: socket.__init__(self, fileno=fileno) else: socket.__init__(self, family=family, type=type, proto=proto) # See if we are connected try: self.getpeername() except OSError as e: if e.errno != errno.ENOTCONN: raise connected = False else: connected = True self._closed = False self._sslobj = None self._connected = connected if connected: # create the SSL object try: sslobj = self._context._wrap_socket(self, server_side, server_hostname) self._sslobj = SSLObject(sslobj, owner=self, session=self._session) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError( "do_handshake_on_connect should not be specified for non-blocking sockets" ) self.do_handshake() except (OSError, ValueError): self.close() raise
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True, npn_protocols=None, ciphers=None, server_hostname=None, _context=None): self._makefile_refs = 0 if _context: self._context = _context else: if server_side and not certfile: raise ValueError("certfile must be specified for server-side " "operations") if keyfile and not certfile: raise ValueError("certfile must be specified") if certfile and not keyfile: keyfile = certfile self._context = SSLContext(ssl_version) self._context.verify_mode = cert_reqs if ca_certs: self._context.load_verify_locations(ca_certs) if certfile: self._context.load_cert_chain(certfile, keyfile) if npn_protocols: self._context.set_npn_protocols(npn_protocols) if ciphers: self._context.set_ciphers(ciphers) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers # Can't use sock.type as other flags (such as SOCK_NONBLOCK) get # mixed in. if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError("only stream sockets are supported") socket.__init__(self, _sock=sock._sock) # The initializer for socket overrides the methods send(), recv(), etc. # in the instancce, which we don't need -- but we want to provide the # methods defined in SSLSocket. for attr in _delegate_methods: try: delattr(self, attr) except AttributeError: pass if server_side and server_hostname: raise ValueError("server_hostname can only be specified " "in client mode") if self._context.check_hostname and not server_hostname: raise ValueError("check_hostname requires server_hostname") self.server_side = server_side self.server_hostname = server_hostname self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs # See if we are connected try: self.getpeername() except socket_error as e: if e.errno != errno.ENOTCONN: raise connected = False else: connected = True self._closed = False self._sslobj = None self._connected = connected if connected: # create the SSL object try: self._sslobj = self._context._wrap_socket(self._sock, server_side, server_hostname, ssl_sock=self) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets") self.do_handshake() except (OSError, ValueError): self.close() raise
def __init__(self, family=-1, sock_type=-1, proto=-1, fileno=None): socket.__init__(self, family, sock_type, proto, fileno) self._can_id = None self._can_mask = None self._can_filter = None
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True, npn_protocols=None, ciphers=None, server_hostname=None, _context=None): if _context: self.context = _context else: if server_side and not certfile: raise ValueError('certfile must be specified for server-side operations') if keyfile and not certfile: raise ValueError('certfile must be specified') if certfile and not keyfile: keyfile = certfile self.context = SSLContext(ssl_version) self.context.verify_mode = cert_reqs if ca_certs: self.context.load_verify_locations(ca_certs) if certfile: self.context.load_cert_chain(certfile, keyfile) if npn_protocols: self.context.set_npn_protocols(npn_protocols) if ciphers: self.context.set_ciphers(ciphers) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError('only stream sockets are supported') if server_side and server_hostname: raise ValueError('server_hostname can only be specified in client mode') self.server_side = server_side self.server_hostname = server_hostname self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs connected = False if sock is not None: socket.__init__(self, family=sock.family, type=sock.type, proto=sock.proto, fileno=sock.fileno()) self.settimeout(sock.gettimeout()) try: sock.getpeername() except socket_error as e: while e.errno != errno.ENOTCONN: raise connected = True sock.detach() elif fileno is not None: socket.__init__(self, fileno=fileno) else: socket.__init__(self, family=family, type=type, proto=proto) self._closed = False self._sslobj = None self._connected = connected if connected: try: self._sslobj = self.context._wrap_socket(self, server_side, server_hostname) while do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: raise ValueError('do_handshake_on_connect should not be specified for non-blocking sockets') self.do_handshake() except socket_error as x: self.close() raise x
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True, npn_protocols=None, ciphers=None, server_hostname=None, _context=None): self._makefile_refs = 0 if _context: self._context = _context else: if server_side and not certfile: raise ValueError("certfile must be specified for server-side " "operations") if keyfile and not certfile: raise ValueError("certfile must be specified") if certfile and not keyfile: keyfile = certfile self._context = SSLContext(ssl_version) self._context.verify_mode = cert_reqs if ca_certs: self._context.load_verify_locations(ca_certs) if certfile: self._context.load_cert_chain(certfile, keyfile) if npn_protocols: self._context.set_npn_protocols(npn_protocols) if ciphers: self._context.set_ciphers(ciphers) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers # Can't use sock.type as other flags (such as SOCK_NONBLOCK) get # mixed in. if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError("only stream sockets are supported") socket.__init__(self, _sock=sock._sock) # "close" the original socket: it is not usable any more. which should # not actually call the operating system's close() because the # reference counter is greater than 1 (we hold one too). sock._sock._drop() if server_side and server_hostname: raise ValueError("server_hostname can only be specified " "in client mode") if self._context.check_hostname and not server_hostname: raise ValueError("check_hostname requires server_hostname") self.server_side = server_side self.server_hostname = server_hostname self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs # See if we are connected try: self.getpeername() except socket_error as e: if e.errno != errno.ENOTCONN: raise connected = False else: connected = True self._closed = False self._sslobj = None self._connected = connected if connected: # create the SSL object try: self._sslobj = self._context._wrap_socket(self._sock, server_side, server_hostname, ssl_sock=self) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets") self.do_handshake() except (OSError, ValueError): self.close() raise
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True, npn_protocols=None, ciphers=None, server_hostname=None, _context=None): self._makefile_refs = 0 if _context: self._context = _context else: if server_side and not certfile: raise ValueError("certfile must be specified for server-side " "operations") if keyfile and not certfile: raise ValueError("certfile must be specified") if certfile and not keyfile: keyfile = certfile self._context = SSLContext(ssl_version) self._context.verify_mode = cert_reqs if ca_certs: self._context.load_verify_locations(ca_certs) if certfile: self._context.load_cert_chain(certfile, keyfile) if npn_protocols: self._context.set_npn_protocols(npn_protocols) if ciphers: self._context.set_ciphers(ciphers) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers # Can't use sock.type as other flags (such as SOCK_NONBLOCK) get # mixed in. if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError("only stream sockets are supported") socket.__init__(self, _sock=sock._sock) # The initializer for socket overrides the methods send(), recv(), etc. # in the instancce, which we don't need -- but we want to provide the # methods defined in SSLSocket. for attr in _delegate_methods: try: delattr(self, attr) except AttributeError: pass if server_side and server_hostname: raise ValueError("server_hostname can only be specified " "in client mode") if self._context.check_hostname and not server_hostname: raise ValueError("check_hostname requires server_hostname") self.server_side = server_side self.server_hostname = server_hostname self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs # See if we are connected try: self.getpeername() except socket_error as e: if e.errno != errno.ENOTCONN: raise connected = False else: connected = True self._closed = False self._sslobj = None self._connected = connected if connected: # create the SSL object try: self._sslobj = self._context._wrap_socket(self._sock, server_side, server_hostname, ssl_sock=self) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError( "do_handshake_on_connect should not be specified for non-blocking sockets" ) self.do_handshake() except (OSError, ValueError): self.close() raise
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True, npn_protocols=None, ciphers=None, server_hostname=None, _context=None): if _context: self._context = _context else: if server_side and not certfile: raise ValueError("certfile must be specified for server-side " "operations") if keyfile and not certfile: raise ValueError("certfile must be specified") if certfile and not keyfile: keyfile = certfile self._context = SSLContext(ssl_version) self._context.verify_mode = cert_reqs if ca_certs: self._context.load_verify_locations(ca_certs) if certfile: self._context.load_cert_chain(certfile, keyfile) if npn_protocols: self._context.set_npn_protocols(npn_protocols) if ciphers: self._context.set_ciphers(ciphers) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers # Can't use sock.type as other flags (such as SOCK_NONBLOCK) get # mixed in. if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError("only stream sockets are supported") if server_side and server_hostname: raise ValueError("server_hostname can only be specified " "in client mode") if self._context.check_hostname and not server_hostname: raise ValueError("check_hostname requires server_hostname") self.server_side = server_side self.server_hostname = server_hostname self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs if sock is not None: socket.__init__(self, family=sock.family, type=sock.type, proto=sock.proto, fileno=sock.fileno()) self.settimeout(sock.gettimeout()) sock.detach() elif fileno is not None: socket.__init__(self, fileno=fileno) else: socket.__init__(self, family=family, type=type, proto=proto) # See if we are connected try: self.getpeername() except OSError as e: if e.errno != errno.ENOTCONN: raise connected = False else: connected = True self._closed = False self._sslobj = None self._connected = connected if connected: # create the SSL object try: sslobj = self._context._wrap_socket(self, server_side, server_hostname) self._sslobj = SSLObject(sslobj, owner=self) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets") self.do_handshake() except (OSError, ValueError): self.close() raise
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True, ciphers=None, server_hostname=None, _context=None): if _context: self.context = _context else: if server_side and not certfile: raise ValueError("certfile must be specified for server-side " "operations") if keyfile and not certfile: raise ValueError("certfile must be specified") if certfile and not keyfile: keyfile = certfile self.context = SSLContext(ssl_version) self.context.verify_mode = cert_reqs if ca_certs: self.context.load_verify_locations(ca_certs) if certfile: self.context.load_cert_chain(certfile, keyfile) if ciphers: self.context.set_ciphers(ciphers) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers if server_side and server_hostname: raise ValueError("server_hostname can only be specified " "in client mode") self.server_side = server_side self.server_hostname = server_hostname self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs connected = False if sock is not None: socket.__init__(self, family=sock.family, type=sock.type, proto=sock.proto, fileno=sock.fileno()) self.settimeout(sock.gettimeout()) # see if it's connected try: sock.getpeername() except socket_error as e: if e.errno != errno.ENOTCONN: raise else: connected = True sock.detach() elif fileno is not None: socket.__init__(self, fileno=fileno) else: socket.__init__(self, family=family, type=type, proto=proto) self._closed = False self._sslobj = None self._connected = connected if connected: # create the SSL object try: self._sslobj = self.context._wrap_socket(self, server_side, server_hostname) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: # non-blocking raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets") self.do_handshake() except socket_error as x: self.close() raise x
def __init__(self, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_TLS, ca_certs=None, do_handshake_on_connect=True, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, suppress_ragged_eofs=True, npn_protocols=None, ciphers=None, server_hostname=None, _context=None): self._makefile_refs = 0 if _context: self._context = _context else: if server_side and not certfile: raise ValueError( 'certfile must be specified for server-side operations') if keyfile and not certfile: raise ValueError('certfile must be specified') if certfile and not keyfile: keyfile = certfile self._context = SSLContext(ssl_version) self._context.verify_mode = cert_reqs if ca_certs: self._context.load_verify_locations(ca_certs) if certfile: self._context.load_cert_chain(certfile, keyfile) if npn_protocols: self._context.set_npn_protocols(npn_protocols) if ciphers: self._context.set_ciphers(ciphers) self.keyfile = keyfile self.certfile = certfile self.cert_reqs = cert_reqs self.ssl_version = ssl_version self.ca_certs = ca_certs self.ciphers = ciphers if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: raise NotImplementedError('only stream sockets are supported') socket.__init__(self, _sock=sock._sock) for attr in _delegate_methods: try: delattr(self, attr) except AttributeError: pass if server_side and server_hostname: raise ValueError( 'server_hostname can only be specified in client mode') if self._context.check_hostname and not server_hostname: raise ValueError('check_hostname requires server_hostname') self.server_side = server_side self.server_hostname = server_hostname self.do_handshake_on_connect = do_handshake_on_connect self.suppress_ragged_eofs = suppress_ragged_eofs try: self.getpeername() except socket_error as e: if e.errno != errno.ENOTCONN: raise connected = False else: connected = True self._closed = False self._sslobj = None self._connected = connected if connected: try: self._sslobj = self._context._wrap_socket(self._sock, server_side, server_hostname, ssl_sock=self) if do_handshake_on_connect: timeout = self.gettimeout() if timeout == 0.0: raise ValueError( 'do_handshake_on_connect should not be specified for non-blocking sockets' ) self.do_handshake() except (OSError, ValueError): self.close() raise return