File: //proc/thread-self/root/lib/python3/dist-packages/twisted/internet/__pycache__/tcp.cpython-38.pyc
U
��W[|� � @ s0 d Z ddlmZmZ ddlZddlZddlZddlZddlZddl Z ddl
m Z m Z ddl
mZ ddlmZmZ ddlmZ ddlmZmZ zdd lmZmZm Z W nD e k
r� G d
d � d e �ZG d d
� d
e �ZG dd� de �Z Y nX edk�rxe � Z ddl!m"Z# ddl!m$Z% ddl!m&Z' ddl!m(Z) ddl!m*Z+ ddl!m,Z- ddl!m.Z/ e � Z0e � Z1e%Z2ddl!m3Z4 ddl5m6Z7 n�ddl!m Z ddl!m#Z# dd l!m%Z% dd l!m'Z' dd l!m)Z) dd l!m+Z+ dd l!m-Z- dd!l!m/Z/ dd"l!m0Z0 dd#l!m1Z1 dd$l!m2Z2 dd%l!m4Z4 dd&lm7Z7 dd'l!m8Z8 dd(l9m:Z:m;Z;m<Z< dd)l=m>Z> dd*lm?Z?m@Z@mAZA dd+lBmCZC dd,lDmEZE dd-l9mFZFmGZGmHZHmIZI dd.lJmKZK eLed/d�ZMeNefZOd0d1� ZPd2d3� ZQd4d5� ZRG d6d7� d7e �ZSG d8d9� d9e �ZTe eHjUeHjV�G d:d;� d;eeFjWeSeT��ZXG d<d=� d=e �ZYG d>d?� d?eYeeX�ZZej[eMB Z\d@dA� Z]G dBdC� dCe �Z^G dDdE� dEe^eZ�Z_G dFdG� dGe eX�Z`G dHdI� dIe �Zae ea�e jbG dJdK� dKe ���Zce ea�G dLdM� dMe ��Zdedk�r�ed� Zen ecdNdO� �Zee/e-e0e1e4fZfe jbG dPdQ� dQe ��ZgdRdS� Zhe eHji�G dTdU� dUe:jjeS��ZkG dVdW� dWe:jl�ZmdS )Xzt
Various asynchronous TCP/IP classes.
End users shouldn't use this module directly - use the reactor APIs instead.
� )�division�absolute_importN)� Interface� implementer)�Logger)�
lazyByteSlice�unicode)� platformType)�versions� deprecate)�ConnectionMixin� ClientMixin� ServerMixinc @ s e Zd ZdZdS )�_TLSConnectionMixinFN)�__name__�
__module__� __qualname__ZTLS� r r �6/usr/lib/python3/dist-packages/twisted/internet/tcp.pyr % s r c @ s e Zd ZdS )�_TLSClientMixinN�r r r r r r r r ) s r c @ s e Zd ZdS )�_TLSServerMixinNr r r r r r - s r �win32)� WSAEINVAL)�WSAEWOULDBLOCK)�WSAEINPROGRESS)� WSAEALREADY)�
WSAEISCONN)�
WSAENOBUFS)� WSAEMFILE)�
WSAECONNRESET)� formatError)�EPERM)�EINVAL)� EWOULDBLOCK)� EINPROGRESS)�EALREADY)�EISCONN)�ENOBUFS)�EMFILE)�ENFILE)�ENOMEM)�EAGAIN)� ECONNABORTED)�strerror)� errorcode)�base�address�fdesc)�
deferLater)�log�failure�reflect)�untilConcludes)�CannotListenError)�abstract�main�
interfaces�error)�ProtocolZAI_NUMERICSERVc C sN t | �dkr>t�| tjtjB �d }t|gt| dd� � �S | dd� S dS )ai
Return a 2-tuple of socket IP and port for IPv4 and a 4-tuple of
socket IP, port, flowInfo, and scopeID for IPv6. For IPv6, it
returns the interface portion (the part after the %) as a part of
the IPv6 address, which Python 3.7+ does not include.
@param addr: A 2-tuple for IPv4 information or a 4-tuple for IPv6
information.
� r � N� )�len�socket� getnameinfo�NI_NUMERICHOST�NI_NUMERICSERV�tuple�list)�addr�hostr r r � _getrealnameg s
��rJ c C s t | �� �S �z
See L{_getrealname}.
)rJ Z getpeername��sktr r r � _getpeername{ s rN c C s t | �� �S rK )rJ � getsocknamerL r r r � _getsockname� s rP c @ s e Zd ZdZdZdd� ZdS )�
_SocketCloserz�
@ivar _shouldShutdown: Set to C{True} if C{shutdown} should be called
before calling C{close} on the underlying socket.
@type _shouldShutdown: C{bool}
Tc C s~ | j }z8|r | jr<|�d� n | j �t jt jt�ddd�� W n t jk
rT Y nX z |� � W n t jk
rx Y nX d S )Nr@ Ziir? r )
rB �_shouldShutdown�shutdown�
setsockopt�
SOL_SOCKETZ SO_LINGER�structZpackr< �close)�selfZorderlyrM r r r � _closeSocket� s � z_SocketCloser._closeSocketN)r r r �__doc__rR rY r r r r rQ � s rQ c @ s e Zd ZdZdZdd� ZdS )�_AbortingMixinz�
Common implementation of C{abortConnection}.
@ivar _aborting: Set to C{True} when C{abortConnection} is called.
@type _aborting: C{bool}
Fc C sZ | j s | jrdS d| _| �� | �� dd� | _dd� | _| j�d| jt �
t � � �� dS )zf
Aborts the connection immediately, dropping any buffered data.
@since: 11.1
NTc _ s d S �Nr ��args�kwargsr r r �<lambda>� � z0_AbortingMixin.abortConnection.<locals>.<lambda>c _ s d S r\ r r] r r r r` � ra r )
� disconnected� _aborting� stopReading� stopWriting�doRead�doWrite�reactor� callLater�connectionLostr5 �Failurer< �ConnectionAborted�rX r r r �abortConnection� s
�z _AbortingMixin.abortConnectionN)r r r rZ rc rn r r r r r[ � s r[ c @ s~ e Zd ZdZd dd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dZ dd� Z
dd� Zdd� Zdd� Zd d � ZdS ) �
Connectiona
Superclass of all socket-based FileDescriptors.
This is an abstract superclass of all objects which represent a TCP/IP
connection based socket.
@ivar logstr: prefix used when logging events related to this connection.
@type logstr: C{str}
Nc C s4 t jj| |d� || _| j�d� |j| _|| _d S )N�rh r )r9 �FileDescriptor�__init__rB � setblocking�fileno�protocol)rX rM ru rh r r r rr � s
zConnection.__init__c C s | j S )z&Return the socket for this connection.)rB rm r r r � getHandle� s zConnection.getHandlec
C sh z| j �| j�}W nJ t jk
r\ } z*|jd tkr>W Y �dS tj W Y �S W 5 d}~X Y nX | �|�S )a\ Calls self.protocol.dataReceived with all available data.
This reads up to self.bufferSize bytes of data from its socket, then
calls self.dataReceived(data) to process it. If the connection is not
lost through an error in the physical recv(), this function will return
the result of the dataReceived call.
r N) rB ZrecvZ
bufferSizer< r^ r$ r: �CONNECTION_LOST�
_dataReceived)rX �data�ser r r rf � s
zConnection.doReadc C sV |s
t jS | j�|�}|d k rR| jj}d}tj|t�dddd�|d�}t�||� |S )NzPReturning a value other than None from %(fqpn)s is deprecated since %(version)s.ZTwisted� r )�format) r: �CONNECTION_DONEru Z dataReceivedr ZgetDeprecationWarningStringr
ZVersionZwarnAboutFunction)rX ry ZrvalZoffenderZ
warningFormatZ
warningStringr r r rx � s � � zConnection._dataReceivedc
C sr t |d| j�}zt| jj|�W S tjk
rl } z.|jd ttfkrNW Y �dS t j
W Y �S W 5 d}~X Y nX dS )a
Write as much as possible of the given data to this TCP connection.
This sends up to C{self.SEND_LIMIT} bytes from C{data}. If the
connection is lost, an exception is returned. Otherwise, the number
of bytes successfully written is returned.
r N) r Z
SEND_LIMITr7 rB �sendr< r^ r$ r( r: rw )rX ry Z limitedDatarz r r r �
writeSomeData s
zConnection.writeSomeDatac C sr z| j �d� W n t jk
r& Y nX t�| jd �}|rnz |�� W n& t�� }t �
� | � |� Y nX d S �Nr? ) rB rS r< r; �IHalfCloseableProtocolru ZwriteConnectionLostr5 rk r4 �errrj )rX �p�fr r r �_closeWriteConnection s z Connection._closeWriteConnectionc C sR t �| jd �}|rDz |�� W qN t�� | �t�� � Y qNX n
| �|� d S r\ ) r; r� ru �readConnectionLostr4 r� rj r5 rk )rX �reasonr� r r r r� * s z Connection.readConnectionLostc C sP t | d�sdS tj�| |� | �|�tj� � | j}| `| ` | `
|�|� dS )z6See abstract.FileDescriptor.connectionLost().
rB N) �hasattrr9 rq rj rY Zcheckr< rl ru rB rt )rX r� ru r r r rj 7 s
zConnection.connectionLostZ
Uninitializedc C s | j S )zEReturn the prefix to log with when I own the logging thread.
)�logstrrm r r r � logPrefixL s zConnection.logPrefixc C s t �| j�tjtj��S r\ )�operator�truthrB �
getsockopt� IPPROTO_TCP� TCP_NODELAYrm r r r �
getTcpNoDelayQ s zConnection.getTcpNoDelayc C s | j �t jt j|� d S r\ )rB rT r� r� �rX �enabledr r r �
setTcpNoDelayT s zConnection.setTcpNoDelayc C s t �| j�tjtj��S r\ )r� r� rB r� rU � SO_KEEPALIVErm r r r �getTcpKeepAliveW s �zConnection.getTcpKeepAlivec C s | j �t jt j|� d S r\ )rB rT rU r� r� r r r �setTcpKeepAlive[ s zConnection.setTcpKeepAlive)N)r r r rZ rr rv rf rx r r� r� rj r� r� r� r� r� r� r r r r ro � s
ro c @ sL e Zd ZdZejZejZdd� Z dd� Z
dd� Z dd � Z d
d � Z
d d
� ZdS )�_BaseBaseClienta�
Code shared with other (non-POSIX) reactors for management of general
outgoing connections.
Requirements upon subclasses are documented as instance variables rather
than abstract methods, in order to avoid MRO confusion, since this base is
mixed in to unfortunately weird and distinctive multiple-inheritance
hierarchies and many of these attributes are provided by peer classes
rather than descendant classes in those hierarchies.
@ivar addressFamily: The address family constant (C{socket.AF_INET},
C{socket.AF_INET6}, C{socket.AF_UNIX}) of the underlying socket of this
client connection.
@type addressFamily: C{int}
@ivar socketType: The socket type constant (C{socket.SOCK_STREAM} or
C{socket.SOCK_DGRAM}) of the underlying socket.
@type socketType: C{int}
@ivar _requiresResolution: A flag indicating whether the address of this
client will require name resolution. C{True} if the hostname of said
address indicates a name that must be resolved by hostname lookup,
C{False} if it indicates an IP address literal.
@type _requiresResolution: C{bool}
@cvar _commonConnection: Subclasses must provide this attribute, which
indicates the L{Connection}-alike class to invoke C{__init__} and
C{connectionLost} on.
@type _commonConnection: C{type}
@ivar _stopReadingAndWriting: Subclasses must implement in order to remove
this transport from its reactor's notifications in response to a
terminated connection attempt.
@type _stopReadingAndWriting: 0-argument callable returning L{None}
@ivar _closeSocket: Subclasses must implement in order to close the socket
in response to a terminated connection attempt.
@type _closeSocket: 1-argument callable; see L{_SocketCloser._closeSocket}
@ivar _collectSocketDetails: Clean up references to the attached socket in
its underlying OS resource (such as a file descriptor or file handle),
as part of post connection-failure cleanup.
@type _collectSocketDetails: 0-argument callable returning L{None}.
@ivar reactor: The class pointed to by C{_commonConnection} should set this
attribute in its constructor.
@type reactor: L{twisted.internet.interfaces.IReactorTime},
L{twisted.internet.interfaces.IReactorCore},
L{twisted.internet.interfaces.IReactorFDSet}
c C s8 |r$| j �| |d|� |�d|� n|�d| j|� dS )ax
Called by subclasses to continue to the stage of initialization where
the socket connect attempt is made.
@param whenDone: A 0-argument callable to invoke once the connection is
set up. This is L{None} if the connection could not be prepared
due to a previous error.
@param skt: The socket object to use to perform the connection.
@type skt: C{socket._socketobject}
@param error: The error to fail the connection with.
@param reactor: The reactor to use for this client.
@type reactor: L{twisted.internet.interfaces.IReactorTime}
Nr )�_commonConnectionrr ri �failIfNotConnected)rX �whenDonerM r< rh r r r � _finishInit� s z_BaseBaseClient._finishInitc sL � j r<� j�� jd �}|�� fdd�� |�� j� j� n � �� j� dS )a�
Resolve the name that was passed to this L{_BaseBaseClient}, if
necessary, and then move on to attempting the connection once an
address has been determined. (The connection will be attempted
immediately within this function if either name resolution can be
synchronous or the address was an IP address literal.)
@note: You don't want to call this method from outside, as it won't do
anything useful; it's just part of the connection bootstrapping
process. Also, although this method is on L{_BaseBaseClient} for
historical reasons, it's not used anywhere except for L{Client}
itself.
@return: L{None}
r c s | f� j dd � S r� )rH )�nrm r r r` � ra z0_BaseBaseClient.resolveAddress.<locals>.<lambda>N)�_requiresResolutionrh ZresolverH Z addCallbackZ addCallbacks�_setRealAddressr� )rX �dr rm r �resolveAddress� s
z _BaseBaseClient.resolveAddressc C sT t |�dkrBt�|tjtjB �d }t|gt|dd� � �| _n|| _| �� dS )a�
Set the resolved address of this L{_BaseBaseClient} and initiate the
connection attempt.
@param address: Depending on whether this is an IPv4 or IPv6 connection
attempt, a 2-tuple of C{(host, port)} or a 4-tuple of C{(host,
port, flow, scope)}. At this point it is a fully resolved address,
and the 'host' portion will always be an IP address, not a DNS
name.
r> r r? N) rA rB rC rD rE rF rG � realAddress� doConnect)rX r1 �hostnamer r r r� � s
�� z _BaseBaseClient._setRealAddressc C sh | j s| jst| d�sdS | �� z| �d� W n tk
rD Y n
X | �� | j�t �
|�� | `dS )z�
Generic method called when the attempts to connect failed. It basically
cleans everything it can: call connectionFailed, stop read and write,
delete socket related members.
� connectorNT) � connectedrb r� �_stopReadingAndWritingrY �AttributeError�_collectSocketDetailsr� ZconnectionFailedr5 rk )rX r� r r r r� � s �z"_BaseBaseClient.failIfNotConnectedc C s | � t�� � dS )z�
If a connection attempt is still outstanding (i.e. no connection is
yet established), immediately stop attempting to connect.
N)r� r< Z UserErrorrm r r r �stopConnecting� s z _BaseBaseClient.stopConnectingc C s8 | j s| �tj|d�� n| j�| |� | j�|� dS )a�
Invoked by lower-level logic when it's time to clean the socket up.
Depending on the state of the connection, either inform the attached
L{Connector} that the connection attempt has failed, or inform the
connected L{IProtocol} that the established connection has been lost.
@param reason: the reason that the connection was terminated
@type reason: L{Failure}
��stringN)r� r� r< Z ConnectErrorr� rj r� �rX r� r r r rj � s
z _BaseBaseClient.connectionLostN)r r r rZ rB �AF_INET�
addressFamily� SOCK_STREAM�
socketTyper� r� r� r� r� rj r r r r r� a s 3r� c @ s@ e Zd ZdZeZeZdd� Zdd� Zdd� Z dd � Z
d
d � Z d S )
�
BaseClienta�
A base class for client TCP (and similar) sockets.
@ivar realAddress: The address object that will be used for socket.connect;
this address is an address tuple (the number of elements dependent upon
the address family) which does not contain any names which need to be
resolved.
@type realAddress: C{tuple}
@ivar _base: L{Connection}, which is the base class of this class which has
all of the useful file descriptor methods. This is used by
L{_TLSServerMixin} to call the right methods to directly manipulate the
transport, as is necessary for writing TLS-encrypted bytes (whereas
those methods on L{Server} will go through another layer of TLS if it
has been enabled).
c C s t | d�r| �� | �� dS )z�
Implement the POSIX-ish (i.e.
L{twisted.internet.interfaces.IReactorFDSet}) method of detaching this
socket from the reactor for L{_BaseBaseClient}.
rh N)r� rd re rm r r r r� ! s
z!BaseClient._stopReadingAndWritingc C s | ` | `dS )zn
Clean up references to the socket and its file descriptor.
@see: L{_BaseBaseClient}
N)rB rt rm r r r r� - s z BaseClient._collectSocketDetailsc C s, t � | j| j�}|�d� t�|�� � |S )zc(internal) Create a non-blocking socket using
self.addressFamily, self.socketType.
r )rB r� r� rs r2 �_setCloseOnExecrt �rX �sr r r �createInternetSocket6 s
z BaseClient.createInternetSocketc
C s | j | _| j | _t| d�s dS | j�tjtj�}|rP| �t �
|t |�f�� dS z| j� | j
�}W n. tj k
r� } z|jd }W 5 d}~X Y nX |r�|tkr�nN|tttfks�|tkr�tdkr�| �� | �� dS | �t �
|t |�f�� dS | `| `| �� | �� | �� dS )z�
Initiate the outgoing connection attempt.
@note: Applications do not need to call this method; it will be invoked
internally as part of L{IReactorTCP.connectTCP}.
r� Nr r )r� rg rf r� rB r� rU ZSO_ERRORr� r< ZgetConnectErrorr. Z
connect_exr� r^ r' r$ r% r& r# r � startReadingZ startWritingrd re � _connectDone)rX r� Z
connectResultrz r r r r� @ s<
��zBaseClient.doConnectc C sb | j �| �� �| _d| _| �| j�}d| | _| jdkrJt� | _| �� n| � � | j�
| � dS )a�
This is a hook for when a connection attempt has succeeded.
Here, we build the protocol from the
L{twisted.internet.protocol.ClientFactory} that was passed in, compute
a log string, begin reading so as to send traffic to the newly built
protocol, and finally hook up the protocol itself.
This hook is overridden by L{ssl.Client} to initiate the TLS protocol.
r? z %s,clientN) r� �
buildProtocol�getPeerru r� �
_getLogPrefixr� r= �loseConnectionr� �makeConnection)rX r� r r r r� v s
zBaseClient._connectDoneN) r r r rZ ro �_baser� r� r� r� r� r� r r r r r� s
6r� c C s t �| |dddt�d d S )av
Resolve an IPv6 literal into an IPv6 address.
This is necessary to resolve any embedded scope identifiers to the relevant
C{sin6_scope_id} for use with C{socket.connect()}, C{socket.listen()}, or
C{socket.bind()}; see U{RFC 3493 <https://tools.ietf.org/html/rfc3493>} for
more information.
@param ip: An IPv6 address literal.
@type ip: C{str}
@param port: A port number.
@type port: C{int}
@return: a 4-tuple of C{(host, port, flow, scope)}, suitable for use as an
IPv6 address.
@raise socket.gaierror: if either the IP or port is not numeric as it
should be.
r r> )rB Z getaddrinfo�
_NUMERIC_ONLY)Zip�portr r r � _resolveIPv6� s r� c @ s8 e Zd ZdZejZd dd�Zdd� Zdd� Z d d
� Z
dS ) �_BaseTCPClienta�
Code shared with other (non-POSIX) reactors for management of outgoing TCP
connections (both TCPv4 and TCPv6).
@note: In order to be functional, this class must be mixed into the same
hierarchy as L{_BaseBaseClient}. It would subclass L{_BaseBaseClient}
directly, but the class hierarchy here is divided in strange ways out
of the need to share code along multiple axes; specifically, with the
IOCP reactor and also with UNIX clients in other reactors.
@ivar _addressType: The Twisted _IPAddress implementation for this client
@type _addressType: L{IPv4Address} or L{IPv6Address}
@ivar connector: The L{Connector} which is driving this L{_BaseTCPClient}'s
connection attempt.
@ivar addr: The address that this socket will be connecting to.
@type addr: If IPv4, a 2-C{tuple} of C{(str host, int port)}. If IPv6, a
4-C{tuple} of (C{str host, int port, int ignored, int scope}).
@ivar createInternetSocket: Subclasses must implement this as a method to
create a python socket object of the appropriate address family and
socket type.
@type createInternetSocket: 0-argument callable returning
C{socket._socketobject}.
Nc
C sD || _ ||f| _| j}d }d }t�|�r0d| _n4t�|�r^d| _t||�| _tj | _
t j | _
nd| _z | �� }W n@ tjk
r� } z t�| jd | jd �}d }W 5 d } ~ X Y nX |�r0|d k �r0z*t�|d �r�t|� }
n|}
|�|
� W nB tjk
�r. } z t�| jd | jd �}d }W 5 d } ~ X Y nX | �||||� d S )NFTr r? )r� rH r� r9 Z isIPAddressr� �
isIPv6Addressr� rB �AF_INET6r� r1 � IPv6Address� _addressTyper� r< ZConnectBindErrorr^ �bindr� ) rX rI r� � bindAddressr� rh r� r� rM rz Zbindinfor r r rr � s8
z_BaseTCPClient.__init__c C s | j dt| j��� S )z~
Returns an L{IPv4Address} or L{IPv6Address}.
This indicates the address from which I am connecting.
�TCP)r� )r� rP rB rm r r r �getHost� s z_BaseTCPClient.getHostc C s | j d| j�� S )zz
Returns an L{IPv4Address} or L{IPv6Address}.
This indicates the address that I am connected to.
r� )r� )r� r� rm r r r r� � s z_BaseTCPClient.getPeerc C s d| j | jt| �f }|S )Nz<%s to %s at %x>)� __class__rH �idr� r r r �__repr__ s z_BaseTCPClient.__repr__)N) r r r rZ r1 � IPv4Addressr� rr r� r� r� r r r r r� � s
$ r� c @ s e Zd ZdZdS )�Clientz�
A transport for a TCP protocol; either TCPv4 or TCPv6.
Do not create these directly; use L{IReactorTCP.connectTCP}.
N)r r r rZ r r r r r� s r� c @ sF e Zd ZdZeZejZdd� Z dd� Z
e dd� �Z dd � Z
d
d � Zd S )
�Servera<
Serverside socket-stream connection class.
This is a serverside network connection transport; a socket which came from
an accept() on a server.
@ivar _base: L{Connection}, which is the base class of this class which has
all of the useful file descriptor methods. This is used by
L{_TLSServerMixin} to call the right methods to directly manipulate the
transport, as is necessary for writing TLS-encrypted bytes (whereas
those methods on L{Server} will go through another layer of TLS if it
has been enabled).
c C s� t �| |||� t|�dkr$tj| _|| _|| _|| _|d | _ | �
| j �}d||| j f | _ | jdk r�d| j j
j| j| jjf | _| �� d| _dS )a
Server(sock, protocol, client, server, sessionno)
Initialize it with a socket, a protocol, a descriptor for my peer (a
tuple of host, port describing the other end of the connection), an
instance of Port, and a session number.
r@ r z%s,%s,%sN�<%s #%s on %s>r? )ro rr rA r1 r� r� �server�client� sessionnor� r� ru r� r� r �_realPortNumber�repstrr� r� )rX Zsockru r� r� r� rh r� r r r rr $ s&
�
�zServer.__init__c C s | j S )z=
A string representation of this connection.
)r� rm r r r r� ? s zServer.__repr__c C s� t j}|tjkrt j}t�||tj�}t|�}|d|�� }|�� d } |� |�}
|
dkrd|�
� dS | ||
|d|d |�} d| j j j
| j| f | _|
�| � | S )a�
Create a new L{Server} based on an existing connected I{SOCK_STREAM}
socket.
Arguments are the same as to L{Server.__init__}, except where noted.
@param fileDescriptor: An integer file descriptor associated with a
connected socket. The socket must be in non-blocking mode. Any
additional attributes desired, such as I{FD_CLOEXEC}, must also be
set already.
@param addressFamily: The address family (sometimes called I{domain})
of the existing socket. For example, L{socket.AF_INET}.
@return: A new instance of C{cls} wrapping the socket given by
C{fileDescriptor}.
r� r? Nr� )r� )r1 r� rB r� r� �fromfdr� rN rO r� rW ru r� r r� r� r� ) �cls�fileDescriptorr� �factoryrh Z addressTyperM rH Z protocolAddrZ localPortru rX r r r �_fromConnectedSocketF s&
�
zServer._fromConnectedSocketc C s t | j�}| jd|�� S )zl
Returns an L{IPv4Address} or L{IPv6Address}.
This indicates the server's address.
r� )r� �rP rB r� �rX rH r r r r� n s
zServer.getHostc C s | j d| j�� S )zl
Returns an L{IPv4Address} or L{IPv6Address}.
This indicates the client's address.
r� )r� )r� r� rm r r r r� x s zServer.getPeerN)r r r rZ ro r� r1 r� r� rr r� � classmethodr� r� r� r r r r r� s
'
r� c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) �_IFileDescriptorReservationaT
An open file that represents an emergency reservation in the
process' file descriptor table. If L{Port} encounters C{EMFILE}
on C{accept(2)}, it can close this file descriptor, retry the
C{accept} so that the incoming connection occupies this file
descriptor's space, and then close that connection and reopen this
one.
Calling L{_IFileDescriptorReservation.reserve} attempts to open
the reserve file descriptor if it is not already open.
L{_IFileDescriptorReservation.available} returns L{True} if the
underlying file is open and its descriptor claimed.
L{_IFileDescriptorReservation} instances are context managers;
entering them releases the underlying file descriptor, while
exiting them attempts to reacquire it. The block can take
advantage of the free slot in the process' file descriptor table
accept and close a client connection.
Because another thread might open a file descriptor between the
time the context manager is entered and the time C{accept} is
called, opening the reserve descriptor is best-effort only.
c C s dS )z�
Is the reservation available?
@return: L{True} if the reserved file descriptor is open and
can thus be closed to allow a new file to be opened in its
place; L{False} if it is not open.
Nr r r r r � available� s z%_IFileDescriptorReservation.availablec C s dS )a%
Attempt to open the reserved file descriptor; if this fails
because of C{EMFILE}, internal state is reset so that another
reservation attempt can be made.
@raises: Any exception except an L{OSError} or L{IOError}
whose errno is L{EMFILE}.
Nr r r r r �reserve� s z#_IFileDescriptorReservation.reservec C s dS )z}
Release the underlying file descriptor so that code within the
context manager can open a new file.
Nr r r r r � __enter__� s z%_IFileDescriptorReservation.__enter__c C s dS )z�
Attempt to re-open the reserved file descriptor. See
L{reserve} for caveats.
@param excType: See L{object.__exit__}
@param excValue: See L{object.__exit__}
@param traceback: See L{object.__exit__}
Nr )�excType�excValue� tracebackr r r �__exit__� s z$_IFileDescriptorReservation.__exit__N�r r r rZ r� r� r� r� r r r r r� � s
r� c @ sL e Zd ZdZe� Ze�� Zejddd�Z dd� Z
dd� Z d d
� Z d d � Z
dS )
�_FileDescriptorReservationa
L{_IFileDescriptorReservation} implementation.
@ivar fileFactory: A factory that will be called to reserve a
file descriptor.
@type fileFactory: A L{callable} that accepts no arguments and
returns an object with a C{close} method.
FN)Zinit�defaultc C s
| j dk S )z�
See L{_IFileDescriptorReservation.available}.
@return: L{True} if the reserved file descriptor is open and
can thus be closed to allow a new file to be opened in its
place; L{False} if it is not open.
N)�_fileDescriptorrm r r r r� � s z$_FileDescriptorReservation.availablec
C sb | j dkr^z | �� }W n@ ttfk
rV } z |jtkrD| j�d� n� W 5 d}~X Y nX || _ dS )z=
See L{_IFileDescriptorReservation.reserve}.
Nz2Could not reserve EMFILE recovery file descriptor.)r� � _fileFactory�IOError�OSError�errnor) �_logr5 )rX r� �er r r r� � s
�z"_FileDescriptorReservation.reservec C s& | j dkrtd��| j �� d| _ dS )z?
See L{_IFileDescriptorReservation.__enter__}.
Nz5No file reserved. Have you called my reserve method?)r� � RuntimeErrorrW rm r r r r� � s
�
z$_FileDescriptorReservation.__enter__c C s2 z | � � W n tk
r, | j�d� Y nX dS )z>
See L{_IFileDescriptorReservation.__exit__}.
z5Could not re-reserve EMFILE recovery file descriptor.N)r� � Exceptionr� r5 �rX r� r� r� r r r r� � s �z#_FileDescriptorReservation.__exit__)r r r rZ r r� �attr�ibr� r� r� r� r� r� r r r r r� � s r� c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) � _NullFileDescriptorReservationzB
A null implementation of L{_IFileDescriptorReservation}.
c C s dS )z�
The reserved file is never available. See
L{_IFileDescriptorReservation.available}.
@return: L{False}
Fr rm r r r r�
s z(_NullFileDescriptorReservation.availablec C s dS )zJ
Do nothing. See L{_IFileDescriptorReservation.reserve}.
Nr rm r r r r� s z&_NullFileDescriptorReservation.reservec C s dS )ze
Do nothing. See L{_IFileDescriptorReservation.__enter__}
@return: L{False}
Nr rm r r r r� s z(_NullFileDescriptorReservation.__enter__c C s dS )z�
Do nothing. See L{_IFileDescriptorReservation.__exit__}.
@param excType: See L{object.__exit__}
@param excValue: See L{object.__exit__}
@param traceback: See L{object.__exit__}
Nr r� r r r r� % s z'_NullFileDescriptorReservation.__exit__Nr� r r r r r� s
r� c C s
t tj�S r\ )�open�os�devnullr r r r r` N ra r` c @ sB e Zd ZdZe�� Ze�� Zeje�e �d�Z
dd� Z dd� Z dS )� _BuffersLogsa@
A context manager that buffers any log events until after its
block exits.
@ivar _namespace: The namespace of the buffered events.
@type _namespace: L{str}.
@ivar _observer: The observer to which buffered log events will be
written
@type _observer: L{twisted.logger.ILogObserver}.
)r� c C s t | j| jjd�S )z
Enter a log buffering context.
@return: A logger that buffers log events.
@rtype: L{Logger}.
)� namespace�observer)r �
_namespace�_logs�appendrm r r r r� u s z_BuffersLogs.__enter__c C s | j D ]}| �|� qdS )z�
Exit a log buffering context and log all buffered events to
the provided observer.
@param excType: See L{object.__exit__}
@param excValue: See L{object.__exit__}
@param traceback: See L{object.__exit__}
N)r� � _observer)rX r� r� r� Zeventr r r r� s
z_BuffersLogs.__exit__N)
r r r rZ r� r� r� r� ZFactoryrG r� r� r� r r r r r� d s
r� c
c s8 |D �],}z|� � \}}W �n
tjk
�r& } z�|jd ttfkrPW Y �� dS |jd tkrhW Y ��qn�|jd tkr�|�� r�| � d� |�B t
| |||�}|D ] \} }
| � � | j d|
d� q�| � d� W 5 Q R X W Y �@ dS |jd t k�r| j dt
|jd d� W Y � dS � W 5 d}~X Y qX ||fV qdS ) a�
Return a generator that yields client sockets from the provided
listening socket until there are none left or an unrecoverable
error occurs.
@param logger: A logger to which C{accept}-related events will be
logged. This should not log to arbitrary observers that might
open a file descriptor to avoid claiming the C{EMFILE} file
descriptor on UNIX-like systems.
@type logger: L{Logger}
@param accepts: An iterable iterated over to limit the number
consecutive C{accept}s.
@type accepts: An iterable.
@param listener: The listening socket.
@type listener: L{socket.socket}
@param reservedFD: A reserved file descriptor that can be used to
recover from C{EMFILE} on UNIX-like systems.
@type reservedFD: L{_IFileDescriptorReservation}
@return: A generator that yields C{(socket, addr)} tuples from
L{socket.socket.accept}
r Nz7EMFILE encountered; releasing reserved file descriptor.z-EMFILE recovery: Closed socket from {address})r1 z-Re-reserving EMFILE recovery file descriptor.z/Could not accept new connection ({acceptError}))Z acceptError)ZacceptrB r< r^ r$ r, r" r) r� �info�_acceptrW �_ACCEPT_ERRORSr/ ) ZloggerZacceptsZlistenerZ
reservedFD�_r� r1 r� ZclientsToCloseZ
clientToCloseZ
closedAddressr r r r � sB
� �� � r c @ s� e Zd ZdZejZeZdZ dZ
dZ dZ dZ
dZejZejZe� Zd dd�Zed d
� �Zd d � Zd
d� Zdd� Zdd� Z dd� Z e � e j!�fdd�Z"e"Z#dd� Z$dd� Z%dd � Z&d d � Z'dS ) �Porta.
A TCP server port, listening for connections.
When a connection is accepted, this will call a factory's buildProtocol
with the incoming address as an argument, according to the specification
described in L{twisted.internet.interfaces.IProtocolFactory}.
If you wish to change the sort of transport that will be used, the
C{transport} attribute will be called with the signature expected for
C{Server.__init__}, so it can be replaced.
@ivar deferred: a deferred created when L{stopListening} is called, and
that will fire when connection is lost. This is not to be used it
directly: prefer the deferred returned by L{stopListening} instead.
@type deferred: L{defer.Deferred}
@ivar disconnecting: flag indicating that the L{stopListening} method has
been called and that no connections should be accepted anymore.
@type disconnecting: C{bool}
@ivar connected: flag set once the listen has successfully been called on
the socket.
@type connected: C{bool}
@ivar _type: A string describing the connections which will be created by
this port. Normally this is C{"TCP"}, since this is a TCP port, but
when the TLS implementation re-uses this class it overrides the value
with C{"TLS"}. Only used for logging.
@ivar _preexistingSocket: If not L{None}, a L{socket.socket} instance which
was created and initialized outside of the reactor and will be used to
listen for connections (instead of a new socket being created by this
L{Port}).
r � �2 r� Nc C sF t jj| |d� || _|| _|| _t�|�r<tj | _
t j | _
|| _dS )z5Initialize with a numeric port to listen on.
rp N)r0 �BasePortrr r� r� �backlogr9 r� rB r� r� r1 r� r� � interface)rX r� r� r r rh r r r rr s
z
Port.__init__c C s6 t �||| j�}t|�d }| d|d||�}||_|S )a}
Create a new L{Port} based on an existing listening I{SOCK_STREAM}
socket.
Arguments are the same as to L{Port.__init__}, except where noted.
@param fd: An integer file descriptor associated with a listening
socket. The socket must be in non-blocking mode. Any additional
attributes desired, such as I{FD_CLOEXEC}, must also be set already.
@param addressFamily: The address family (sometimes called I{domain}) of
the existing socket. For example, L{socket.AF_INET}.
@return: A new instance of C{cls} wrapping the socket given by C{fd}.
r N)rB r� r� rP �_preexistingSocket)r� rh �fdr� r� r� r rX r r r �_fromListeningDescriptor s
z Port._fromListeningDescriptorc C s6 | j d k r d| j| jj| j f S d| j| jjf S d S )Nz<%s of %s on %s>z<%s of %s (not listening)>)r� r� r� rm r r r r� 4 s
�z
Port.__repr__c C s4 t j�| �}tdkr0tjdkr0|�tjtj d� |S )N�posix�cygwinr? )
r0 r r� r �sys�platformrT rB rU Z SO_REUSEADDRr� r r r r� ; s zPort.createInternetSocketc
C s t �� | jdkr�z>| �� }| jtjkr8t| j| j �}n | j| j f}|�
|� W n4 tj k
r� } zt | j| j |��W 5 d}~X Y nX |�
| j� n| j}d| _d| _|�� d | _t�d| �| j�| jf � | j�� d| _|| _| jj| _d| _| �� dS )z�Create and bind my socket, and begin listening on it.
This is called on unserialization, and must be called after creating a
server to begin listening on the specified port.
NFr? z%s starting on %sT�d )� _reservedFDr� r
r� r� rB r� r� r r� r� r< r8 Zlistenr rR rO r� r4 �msgr� r� ZdoStartr� rt �
numberAcceptsr� )rX rM rH �ler r r �startListeningB s2
"
�
zPort.startListeningc C s | j d|�� S )Nr� )r� )r� )rX r1 r r r �
_buildAddrm s zPort._buildAddrc
C sT �z.t dkr| j}nd}t| jj| jj���}d}t|t|�| jt �}t
|d�D ]�\}\}}t � |�
� � t|�dkr�t�|tjtjB �}t|d gt|dd� � �}| j�| �|��}|dkr�|�� qN| j} | d | _| �|||| | | j�}
|�|
� qNW 5 Q R X || jk�r"| jd7 _n t d|�| _W n t k
�rN t � � Y nX dS )z�
Called when my socket is ready for reading.
This accepts a connection and calls self.protocol() to handle the
wire-level protocol.
r
r? r r> N� ) r r r� �_loggerr� r� r �rangerB r � enumerater2 r� rt rA rC rD rE rF rG r� r� r rW r� � transportrh r� �max�
BaseExceptionr4 Zdeferr) rX Z
numAcceptsZbufferingLoggerZacceptedZclientsrM rH rI ru r� r r r r rf p sX ��
� �
� z Port.doReadc C s2 d| _ | �� | jr.t| jd| j|�| _| jS dS )a
Stop accepting connections on this port.
This will shut down the socket and call self.connectionLost(). It
returns a deferred which will fire successfully when the port is
actually closed, or with a failure if an error occurs shutting down.
Tr N)�
disconnectingrd r� r3 rh rj Zdeferred)rX ZconnDoner r r r� � s �zPort.loseConnectionc C s t �d| j| jf � dS )z.
Log message for closing port
z(%s Port %s Closed)N)r4 r �_typer� rm r r r �_logConnectionLostMsg� s zPort._logConnectionLostMsgc C sP | � � d| _tj�| |� d| _| �d� | `| `z| j
� � W 5 d| _ X dS )z'
Cleans up the socket.
NFT) r! r� r0 r rj r� rY rB rt r r� ZdoStopr� r r r rj � s
zPort.connectionLostc C s t �| jj�S )zBReturns the name of my class, to prefix log entries with.
)r6 Zqualr� r� rm r r r r� � s zPort.logPrefixc C s t | j�}| jd|�� S )zs
Return an L{IPv4Address} or L{IPv6Address} indicating the listening
address of this port.
r� )r� r� r� r r r r� � s
z Port.getHost)r r N)(r r r rZ rB r� r� r� r r� r r r r� r
r� r� r1 r� r� r r rr r� r r� r� r r rf r5 rk r: r} r� Z
stopListeningr! rj r� r� r r r r r � s4 #
+Ar c @ s0 e Zd ZdZejZd dd�Zdd� Zdd� Z dS )
� Connectora6
A L{Connector} provides of L{twisted.internet.interfaces.IConnector} for
all POSIX-style reactors.
@ivar _addressType: the type returned by L{Connector.getDestination}.
Either L{IPv4Address} or L{IPv6Address}, depending on the type of
address.
@type _addressType: C{type}
Nc
C s� t |t�rTzt�|d�}W n8 tjk
rR } ztjd||f d��W 5 d }~X Y nX || | _| _t� |�rtt
j | _ || _
tj�| |||� d S )NZtcpz%s (%r)r� )�
isinstance�
_portNameTyperB Z
getservbynamer< ZServiceNameUnknownErrorrI r� r9 r� r1 r� r� r� r0 �
BaseConnectorrr )rX rI r� r� Ztimeoutr� rh r� r r r rr � s
&
zConnector.__init__c C s t | j| j| j| | j�S )z|
Create a L{Client} bound to this L{Connector}.
@return: a new L{Client}
@rtype: L{Client}
)r� rI r� r� rh rm r r r �_makeTransport s zConnector._makeTransportc C s | � d| j| j�S )zQ
@see: L{twisted.internet.interfaces.IConnector.getDestination}.
r� )r� rI r� rm r r r �getDestination s zConnector.getDestination)N)
r r r rZ r1 r� r� rr r& r' r r r r r" � s
r" )nrZ Z
__future__r r rB r r� r� rV r� Zzope.interfacer r Ztwisted.loggerr Ztwisted.python.compatr r Ztwisted.python.runtimer Ztwisted.pythonr
r Ztwisted.internet._newtlsr r r
r r r � ImportError�objectr" r� r r# r r$ r r% r r& r r' r r( r r) r* r+ r, r r- Ztwisted.python.win32r! r. r/ Ztwisted.internetr0 r1 r2 Ztwisted.internet.taskr3 r4 r5 r6 Ztwisted.python.utilr7 Ztwisted.internet.errorr8 r9 r: r; r< Ztwisted.internet.protocolr= �getattrZ_AI_NUMERICSERV�strr$ rJ rN rP rQ r[ Z
ITCPTransportZ
ISystemHandlerq ro r� r� ZAI_NUMERICHOSTr� r� r� r� r� r� r� r� r� r r r� r ZIListeningPortr r r% r" r r r r �<module> s�
" � ,
Z pABC
(H