def validate_new_sslsock(**kwargs): """Validate contructor arguments of ssl.SSLSocket. Validate SSL parameter constructor arguments of ssl.SSLSocket. This is useful to check if the specified keyfile= and certfile= exist and have a valid format etc. Normal ssl.SSLSocket does the validation only upon connect() or accept(). Args: kwargs: keyfile=, certfile=, cert_reqs=, ssl_version=, ca_certs= (some of them can be missing) """ nsock = socket._realsocket(socket.AF_INET, socket.SOCK_STREAM) try: nsslobj = ssl._ssl.sslwrap( nsock, False, kwargs.get('keyfile'), kwargs.get('certfile'), kwargs.get('cert_reqs', ssl.CERT_NONE), kwargs.get('ssl_version', ssl.PROTOCOL_SSLv23), kwargs.get('ca_certs')) try: nsslobj.do_handshake() except socket.error, e: if e.errno not in (errno.EPIPE, errno.ENOTCONN): raise finally: nsock.close()
def __init__(self, family=socket.AF_INET, type_=socket.SOCK_STREAM, proto=socket.IPPROTO_TCP): sock = self._sock = socket._realsocket(family, type_, proto) fileno = self._fileno = sock.fileno() self._nonblock()
def __init__(self, family, type, sock=None): if(sock): self._sock = sock._sock else: self._sock = socket._realsocket(family, type) self.fno = self.fileno() addReadChannel(self) if(not hasattr(self, 'send')): self.send = self._sock.send if(not hasattr(self, 'recv')): self.recv = self._sock.recv if(not hasattr(self, 'sendto')): self.sendto = self._sock.sendto if(not hasattr(self, 'recvfrom')): self.recvfrom = self._sock.recvfrom
def perform_accept_ex(self): """ maintain a cache of preallocated sockets for faster accepting sockets """ if self.listening_n == 0: self.listening_n = self.MAX_CACHED_SOCKETS[0] if not self.max_cached_sockets_n: if self.listening_n > self.MAX_CACHED_SOCKETS[0]: self.max_cached_sockets_n = self.MAX_CACHED_SOCKETS[0] else: self.max_cached_sockets_n = self.listening_n if not self.acceptors: print "performing acceptors" while len(self.acceptors) < self.max_cached_sockets_n: s = self.socket print "creating acceptor,", #s1 = WSASocket(s.family, s.type) s1 = _socket._realsocket(s.family, s.type) buff = AllocateBuffer(128) overlapped = OVERLAPPED() AcceptEx(s.fileno(), s1.fileno(), buff, overlapped ) self.acceptors.append((s1,buff, overlapped))
def __init__(self, *args, **kwargs): sock = kwargs.pop('fromsock', None) if sock is None: sock = socket._realsocket(*args, **kwargs) while hasattr(sock, "_sock"): sock = sock._sock self._sock = sock # copy over attributes self._fileno = sock.fileno() self._timeout = sock.gettimeout() self._closed = False # make the underlying socket non-blocking fl = _fcntl(self._fileno, fcntl.F_GETFL) if 0 == fl & os.O_NONBLOCK: _fcntl(self._fileno, fcntl.F_SETFL, fl | os.O_NONBLOCK) # but by default, it blocks greenlets self._blocking = True # create events self._readable = util.Event() self._writable = util.Event()
def make_throttled_socket(*args, **kwargs): ''' Create a wrapped _realsocket that throttles received data rate to 5KB/s ''' return ThrottledSocket(socket._realsocket(*args, **kwargs), 5 * 8 * 1024)
def make_throttled_socket(*args, **kwargs): return ThrottledSocket( download_bytes_per_sec, upload_bytes_per_sec, socket._realsocket(*args, **kwargs))
def make_throttled_socket(*args, **kwargs): ''' Create a wrapped _realsocket that throttles received data rate to 5KB/s ''' return ThrottledSocket(socket._realsocket(*args, **kwargs), 25 * 8 * 1024)
def make_throttled_socket(*args, **kwargs): return ThrottledSocket(download_bytes_per_sec, upload_bytes_per_sec, socket._realsocket(*args, **kwargs))
def socketInit(self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0, _sock=None): if _sock is None: _sock = socket._realsocket(family, type, proto) self._sock = _sock for method in socket._delegate_methods: setattr(self, method, getattr(_sock, method))