Fix loop.create_connection() to skip DNS lookup if host is an IP address

Author: 1st1

tests/test_aiohttp.py

@@ -34,13 +34,15 @@ async def handle_request(self, message, payload):
             '0.0.0.0', '0')
         srv = self.loop.run_until_complete(f)
 
-        addr = srv.sockets[0].getsockname()[:2]
+        port = srv.sockets[0].getsockname()[1]
 
         async def test():
-            with aiohttp.ClientSession() as client:
-                async with client.get('http://{}:{}'.format(*addr)) as resp:
-                    self.assertEqual(resp.status, 200)
-                    self.assertEqual(len(await resp.text()), len(PAYLOAD))
+            for addr in (('localhost', port),
+                         ('127.0.0.1', port)):
+                with aiohttp.ClientSession() as client:
+                    async with client.get('http://{}:{}'.format(*addr)) as r:
+                        self.assertEqual(r.status, 200)
+                        self.assertEqual(len(await r.text()), len(PAYLOAD))
 
         self.loop.run_until_complete(test())
         srv.close()

uvloop/loop.pyx

@@ -1298,10 +1298,19 @@ cdef class Loop:
         cdef:
             AddrInfo ai_local = None
             AddrInfo ai_remote
-            system.addrinfo *rai
-            system.addrinfo *lai
             TCPTransport tr
 
+            system.addrinfo *rai = NULL
+            system.addrinfo *lai = NULL
+
+            system.addrinfo *rai_iter = NULL
+            system.addrinfo *lai_iter = NULL
+
+            system.addrinfo rai_static
+            system.sockaddr rai_addr_static
+            system.addrinfo lai_static
+            system.sockaddr lai_addr_static
+
             object app_protocol
             object protocol
             object ssl_waiter
@@ -1325,60 +1334,89 @@ cdef class Loop:
                 raise ValueError('server_hostname is only meaningful with ssl')
 
         if host is not None or port is not None:
-            f1 = self._getaddrinfo(host, port, family,
-                                   uv.SOCK_STREAM, proto, flags,
-                                   0)  # 0 == don't unpack
+            fs = []
+            f1 = f2 = None
 
-            fs = [f1]
+            try:
+                __static_getaddrinfo(
+                    host, port, family, uv.SOCK_STREAM,
+                    proto, &rai_addr_static)
+            except LookupError:
+                f1 = self._getaddrinfo(
+                    host, port, family,
+                    uv.SOCK_STREAM, proto, flags,
+                    0)  # 0 == don't unpack
+
+                fs.append(f1)
+            else:
+                rai_static.ai_addr = &rai_addr_static
+                rai_static.ai_next = NULL
+                rai = &rai_static
 
-            f2 = None
             if local_addr is not None:
                 if not isinstance(local_addr, (tuple, list)) or \
                         len(local_addr) != 2:
                     raise ValueError(
                         'local_addr must be a tuple of host and port')
 
-                f2 = self._getaddrinfo(local_addr[0], local_addr[1], family,
-                                       uv.SOCK_STREAM, proto, flags,
-                                       0)  # 0 == don't unpack
-                fs.append(f2)
+                try:
+                    __static_getaddrinfo(
+                        local_addr[0], local_addr[1],
+                        family, uv.SOCK_STREAM,
+                        proto, &lai_addr_static)
+                except LookupError:
+                    f2 = self._getaddrinfo(
+                        local_addr[0], local_addr[1], family,
+                        uv.SOCK_STREAM, proto, flags,
+                        0)  # 0 == don't unpack
+
+                    fs.append(f2)
+                else:
+                    lai_static.ai_addr = &lai_addr_static
+                    lai_static.ai_next = NULL
+                    lai = &rai_static
 
-            await aio_wait(fs, loop=self)
+            if len(fs):
+                await aio_wait(fs, loop=self)
 
-            ai_remote = f1.result()
-            if ai_remote.data is NULL:
-                raise OSError('getaddrinfo() returned empty list')
+            if rai is NULL:
+                ai_remote = f1.result()
+                if ai_remote.data is NULL:
+                    raise OSError('getaddrinfo() returned empty list')
+                rai = ai_remote.data
 
-            if f2 is not None:
+            if lai is NULL and f2 is not None:
                 ai_local = f2.result()
                 if ai_local.data is NULL:
                     raise OSError(
                         'getaddrinfo() returned empty list for local_addr')
+                lai = ai_local.data
 
             exceptions = []
-            rai = ai_remote.data
-            while rai is not NULL:
+            rai_iter = rai
+            while rai_iter is not NULL:
                 tr = None
                 try:
                     waiter = self._new_future()
                     tr = TCPTransport.new(self, protocol, None, waiter)
-                    if ai_local is not None:
-                        lai = ai_local.data
-                        while lai is not NULL:
+
+                    if lai is not NULL:
+                        lai_iter = lai
+                        while lai_iter is not NULL:
                             try:
-                                tr.bind(lai.ai_addr)
+                                tr.bind(lai_iter.ai_addr)
                                 break
                             except OSError as exc:
                                 exceptions.append(exc)
-                            lai = lai.ai_next
+                            lai_iter = lai_iter.ai_next
                         else:
                             tr._close()
                             tr = None
 
-                            rai = rai.ai_next
+                            rai_iter = rai_iter.ai_next
                             continue
 
-                    tr.connect(rai.ai_addr)
+                    tr.connect(rai_iter.ai_addr)
                     await waiter
 
                 except OSError as exc:
@@ -1394,7 +1432,7 @@ cdef class Loop:
                 else:
                     break
 
-                rai = rai.ai_next
+                rai_iter = rai_iter.ai_next
 
             else:
                 # If they all have the same str(), raise one.