Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Doc/library/socket.rst

    r2 r391  
    1 
    21:mod:`socket` --- Low-level networking interface
    32================================================
    … …  
    3029The Python interface is a straightforward transliteration of the Unix system
    3130call and library interface for sockets to Python's object-oriented style: the
    32 :func:`socket` function returns a :dfn:`socket object` whose methods implement
     31:func:`.socket` function returns a :dfn:`socket object` whose methods implement
    3332the various socket system calls.  Parameter types are somewhat higher-level than
    3433in the C interface: as with :meth:`read` and :meth:`write` operations on Python
    … …  
    4039:const:`AF_INET` address family, where *host* is a string representing either a
    4140hostname in Internet domain notation like ``'daring.cwi.nl'`` or an IPv4 address
    42 like ``'100.50.200.5'``, and *port* is an integral port number. For
     41like ``'100.50.200.5'``, and *port* is an integer. For
    4342:const:`AF_INET6` address family, a four-tuple ``(host, port, flowinfo,
    4443scopeid)`` is used, where *flowinfo* and *scopeid* represents ``sin6_flowinfo``
    … …  
    7473   ``(addr_type, v1, v2, v3 [, scope])``, where:
    7574
    76      - *addr_type* is one of TIPC_ADDR_NAMESEQ, TIPC_ADDR_NAME, or
    77        TIPC_ADDR_ID.
    78      - *scope* is one of TIPC_ZONE_SCOPE, TIPC_CLUSTER_SCOPE, and
    79        TIPC_NODE_SCOPE.
    80      - If *addr_type* is TIPC_ADDR_NAME, then *v1* is the server type, *v2* is
    81        the port identifier, and *v3* should be 0.
    82 
    83        If *addr_type* is TIPC_ADDR_NAMESEQ, then *v1* is the server type, *v2*
    84        is the lower port number, and *v3* is the upper port number.
    85 
    86        If *addr_type* is TIPC_ADDR_ID, then *v1* is the node, *v2* is the
    87        reference, and *v3* should be set to 0.
     75   - *addr_type* is one of :const:`TIPC_ADDR_NAMESEQ`, :const:`TIPC_ADDR_NAME`,
     76     or :const:`TIPC_ADDR_ID`.
     77   - *scope* is one of :const:`TIPC_ZONE_SCOPE`, :const:`TIPC_CLUSTER_SCOPE`,
     78     and :const:`TIPC_NODE_SCOPE`.
     79   - If *addr_type* is :const:`TIPC_ADDR_NAME`, then *v1* is the server type, *v2* is
     80     the port identifier, and *v3* should be 0.
     81
     82     If *addr_type* is :const:`TIPC_ADDR_NAMESEQ`, then *v1* is the server type, *v2*
     83     is the lower port number, and *v3* is the upper port number.
     84
     85     If *addr_type* is :const:`TIPC_ADDR_ID`, then *v1* is the node, *v2* is the
     86     reference, and *v3* should be set to 0.
    8887
    8988
    … …  
    9291semantics raise the error :exc:`socket.error`.
    9392
    94 Non-blocking mode is supported through :meth:`setblocking`.  A generalization of
    95 this based on timeouts is supported through :meth:`settimeout`.
     93Non-blocking mode is supported through :meth:`~socket.setblocking`.  A
     94generalization of this based on timeouts is supported through
     95:meth:`~socket.settimeout`.
    9696
    9797The module :mod:`socket` exports the following constants and functions:
    … …  
    120120   The accompanying value is a pair ``(h_errno, string)`` representing an error
    121121   returned by a library call. *string* represents the description of *h_errno*, as
    122    returned by the :cfunc:`hstrerror` C function.
     122   returned by the :c:func:`hstrerror` C function.
    123123
    124124
    … …  
    128128   :func:`getnameinfo`. The accompanying value is a pair ``(error, string)``
    129129   representing an error returned by a library call. *string* represents the
    130    description of *error*, as returned by the :cfunc:`gai_strerror` C function. The
     130   description of *error*, as returned by the :c:func:`gai_strerror` C function. The
    131131   *error* value will match one of the :const:`EAI_\*` constants defined in this
    132132   module.
    … …  
    147147
    148148   These constants represent the address (and protocol) families, used for the
    149    first argument to :func:`socket`.  If the :const:`AF_UNIX` constant is not
     149   first argument to :func:`.socket`.  If the :const:`AF_UNIX` constant is not
    150150   defined then this protocol is unsupported.
    151151
    … …  
    187187
    188188   Constants for Windows' WSAIoctl(). The constants are used as arguments to the
    189    :meth:`ioctl` method of socket objects.
     189   :meth:`~socket.socket.ioctl` method of socket objects.
    190190
    191191   .. versionadded:: 2.6
    … …  
    206206
    207207
    208 .. function:: create_connection(address[, timeout])
    209 
    210    Convenience function.  Connect to *address* (a 2-tuple ``(host, port)``),
    211    and return the socket object.  Passing the optional *timeout* parameter will
    212    set the timeout on the socket instance before attempting to connect.  If no
    213    *timeout* is supplied, the global default timeout setting returned by
     208.. function:: create_connection(address[, timeout[, source_address]])
     209
     210   Connect to a TCP service listening on the Internet *address* (a 2-tuple
     211   ``(host, port)``), and return the socket object.  This is a higher-level
     212   function than :meth:`socket.connect`: if *host* is a non-numeric hostname,
     213   it will try to resolve it for both :data:`AF_INET` and :data:`AF_INET6`,
     214   and then try to connect to all possible addresses in turn until a
     215   connection succeeds.  This makes it easy to write clients that are
     216   compatible to both IPv4 and IPv6.
     217
     218   Passing the optional *timeout* parameter will set the timeout on the
     219   socket instance before attempting to connect.  If no *timeout* is
     220   supplied, the global default timeout setting returned by
    214221   :func:`getdefaulttimeout` is used.
    215222
     223   If supplied, *source_address* must be a 2-tuple ``(host, port)`` for the
     224   socket to bind to as its source address before connecting.  If host or port
     225   are '' or 0 respectively the OS default behavior will be used.
     226
    216227   .. versionadded:: 2.6
    217228
     229   .. versionchanged:: 2.7
     230      *source_address* was added.
     231
    218232
    219233.. function:: getaddrinfo(host, port[, family[, socktype[, proto[, flags]]]])
    220234
    221    Resolves the *host*/*port* argument, into a sequence of 5-tuples that contain
    222    all the necessary arguments for creating the corresponding socket. *host* is a domain
    223    name, a string representation of an IPv4/v6 address or ``None``. *port* is a string
    224    service name such as ``'http'``, a numeric port number or ``None``.
    225    The rest of the arguments are optional and must be numeric if specified.
    226    By passing ``None`` as the value of *host* and *port*, , you can pass ``NULL`` to the C API.
    227 
    228    The :func:`getaddrinfo` function returns a list of 5-tuples with the following
    229    structure:
     235   Translate the *host*/*port* argument into a sequence of 5-tuples that contain
     236   all the necessary arguments for creating a socket connected to that service.
     237   *host* is a domain name, a string representation of an IPv4/v6 address
     238   or ``None``. *port* is a string service name such as ``'http'``, a numeric
     239   port number or ``None``.  By passing ``None`` as the value of *host*
     240   and *port*, you can pass ``NULL`` to the underlying C API.
     241
     242   The *family*, *socktype* and *proto* arguments can be optionally specified
     243   in order to narrow the list of addresses returned.  By default, their value
     244   is ``0``, meaning that the full range of results is selected.
     245   The *flags* argument can be one or several of the ``AI_*`` constants,
     246   and will influence how results are computed and returned.  Its default value
     247   is ``0``.  For example, :const:`AI_NUMERICHOST` will disable domain name
     248   resolution and will raise an error if *host* is a domain name.
     249
     250   The function returns a list of 5-tuples with the following structure:
    230251
    231252   ``(family, socktype, proto, canonname, sockaddr)``
    232253
    233    *family*, *socktype*, *proto* are all integers and are meant to be passed to the
    234    :func:`socket` function. *canonname* is a string representing the canonical name
    235    of the *host*. It can be a numeric IPv4/v6 address when :const:`AI_CANONNAME` is
    236    specified for a numeric *host*. *sockaddr* is a tuple describing a socket
    237    address, as described above. See the source for :mod:`socket` and other
    238    library modules for a typical usage of the function.
     254   In these tuples, *family*, *socktype*, *proto* are all integers and are
     255   meant to be passed to the :func:`.socket` function.  *canonname* will be
     256   a string representing the canonical name of the *host* if
     257   :const:`AI_CANONNAME` is part of the *flags* argument; else *canonname*
     258   will be empty.  *sockaddr* is a tuple describing a socket address, whose
     259   format depends on the returned *family* (a ``(address, port)`` 2-tuple for
     260   :const:`AF_INET`, a ``(address, port, flow info, scope id)`` 4-tuple for
     261   :const:`AF_INET6`), and is meant to be passed to the :meth:`socket.connect`
     262   method.
     263
     264   The following example fetches address information for a hypothetical TCP
     265   connection to ``www.python.org`` on port 80 (results may differ on your
     266   system if IPv6 isn't enabled)::
     267
     268      >>> socket.getaddrinfo("www.python.org", 80, 0, 0, socket.SOL_TCP)
     269      [(2, 1, 6, '', ('82.94.164.162', 80)),
     270       (10, 1, 6, '', ('2001:888:2000:d::a2', 80, 0, 0))]
    239271
    240272   .. versionadded:: 2.2
    … …  
    312344
    313345   Translate an Internet protocol name (for example, ``'icmp'``) to a constant
    314    suitable for passing as the (optional) third argument to the :func:`socket`
     346   suitable for passing as the (optional) third argument to the :func:`.socket`
    315347   function.  This is usually only needed for sockets opened in "raw" mode
    316348   (:const:`SOCK_RAW`); for the normal socket modes, the correct protocol is chosen
    … …  
    346378   Build a pair of connected socket objects using the given address family, socket
    347379   type, and protocol number.  Address family, socket type, and protocol number are
    348    as for the :func:`socket` function above. The default family is :const:`AF_UNIX`
     380   as for the :func:`.socket` function above. The default family is :const:`AF_UNIX`
    349381   if defined on the platform; otherwise, the default is :const:`AF_INET`.
    350382   Availability: Unix.
    … …  
    357389   Duplicate the file descriptor *fd* (an integer as returned by a file object's
    358390   :meth:`fileno` method) and build a socket object from the result.  Address
    359    family, socket type and protocol number are as for the :func:`socket` function
     391   family, socket type and protocol number are as for the :func:`.socket` function
    360392   above. The file descriptor should refer to a socket, but this is not checked ---
    361393   subsequent operations on the object may fail if the file descriptor is invalid.
    … …  
    399431   '123.45.67.89') to 32-bit packed binary format, as a string four characters in
    400432   length.  This is useful when conversing with a program that uses the standard C
    401    library and needs objects of type :ctype:`struct in_addr`, which is the C type
     433   library and needs objects of type :c:type:`struct in_addr`, which is the C type
    402434   for the 32-bit packed binary this function returns.
    403435
    … …  
    407439   If the IPv4 address string passed to this function is invalid,
    408440   :exc:`socket.error` will be raised. Note that exactly what is valid depends on
    409    the underlying C implementation of :cfunc:`inet_aton`.
     441   the underlying C implementation of :c:func:`inet_aton`.
    410442
    411443   :func:`inet_aton` does not support IPv6, and :func:`inet_pton` should be used
    … …  
    418450   standard dotted-quad string representation (for example, '123.45.67.89').  This
    419451   is useful when conversing with a program that uses the standard C library and
    420    needs objects of type :ctype:`struct in_addr`, which is the C type for the
     452   needs objects of type :c:type:`struct in_addr`, which is the C type for the
    421453   32-bit packed binary data this function takes as an argument.
    422454
    … …  
    430462   Convert an IP address from its family-specific string format to a packed, binary
    431463   format. :func:`inet_pton` is useful when a library or network protocol calls for
    432    an object of type :ctype:`struct in_addr` (similar to :func:`inet_aton`) or
    433    :ctype:`struct in6_addr`.
     464   an object of type :c:type:`struct in_addr` (similar to :func:`inet_aton`) or
     465   :c:type:`struct in6_addr`.
    434466
    435467   Supported values for *address_family* are currently :const:`AF_INET` and
    … …  
    437469   :exc:`socket.error` will be raised. Note that exactly what is valid depends on
    438470   both the value of *address_family* and the underlying implementation of
    439    :cfunc:`inet_pton`.
     471   :c:func:`inet_pton`.
    440472
    441473   Availability: Unix (maybe not all platforms).
    … …  
    449481   standard, family-specific string representation (for example, ``'7.10.0.5'`` or
    450482   ``'5aef:2b::8'``) :func:`inet_ntop` is useful when a library or network protocol
    451    returns an object of type :ctype:`struct in_addr` (similar to :func:`inet_ntoa`)
    452    or :ctype:`struct in6_addr`.
     483   returns an object of type :c:type:`struct in_addr` (similar to :func:`inet_ntoa`)
     484   or :c:type:`struct in6_addr`.
    453485
    454486   Supported values for *address_family* are currently :const:`AF_INET` and
    … …  
    464496.. function:: getdefaulttimeout()
    465497
    466    Return the default timeout in floating seconds for new socket objects. A value
     498   Return the default timeout in seconds (float) for new socket objects. A value
    467499   of ``None`` indicates that new socket objects have no timeout. When the socket
    468500   module is first imported, the default is ``None``.
    … …  
    473505.. function:: setdefaulttimeout(timeout)
    474506
    475    Set the default timeout in floating seconds for new socket objects. A value of
     507   Set the default timeout in seconds (float) for new socket objects. A value of
    476508   ``None`` indicates that new socket objects have no timeout. When the socket
    477509   module is first imported, the default is ``None``.
    … …  
    490522   Module :mod:`SocketServer`
    491523      Classes that simplify writing network servers.
     524
     525   Module :mod:`ssl`
     526      A TLS/SSL wrapper for socket objects.
    492527
    493528
    … …  
    527562   automatically closed when they are garbage-collected.
    528563
     564   .. note::
     565      :meth:`close()` releases the resource associated with a connection but
     566      does not necessarily close the connection immediately.  If you want
     567      to close the connection in a timely fashion, call :meth:`shutdown()`
     568      before :meth:`close()`.
     569
    529570
    530571.. method:: socket.connect(address)
    … …  
    543584
    544585   Like ``connect(address)``, but return an error indicator instead of raising an
    545    exception for errors returned by the C-level :cfunc:`connect` call (other
     586   exception for errors returned by the C-level :c:func:`connect` call (other
    546587   problems, such as "host not found," can still raise exceptions).  The error
    547588   indicator is ``0`` if the operation succeeded, otherwise the value of the
    548    :cdata:`errno` variable.  This is useful to support, for example, asynchronous
     589   :c:data:`errno` variable.  This is useful to support, for example, asynchronous
    549590   connects.
    550591
    … …  
    598639
    599640   The :meth:`ioctl` method is a limited interface to the WSAIoctl system
    600    interface. Please refer to the MSDN documentation for more information.
     641   interface.  Please refer to the `Win32 documentation
     642   <http://msdn.microsoft.com/en-us/library/ms741621%28VS.85%29.aspx>`_ for more
     643   information.
    601644
    602645   On other platforms, the generic :func:`fcntl.fcntl` and :func:`fcntl.ioctl`
    … …  
    609652
    610653   Listen for connections made to the socket.  The *backlog* argument specifies the
    611    maximum number of queued connections and should be at least 1; the maximum value
    612    is system-dependent (usually 5).
     654   maximum number of queued connections and should be at least 0; the maximum value
     655   is system-dependent (usually 5), the minimum value is forced to 0.
    613656
    614657
    … …  
    619662   Return a :dfn:`file object` associated with the socket.  (File objects are
    620663   described in :ref:`bltin-file-objects`.) The file object
    621    references a :cfunc:`dup`\ ped version of the socket file descriptor, so the
     664   references a :c:func:`dup`\ ped version of the socket file descriptor, so the
    622665   file object and socket object may be closed or garbage-collected independently.
    623666   The socket must be in blocking mode (it can not have a timeout). The optional
    624667   *mode* and *bufsize* arguments are interpreted the same way as by the built-in
    625668   :func:`file` function.
     669
     670   .. note::
     671
     672      On Windows, the file-like object created by :meth:`makefile` cannot be
     673      used where a file object with a file descriptor is expected, such as the
     674      stream arguments of :meth:`subprocess.Popen`.
    626675
    627676
    … …  
    663712
    664713   Receive up to *nbytes* bytes from the socket, storing the data into a buffer
    665    rather than creating a new string.     If *nbytes* is not specified (or 0),
    666    receive up to the size available in the given buffer. See the Unix manual page
    667    :manpage:`recv(2)` for the meaning of the optional argument *flags*; it defaults
    668    to zero.
     714   rather than creating a new string.  If *nbytes* is not specified (or 0),
     715   receive up to the size available in the given buffer.  Returns the number of
     716   bytes received.  See the Unix manual page :manpage:`recv(2)` for the meaning
     717   of the optional argument *flags*; it defaults to zero.
    669718
    670719   .. versionadded:: 2.5
    … …  
    677726   Returns the number of bytes sent. Applications are responsible for checking that
    678727   all data has been sent; if only some of the data was transmitted, the
    679    application needs to attempt delivery of the remaining data.
     728   application needs to attempt delivery of the remaining data. For further
     729   information on this concept, consult the :ref:`socket-howto`.
    680730
    681731
    … …  
    690740
    691741
    692 .. method:: socket.sendto(string[, flags], address)
     742.. method:: socket.sendto(string, address)
     743            socket.sendto(string, flags, address)
    693744
    694745   Send data to the socket.  The socket should not be connected to a remote socket,
    … …  
    706757   data, or if a :meth:`send` call can't immediately dispose of the data, a
    707758   :exc:`error` exception is raised; in blocking mode, the calls block until they
    708    can proceed. ``s.setblocking(0)`` is equivalent to ``s.settimeout(0)``;
     759   can proceed. ``s.setblocking(0)`` is equivalent to ``s.settimeout(0.0)``;
    709760   ``s.setblocking(1)`` is equivalent to ``s.settimeout(None)``.
    710761
    … …  
    714765   Set a timeout on blocking socket operations.  The *value* argument can be a
    715766   nonnegative float expressing seconds, or ``None``. If a float is given,
    716    subsequent socket operations will raise an :exc:`timeout` exception if the
     767   subsequent socket operations will raise a :exc:`timeout` exception if the
    717768   timeout period *value* has elapsed before the operation has completed.  Setting
    718769   a timeout of ``None`` disables timeouts on socket operations.
    … …  
    725776.. method:: socket.gettimeout()
    726777
    727    Return the timeout in floating seconds associated with socket operations, or
     778   Return the timeout in seconds (float) associated with socket operations, or
    728779   ``None`` if no timeout is set.  This reflects the last call to
    729780   :meth:`setblocking` or :meth:`settimeout`.
    … …  
    738789system-dependent) if they cannot be completed immediately.  In timeout mode,
    739790operations fail if they cannot be completed within the timeout specified for the
    740 socket or if the system returns an error.  The :meth:`setblocking` method is simply
    741 a shorthand for certain :meth:`settimeout` calls.
     791socket or if the system returns an error.  The :meth:`~socket.setblocking`
     792method is simply a shorthand for certain :meth:`~socket.settimeout` calls.
    742793
    743794Timeout mode internally sets the socket in non-blocking mode.  The blocking and
    744795timeout modes are shared between file descriptors and socket objects that refer
    745796to the same network endpoint.  A consequence of this is that file objects
    746 returned by the :meth:`makefile` method must only be used when the socket is in
    747 blocking mode; in timeout or non-blocking mode file operations that cannot be
    748 completed immediately will fail.
    749 
    750 Note that the :meth:`connect` operation is subject to the timeout setting, and
    751 in general it is recommended to call :meth:`settimeout` before calling
    752 :meth:`connect` or pass a timeout parameter to :meth:`create_connection`.
    753 The system network stack may return a connection timeout error
    754 of its own regardless of any Python socket timeout setting.
     797returned by the :meth:`~socket.makefile` method must only be used when the
     798socket is in blocking mode; in timeout or non-blocking mode file operations
     799that cannot be completed immediately will fail.
     800
     801Note that the :meth:`~socket.connect` operation is subject to the timeout
     802setting, and in general it is recommended to call :meth:`~socket.settimeout`
     803before calling :meth:`~socket.connect` or pass a timeout parameter to
     804:meth:`create_connection`.  The system network stack may return a connection
     805timeout error of its own regardless of any Python socket timeout setting.
    755806
    756807
    … …  
    772823   further receives are disallowed.  If *how* is :const:`SHUT_WR`, further sends
    773824   are disallowed.  If *how* is :const:`SHUT_RDWR`, further sends and receives are
    774    disallowed.
    775 
    776 Note that there are no methods :meth:`read` or :meth:`write`; use :meth:`recv`
    777 and :meth:`send` without *flags* argument instead.
     825   disallowed.  Depending on the platform, shutting down one half of the connection
     826   can also close the opposite half (e.g. on Mac OS X, ``shutdown(SHUT_WR)`` does
     827   not allow further reads on the other end of the connection).
     828
     829Note that there are no methods :meth:`read` or :meth:`write`; use
     830:meth:`~socket.recv` and :meth:`~socket.send` without *flags* argument instead.
    778831
    779832Socket objects also have these (read-only) attributes that correspond to the
    … …  
    809862Here are four minimal example programs using the TCP/IP protocol: a server that
    810863echoes all data that it receives back (servicing only one client), and a client
    811 using it.  Note that a server must perform the sequence :func:`socket`,
    812 :meth:`bind`, :meth:`listen`, :meth:`accept` (possibly repeating the
    813 :meth:`accept` to service more than one client), while a client only needs the
    814 sequence :func:`socket`, :meth:`connect`.  Also note that the server does not
    815 :meth:`send`/:meth:`recv` on the  socket it is listening on but on the new
    816 socket returned by :meth:`accept`.
     864using it.  Note that a server must perform the sequence :func:`.socket`,
     865:meth:`~socket.bind`, :meth:`~socket.listen`, :meth:`~socket.accept` (possibly
     866repeating the :meth:`~socket.accept` to service more than one client), while a
     867client only needs the sequence :func:`.socket`, :meth:`~socket.connect`.  Also
     868note that the server does not :meth:`~socket.sendall`/:meth:`~socket.recv` on
     869the socket it is listening on but on the new socket returned by
     870:meth:`~socket.accept`.
    817871
    818872The first two examples support IPv4 only. ::
    … …  
    831885       data = conn.recv(1024)
    832886       if not data: break
    833        conn.send(data)
     887       conn.sendall(data)
    834888   conn.close()
    835889
    … …  
    843897   s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    844898   s.connect((HOST, PORT))
    845    s.send('Hello, world')
     899   s.sendall('Hello, world')
    846900   data = s.recv(1024)
    847901   s.close()
    … …  
    867921       try:
    868922           s = socket.socket(af, socktype, proto)
    869        except socket.error, msg:
     923       except socket.error as msg:
    870924           s = None
    871925           continue
    … …  
    873927           s.bind(sa)
    874928           s.listen(1)
    875        except socket.error, msg:
     929       except socket.error as msg:
    876930           s.close()
    877931           s = None
    … …  
    902956       try:
    903957           s = socket.socket(af, socktype, proto)
    904        except socket.error, msg:
     958       except socket.error as msg:
    905959           s = None
    906960           continue
    907961       try:
    908962           s.connect(sa)
    909        except socket.error, msg:
     963       except socket.error as msg:
    910964           s.close()
    911965           s = None
    … …  
    915969       print 'could not open socket'
    916970       sys.exit(1)
    917    s.send('Hello, world')
     971   s.sendall('Hello, world')
    918972   data = s.recv(1024)
    919973   s.close()
    … …  
    945999   # disabled promiscuous mode
    9461000   s.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)
     1001
     1002
     1003Running an example several times with too small delay between executions, could
     1004lead to this error::
     1005
     1006   socket.error: [Errno 98] Address already in use
     1007
     1008This is because the previous execution has left the socket in a ``TIME_WAIT``
     1009state, and can't be immediately reused.
     1010
     1011There is a :mod:`socket` flag to set, in order to prevent this,
     1012:data:`socket.SO_REUSEADDR`::
     1013
     1014   s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     1015   s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     1016   s.bind((HOST, PORT))
     1017
     1018the :data:`SO_REUSEADDR` flag tells the kernel to reuse a local socket in
     1019``TIME_WAIT`` state, without waiting for its natural timeout to expire.
Note: See TracChangeset for help on using the changeset viewer.