def _connect(self): """Connect to the remote server and start reader/writer greenlets.""" # NB. this method isn't safe to call directly; must only be called # via connect() which adds the necessary locking self.state = STATE_CONNECTING try: try: addrinfo = socket.getaddrinfo(self.host, self.port, socket.AF_INET6, socket.SOCK_STREAM) except socket.gaierror: addrinfo = socket.getaddrinfo(self.host, self.port, socket.AF_INET, socket.SOCK_STREAM) (family, socktype, proto, canonname, sockaddr) = addrinfo[0] self.sock = socket.socket(family, socktype, proto) self.sock.connect(sockaddr) except: self.state = STATE_DISCONNECTED raise # Set up channel state self.channel_id = 1 self.channels = {} # Set up connection greenlets self.queue = Queue(self.MAX_SEND_QUEUE) reader = gevent.spawn(self.do_read, self.sock) writer = gevent.spawn(self.do_write, self.sock, self.queue) reader.link(lambda reader: writer.kill()) writer.link(lambda writer: reader.kill()) self.reader = reader self.writer = writer
def test_error(self): socket.getaddrinfo('host', 25, socket.AF_INET).AndReturn([ (None, None, None, None, 'sockaddr') ]) socket.create_connection('sockaddr', IgnoreArg(), IgnoreArg()).AndRaise(socket.error('error')) self.mox.ReplayAll() with self.assertRaises(socket.error): self.socket_creator(('host', 25), 'timeout', 'source')
def test_socket_error(self): socket.getaddrinfo('host', 25, socket.AF_UNSPEC, socket.SOCK_STREAM, socket.IPPROTO_IP, socket.AI_PASSIVE).AndReturn([ (11, 12, 13, None, 'sockaddr') ]) socket.socket(11, 12, 13).AndRaise(socket.error) self.mox.ReplayAll() with self.assertRaises(socket.error): util.create_listeners(('host', 25))
def test_successful(self): socket.getaddrinfo('host', 25, socket.AF_INET).AndReturn([ (None, None, None, None, 'sockaddr') ]) socket.create_connection('sockaddr', IgnoreArg(), IgnoreArg()).AndReturn('socket') self.mox.ReplayAll() ret = self.socket_creator(('host', 25), 'timeout', 'source') self.assertEqual('socket', ret)
def test_getaddrinfo_mp(self): """This test would make gevent's hub threadpool kill upon hub destruction in child block forever. Gipc resolves this by killing threadpool even harder. """ import gevent.socket as socket socket.getaddrinfo("localhost", 21) p = start_process(target=complchild_test_getaddrinfo_mp) p.join(timeout=1) assert p.exitcode == 0
def test_successful(self): socket.getaddrinfo('host', 25, socket.AF_UNSPEC, socket.SOCK_STREAM, socket.IPPROTO_IP, socket.AI_PASSIVE).AndReturn([ (11, 12, 13, None, 'sockaddr') ]) socket.socket(11, 12, 13).AndReturn(self.sock) self.sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.setblocking(0) self.sock.bind('sockaddr') self.sock.listen(socket.SOMAXCONN) self.mox.ReplayAll() listeners = util.create_listeners(('host', 25)) self.assertEqual([self.sock], listeners)
def check(self, url, host_info): host_info[self.description()] = None if host_info["ssl checked"].get(): return None else: host_ip = socket.getaddrinfo(url, 443)[0][4][0] try: sock = socket.socket() except socket.error: host_info[self.description()] = False return False try: sock = ssl.wrap_socket(sock, ca_certs="/etc/ssl/certs/ca-certificates.crt", cert_reqs=ssl.CERT_NONE, ssl_version=ssl.PROTOCOL_SSLv3, ) sock.connect((host_ip, 443)) cert = sock.getpeercert() usedcipher = str(sock.cipher()) except ssl.SSLError: host_info[self.description()] = False return False if (re.search(r'SSLv3', usedcipher)): host_info[self.description()] = True return True host_info[self.description()] = False return False
def register_addresslist(cls, addresslist): for addr in addresslist: port = 80 if ":" in addr: addr, port = addr.split(":") port = int(port) cls.addresses += socket.getaddrinfo(addr, port, socket.AF_INET, socket.SOCK_STREAM, socket.SOL_TCP, 0)
def check(self, url, host_info): host_info[self.description()] = None host_ip = socket.getaddrinfo(url, 443)[0][4][0] try: sock = socket.socket() sock.connect((host_ip, 443)) except socket.error: host_info["ssl checked"].set(True) host_info[self.description()] = True return True try: sock = ssl.wrap_socket(sock, ca_certs="/etc/ssl/certs/ca-certificates.crt", cert_reqs=ssl.CERT_NONE, ) cert = sock.getpeercert() except ssl.SSLError: host_info["ssl checked"].set(True) host_info[self.description()] = True return True host_info["ssl checked"].set(False) host_info[self.description()] = False return False
def detect_ipv6(): try: addrinfo = socket.getaddrinfo("www.google.com", 80) af, _, _, _, _ = addrinfo[0] return af == socket.AF_INET6 # @UndefinedVariable except: return False
def bind_local_sock_by_addr(addr): addrinfo = socket.getaddrinfo(addr[0], addr[1], 0, socket.SOCK_DGRAM, socket.SOL_UDP) af, socktype, proto, _, remoteaddr = addrinfo[0] sock = socket.socket(af, socktype, proto) sock.connect(remoteaddr) return sock
def create_connection_ipv4(address, timeout=None, source_address=None, only_ports=None): """Attempts to mimick to :py:func:`socket.create_connection`, but connections are only made to IPv4 addresses. :param only_ports: If given, can be a list to limit which ports are restricted to IPv4. Connections to all other ports may be IPv6. """ host, port = address if only_ports and port not in only_ports: return socket.create_connection(address, timeout, source_address) last_exc = None for res in socket.getaddrinfo(host, port, socket.AF_INET): _, _, _, _, sockaddr = res try: return socket.create_connection(sockaddr, timeout, source_address) except socket.error as exc: last_exc = exc if last_exc is not None: raise last_exc else: raise socket.error('getaddrinfo returns an empty list')
def create(self): family, socktype, proto, canonname, sockaddr = \ socket.getaddrinfo(self.server, self.port, 0, socket.SOCK_DGRAM, 0, socket.AI_PASSIVE)[0] self.socket = socket.socket(family, socktype) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind(sockaddr)
def create(self): family, socktype, proto, canonname, sockaddr = \ socket.getaddrinfo(self.server, self.port, 0, socket.SOCK_STREAM, 0, 0)[0] self.socket = socket.socket(family, socktype) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.connect(sockaddr)
def __init__(self, *args, **kwargs): Connection.__init__(self, *args, **kwargs) self.connected_event = Event() self._write_queue = Queue() self._callbacks = {} self._push_watchers = defaultdict(set) sockerr = None addresses = socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC, socket.SOCK_STREAM) for (af, socktype, proto, canonname, sockaddr) in addresses: try: self._socket = socket.socket(af, socktype, proto) if self.ssl_options: self._socket = ssl.wrap_socket(self._socket, **self.ssl_options) self._socket.settimeout(1.0) self._socket.connect(sockaddr) sockerr = None break except socket.error as err: sockerr = err if sockerr: raise socket.error(sockerr.errno, "Tried connecting to %s. Last error: %s" % ([a[4] for a in addresses], sockerr.strerror)) if self.sockopts: for args in self.sockopts: self._socket.setsockopt(*args) self._read_watcher = gevent.spawn(self.handle_read) self._write_watcher = gevent.spawn(self.handle_write) self._send_options_message()
def _dnsQuery(hostname, serveListr='system', tcp=False): u'''纯粹的查询,并没有过滤之类的功能 server: 'system' '8.8.8.8' ['8.8.8.8','8.8.4.4'] 返回值 ['1.1.1.1','2.2.2.2'] ''' if serveListr == 'system': try: res = socket.getaddrinfo(hostname, 80, 0, socket.SOCK_STREAM, socket.IPPROTO_TCP) return [r[4][0] for r in res] except Exception: info = traceback.format_exc() logging.debug( u'[DNS][_dnsQuery][socket.getaddrinfo] 解析失败,host=%s 详细信息:' % hostname) logging.debug('%s\r\n\r\n' % info) return [] else: t = dnsPool.spawn(_dnspythonQuery, hostname, serveListr, tcp) return t.get(True)
def __init__(self, host, port, max_connection=1024, request_model=Request, use_ipv6=False): """ 初始化server @args: host 主机ip :string port 监听端口 :int max_connection 最大连接数 :int request_model 请求处理模板 :type """ self.host = host self.port = port self.max_connection = max_connection if use_ipv6: self.server = socket.socket(socket.AF_INET6) self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) ipv6_addr = socket.getaddrinfo(host, port)[0][-1] self.server.bind(ipv6_addr) else: self.server = socket.socket() self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) self.server.bind((host, port)) self.request_model = request_model
def get_listening_sockets(sport): sockets = [] # Use two sockets, one for IPv4, one for IPv6. IPv4-to-IPv6 mapped # addresses do not work reliably everywhere (under linux it may have # been disabled in /proc/sys/net/ipv6/bind_ipv6_only). for res in socket.getaddrinfo(None, sport, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE): af, socktype, proto, canonname, sa = res try: s = None s = socket.socket(af, socktype, proto) if af == socket.AF_INET6: # Bind v6 only when AF_INET6, otherwise either v4 or v6 bind # will fail. s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1) s.bind(sa) s.listen(1) sockets.append(s) logger.debug("Listening on %s:%d" % sa[:2]) except socket.error, msg: logger.error("Error binding to %s:%d: %s" % (sa[0], sa[1], msg[1])) if s: s.close() while sockets: sockets.pop().close() # Make sure we fail immediately if we cannot get a socket raise msg
def check(self, url, host_info): host_info[self.description()] = None host_ip = socket.getaddrinfo(url, 443)[0][4][0] try: sock = socket.socket() sock.connect((host_ip, 443)) except socket.error: host_info["ssl checked"].set(True) host_info[self.description()] = True return True try: sock = ssl.wrap_socket( sock, ca_certs="/etc/ssl/certs/ca-certificates.crt", cert_reqs=ssl.CERT_NONE, ) cert = sock.getpeercert() except ssl.SSLError: host_info["ssl checked"].set(True) host_info[self.description()] = True return True host_info["ssl checked"].set(False) host_info[self.description()] = False return False
def bootstrap_from_dns(self): """ Fetches CM server list from WebAPI and replaces the current one """ self._LOG.debug("Attempting bootstrap via DNS") try: answer = socket.getaddrinfo("cm0.steampowered.com", 27017, socket.AF_INET, proto=socket.IPPROTO_TCP) except Exception as exp: self._LOG.error("DNS boostrap failed: %s" % str(exp)) return False servers = list(map(lambda addr: addr[4], answer)) if servers: self.clear() self.merge_list(servers) return True else: self._LOG.error( "DNS boostrap: cm0.steampowered.com resolved no A records") return False
def test_AI_CANONNAME(self): # Not all systems support AI_CANONNAME; notably tha manylinux # resolvers *sometimes* do not. Specifically, sometimes they # provide the canonical name *only* on the first result. args = ( # host TestGeventOrg.HOSTNAME, # port None, # family socket.AF_INET, # type 0, # proto 0, # flags socket.AI_CANONNAME) gevent_result = gevent_socket.getaddrinfo(*args) self.assertEqual(gevent_result[0][3], 'readthedocs.io') real_result = socket.getaddrinfo(*args) self.NORMALIZE_GAI_IGNORE_CANONICAL_NAME = not all( r[3] for r in real_result) try: self.assertEqualResults(real_result, gevent_result, 'getaddrinfo') finally: del self.NORMALIZE_GAI_IGNORE_CANONICAL_NAME
def _getaddrinfo(self, host, family): self.logger.debug("Resolving %s", host) try: info = getaddrinfo(host, 0, family, SOCK_DGRAM) return set(map(itemgetter(0), map(itemgetter(-1), info))) except gaierror as e: self.logger.error("Failed to resolve %s: %s", host, e) return set()
def bind_local_udp(tcpsock): tcpaddr = tcpsock.getsockname() addrinfo = socket.getaddrinfo(tcpaddr[0], 0, 0, socket.SOCK_DGRAM, socket.SOL_UDP) af, socktype, proto, _, localaddr = addrinfo[0] udpsock = socket.socket(af, socktype, proto) udpsock.bind(localaddr) return udpsock
def __init__(self, ip, port, relayfactory, timeout=30, maxclient=200): self.ip = ip self.port = port self.timeout = timeout self.relayfactory = relayfactory self.pool = Pool(maxclient) addrinfo = socket.getaddrinfo(ip, port, 0, socket.SOCK_STREAM, socket.SOL_TCP) af, socktype, proto, _, localaddr = addrinfo[0] self.server = StreamServer(localaddr, self._handle, spawn=self.pool)
def connect(self, destpair): for res in socket.getaddrinfo(destpair[0], destpair[1], self.family, self.type, self.proto): af, socktype, proto, _canonname, sa = res ip = IPAddress(sa[0]) if self._force_direct_connect or config['type'] is None or not config['enabled'] or config['last_error'] or any(ip in network for network in local_networks): self.setproxy() else: self.setproxy(proxytype=type_to_int(config['type']), addr=config['host'], port=config['port'], rdns=True, username=config['username'], password=config['password']) socks.socksocket.connect(self, sa) break
def run(self): addrs = socket.getaddrinfo(self.listen_ip, self.listen_port, 0, socket.SOCK_STREAM, socket.SOL_TCP) af, socktype, proto, canonname, sa = addrs[0] listen_socket = socket.socket(af, socktype, proto) listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) listen_socket.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, 1) listen_socket.bind(sa) listen_socket.listen(1024) gevent.joinall([gevent.spawn(self.get_connection, listen_socket)])
def test_enums(self): # https://github.com/gevent/gevent/issues/1310 # On Python 3, getaddrinfo does special things to make sure that # the fancy enums are returned. gai = gevent_socket.getaddrinfo('example.com', 80, socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP) af, socktype, _proto, _canonname, _sa = gai[0] self.assertIs(socktype, socket.SOCK_STREAM) self.assertIs(af, socket.AF_INET)
def resolve_fn(d, timeout=4): ips = None try: with gevent.Timeout(timeout, False): ips = { f[4][0] for f in socket.getaddrinfo(d, 80, socket.AF_INET, 0, socket.IPPROTO_TCP) } except socket.gaierror as ex: pass return d, ips
def connect(self): host, port = (self.host, self.port) #Clean out the buffers self._buffer.clear() #If the existing socket is not None close it if self._socket is not None: self.close() # Resolve the hostname and connect (ipv6 ready) sock = None try: for info in socket.getaddrinfo(host, port, socket.AF_UNSPEC, socket.SOCK_STREAM): family, socktype, proto, canonname, sockaddr = info #Validate the socket will make try: sock = socket.socket(family, socktype, proto) #Set Keepalives sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) except socket.error, msg: print('Socket Error: %s' % msg) sock = None continue #Wrap in ssl if asked if self.SSL: print('Starting SSL') try: ctx = SSL.Context(SSL.SSLv23_METHOD) sock = SSL.Connection(ctx, sock) except SSL.Error, err: print('Could not Initiate SSL: %s' % err) sock = None continue #Try to establish the connection try: print('Trying Connect(%s)' % repr(sockaddr)) sock.settimeout(10) sock.connect(sockaddr) except socket.error, msg: print('Socket Error: %s' % msg) if self.SSL: sock.shutdown() sock.close() sock = None continue
def listen_all(self): for res in socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC, socket.SOCK_DGRAM, 0, socket.AI_PASSIVE): print "dl_server: listening to", res af, socktype, proto, canonname, sa = res try: self.receive_socket = socket.socket(af, socktype, proto) except socket.error, msg: self.receive_socket = None continue try: self.receive_socket.bind(sa) except socket.error, msg: self.receive_socket.close() self.receive_socket = None continue
def create_connection(address, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, source_address=None, socket_options=None): """Connect to *address* and return the socket object. Convenience function. Connect to *address* (a 2-tuple ``(host, port)``) and return the socket object. Passing the optional *timeout* parameter will set the timeout on the socket instance before attempting to connect. If no *timeout* is supplied, the global default timeout setting returned by :func:`getdefaulttimeout` is used. If *source_address* is set it must be a tuple of (host, port) for the socket to bind as a source address before making the connection. An host of '' or port 0 tells the OS to use the default. """ host, port = address err = None for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM): af, socktype, proto, canonname, sa = res sock = None try: sock = socket.socket(af, socktype, proto) # If provided, set socket level options before connecting. # This is the only addition urllib3 makes to this function. _set_socket_options(sock, socket_options) if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT: sock.settimeout(timeout) if source_address: sock.bind(source_address) sock.connect(sa) return sock except socket.error as _: err = _ if sock is not None: sock.close() if err is not None: raise err else: raise socket.error("getaddrinfo returns an empty list")
def create_connection(address, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, source_address=None): """Connect to *address* and return the socket object. Convenience function. Connect to *address* (a 2-tuple ``(host, port)``) and return the socket object. Passing the optional *timeout* parameter will set the timeout on the socket instance before attempting to connect. If no *timeout* is supplied, the global default timeout setting returned by :func:`getdefaulttimeout` is used. If *source_address* is set it must be a tuple of (host, port) for the socket to bind as a source address before making the connection. An host of '' or port 0 tells the OS to use the default. """ host, port = address err = None force_direct_connect = host == globalconfig['reconnect.routerip'] and True or False for res in socket.getaddrinfo(host, port, 0 if socket.has_ipv6 else socket.AF_INET, socket.SOCK_STREAM): af, socktype, proto, _canonname, sa = res sock = None try: sock = socket.socket(af, socktype, proto, force_direct_connect=force_direct_connect) if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT: sock.settimeout(timeout) if source_address: sock.bind(source_address) sock.connect(sa) return sock except socket.error: err = sys.exc_info()[1] # without exc_clear(), if connect() fails once, the socket is referenced by the frame in exc_info # and the next bind() fails (see test__socket.TestCreateConnection) # that does not happen with regular sockets though, because _socket.socket.connect() is a built-in. # this is similar to "getnameinfo loses a reference" failure in test_socket.py sys.exc_clear() if sock is not None: sock.close() if err is not None: raise err else: raise socket.error("getaddrinfo returns an empty list")
def create_listeners(address, family=socket.AF_UNSPEC, socktype=socket.SOCK_STREAM, proto=socket.IPPROTO_IP): """Uses :func:`socket.getaddrinfo` to create listening sockets for available socket parameters. For example, giving *address* as ``('localhost', 80)`` on a system with IPv6 would return one socket bound to ``127.0.0.1`` and one bound to ``::1`. May also be used for ``socket.AF_UNIX`` with a file path to produce a single unix domain socket listening on that path. :param address: A ``(host, port)`` tuple to listen on. :param family: the socket family, default ``AF_UNSPEC``. :param socktype: the socket type, default ``SOCK_STREAM``. :param proto: the socket protocol, default ``IPPROTO_IP``. """ if family == socket.AF_UNIX: sock = socket.socket(family, socktype, proto) _init_socket(sock, address) return [sock] elif not isinstance(address, tuple) or len(address) != 2: raise ValueError(address) flags = socket.AI_PASSIVE host, port = address listeners = [] last_exc = None for res in socket.getaddrinfo(host, port, family, socktype, proto, flags): fam, typ, prt, _, sockaddr = res try: sock = socket.socket(fam, typ, prt) _init_socket(sock, sockaddr) except socket.error as exc: last_exc = exc else: listeners.append(sock) if last_exc and not listeners: raise last_exc return listeners
def _dnsQuery(hostname, serveListr='system', tcp=False): u'''纯粹的查询,并没有过滤之类的功能 server: 'system' '8.8.8.8' ['8.8.8.8','8.8.4.4'] 返回值 ['1.1.1.1','2.2.2.2'] ''' if serveListr == 'system': try: res = socket.getaddrinfo(hostname, 80, 0, socket.SOCK_STREAM, socket.IPPROTO_TCP) return [r[4][0] for r in res] except Exception: info = traceback.format_exc() logging.debug(u'[DNS][_dnsQuery][socket.getaddrinfo] 解析失败,host=%s 详细信息:' % hostname) logging.debug('%s\r\n\r\n' % info) return [] else: t = dnsPool.spawn(_dnspythonQuery, hostname, serveListr, tcp) return t.get(True)
def _connect(self): """这部分是真正的建立与reids的tcp连接""" # we want to mimic what socket.create_connection does to support # ipv4/ipv6, but we want to set options prior to calling # socket.connect() err = None for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM): family, socktype, proto, canonname, socket_address = res sock = None try: sock = socket.socket(family, socktype, proto) # TCP_NODELAY sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) # TCP_KEEPALIVE if self.socket_keepalive: sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) for k, v in iteritems(self.socket_keepalive_options): sock.setsockopt(socket.SOL_TCP, k, v) # set the socket_connect_timeout before we connect sock.settimeout(self.socket_connect_timeout) # connect sock.connect(socket_address) # set the socket_timeout now that we're connected sock.settimeout(self.socket_timeout) return sock except socket.error as _: err = _ if sock is not None: sock.close() if err is not None: raise err raise socket.error("socket.getaddrinfo returned an empty list")
def _create_connection(address, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, source_address=None, prepare=None): # Taken from: # https://github.com/python/cpython/blob/0f40482fde59ff307569fa5676183dd8432809a8/Lib/socket.py#L771 # Licensed under the PSFL, version 2 # Copyright (c) 2001-now Python Software Foundation host, port = address err = None for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM): af, socktype, proto, canonname, sa = res sock = None try: sock = socket(af, socktype, proto) if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT: sock.settimeout(timeout) if source_address: sock.bind(source_address) if prepare: prepare(sock) sock.connect(sa) # Break explicitly a reference cycle err = None return sock except socket.error as e: err = e if sock is not None: sock.close() if err is not None: try: raise err finally: # Break explicitly a reference cycle err = None else: raise socket.error("getaddrinfo returns an empty list")
def _do_connect(endpoint): net, addr = endpoint if net in ('unix',): is_tcp = False addrinfo = [(AF_UNIX, SOCK_STREAM, 0, '', addr)] else: is_tcp = True addrinfo = getaddrinfo(addr[0], addr[1], 0, SOCK_STREAM) if not addrinfo: raise ValueError('no addresses for %r' % (endpoint,)) exc = RuntimeError # pylint can't figure it out otherwise for family, socktype, proto, canonname, address in addrinfo: sock = socket(family, socktype, proto) try: sock.connect(address) except: exc = sys.exc_info()[1] continue if is_tcp: sock.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1) # pylint: disable=E1101 return sock raise exc
def test_unspec(self): self.assertEqual(gevent_socket.getaddrinfo('gevent.org', None, socket.AF_UNSPEC), self.getresult())
def test_inet(self): self.assertEqual(gevent_socket.getaddrinfo('gevent.org', None, socket.AF_INET), self.getresult())
def _handshake(self): """ Perform handshake/authentication with a connecting client Outline: 1. Client connects 2. We fake RFB 3.8 protocol and require VNC authentication [also supports RFB 3.3] 3. Client accepts authentication method 4. We send an authentication challenge 5. Client sends the authentication response 6. We check the authentication 7. We initiate a connection with the backend server and perform basic RFB 3.8 handshake with it. Upon return, self.client and self.server are sockets connected to the client and the backend server, respectively. """ self.client.send(rfb.RFB_VERSION_3_8 + "\n") client_version_str = self.client.recv(1024) client_version = rfb.check_version(client_version_str) if not client_version: self.error("Invalid version: %s" % client_version_str) raise gevent.GreenletExit # Both for RFB 3.3 and 3.8 self.debug("Requesting authentication") auth_request = rfb.make_auth_request(rfb.RFB_AUTHTYPE_VNC, version=client_version) self.client.send(auth_request) # The client gets to propose an authtype only for RFB 3.8 if client_version == rfb.RFB_VERSION_3_8: res = self.client.recv(1024) type = rfb.parse_client_authtype(res) if type == rfb.RFB_AUTHTYPE_ERROR: self.warn("Client refused authentication: %s" % res[1:]) else: self.debug("Client requested authtype %x" % type) if type != rfb.RFB_AUTHTYPE_VNC: self.error("Wrong auth type: %d" % type) self.client.send(rfb.to_u32(rfb.RFB_AUTH_ERROR)) raise gevent.GreenletExit # Generate the challenge challenge = os.urandom(16) self.client.send(challenge) response = self.client.recv(1024) if len(response) != 16: self.error("Wrong response length %d, should be 16" % len(response)) raise gevent.GreenletExit if rfb.check_password(challenge, response, self.password): self.debug("Authentication successful!") else: self.warn("Authentication failed") self.client.send(rfb.to_u32(rfb.RFB_AUTH_ERROR)) raise gevent.GreenletExit # Accept the authentication self.client.send(rfb.to_u32(rfb.RFB_AUTH_SUCCESS)) # Try to connect to the server tries = 50 while tries: tries -= 1 # Initiate server connection for res in socket.getaddrinfo(self.daddr, self.dport, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE): af, socktype, proto, canonname, sa = res try: self.server = socket.socket(af, socktype, proto) except socket.error, msg: self.server = None continue try: self.debug("Connecting to %s:%s" % sa[:2]) self.server.connect(sa) self.debug("Connection to %s:%s successful" % sa[:2]) except socket.error, msg: self.server.close() self.server = None continue # We succesfully connected to the server tries = 0 break
def test_unspec(self): self.assertEqualResults(self.getresult(), gevent_socket.getaddrinfo(TestGeventOrg.HOSTNAME, None, socket.AF_UNSPEC), 'getaddrinfo')
def test_inet(self): self.assertEqualResults(self.getresult(), gevent_socket.getaddrinfo(TestGeventOrg.HOSTNAME, None, socket.AF_INET), 'getaddrinfo')
def _app(self, environ, start_response): start_response('200 OK', [('Content-Type','text/plain')]) yield "{0}\n".format(socket.getaddrinfo('www.baidu.com', 80))
def worker(host): try: return socket.getaddrinfo(host, port, family, socktype, proto, flags) except Exception as e: return e
def test_error(self): socket.getaddrinfo('host', 25, socket.AF_INET).AndReturn([(None, None, None, None, 'sockaddr')]) socket.create_connection('sockaddr', IgnoreArg(), IgnoreArg()).AndRaise(socket.error('error')) self.mox.ReplayAll() with self.assertRaises(socket.error): self.socket_creator(('host', 25), 'timeout', 'source')
import socket import gevent.socket as gevent_socket gevent_socket.getaddrinfo(u'gevent.org', None, socket.AF_INET)
def _perform_server_handshake(self): """ Initiate a connection with the backend server and perform basic RFB 3.8 handshake with it. Return a socket connected to the backend server. """ server = None tries = VncAuthProxy.connect_retries while tries: tries -= 1 # Initiate server connection for res in socket.getaddrinfo(self.daddr, self.dport, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE): af, socktype, proto, canonname, sa = res try: server = socket.socket(af, socktype, proto) except socket.error: server = None continue # Set socket timeout for the initial handshake server.settimeout(VncAuthProxy.server_timeout) try: self.debug("Connecting to %s:%s", *sa[:2]) server.connect(sa) self.debug("Connection to %s:%s successful", *sa[:2]) except socket.error as err: self.debug("Failed to perform sever hanshake, retrying...") server.close() server = None continue # We succesfully connected to the server tries = 0 break # Wait and retry gevent.sleep(VncAuthProxy.retry_wait) if server is None: raise InternalError("Failed to connect to server") version = server.recv(1024) if not rfb.check_version(version): raise InternalError("Unsupported RFB version: %s" % version.strip()) server.send(rfb.RFB_VERSION_3_8 + "\n") res = server.recv(1024) types = rfb.parse_auth_request(res) if not types: raise InternalError("Error handshaking with the server") else: self.debug("Supported authentication types: %s", " ".join([str(x) for x in types])) if rfb.RFB_AUTHTYPE_NONE not in types: raise InternalError("Error, server demands authentication") server.send(rfb.to_u8(rfb.RFB_AUTHTYPE_NONE)) # Check authentication response res = server.recv(4) res = rfb.from_u32(res) if res != 0: raise InternalError("Authentication error") # Reset the timeout for the rest of the session server.settimeout(None) self.server = server
def test_no_addresses(self): socket.getaddrinfo('host', 25, socket.AF_INET).AndReturn([]) self.mox.ReplayAll() with self.assertRaises(socket.error): self.socket_creator(('host', 25), 'timeout', 'source')
def test_successful(self): socket.getaddrinfo('host', 25, socket.AF_INET).AndReturn([(None, None, None, None, 'sockaddr')]) socket.create_connection('sockaddr', IgnoreArg(), IgnoreArg()).AndReturn('socket') self.mox.ReplayAll() ret = self.socket_creator(('host', 25), 'timeout', 'source') self.assertEqual('socket', ret)