PageRenderTime 2ms CodeModel.GetById 76ms app.highlight 35ms RepoModel.GetById 1ms app.codeStats 0ms

/Lib/socket.py

https://bitbucket.org/ncoghlan/cpython_sandbox
Python | 737 lines | 709 code | 1 blank | 27 comment | 8 complexity | dbfb74ca9970ab06710683cfa9813cc9 MD5 | raw file
  1# Wrapper module for _socket, providing some additional facilities
  2# implemented in Python.
  3
  4"""\
  5This module provides socket operations and some related functions.
  6On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
  7On other systems, it only supports IP. Functions specific for a
  8socket are available as methods of the socket object.
  9
 10Functions:
 11
 12socket() -- create a new socket object
 13socketpair() -- create a pair of new socket objects [*]
 14fromfd() -- create a socket object from an open file descriptor [*]
 15fromshare() -- create a socket object from data received from socket.share() [*]
 16gethostname() -- return the current hostname
 17gethostbyname() -- map a hostname to its IP number
 18gethostbyaddr() -- map an IP number or hostname to DNS info
 19getservbyname() -- map a service name and a protocol name to a port number
 20getprotobyname() -- map a protocol name (e.g. 'tcp') to a number
 21ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
 22htons(), htonl() -- convert 16, 32 bit int from host to network byte order
 23inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
 24inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
 25socket.getdefaulttimeout() -- get the default timeout value
 26socket.setdefaulttimeout() -- set the default timeout value
 27create_connection() -- connects to an address, with an optional timeout and
 28                       optional source address.
 29
 30 [*] not available on all platforms!
 31
 32Special objects:
 33
 34SocketType -- type object for socket objects
 35error -- exception raised for I/O errors
 36has_ipv6 -- boolean value indicating if IPv6 is supported
 37
 38IntEnum constants:
 39
 40AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
 41SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
 42
 43Integer constants:
 44
 45Many other constants may be defined; these may be used in calls to
 46the setsockopt() and getsockopt() methods.
 47"""
 48
 49import _socket
 50from _socket import *
 51
 52import os, sys, io, selectors
 53from enum import IntEnum
 54
 55try:
 56    import errno
 57except ImportError:
 58    errno = None
 59EBADF = getattr(errno, 'EBADF', 9)
 60EAGAIN = getattr(errno, 'EAGAIN', 11)
 61EWOULDBLOCK = getattr(errno, 'EWOULDBLOCK', 11)
 62
 63__all__ = ["fromfd", "getfqdn", "create_connection",
 64        "AddressFamily", "SocketKind"]
 65__all__.extend(os._get_exports_list(_socket))
 66
 67# Set up the socket.AF_* socket.SOCK_* constants as members of IntEnums for
 68# nicer string representations.
 69# Note that _socket only knows about the integer values. The public interface
 70# in this module understands the enums and translates them back from integers
 71# where needed (e.g. .family property of a socket object).
 72
 73IntEnum._convert(
 74        'AddressFamily',
 75        __name__,
 76        lambda C: C.isupper() and C.startswith('AF_'))
 77
 78IntEnum._convert(
 79        'SocketKind',
 80        __name__,
 81        lambda C: C.isupper() and C.startswith('SOCK_'))
 82
 83_LOCALHOST    = '127.0.0.1'
 84_LOCALHOST_V6 = '::1'
 85
 86
 87def _intenum_converter(value, enum_klass):
 88    """Convert a numeric family value to an IntEnum member.
 89
 90    If it's not a known member, return the numeric value itself.
 91    """
 92    try:
 93        return enum_klass(value)
 94    except ValueError:
 95        return value
 96
 97_realsocket = socket
 98
 99# WSA error codes
100if sys.platform.lower().startswith("win"):
101    errorTab = {}
102    errorTab[10004] = "The operation was interrupted."
103    errorTab[10009] = "A bad file handle was passed."
104    errorTab[10013] = "Permission denied."
105    errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT
106    errorTab[10022] = "An invalid operation was attempted."
107    errorTab[10035] = "The socket operation would block"
108    errorTab[10036] = "A blocking operation is already in progress."
109    errorTab[10048] = "The network address is in use."
110    errorTab[10054] = "The connection has been reset."
111    errorTab[10058] = "The network has been shut down."
112    errorTab[10060] = "The operation timed out."
113    errorTab[10061] = "Connection refused."
114    errorTab[10063] = "The name is too long."
115    errorTab[10064] = "The host is down."
116    errorTab[10065] = "The host is unreachable."
117    __all__.append("errorTab")
118
119
120class _GiveupOnSendfile(Exception): pass
121
122
123class socket(_socket.socket):
124
125    """A subclass of _socket.socket adding the makefile() method."""
126
127    __slots__ = ["__weakref__", "_io_refs", "_closed"]
128
129    def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None):
130        # For user code address family and type values are IntEnum members, but
131        # for the underlying _socket.socket they're just integers. The
132        # constructor of _socket.socket converts the given argument to an
133        # integer automatically.
134        _socket.socket.__init__(self, family, type, proto, fileno)
135        self._io_refs = 0
136        self._closed = False
137
138    def __enter__(self):
139        return self
140
141    def __exit__(self, *args):
142        if not self._closed:
143            self.close()
144
145    def __repr__(self):
146        """Wrap __repr__() to reveal the real class name and socket
147        address(es).
148        """
149        closed = getattr(self, '_closed', False)
150        s = "<%s.%s%s fd=%i, family=%s, type=%s, proto=%i" \
151            % (self.__class__.__module__,
152               self.__class__.__qualname__,
153               " [closed]" if closed else "",
154               self.fileno(),
155               self.family,
156               self.type,
157               self.proto)
158        if not closed:
159            try:
160                laddr = self.getsockname()
161                if laddr:
162                    s += ", laddr=%s" % str(laddr)
163            except error:
164                pass
165            try:
166                raddr = self.getpeername()
167                if raddr:
168                    s += ", raddr=%s" % str(raddr)
169            except error:
170                pass
171        s += '>'
172        return s
173
174    def __getstate__(self):
175        raise TypeError("Cannot serialize socket object")
176
177    def dup(self):
178        """dup() -> socket object
179
180        Duplicate the socket. Return a new socket object connected to the same
181        system resource. The new socket is non-inheritable.
182        """
183        fd = dup(self.fileno())
184        sock = self.__class__(self.family, self.type, self.proto, fileno=fd)
185        sock.settimeout(self.gettimeout())
186        return sock
187
188    def accept(self):
189        """accept() -> (socket object, address info)
190
191        Wait for an incoming connection.  Return a new socket
192        representing the connection, and the address of the client.
193        For IP sockets, the address info is a pair (hostaddr, port).
194        """
195        fd, addr = self._accept()
196        # If our type has the SOCK_NONBLOCK flag, we shouldn't pass it onto the
197        # new socket. We do not currently allow passing SOCK_NONBLOCK to
198        # accept4, so the returned socket is always blocking.
199        type = self.type & ~globals().get("SOCK_NONBLOCK", 0)
200        sock = socket(self.family, type, self.proto, fileno=fd)
201        # Issue #7995: if no default timeout is set and the listening
202        # socket had a (non-zero) timeout, force the new socket in blocking
203        # mode to override platform-specific socket flags inheritance.
204        if getdefaulttimeout() is None and self.gettimeout():
205            sock.setblocking(True)
206        return sock, addr
207
208    def makefile(self, mode="r", buffering=None, *,
209                 encoding=None, errors=None, newline=None):
210        """makefile(...) -> an I/O stream connected to the socket
211
212        The arguments are as for io.open() after the filename, except the only
213        supported mode values are 'r' (default), 'w' and 'b'.
214        """
215        # XXX refactor to share code?
216        if not set(mode) <= {"r", "w", "b"}:
217            raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,))
218        writing = "w" in mode
219        reading = "r" in mode or not writing
220        assert reading or writing
221        binary = "b" in mode
222        rawmode = ""
223        if reading:
224            rawmode += "r"
225        if writing:
226            rawmode += "w"
227        raw = SocketIO(self, rawmode)
228        self._io_refs += 1
229        if buffering is None:
230            buffering = -1
231        if buffering < 0:
232            buffering = io.DEFAULT_BUFFER_SIZE
233        if buffering == 0:
234            if not binary:
235                raise ValueError("unbuffered streams must be binary")
236            return raw
237        if reading and writing:
238            buffer = io.BufferedRWPair(raw, raw, buffering)
239        elif reading:
240            buffer = io.BufferedReader(raw, buffering)
241        else:
242            assert writing
243            buffer = io.BufferedWriter(raw, buffering)
244        if binary:
245            return buffer
246        text = io.TextIOWrapper(buffer, encoding, errors, newline)
247        text.mode = mode
248        return text
249
250    if hasattr(os, 'sendfile'):
251
252        def _sendfile_use_sendfile(self, file, offset=0, count=None):
253            self._check_sendfile_params(file, offset, count)
254            sockno = self.fileno()
255            try:
256                fileno = file.fileno()
257            except (AttributeError, io.UnsupportedOperation) as err:
258                raise _GiveupOnSendfile(err)  # not a regular file
259            try:
260                fsize = os.fstat(fileno).st_size
261            except OSError:
262                raise _GiveupOnSendfile(err)  # not a regular file
263            if not fsize:
264                return 0  # empty file
265            blocksize = fsize if not count else count
266
267            timeout = self.gettimeout()
268            if timeout == 0:
269                raise ValueError("non-blocking sockets are not supported")
270            # poll/select have the advantage of not requiring any
271            # extra file descriptor, contrarily to epoll/kqueue
272            # (also, they require a single syscall).
273            if hasattr(selectors, 'PollSelector'):
274                selector = selectors.PollSelector()
275            else:
276                selector = selectors.SelectSelector()
277            selector.register(sockno, selectors.EVENT_WRITE)
278
279            total_sent = 0
280            # localize variable access to minimize overhead
281            selector_select = selector.select
282            os_sendfile = os.sendfile
283            try:
284                while True:
285                    if timeout and not selector_select(timeout):
286                        raise _socket.timeout('timed out')
287                    if count:
288                        blocksize = count - total_sent
289                        if blocksize <= 0:
290                            break
291                    try:
292                        sent = os_sendfile(sockno, fileno, offset, blocksize)
293                    except BlockingIOError:
294                        if not timeout:
295                            # Block until the socket is ready to send some
296                            # data; avoids hogging CPU resources.
297                            selector_select()
298                        continue
299                    except OSError as err:
300                        if total_sent == 0:
301                            # We can get here for different reasons, the main
302                            # one being 'file' is not a regular mmap(2)-like
303                            # file, in which case we'll fall back on using
304                            # plain send().
305                            raise _GiveupOnSendfile(err)
306                        raise err from None
307                    else:
308                        if sent == 0:
309                            break  # EOF
310                        offset += sent
311                        total_sent += sent
312                return total_sent
313            finally:
314                if total_sent > 0 and hasattr(file, 'seek'):
315                    file.seek(offset)
316    else:
317        def _sendfile_use_sendfile(self, file, offset=0, count=None):
318            raise _GiveupOnSendfile(
319                "os.sendfile() not available on this platform")
320
321    def _sendfile_use_send(self, file, offset=0, count=None):
322        self._check_sendfile_params(file, offset, count)
323        if self.gettimeout() == 0:
324            raise ValueError("non-blocking sockets are not supported")
325        if offset:
326            file.seek(offset)
327        blocksize = min(count, 8192) if count else 8192
328        total_sent = 0
329        # localize variable access to minimize overhead
330        file_read = file.read
331        sock_send = self.send
332        try:
333            while True:
334                if count:
335                    blocksize = min(count - total_sent, blocksize)
336                    if blocksize <= 0:
337                        break
338                data = memoryview(file_read(blocksize))
339                if not data:
340                    break  # EOF
341                while True:
342                    try:
343                        sent = sock_send(data)
344                    except BlockingIOError:
345                        continue
346                    else:
347                        total_sent += sent
348                        if sent < len(data):
349                            data = data[sent:]
350                        else:
351                            break
352            return total_sent
353        finally:
354            if total_sent > 0 and hasattr(file, 'seek'):
355                file.seek(offset + total_sent)
356
357    def _check_sendfile_params(self, file, offset, count):
358        if 'b' not in getattr(file, 'mode', 'b'):
359            raise ValueError("file should be opened in binary mode")
360        if not self.type & SOCK_STREAM:
361            raise ValueError("only SOCK_STREAM type sockets are supported")
362        if count is not None:
363            if not isinstance(count, int):
364                raise TypeError(
365                    "count must be a positive integer (got {!r})".format(count))
366            if count <= 0:
367                raise ValueError(
368                    "count must be a positive integer (got {!r})".format(count))
369
370    def sendfile(self, file, offset=0, count=None):
371        """sendfile(file[, offset[, count]]) -> sent
372
373        Send a file until EOF is reached by using high-performance
374        os.sendfile() and return the total number of bytes which
375        were sent.
376        *file* must be a regular file object opened in binary mode.
377        If os.sendfile() is not available (e.g. Windows) or file is
378        not a regular file socket.send() will be used instead.
379        *offset* tells from where to start reading the file.
380        If specified, *count* is the total number of bytes to transmit
381        as opposed to sending the file until EOF is reached.
382        File position is updated on return or also in case of error in
383        which case file.tell() can be used to figure out the number of
384        bytes which were sent.
385        The socket must be of SOCK_STREAM type.
386        Non-blocking sockets are not supported.
387        """
388        try:
389            return self._sendfile_use_sendfile(file, offset, count)
390        except _GiveupOnSendfile:
391            return self._sendfile_use_send(file, offset, count)
392
393    def _decref_socketios(self):
394        if self._io_refs > 0:
395            self._io_refs -= 1
396        if self._closed:
397            self.close()
398
399    def _real_close(self, _ss=_socket.socket):
400        # This function should not reference any globals. See issue #808164.
401        _ss.close(self)
402
403    def close(self):
404        # This function should not reference any globals. See issue #808164.
405        self._closed = True
406        if self._io_refs <= 0:
407            self._real_close()
408
409    def detach(self):
410        """detach() -> file descriptor
411
412        Close the socket object without closing the underlying file descriptor.
413        The object cannot be used after this call, but the file descriptor
414        can be reused for other purposes.  The file descriptor is returned.
415        """
416        self._closed = True
417        return super().detach()
418
419    @property
420    def family(self):
421        """Read-only access to the address family for this socket.
422        """
423        return _intenum_converter(super().family, AddressFamily)
424
425    @property
426    def type(self):
427        """Read-only access to the socket type.
428        """
429        return _intenum_converter(super().type, SocketKind)
430
431    if os.name == 'nt':
432        def get_inheritable(self):
433            return os.get_handle_inheritable(self.fileno())
434        def set_inheritable(self, inheritable):
435            os.set_handle_inheritable(self.fileno(), inheritable)
436    else:
437        def get_inheritable(self):
438            return os.get_inheritable(self.fileno())
439        def set_inheritable(self, inheritable):
440            os.set_inheritable(self.fileno(), inheritable)
441    get_inheritable.__doc__ = "Get the inheritable flag of the socket"
442    set_inheritable.__doc__ = "Set the inheritable flag of the socket"
443
444def fromfd(fd, family, type, proto=0):
445    """ fromfd(fd, family, type[, proto]) -> socket object
446
447    Create a socket object from a duplicate of the given file
448    descriptor.  The remaining arguments are the same as for socket().
449    """
450    nfd = dup(fd)
451    return socket(family, type, proto, nfd)
452
453if hasattr(_socket.socket, "share"):
454    def fromshare(info):
455        """ fromshare(info) -> socket object
456
457        Create a socket object from the bytes object returned by
458        socket.share(pid).
459        """
460        return socket(0, 0, 0, info)
461    __all__.append("fromshare")
462
463if hasattr(_socket, "socketpair"):
464
465    def socketpair(family=None, type=SOCK_STREAM, proto=0):
466        """socketpair([family[, type[, proto]]]) -> (socket object, socket object)
467
468        Create a pair of socket objects from the sockets returned by the platform
469        socketpair() function.
470        The arguments are the same as for socket() except the default family is
471        AF_UNIX if defined on the platform; otherwise, the default is AF_INET.
472        """
473        if family is None:
474            try:
475                family = AF_UNIX
476            except NameError:
477                family = AF_INET
478        a, b = _socket.socketpair(family, type, proto)
479        a = socket(family, type, proto, a.detach())
480        b = socket(family, type, proto, b.detach())
481        return a, b
482
483else:
484
485    # Origin: https://gist.github.com/4325783, by Geert Jansen.  Public domain.
486    def socketpair(family=AF_INET, type=SOCK_STREAM, proto=0):
487        if family == AF_INET:
488            host = _LOCALHOST
489        elif family == AF_INET6:
490            host = _LOCALHOST_V6
491        else:
492            raise ValueError("Only AF_INET and AF_INET6 socket address families "
493                             "are supported")
494        if type != SOCK_STREAM:
495            raise ValueError("Only SOCK_STREAM socket type is supported")
496        if proto != 0:
497            raise ValueError("Only protocol zero is supported")
498
499        # We create a connected TCP socket. Note the trick with
500        # setblocking(False) that prevents us from having to create a thread.
501        lsock = socket(family, type, proto)
502        try:
503            lsock.bind((host, 0))
504            lsock.listen()
505            # On IPv6, ignore flow_info and scope_id
506            addr, port = lsock.getsockname()[:2]
507            csock = socket(family, type, proto)
508            try:
509                csock.setblocking(False)
510                try:
511                    csock.connect((addr, port))
512                except (BlockingIOError, InterruptedError):
513                    pass
514                csock.setblocking(True)
515                ssock, _ = lsock.accept()
516            except:
517                csock.close()
518                raise
519        finally:
520            lsock.close()
521        return (ssock, csock)
522
523socketpair.__doc__ = """socketpair([family[, type[, proto]]]) -> (socket object, socket object)
524Create a pair of socket objects from the sockets returned by the platform
525socketpair() function.
526The arguments are the same as for socket() except the default family is AF_UNIX
527if defined on the platform; otherwise, the default is AF_INET.
528"""
529
530_blocking_errnos = { EAGAIN, EWOULDBLOCK }
531
532class SocketIO(io.RawIOBase):
533
534    """Raw I/O implementation for stream sockets.
535
536    This class supports the makefile() method on sockets.  It provides
537    the raw I/O interface on top of a socket object.
538    """
539
540    # One might wonder why not let FileIO do the job instead.  There are two
541    # main reasons why FileIO is not adapted:
542    # - it wouldn't work under Windows (where you can't used read() and
543    #   write() on a socket handle)
544    # - it wouldn't work with socket timeouts (FileIO would ignore the
545    #   timeout and consider the socket non-blocking)
546
547    # XXX More docs
548
549    def __init__(self, sock, mode):
550        if mode not in ("r", "w", "rw", "rb", "wb", "rwb"):
551            raise ValueError("invalid mode: %r" % mode)
552        io.RawIOBase.__init__(self)
553        self._sock = sock
554        if "b" not in mode:
555            mode += "b"
556        self._mode = mode
557        self._reading = "r" in mode
558        self._writing = "w" in mode
559        self._timeout_occurred = False
560
561    def readinto(self, b):
562        """Read up to len(b) bytes into the writable buffer *b* and return
563        the number of bytes read.  If the socket is non-blocking and no bytes
564        are available, None is returned.
565
566        If *b* is non-empty, a 0 return value indicates that the connection
567        was shutdown at the other end.
568        """
569        self._checkClosed()
570        self._checkReadable()
571        if self._timeout_occurred:
572            raise OSError("cannot read from timed out object")
573        while True:
574            try:
575                return self._sock.recv_into(b)
576            except timeout:
577                self._timeout_occurred = True
578                raise
579            except error as e:
580                if e.args[0] in _blocking_errnos:
581                    return None
582                raise
583
584    def write(self, b):
585        """Write the given bytes or bytearray object *b* to the socket
586        and return the number of bytes written.  This can be less than
587        len(b) if not all data could be written.  If the socket is
588        non-blocking and no bytes could be written None is returned.
589        """
590        self._checkClosed()
591        self._checkWritable()
592        try:
593            return self._sock.send(b)
594        except error as e:
595            # XXX what about EINTR?
596            if e.args[0] in _blocking_errnos:
597                return None
598            raise
599
600    def readable(self):
601        """True if the SocketIO is open for reading.
602        """
603        if self.closed:
604            raise ValueError("I/O operation on closed socket.")
605        return self._reading
606
607    def writable(self):
608        """True if the SocketIO is open for writing.
609        """
610        if self.closed:
611            raise ValueError("I/O operation on closed socket.")
612        return self._writing
613
614    def seekable(self):
615        """True if the SocketIO is open for seeking.
616        """
617        if self.closed:
618            raise ValueError("I/O operation on closed socket.")
619        return super().seekable()
620
621    def fileno(self):
622        """Return the file descriptor of the underlying socket.
623        """
624        self._checkClosed()
625        return self._sock.fileno()
626
627    @property
628    def name(self):
629        if not self.closed:
630            return self.fileno()
631        else:
632            return -1
633
634    @property
635    def mode(self):
636        return self._mode
637
638    def close(self):
639        """Close the SocketIO object.  This doesn't close the underlying
640        socket, except if all references to it have disappeared.
641        """
642        if self.closed:
643            return
644        io.RawIOBase.close(self)
645        self._sock._decref_socketios()
646        self._sock = None
647
648
649def getfqdn(name=''):
650    """Get fully qualified domain name from name.
651
652    An empty argument is interpreted as meaning the local host.
653
654    First the hostname returned by gethostbyaddr() is checked, then
655    possibly existing aliases. In case no FQDN is available, hostname
656    from gethostname() is returned.
657    """
658    name = name.strip()
659    if not name or name == '0.0.0.0':
660        name = gethostname()
661    try:
662        hostname, aliases, ipaddrs = gethostbyaddr(name)
663    except error:
664        pass
665    else:
666        aliases.insert(0, hostname)
667        for name in aliases:
668            if '.' in name:
669                break
670        else:
671            name = hostname
672    return name
673
674
675_GLOBAL_DEFAULT_TIMEOUT = object()
676
677def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT,
678                      source_address=None):
679    """Connect to *address* and return the socket object.
680
681    Convenience function.  Connect to *address* (a 2-tuple ``(host,
682    port)``) and return the socket object.  Passing the optional
683    *timeout* parameter will set the timeout on the socket instance
684    before attempting to connect.  If no *timeout* is supplied, the
685    global default timeout setting returned by :func:`getdefaulttimeout`
686    is used.  If *source_address* is set it must be a tuple of (host, port)
687    for the socket to bind as a source address before making the connection.
688    A host of '' or port 0 tells the OS to use the default.
689    """
690
691    host, port = address
692    err = None
693    for res in getaddrinfo(host, port, 0, SOCK_STREAM):
694        af, socktype, proto, canonname, sa = res
695        sock = None
696        try:
697            sock = socket(af, socktype, proto)
698            if timeout is not _GLOBAL_DEFAULT_TIMEOUT:
699                sock.settimeout(timeout)
700            if source_address:
701                sock.bind(source_address)
702            sock.connect(sa)
703            return sock
704
705        except error as _:
706            err = _
707            if sock is not None:
708                sock.close()
709
710    if err is not None:
711        raise err
712    else:
713        raise error("getaddrinfo returns an empty list")
714
715def getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):
716    """Resolve host and port into list of address info entries.
717
718    Translate the host/port argument into a sequence of 5-tuples that contain
719    all the necessary arguments for creating a socket connected to that service.
720    host is a domain name, a string representation of an IPv4/v6 address or
721    None. port is a string service name such as 'http', a numeric port number or
722    None. By passing None as the value of host and port, you can pass NULL to
723    the underlying C API.
724
725    The family, type and proto arguments can be optionally specified in order to
726    narrow the list of addresses returned. Passing zero as a value for each of
727    these arguments selects the full range of results.
728    """
729    # We override this function since we want to translate the numeric family
730    # and socket type values to enum constants.
731    addrlist = []
732    for res in _socket.getaddrinfo(host, port, family, type, proto, flags):
733        af, socktype, proto, canonname, sa = res
734        addrlist.append((_intenum_converter(af, AddressFamily),
735                         _intenum_converter(socktype, SocketKind),
736                         proto, canonname, sa))
737    return addrlist