Make loop methods reject socket kinds they do not support.

More specifically:
* loop.create_connection() and loop.create_server() can accept
  AF_INET or AF_INET6 SOCK_STREAM sockets;

* loop.create_datagram_endpoint() can accept only SOCK_DGRAM
  sockets;

* loop.connect_accepted_socket() can accept only SOCK_STREAM
  sockets;

* fixed a bug in create_unix_server() and create_unix_connection()
  to properly check for SOCK_STREAM sockets on Linux;

* fixed static DNS resolution to decline socket types that aren't
  strictly equal to SOCK_STREAM or SOCK_DGRAM.  On Linux socket
  type can be a bit mask, and we should let system getaddrinfo()
  to deal with it.

Author: 1st1

tests/test_dns.py

@@ -130,6 +130,10 @@ def test_getaddrinfo_19(self):
         self._test_getaddrinfo('::1', 80)
         self._test_getaddrinfo('::1', 80, type=socket.SOCK_STREAM)
 
+    def test_getaddrinfo_20(self):
+        self._test_getaddrinfo('127.0.0.1', 80)
+        self._test_getaddrinfo('127.0.0.1', 80, type=socket.SOCK_STREAM)
+
     ######
 
     def test_getnameinfo_1(self):

tests/test_tcp.py

@@ -806,6 +806,35 @@ def client():
         tr, _ = f.result()
         tr.close()
 
+    @unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'no Unix sockets')
+    def test_create_connection_wrong_sock(self):
+        sock = socket.socket(socket.AF_UNIX)
+        with sock:
+            coro = self.loop.create_connection(MyBaseProto, sock=sock)
+            with self.assertRaisesRegex(ValueError,
+                                        'A TCP Stream Socket was expected'):
+                self.loop.run_until_complete(coro)
+
+    @unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'no Unix sockets')
+    def test_create_server_wrong_sock(self):
+        sock = socket.socket(socket.AF_UNIX)
+        with sock:
+            coro = self.loop.create_server(MyBaseProto, sock=sock)
+            with self.assertRaisesRegex(ValueError,
+                                        'A TCP Stream Socket was expected'):
+                self.loop.run_until_complete(coro)
+
+    @unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
+                         'no socket.SOCK_NONBLOCK (linux only)')
+    def test_create_server_stream_bittype(self):
+        sock = socket.socket(
+            socket.AF_INET, socket.SOCK_STREAM | socket.SOCK_NONBLOCK)
+        with sock:
+            coro = self.loop.create_server(lambda: None, sock=sock)
+            srv = self.loop.run_until_complete(coro)
+            srv.close()
+            self.loop.run_until_complete(srv.wait_closed())
+
 
 class Test_AIO_TCP(_TestTCP, tb.AIOTestCase):
     pass

tests/test_udp.py

@@ -131,7 +131,14 @@ def test_create_datagram_endpoint_sock(self):
 
 
 class Test_UV_UDP(_TestUDP, tb.UVTestCase):
-    pass
+
+    def test_create_datagram_endpoint_wrong_sock(self):
+        sock = socket.socket(socket.AF_INET)
+        with sock:
+            coro = self.loop.create_datagram_endpoint(lambda: None, sock=sock)
+            with self.assertRaisesRegex(ValueError,
+                                        'A UDP Socket was expected'):
+                self.loop.run_until_complete(coro)
 
 
 class Test_AIO_UDP(_TestUDP, tb.AIOTestCase):

tests/test_unix.py

@@ -2,6 +2,7 @@
 import os
 import socket
 import tempfile
+import unittest
 
 from uvloop import _testbase as tb
 
@@ -354,6 +355,33 @@ async def test(sock):
         with s1, s2:
             self.loop.run_until_complete(test(s1))
 
+    def test_create_unix_server_path_dgram(self):
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+        with sock:
+            coro = self.loop.create_unix_server(lambda: None, path=None,
+                                                sock=sock)
+            with self.assertRaisesRegex(ValueError,
+                                        'A UNIX Domain Stream.*was expected'):
+                self.loop.run_until_complete(coro)
+
+    @unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
+                         'no socket.SOCK_NONBLOCK (linux only)')
+    def test_create_unix_server_path_stream_bittype(self):
+        sock = socket.socket(
+            socket.AF_UNIX, socket.SOCK_STREAM | socket.SOCK_NONBLOCK)
+        with tempfile.NamedTemporaryFile() as file:
+            fn = file.name
+        try:
+            with sock:
+                sock.bind(fn)
+                coro = self.loop.create_unix_server(lambda: None, path=None,
+                                                    sock=sock)
+                srv = self.loop.run_until_complete(coro)
+                srv.close()
+                self.loop.run_until_complete(srv.wait_closed())
+        finally:
+            os.unlink(fn)
+
 
 class Test_AIO_Unix(_TestUnix, tb.AIOTestCase):
     pass

uvloop/dns.pyx

@@ -126,8 +126,12 @@ cdef __static_getaddrinfo(object host, object port,
     if proto not in {0, uv.IPPROTO_TCP, uv.IPPROTO_UDP}:
         raise LookupError
 
-    type &= ~_SOCKET_TYPE_MASK
     if type == uv.SOCK_STREAM:
+        # Linux only:
+        #    getaddrinfo() can raise when socket.type is a bit mask.
+        #    So if socket.type is a bit mask of SOCK_STREAM, and say
+        #    SOCK_NONBLOCK, we simply return None, which will trigger
+        #    a call to getaddrinfo() letting it process this request.
         proto = uv.IPPROTO_TCP
     elif type == uv.SOCK_DGRAM:
         proto = uv.IPPROTO_UDP

uvloop/includes/stdlib.pxi

@@ -83,13 +83,6 @@ cdef int socket_EAI_SERVICE    = getattr(socket, 'EAI_SERVICE', -1)
 cdef int socket_EAI_SOCKTYPE   = getattr(socket, 'EAI_SOCKTYPE', -1)
 
 
-cdef int _SOCKET_TYPE_MASK = 0
-if hasattr(socket, 'SOCK_NONBLOCK'):
-    _SOCKET_TYPE_MASK |= socket.SOCK_NONBLOCK
-if hasattr(socket, 'SOCK_CLOEXEC'):
-    _SOCKET_TYPE_MASK |= socket.SOCK_CLOEXEC
-
-
 cdef str os_name = os.name
 cdef os_environ = os.environ
 cdef os_dup = os.dup

uvloop/loop.pyx

@@ -40,6 +40,24 @@ include "includes/stdlib.pxi"
 include "errors.pyx"
 
 
+cdef _is_sock_ip(sock_family):
+    return sock_family == uv.AF_INET or sock_family == uv.AF_INET6
+
+
+cdef _is_sock_stream(sock_type):
+    # Linux's socket.type is a bitmask that can include extra info
+    # about socket, therefore we can't do simple
+    # `sock_type == socket.SOCK_STREAM`.
+    return (sock_type & uv.SOCK_STREAM) == uv.SOCK_STREAM
+
+
+cdef _is_sock_dgram(sock_type):
+    # Linux's socket.type is a bitmask that can include extra info
+    # about socket, therefore we can't do simple
+    # `sock_type == socket.SOCK_DGRAM`.
+    return (sock_type & uv.SOCK_DGRAM) == uv.SOCK_DGRAM
+
+
 cdef isfuture(obj):
     if aio_isfuture is None:
         return isinstance(obj, aio_Future)
@@ -1322,6 +1340,10 @@ cdef class Loop:
         else:
             if sock is None:
                 raise ValueError('Neither host/port nor sock were specified')
+            if (not _is_sock_stream(sock.type) or
+                    not _is_sock_ip(sock.family)):
+                raise ValueError(
+                    'A TCP Stream Socket was expected, got {!r}'.format(sock))
             tcp = TCPServer.new(self, protocol_factory, server, ssl,
                                 uv.AF_UNSPEC)
 
@@ -1505,6 +1527,10 @@ cdef class Loop:
             if sock is None:
                 raise ValueError(
                     'host and port was not specified and no sock specified')
+            if (not _is_sock_stream(sock.type) or
+                    not _is_sock_ip(sock.family)):
+                raise ValueError(
+                    'A TCP Stream Socket was expected, got {!r}'.format(sock))
 
             waiter = self._new_future()
             tr = TCPTransport.new(self, protocol, None, waiter)
@@ -1578,8 +1604,6 @@ cdef class Loop:
         if ssl is not None and not isinstance(ssl, ssl_SSLContext):
             raise TypeError('ssl argument must be an SSLContext or None')
 
-        pipe = UnixServer.new(self, protocol_factory, server, ssl)
-
         if path is not None:
             if sock is not None:
                 raise ValueError(
@@ -1594,7 +1618,6 @@ cdef class Loop:
             try:
                 sock.bind(path)
             except OSError as exc:
-                pipe._close()
                 sock.close()
                 if exc.errno == errno.EADDRINUSE:
                     # Let's improve the error message by adding
@@ -1604,7 +1627,6 @@ cdef class Loop:
                 else:
                     raise
             except:
-                pipe._close()
                 sock.close()
                 raise
 
@@ -1613,11 +1635,13 @@ cdef class Loop:
                 raise ValueError(
                     'path was not specified, and no sock specified')
 
-            if sock.family != uv.AF_UNIX or sock.type != uv.SOCK_STREAM:
+            if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
                 raise ValueError(
                     'A UNIX Domain Stream Socket was expected, got {!r}'
                     .format(sock))
 
+        pipe = UnixServer.new(self, protocol_factory, server, ssl)
+
         try:
             # See a comment on os_dup in create_connection
             fileno = os_dup(sock.fileno())
@@ -1686,7 +1710,7 @@ cdef class Loop:
             if sock is None:
                 raise ValueError('no path and sock were specified')
 
-            if sock.family != uv.AF_UNIX or sock.type != uv.SOCK_STREAM:
+            if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
                 raise ValueError(
                     'A UNIX Domain Stream Socket was expected, got {!r}'
                     .format(sock))
@@ -1989,9 +2013,9 @@ cdef class Loop:
 
         if ssl is not None and not isinstance(ssl, ssl_SSLContext):
             raise TypeError('ssl argument must be an SSLContext or None')
-
-        if sock.type != uv.SOCK_STREAM:
-            raise ValueError('invalid socket type, SOCK_STREAM expected')
+        if not _is_sock_stream(sock.type):
+            raise ValueError(
+                'A Stream Socket was expected, got {!r}'.format(sock))
 
         # See a comment on os_dup in create_connection
         fileno = os_dup(sock.fileno())
@@ -2296,6 +2320,9 @@ cdef class Loop:
             system.addrinfo * rai
 
         if sock is not None:
+            if not _is_sock_dgram(sock.type):
+                raise ValueError(
+                    'A UDP Socket was expected, got {!r}'.format(sock))
             if (local_addr or remote_addr or
                     family or proto or flags or
                     reuse_address or reuse_port or allow_broadcast):