Current File : //lib/python3/dist-packages/twisted/internet/__pycache__/endpoints.cpython-312.pyc
�
Ϫ�f\2 � � � d Z ddlZddlZddlZddlZddlmZmZmZ ddl m
Z
ddl m Z m
Z
mZ ddlmZmZ ddlmZ ddlmZmZmZmZmZ dd lmZm Z dd
l m Z m Z m Z m!Z! dd l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z* dd l+m,Z,m-Z-m.Z.m/Z/ dd
l0m1Z1m2Z2 ddl4m5Z5 ddl6m7Z7 ddl8m9Z9 ddl:m;Z; ddl<m=Z=m>Z> ddl?m@Z@mAZA ddlBmCZCmDZDmEZE ddlFmGZG ddlHmIZI ddlJmKZK ddlLmMZM ddlNmOZOmPZP ddlQmRZS dd lTmUZUmVZVmWZWmXZXmYZYmZZZ dd l[m\Z] e]Z\g d �Z^ G d � d e/� Z_ G d!� d"e,� Z` e
ej� � G d#� d$� � Zb G d%� d&ej� ej� ej� � Zf G d'� d( eGefd)� � Zg G d*� d+e.� Zh G d,� d-e� Zi e
ej� � G d.� d/� � Zk e
ej� � G d0� d1� � Zl G d2� d3el� Zm G d4� d5el� Zn e
ej� � G d6� d7� � Zo e
ej� � G d8� d9� � Zp e
e$� G d:� d;� � Zq e
ej� � G d<� d=� � Zr e
ej� � G d>� d?� � Zs e
ej� � G d@� dA� � Zt e
ej� � G dB� dC� � Zu e
ej� � G dD� dE� � Zv e
ej� � G dF� dG� � ZwdkdH�ZxdldI�Zy dmdJ�Zz e
e=e*� G dK� dL� � Z{ e
e=e*� G dM� dN� � Z| e
e=e*� G dO� dP� � Z}exeyezdQ�Z~ edR� \ Z�Z�dS� Z�dT� Z�emeseudU�Z�eoetevdU�Z�dV� Z�dW� Z�dX� Z�dY� Z�dZ� Z�d[� Z�d\� Z�d]� Z�d^� Z�d_� Z�d`� Z�e�e�e�dU�Z�da� Z�db� Z� e
ej� � G dc� dd� � Z� e
ej� � G de� df� � Z�dg� Z� dndh�Z� e
e=e)� G di� dj� � Z�y# e3$ r dZ2dZ1Y ��qw xY w# e3$ r dZ\Y ��w xY w)oa7
Implementations of L{IStreamServerEndpoint} and L{IStreamClientEndpoint} that
wrap the L{IReactorTCP}, L{IReactorSSL}, and L{IReactorUNIX} interfaces.
This also implements an extensible mini-language for describing endpoints,
parsed by the L{clientFromString} and L{serverFromString} functions.
@since: 10.1
� N)�Optional�Sequence�Type)� normalize)�directlyProvides� implementer�provider)�
NamedConstant�Names)�Version)�defer�error�fdesc�
interfaces�threads)� isIPAddress�
isIPv6Address)�HostnameAddress� IPv4Address� IPv6Address�_ProcessAddress)�IAddress�IHostnameResolver�IHostResolution� IReactorPluggableNameResolver�IReactorSocket�IResolutionReceiver�,IStreamClientEndpointStringParserWithReactor�!IStreamServerEndpointStringParser)�
ClientFactory�Factory�ProcessProtocol�Protocol)� PipeAddress�
StandardIO)�HostResolution)�Deferred)� LoopingCall)�Logger)�IPlugin�
getPlugins)� deprecate�log)�_matchingString� iterbytes� nativeString)�proxyForInterface)�Failure)�FilePath)� ListenFDs� )�
_idnaBytes� _idnaText)�Error)� Certificate�CertificateOptions�KeyPair�PrivateCertificate�optionsForClientTLS�trustRootFromCertificates��TLSMemoryBIOFactory)�clientFromString�serverFromString�TCP4ServerEndpoint�TCP6ServerEndpoint�TCP4ClientEndpoint�TCP6ClientEndpoint�UNIXServerEndpoint�UNIXClientEndpoint�SSL4ServerEndpoint�SSL4ClientEndpoint�AdoptedStreamServerEndpoint�StandardIOEndpoint�ProcessEndpoint�HostnameEndpoint�StandardErrorBehavior�connectProtocol�
wrapClientTLSc �F � e Zd ZdZd� Zd� Zd� Zd� Zd� Zd� Z d� Z
d � Z d
� Z y ) �_WrappingProtocolz_
Wrap another protocol in order to notify my user when a connection has
been made.
c �� � || _ || _ t j t j t j
fD ]* }|j
| j � s� t | |� �, y)z�
@param connectedDeferred: The L{Deferred} that will callback
with the C{wrappedProtocol} when it is connected.
@param wrappedProtocol: An L{IProtocol} provider that will be
connected.
N)�_connectedDeferred�_wrappedProtocolr �IHalfCloseableProtocol�IFileDescriptorReceiver�IHandshakeListener�
providedByr )�self�connectedDeferred�wrappedProtocol�ifaces �</usr/lib/python3/dist-packages/twisted/internet/endpoints.py�__init__z_WrappingProtocol.__init__p sb � � #4�� � /�� �
� -� -� � .� .� � )� )�
� .�E�
� � �� 5� 5�6� ��u�-�
.� c �� � t j j | j � r| j j � S | j j
j S )zO
Transparently pass through the wrapped protocol's log prefix.
)r �ILoggingContextrZ rV � logPrefix� __class__�__name__�r[ s r_ rd z_WrappingProtocol.logPrefix� sK � � � %� %� 0� 0��1F�1F� G��(�(�2�2�4� 4��$�$�.�.�7�7�7ra c � � | j j | j � | j j | j � y)z�
Connect the C{self._wrappedProtocol} to our C{self.transport} and
callback C{self._connectedDeferred} with the C{self._wrappedProtocol}
N)rV �makeConnection� transportrU �callbackrg s r_ �connectionMadez _WrappingProtocol.connectionMade� s6 � �
� � �,�,�T�^�^�<� � � �(�(��)>�)>�?ra c �8 � | j j |� S )zM
Proxy C{dataReceived} calls to our C{self._wrappedProtocol}
)rV � dataReceived)r[ �datas r_ rn z _WrappingProtocol.dataReceived� s � � �$�$�1�1�$�7�7ra c �8 � | j j |� S )zW
Proxy C{fileDescriptorReceived} calls to our C{self._wrappedProtocol}
)rV �fileDescriptorReceived)r[ �
descriptors r_ rq z(_WrappingProtocol.fileDescriptorReceived� s � � �$�$�;�;�J�G�Gra c �8 � | j j |� S )zO
Proxy C{connectionLost} calls to our C{self._wrappedProtocol}
)rV �connectionLost�r[ �reasons r_ rt z _WrappingProtocol.connectionLost� s � � �$�$�3�3�F�;�;ra c �8 � | j j � y)zl
Proxy L{IHalfCloseableProtocol.readConnectionLost} to our
C{self._wrappedProtocol}
N)rV �readConnectionLostrg s r_ rx z$_WrappingProtocol.readConnectionLost� � � �
� � �0�0�2ra c �8 � | j j � y)zm
Proxy L{IHalfCloseableProtocol.writeConnectionLost} to our
C{self._wrappedProtocol}
N)rV �writeConnectionLostrg s r_ r{ z%_WrappingProtocol.writeConnectionLost� s � �
� � �1�1�3ra c �8 � | j j � y)za
Proxy L{interfaces.IHandshakeListener} to our
C{self._wrappedProtocol}.
N)rV �handshakeCompletedrg s r_ r} z$_WrappingProtocol.handshakeCompleted� ry ra N)
rf �
__module__� __qualname__�__doc__r` rd rl rn rq rt rx r{ r} � ra r_ rS rS j s6 � ��
.�&8�@�8� H� <� 3�4�3ra rS c �> � e Zd ZdZeZd� Zd� Zd� Zd� Z d� Z
d� Z d� Z y )
�_WrappingFactorya�
Wrap a factory in order to wrap the protocols it builds.
@ivar _wrappedFactory: A provider of I{IProtocolFactory} whose buildProtocol
method will be called and whose resulting protocol will be wrapped.
@ivar _onConnection: A L{Deferred} that fires when the protocol is
connected
@ivar _connector: A L{connector <twisted.internet.interfaces.IConnector>}
that is managing the current or previous connection attempt.
c �\ � || _ t j | j �� | _ y)z�
@param wrappedFactory: A provider of I{IProtocolFactory} whose
buildProtocol method will be called and whose resulting protocol
will be wrapped.
�� cancellerN)�_wrappedFactoryr
r' �
_canceller�
_onConnection)r[ �wrappedFactorys r_ r` z_WrappingFactory.__init__� s! � � .�� � "�^�^�d�o�o� F��ra c � � || _ y)z~
A connection attempt was started. Remember the connector which started
said attempt, for use later.
N)�
_connector)r[ � connectors r_ �startedConnectingz"_WrappingFactory.startedConnecting� s � �
$��ra c � � |j t j | j j � � � | j j � y)a;
The outgoing connection attempt was cancelled. Fail that L{Deferred}
with an L{error.ConnectingCancelledError}.
@param deferred: The L{Deferred <defer.Deferred>} that was cancelled;
should be the same as C{self._onConnection}.
@type deferred: L{Deferred <defer.Deferred>}
@note: This relies on startedConnecting having been called, so it may
seem as though there's a race condition where C{_connector} may not
have been set. However, using public APIs, this condition is
impossible to catch, because a connection API
(C{connectTCP}/C{SSL}/C{UNIX}) is always invoked before a
L{_WrappingFactory}'s L{Deferred <defer.Deferred>} is returned to
C{connect()}'s caller.
@return: L{None}
N)�errbackr �ConnectingCancelledErrorr� �getDestination�stopConnecting)r[ �deferreds r_ r� z_WrappingFactory._canceller� s? � �& ��� � *� *�4�?�?�+I�+I�+K� L�
�
���&�&�(ra c �8 � | j j � y)zY
Start notifications are passed straight through to the wrapped factory.
N)r� �doStartrg s r_ r� z_WrappingFactory.doStart� s � �
� � �$�$�&ra c �8 � | j j � y)zX
Stop notifications are passed straight through to the wrapped factory.
N)r� �doStoprg s r_ r� z_WrappingFactory.doStop� s � �
� � �#�#�%ra c �� � | j j |� }|�t j � � | j | j
|� S # t $ r | j
j � Y yw xY w)a
Proxy C{buildProtocol} to our C{self._wrappedFactory} or errback the
C{self._onConnection} L{Deferred} if the wrapped factory raises an
exception or returns L{None}.
@return: An instance of L{_WrappingProtocol} or L{None}
N)r� �
buildProtocolr �
NoProtocol�protocolr� �
BaseExceptionr� )r[ �addr�protos r_ r� z _WrappingFactory.buildProtocol sr � � <��(�(�6�6�t�<�E��}��&�&�(�(� �
�=�=��!3�!3�U�;� ;�� � )� � � � &� &� (� )�s �1A �#A6�5A6c �h � | j j s | j j |� yy)zi
Errback the C{self._onConnection} L{Deferred} when the
client connection fails.
N)r� �calledr� )r[ r� rv s r_ �clientConnectionFailedz'_WrappingFactory.clientConnectionFailed s, � �
�!�!�(�(� � � � &� &�v� .� )ra N)
rf r~ r r� rS r� r` r� r� r� r� r� r� r� ra r_ r� r� � s2 � � � !�H�G�$�)�0'� &� <�"/ra r� c � � e Zd ZdZeZd� Zd� Zy)rL z�
A Standard Input/Output endpoint
@ivar _stdio: a callable, like L{stdio.StandardIO}, which takes an
L{IProtocol} provider and a C{reactor} keyword argument (interface
dependent upon your platform).
c � � || _ y)z?
@param reactor: The reactor for the endpoint.
N)�_reactor�r[ �reactors r_ r` zStandardIOEndpoint.__init__& s � � ��
ra c � � t j | j |j t � � | j
�� S )zU
Implement L{IStreamServerEndpoint.listen} to listen on stdin/stdout
)r� )r
�execute�_stdior� r$ r� )r[ �stdioProtocolFactorys r_ �listenzStandardIOEndpoint.listen, s3 � � �}�}� �K�K� � .� .�{�}� =��M�M�
�
ra N)rf r~ r r� r% r� r` r� r� ra r_ rL rL s � �� �F� �
ra rL c � � e Zd ZdZy)�)_IProcessTransportWithConsumerAndProducera)
An L{_IProcessTransportWithConsumerAndProducer} combines various interfaces
to work around the issue that L{interfaces.IProcessTransport} is
incompletely defined and doesn't specify flow-control interfaces, and that
L{proxyForInterface} doesn't allow for multiple interfaces.
N�rf r~ r r� r� ra r_ r� r� 7 s � �ra r� c � � e Zd ZdZy)�_ProcessEndpointTransportaj
An L{ITransport}, L{IProcessTransport}, L{IConsumer}, and L{IPushProducer}
provider for the L{IProtocol} instance passed to the process endpoint.
@ivar _process: An active process transport which will be used by write
methods on this object to write data to a child process.
@type _process: L{interfaces.IProcessTransport} provider
Nr� r� ra r_ r� r� B s � � ra r� �_processc �( � e Zd ZdZd� Zd� Zd� Zd� Zy)�_WrapIProtocolz�
An L{IProcessProtocol} provider that wraps an L{IProtocol}.
@ivar transport: A L{_ProcessEndpointTransport} provider that is hooked to
the wrapped L{IProtocol} provider.
@see: L{protocol.ProcessProtocol}
c �. � || _ || _ || _ y)z�
@param proto: An L{IProtocol} provider.
@param errFlag: A constant belonging to L{StandardErrorBehavior}
that determines if stderr is logged or dropped.
@param executable: The file name (full path) to spawn.
N)r� �errFlag�
executable)r[ r� r� r� s r_ r` z_WrapIProtocol.__init__\ s � � ��
� �� �$��ra c �l � t |� | _ | j j | j � S )z�
Call L{IProtocol} provider's makeConnection method with an
L{ITransport} provider.
@param process: An L{IProcessTransport} provider.
)r� rj r� ri )r[ �processs r_ ri z _WrapIProtocol.makeConnectiong s) � � 3�7�;����}�}�+�+�D�N�N�;�;ra c �� � |dk( r| j j |� S |dk( rL| j t j k( r.t j d| j | j |�� yyy)z�
This is called with data from the process's stdout or stderr pipes. It
checks the status of the errFlag to setermine if stderr should be
logged (default) or dropped.
r5 � zGProcess %(executable)r wrote stderr unhandled by %(protocol)s: %(data)s)�formatr� r� ro N)r� rn r� rO �LOGr- �msgr� )r[ �childFDro s r_ �childDataReceivedz _WrapIProtocol.childDataReceivedq sc � � �a�<��=�=�-�-�d�3� 3�
��\�d�l�l�.C�.G�.G� G� �G�G�)� �?�?� � � ��
� H�\ra c �6 � |j t j � t j k( rO|j j dk( r6| j
j
t t j � � � S | j
j
|� S )z�
If the process ends with L{error.ProcessDone}, this method calls the
L{IProtocol} provider's L{connectionLost} with a
L{error.ConnectionDone}
@see: L{ProcessProtocol.processEnded}
r ) �checkr � ProcessDone�value�statusr� rt r2 �ConnectionDoneru s r_ � processEndedz_WrapIProtocol.processEnded� sk � �
�L�L��*�*� +�u�/@�/@� @� �L�L� � �1� $��=�=�/�/���8L�8L�8N�0O�P� P��=�=�/�/��7� 7ra N)rf r~ r r� r` ri r� r� r� ra r_ r� r� R s � �� %�<��"
8ra r� c �, � e Zd ZdZ e� Z e� Zy)rO z�
Constants used in ProcessEndpoint to decide what to do with stderr.
@cvar LOG: Indicates that stderr is to be logged.
@cvar DROP: Indicates that stderr is to be dropped (and not logged).
@since: 13.1
N)rf r~ r r� r
r� �DROPr� ra r_ rO rO � s � �� �/�C� �?�Dra rO c �B � e Zd ZdZdi dddddej
fd�Zd� Zy)rM z�
An endpoint for child processes
@ivar _spawnProcess: A hook used for testing the spawning of child process.
@since: 13.1
r� Nr c �� � || _ || _ || _ || _ || _ || _ || _ || _ | | _ |
| _ | j j | _ y)z�
See L{IReactorProcess.spawnProcess}.
@param errFlag: Determines if stderr should be logged.
@type errFlag: L{endpoints.StandardErrorBehavior}
N) r� � _executable�_args�_env�_path�_uid�_gid�_usePTY� _childFDs�_errFlag� spawnProcess�
_spawnProcess) r[ r� r� �args�env�path�uid�gid�usePTY�childFDsr� s r_ r` zProcessEndpoint.__init__� s] � �& ��
�%�����
��� ���
��� ��� � �� �!��� ��
� !�]�]� 7� 7��ra c � � |j t � � } | j t || j | j
� | j | j | j | j | j | j | j | j � t j |� S # t $ r t j � cY S w xY w)a3
Implement L{IStreamClientEndpoint.connect} to launch a child process
and connect it to a protocol created by C{protocolFactory}.
@param protocolFactory: A factory for an L{IProtocol} provider which
will be notified of all events related to the created process.
)r� r r� r� r� r� r� r� r� r� r� r� r� r
�succeedr� �fail)r[ �protocolFactoryr� s r_ �connectzProcessEndpoint.connect� s� � � �-�-�o�.?�@�� (� � � � �u�d�&6�&6��
�
�F�� � ��
�
�� � ��
�
�� � �� � �� � ����
� �=�=��'� '�� � ��:�:�<� � �s �BB8 �8 C�C)rf r~ r r� rO r� r` r� r� ra r_ rM rM � s1 � �� � �
� � ���%�)�)� 8�>(ra rM c � � e Zd ZdZd� Zd� Zy)�_TCPServerEndpointz)
A TCP server endpoint interface
c �< � || _ || _ || _ || _ y)a+
@param reactor: An L{IReactorTCP} provider.
@param port: The port number used for listening
@type port: int
@param backlog: Size of the listen queue
@type backlog: int
@param interface: The hostname to bind to
@type interface: str
N)r� �_port�_backlog�
_interface�r[ r� �port�backlog� interfaces r_ r` z_TCPServerEndpoint.__init__� s � � ��
���
� ��
�#��ra c � � t j | j j | j || j
| j �� S )z]
Implement L{IStreamServerEndpoint.listen} to listen on a TCP
socket
)r� r� )r
r� r� � listenTCPr� r� r� �r[ r� s r_ r� z_TCPServerEndpoint.listen� s: � �
�}�}� �M�M� #� #� �J�J� ��M�M��o�o�
�
ra N�rf r~ r r� r` r� r� ra r_ r� r� � s � ��$�$
ra r� c � � e Zd ZdZdd�Zy)rC zC
Implements TCP server endpoint with an IPv4 configuration
c �6 � t j | ||||� y)aA
@param reactor: An L{IReactorTCP} provider.
@param port: The port number used for listening
@type port: int
@param backlog: Size of the listen queue
@type backlog: int
@param interface: The hostname to bind to, defaults to '' (all)
@type interface: str
N�r� r` r� s r_ r` zTCP4ServerEndpoint.__init__ � � � �#�#�D�'�4��)�Lra N��2 � �rf r~ r r� r` r� ra r_ rC rC
�
� ��
Mra rC c � � e Zd ZdZdd�Zy)rD zC
Implements TCP server endpoint with an IPv6 configuration
c �6 � t j | ||||� y)aD
@param reactor: An L{IReactorTCP} provider.
@param port: The port number used for listening
@type port: int
@param backlog: Size of the listen queue
@type backlog: int
@param interface: The hostname to bind to, defaults to C{::} (all)
@type interface: str
Nr� r� s r_ r` zTCP6ServerEndpoint.__init__$ r� ra N�r� z::r� r� ra r_ rD rD r� ra rD c � � e Zd ZdZdd�Zd� Zy)rE z9
TCP client endpoint with an IPv4 configuration.
Nc �J � || _ || _ || _ || _ || _ y)a�
@param reactor: An L{IReactorTCP} provider
@param host: A hostname, used when connecting
@type host: str
@param port: The port number, used when connecting
@type port: int
@param timeout: The number of seconds to wait before assuming the
connection has failed.
@type timeout: L{float} or L{int}
@param bindAddress: A (host, port) tuple of local address to bind to,
or None.
@type bindAddress: tuple
N�r� �_hostr� �_timeout� _bindAddress�r[ r� �hostr� �timeout� bindAddresss r_ r` zTCP4ClientEndpoint.__init__: s( � �$ ��
���
���
� ��
� '��ra c � � t |� }| j j | j | j || j
| j �� |j S # t $ r t j � cY S w xY w)zP
Implement L{IStreamClientEndpoint.connect} to connect via TCP.
�r r ) r� r� �
connectTCPr r� r r r� r� r
r� �r[ r� �wfs r_ r� zTCP4ClientEndpoint.connectR sr � � �!�/�2�B� �M�M� $� $��
�
��
�
�� �
�
� � -� -�
%�
� �#�#� #�� � ��:�:�<� � �s �A A! �! B� B�� N�rf r~ r r� r` r� r� ra r_ rE rE 4 s � ��(�0 ra rE c �z � e Zd ZdZ eej � Z eej � Z
dZ dZ d d�Z
d� Zd� Zd� Zy)
rF a�
TCP client endpoint with an IPv6 configuration.
@ivar _getaddrinfo: A hook used for testing name resolution.
@ivar _deferToThread: A hook used for testing deferToThread.
@ivar _GAI_ADDRESS: Index of the address portion in result of
getaddrinfo to be used.
@ivar _GAI_ADDRESS_HOST: Index of the actual host-address in the
5-tuple L{_GAI_ADDRESS}.
� r Nc �J � || _ || _ || _ || _ || _ y)z�
@param host: An IPv6 address literal or a hostname with an
IPv6 address
@see: L{twisted.internet.interfaces.IReactorTCP.connectTCP}
Nr� r s r_ r` zTCP6ClientEndpoint.__init__y s( � � ��
���
���
� ��
� '��ra c � � � t � j � r � j � j |� }|S � j � j � }|j � fd�� |j � j |� |S )z~
Implement L{IStreamClientEndpoint.connect} to connect via TCP,
once the hostname resolution is done.
c �B �� | d �j �j S )Nr )� _GAI_ADDRESS�_GAI_ADDRESS_HOST)�resultr[ s �r_ �<lambda>z,TCP6ClientEndpoint.connect.<locals>.<lambda>� s! �� �v�a�y��):�):� ;�D�<R�<R� S� ra )r r �_resolvedHostConnect�_nameResolution� addCallback)r[ r� �ds ` r_ r� zTCP6ClientEndpoint.connect� sn �� �
���� $��)�)�$�*�*�o�F�A� �� �$�$�T�Z�Z�0�A�
�M�M�S�
�
�M�M�$�3�3�_� E��ra c �Z � | j | j |dt j � S )zd
Resolve the hostname string into a tuple containing the host
IPv6 address.
r )�_deferToThread� _getaddrinfo�socket�AF_INET6�r[ r s r_ r z"TCP6ClientEndpoint._nameResolution� s% � �
�"�"�4�#4�#4�d�A�v���O�Ora c �� � t |� }| j j || j || j | j
�� |j S # t $ r t j � cY S w xY w)zD
Connect to the server using the resolved hostname.
r )
r� r� r r� r r r� r� r
r� )r[ � resolvedHostr� r s r_ r z'TCP6ClientEndpoint._resolvedHostConnect� sn � � �!�/�2�B� �M�M� $� $� ��
�
�� �
�
� � -� -�
%�
� �#�#� #�� � ��:�:�<� � �s �AA � A7�6A7r )rf r~ r r� � staticmethodr � getaddrinfor r �
deferToThreadr r r r` r� r r r� ra r_ rF rF d sI � � � �� 2� 2�3�L�!�'�"7�"7�8�N��L��� (�
� P� ra rF c
�^ � e Zd ZdZ e� Zd� Z d dedede de
e e e
ded ef d
�Zy) �_SimpleHostnameResolvera^
An L{IHostnameResolver} provider that invokes a provided callable
to resolve hostnames.
@ivar _nameResolution: the callable L{resolveHostName} invokes to
resolve hostnames.
@type _nameResolution: A L{callable} that accepts two arguments:
the host to resolve and the port number to include in the
result.
c � � || _ y)z?
Create a L{_SimpleHostnameResolver} instance.
N)r )r[ �nameResolutions r_ r` z _SimpleHostnameResolver.__init__� s � � .�� ra N�resolutionReceiver�hostName�
portNumber� addressTypes�transportSemantics�returnc �� � ��� t �� }�j |� � j �|� }�fd�}�� fd�} |j |� |j | � |j �fd�� |S )a
Initiate a hostname resolution.
@param resolutionReceiver: an object that will receive each resolved
address as it arrives.
@type resolutionReceiver: L{IResolutionReceiver}
@param hostName: see interface
@param portNumber: see interface
@param addressTypes: Ignored in this implementation.
@param transportSemantics: Ignored in this implementation.
@return: The resolution in progress.
@rtype: L{IResolutionReceiver}
c �� �� | D ]f \ }}}}}|t j k( r �j t dg|��� � �8|t j k( s�L�j t dg|��� � �h y )N�TCP)r r �addressResolvedr �AF_INETr )� gairesult�family�socktyper� � canonname�sockaddrr+ s �r_ � cbDeliverz:_SimpleHostnameResolver.resolveHostName.<locals>.cbDeliver� sg �� �@I�
V�<���%��H��V�_�_�,�&�6�6�{�5�7T�8�7T�U��v�~�~�-�&�6�6�{�5�7T�8�7T�U�
Vra c �X �� �j j d| ��j �� y )Nz'while looking up {name} with {callable})�name�callable)�_log�failurer )r r, r[ s ��r_ �ebLogz6_SimpleHostnameResolver.resolveHostName.<locals>.ebLog� s, �� � �I�I� � �9�� � �-�-�
�
ra c �$ �� �j � S �N)�resolutionComplete)�ignoredr+ s �r_ r z9_SimpleHostnameResolver.resolveHostName.<locals>.<lambda>� s �� �"4�"G�"G�"I� ra )r& �resolutionBeganr r �
addErrback�addBoth)
r[ r+ r, r- r. r/ �
resolutionr r; rA s
``` r_ �resolveHostNamez'_SimpleHostnameResolver.resolveHostName� sg �� �4 $�H�-�
��*�*�:�6� � � ��:� 6�� V� �
�
�
�i� � � � �U�� � � �I�J��ra )r Nr3 )rf r~ r r� r) r? r` r �str�intr r r r r rJ r� ra r_ r( r( � sm � � � �8�D�.� �;?�"'�
0� /�0� �0� � 0�
�x��X�� 7�8� 0� �
0�
�0ra r( c � � e Zd ZdZ eej � Z eej � Z
dZ d d�Z de
fd�Zd� Zed� � Zd � Zd
� Zy) rN aB
A name-based endpoint that connects to the fastest amongst the resolved
host addresses.
@cvar _DEFAULT_ATTEMPT_DELAY: The default time to use between attempts, in
seconds, when no C{attemptDelay} is given to
L{HostnameEndpoint.__init__}.
@ivar _hostText: the textual representation of the hostname passed to the
constructor. Used to pass to the reactor's hostname resolver.
@type _hostText: L{unicode}
@ivar _hostBytes: the encoded bytes-representation of the hostname passed
to the constructor. Used to construct the L{HostnameAddress}
associated with this endpoint.
@type _hostBytes: L{bytes}
@ivar _hostStr: the native-string representation of the hostname passed to
the constructor, used for exception construction
@type _hostStr: native L{str}
@ivar _badHostname: a flag - hopefully false! - indicating that an invalid
hostname was passed to the constructor. This might be a textual
hostname that isn't valid IDNA, or non-ASCII bytes.
@type _badHostname: L{bool}
g333333�?Nc �, � || _ | j |� | _ | j |� \ | _ | _ | _ t t u r | j
n | j | _ || _
|| _ || _ |� | j }|| _ y)a�
Create a L{HostnameEndpoint}.
@param reactor: The reactor to use for connections and delayed calls.
@type reactor: provider of L{IReactorTCP}, L{IReactorTime} and either
L{IReactorPluggableNameResolver} or L{IReactorPluggableResolver}.
@param host: A hostname to connect to.
@type host: L{bytes} or L{unicode}
@param port: The port number to connect to.
@type port: L{int}
@param timeout: For each individual connection attempt, the number of
seconds to wait before assuming the connection has failed.
@type timeout: L{float} or L{int}
@param bindAddress: the local address of the network interface to make
the connections from.
@type bindAddress: L{bytes}
@param attemptDelay: The number of seconds to delay between connection
attempts.
@type attemptDelay: L{float}
@see: L{twisted.internet.interfaces.IReactorTCP.connectTCP}
N)r� � _getNameResolverAndMaybeWarn�
_nameResolver�_hostAsBytesAndText� _badHostname�
_hostBytes� _hostText�bytesrK �_hostStrr� r r �_DEFAULT_ATTEMPT_DELAY�
_attemptDelay)r[ r� r r� r r � attemptDelays r_ r` zHostnameEndpoint.__init__ s� � �> ��
� !� >� >�w� G���?C�?W�?W� �@
�<�� �D�O�T�^� ,1�C�<����T�^�^��
���
� ��
� '��� � � �6�6�L� )��ra r0 c � � | j r
| j }n;t | j � rd| j � d�}nt | j � }dj d|dt
| j � dg� S )zh
Produce a string representation of the L{HostnameEndpoint}.
@return: A L{str}
�[�]r� z<HostnameEndpoint �:�>)rR rV r r0 rS �joinrK r� r! s r_ �__repr__zHostnameEndpoint.__repr__C si � � � � � �=�=�D�
�4�=�=�
)��t�}�}�o�Q�'�D� ����0�D��w�w�,�d�C��T�Z�Z� �#�N�O�Ora c � � t j |� s`t j |j t dddd� dd�� }t
j |t d� � t | j � S |j S )
a
Retrieve a C{nameResolver} callable and warn the caller's
caller that using a reactor which doesn't provide
L{IReactorPluggableNameResolver} is deprecated.
@param reactor: The reactor to check.
@return: A L{IHostnameResolver} provider.
�Twisted� � r zPassing HostnameEndpoint a reactor that does not provide IReactorPluggableNameResolver (%(fqpn)s) was deprecated in %(version)sz5a reactor that provides IReactorPluggableNameResolver)r� � replacement� )�
stacklevel) r rZ r, �getDeprecationWarningStringre r �warnings�warn�DeprecationWarningr( �_fallbackNameResolution� nameResolver)r[ r� �
warningStrings r_ rO z-HostnameEndpoint._getNameResolverAndMaybeWarnW st � � -�7�7��@� %� A� A��!�!�� �2�q�!�,�5�
O� �M�
�M�M�-�);�� J�*�4�+G�+G�H� H��#�#�#ra c �� � t | t � r9t | � s t | � rd| | j d� fS d| t | � fS t d| � } t | � s t | � rd| j d� | fS dt | � | fS # t $ r | j d� } Y nw xY w# t $ r Y nw xY w| j dd� }d||j d� fS )a�
For various reasons (documented in the C{@ivar}'s in the class
docstring) we need both a textual and a binary representation of the
hostname given to the constructor. For compatibility and convenience,
we accept both textual and binary representations of the hostname, save
the form that was passed, and convert into the other form. This is
mostly just because L{HostnameAddress} chose somewhat poorly to define
its attribute as bytes; hopefully we can find a compatible way to clean
this up in the future and just operate in terms of text internally.
@param host: A hostname to convert.
@type host: L{bytes} or C{str}
@return: a 3-tuple of C{(invalid, bytes, text)} where C{invalid} is a
boolean indicating the validity of the hostname, C{bytes} is a
binary representation of C{host}, and C{text} is a textual
representation of C{host}.
F�ascii�charmap�NFC�backslashreplaceT)
�
isinstancerU r r �decoder7 � UnicodeErrorr �encoder6 )r �
asciibytess r_ rQ z$HostnameEndpoint._hostAsBytesAndTextr s� � �( �d�E� "��4� �M�$�$7� �d�D�K�K��$8�8�8�2� �$� �$��7�7�
�U�D�)�D��4� �M�$�$7� �d�k�k�'� 2�D�8�8�� �*�T�"2�D�8�8�� $� 2� �;�;�y�1�D�2�� $� ���� �[�[��*<�=�
��Z��!2�!2�7�!;�;�;s# �
B �
B/ �B,�+B,�/ B;�:B;c �� � ����� � j r+t j t d� j � �� � S t � �g �t
t � G ��fd�d� � }� j j |� j � j �� �j � fd�� �j � fd�� }�j t � � fd���j ��� fd�� }�S ) a�
Attempts a connection to each resolved address, and returns a
connection which is established first.
@param protocolFactory: The protocol factory whose protocol
will be connected.
@type protocolFactory:
L{IProtocolFactory<twisted.internet.interfaces.IProtocolFactory>}
@return: A L{Deferred} that fires with the connected protocol
or fails a connection-related error.
zinvalid hostname: c �H �� e Zd Zed� � Ze� fd�� Ze� �fd�� Zy)�2HostnameEndpoint.connect.<locals>.EndpointReceiverc � � y rC r� )�resolutionInProgresss r_ rF zBHostnameEndpoint.connect.<locals>.EndpointReceiver.resolutionBegan� s � �ra c �( �� �j | � y rC ��append)�address� addressess �r_ r4 zBHostnameEndpoint.connect.<locals>.EndpointReceiver.addressResolved� s �� �� � ��)ra c �( �� �j � � y rC �rk �r� r s ��r_ rD zEHostnameEndpoint.connect.<locals>.EndpointReceiver.resolutionComplete� s �� ��
�
�9�%ra N)rf r~ r r$ rF r4 rD r� s ��r_ �EndpointReceiverr{ � s= �� �
�
� �
� �
*� �
*� �
&� �
&ra r� )r- c �p �� t j t j d�j � d�� � S )Nz Couldn't find the hostname '�')r
r� r �DNSLookupErrorrV )rE r[ s �r_ r z*HostnameEndpoint.connect.<locals>.<lambda>� s- �� �E�J�J��$�$�'C�D�M�M�?�RS�%T�U� � ra c 3 �j �K � | D ]� }t |t � rCt �j |j |j
�j �j � �� t |t � s�gt �j |j |j
�j �j � �� �� y �wrC )
rt r rF r� r r� r r r rE )r� � eachAddressr[ s �r_ � resolvedAddressesToEndpointsz>HostnameEndpoint.connect.<locals>.resolvedAddressesToEndpoints� s� �� �� � )�
� � �k�;�7�,� �
�
�#�(�(�#�(�(� �
�
� �)�)� � � �k�;�7�,� �
�
�#�(�(�#�(�(� �
�
� �)�)� � �
�s
�A)B3�-AB3c � �� | j t j t �j �j
� � � y rC )r� r r� r rS r� )r r[ s �r_ r� z,HostnameEndpoint.connect.<locals>._canceller� s1 �� �
�I�I��.�.�#�D�O�O�T�Z�Z�@��
ra c �| �������� | s"t j d�
j � �� �t | � �g �g �t j
��� �����fd��d�_ d�_ t ����� �fd�� ��
j �_
�j �
j � �j ���fd�� }�S )aQ
Given a sequence of endpoints obtained via name resolution, start
connecting to a new one every C{self._attemptDelay} seconds until
one of the connections succeeds, all of them fail, or the attempt
is cancelled.
@param endpoints: a list of all the endpoints we might try to
connect to, as determined by name resolution.
@type endpoints: L{list} of L{IStreamServerEndpoint}
@return: a Deferred that fires with the result of the
C{endpoint.connect} method that completes the fastest, or fails
with the first connection error it encountered if none of them
succeed.
@rtype: L{Deferred} failing with L{error.ConnectingCancelledError}
or firing with L{IProtocol}
z no results for hostname lookup: r� c �z �� �s� j s � j ry �j �j � � y rC )� completed�
endpointsLeftr� �pop)� checkDone�failures�pending�winners ����r_ r� zLHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.checkDone s+ �� ��i� 1� 1�Y�5L�5L�����x�|�|�~�.ra FTc � ��� t �d � } | �d�_ �� y | j � � ��j �� �j ��fd�� }�j
�
fd�� }�j ��fd�� }y )NFc �* �� �j �� | S rC )�remove)r � eachAttemptr� s ��r_ �noLongerPendingzkHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.iterateEndpoint.<locals>.noLongerPending s �� ��N�N�;�/�!�Mra c �( �� �j | � y rC r� )r r� s �r_ � succeededzeHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.iterateEndpoint.<locals>.succeeded" s �� ��O�O�F�+ra c �6 �� �j | � �� y rC r )rv r� r� s ��r_ �failedzbHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.iterateEndpoint.<locals>.failed& s �� � �O�O�F�+� �Kra )�nextr� r� r� rH r rG ) �endpointr� r� r� r� r� r� �
iterEndpointsr� r� r� s @������r_ �iterateEndpointzRHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.iterateEndpoint s� �� � �
�t�4���#�.3�I�+� �K�� &� .� .�� ?� ����{�+� �$�$�"� %�"� �(�(�,� )�,� �'�'� � (� ra c � �� d�_ �d d D ] }|j � � �j r�j � | S �NT)r� �cancel�running�stop)r � remainingr� r� r� s ���r_ �cancelRemainingPendingzYHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.cancelRemainingPending. sD �� �&*� �#�!(��� '�I� �$�$�&�'�"�*�*�#�(�(�*� �
ra )r r� rV �iterr
r' r� r� r( r� �clock�startrX rH ) � endpointsr� r� r� r� r� r� r� r� r� r[ s @@@@@@���r_ �startConnectionAttemptsz9HostnameEndpoint.connect.<locals>.startConnectionAttempts� s� �� �& ��*�*�6�t�}�}�o�F�� � !��O�M��G��H��^�^�j�9�F�
/�
#(�I� �&*�I� #�
�
�
� �
�2 %)�M�M�O� !� � !� !�$�"4�"4� 5�
�^�^�
� �
� �Mra )rR r
r� �
ValueErrorrV r' r r rP rJ rT r� rG r �list)r[ r� r� r� r� r� r� r s `` @@@r_ r� zHostnameEndpoint.connect� s� �� � � � ��:�:�j�+=�d�m�m�_�)M� N�O� O� �J��� � �%� &� &� &�
'� &�
���*�*� �d�n�n���� +�
�
� � �
�
�
� � � �
� �(
�
�
�d��
�
� � �I �
�I �V �ra c �\ � | j | j ||dt j � S )a�
Resolve the hostname string into a tuple containing the host
address. This is method is only used when the reactor does
not provide L{IReactorPluggableNameResolver}.
@param host: A unicode hostname to resolve.
@param port: The port to include in the resolution.
@return: A L{Deferred} that fires with L{_getaddrinfo}'s
return value.
r )r r r � SOCK_STREAM)r[ r r� s r_ rl z(HostnameEndpoint._fallbackNameResolution; s) � � �"�"�4�#4�#4�d�D�!�V�EW�EW�X�Xra )r
NN)rf r~ r r� r$ r r% r r r& r rW r` rK r` rO rQ r� rl r� ra r_ rN rN � sq � ��6 �� 2� 2�3�L�!�'�"7�"7�8�N� �� OS�**�XP�#� P�($�6 �*<� �*<�XZ�x
Yra rN c � � e Zd ZdZdd�Zd� Zy)rI zE
SSL secured TCP server endpoint with an IPv4 configuration.
c �J � || _ || _ || _ || _ || _ y)a�
@param reactor: An L{IReactorSSL} provider.
@param port: The port number used for listening
@type port: int
@param sslContextFactory: An instance of
L{interfaces.IOpenSSLContextFactory}.
@param backlog: Size of the listen queue
@type backlog: int
@param interface: The hostname to bind to, defaults to '' (all)
@type interface: str
N)r� r� �_sslContextFactoryr� r� )r[ r� r� �sslContextFactoryr� r� s r_ r` zSSL4ServerEndpoint.__init__Q s( � � ��
���
�"3�� � ��
�#��ra c � � t j | j j | j || j
| j | j �� S )zf
Implement L{IStreamServerEndpoint.listen} to listen for SSL on a
TCP socket.
)�contextFactoryr� r� )r
r� r� � listenSSLr� r� r� r� r� s r_ r� zSSL4ServerEndpoint.listeng sC � �
�}�}� �M�M� #� #� �J�J� � �2�2��M�M��o�o�
�
ra Nr� r� r� ra r_ rI rI K s � ��$�,
ra rI c � � e Zd ZdZ dd�Zd� Zy)rJ zD
SSL secured TCP client endpoint with an IPv4 configuration
Nc �X � || _ || _ || _ || _ || _ || _ y)ao
@param reactor: An L{IReactorSSL} provider.
@param host: A hostname, used when connecting
@type host: str
@param port: The port number, used when connecting
@type port: int
@param sslContextFactory: SSL Configuration information as an instance
of L{interfaces.IOpenSSLContextFactory}.
@param timeout: Number of seconds to wait before assuming the
connection has failed.
@type timeout: int
@param bindAddress: A (host, port) tuple of local address to bind to,
or None.
@type bindAddress: tuple
N)r� r r� r� r r )r[ r� r r� r� r r s r_ r` zSSL4ClientEndpoint.__init__| s0 � �. ��
���
���
�"3�� � ��
� '��ra c � � t |� }| j j | j | j || j
| j | j �� |j S # t $ r t j � cY S w xY w)zb
Implement L{IStreamClientEndpoint.connect} to connect with SSL over
TCP.
r ) r� r� �
connectSSLr r� r� r r r� r� r
r� r
s r_ r� zSSL4ClientEndpoint.connect� s{ � �
�!�/�2�B� �M�M� $� $��
�
��
�
���'�'� �
�
� � -� -�
%�
� �#�#� #�� � ��:�:�<� � �s �A)A, �, B � B r r r� ra r_ rJ rJ v s � ��
OS� (�< ra rJ c � � e Zd ZdZdd�Zd� Zy)rG z%
UnixSocket server endpoint.
c �J � || _ || _ || _ || _ || _ y)a�
@param reactor: An L{IReactorUNIX} provider.
@param address: The path to the Unix socket file, used when listening
@param backlog: number of connections to allow in backlog.
@param mode: mode to set on the unix socket. This parameter is
deprecated. Permissions should be set on the directory which
contains the UNIX socket.
@param wantPID: If True, create a pidfile for the socket.
N)r� �_addressr� �_mode�_wantPID)r[ r� r� r� �mode�wantPIDs r_ r` zUNIXServerEndpoint.__init__� s' � � ��
� ��
� ��
���
� ��
ra c � � t j | j j | j || j
| j | j �� S )zW
Implement L{IStreamServerEndpoint.listen} to listen on a UNIX socket.
)r� r� r� )r
r� r� �
listenUNIXr� r� r� r� r� s r_ r� zUNIXServerEndpoint.listen� sA � � �}�}� �M�M� $� $� �M�M� ��M�M�����M�M�
�
ra N)r� i� r r� r� ra r_ rG rG � s � �� �
ra rG c � � e Zd ZdZdd�Zd� Zy)rH z%
UnixSocket client endpoint.
c �< � || _ || _ || _ || _ y)a�
@param reactor: An L{IReactorUNIX} provider.
@param path: The path to the Unix socket file, used when connecting
@type path: str
@param timeout: Number of seconds to wait before assuming the
connection has failed.
@type timeout: int
@param checkPID: If True, check for a pid file to verify that a server
is listening.
@type checkPID: bool
N)r� r� r � _checkPID)r[ r� r� r �checkPIDs r_ r` zUNIXClientEndpoint.__init__� s � � ��
���
� ��
�!��ra c �� � t |� }| j j | j || j | j
�� |j S # t $ r t j � cY S w xY w)za
Implement L{IStreamClientEndpoint.connect} to connect via a
UNIX Socket
)r r� )
r� r� � connectUNIXr� r r� r� r� r
r� r
s r_ r� zUNIXClientEndpoint.connect� sf � �
�!�/�2�B� �M�M� %� %��
�
�B��
�
����
&�
� �#�#� #�� � ��:�:�<� � �s �AA � A6�5A6N)r
r r r� ra r_ rH rH � s � ��"�( ra rH c �X � e Zd ZdZej
Z eej � Z
d� Z d� Z y)rK z�
An endpoint for listening on a file descriptor initialized outside of
Twisted.
@ivar _used: A C{bool} indicating whether this endpoint has been used to
listen with a factory yet. C{True} if so.
c �< � || _ || _ || _ d| _ y)a
@param reactor: An L{IReactorSocket} provider.
@param fileno: An integer file descriptor corresponding to a listening
I{SOCK_STREAM} socket.
@param addressFamily: The address family of the socket given by
C{fileno}.
FN)r� �fileno�
addressFamily�_used)r[ r� r� r� s r_ r` z$AdoptedStreamServerEndpoint.__init__ s! � � �� � �� � *�����
ra c � � | j r't j t j � � S d| _ | j | j � | j j | j | j |� }| j | j � t j |� S # t $ r t j � cY S w xY w)z{
Implement L{IStreamServerEndpoint.listen} to start listening on, and
then close, C{self._fileno}.
T)
r� r
r� r �AlreadyListened�_setNonBlockingr� r� �adoptStreamPortr� �_closer� r� )r[ �factoryr� s r_ r� z"AdoptedStreamServerEndpoint.listen s� � �
�:�:��:�:�e� 3� 3� 5�6� 6���
� � � � ���� -��<�<�/�/�� � �T� /� /���D�
�K�K�� � � $� �}�}�T�"�"�� � ��:�:�<� � �s �A'B8 �8 C�CN)
rf r~ r r� �os�closer� r$ r �setNonBlockingr� r` r� r� ra r_ rK rK � s, � �� �X�X�F�"�5�#7�#7�8�O�
� #ra rK c �8 � t |� | f|t |� d�fS )a
Internal parser function for L{_parseServer} to convert the string
arguments for a TCP(IPv4) stream endpoint into the structured arguments.
@param factory: the protocol factory being parsed, or L{None}. (This was a
leftover argument from when this code was in C{strports}, and is now
mostly None and unused.)
@type factory: L{IProtocolFactory} or L{None}
@param port: the integer port number to bind
@type port: C{str}
@param interface: the interface IP to listen on
@param backlog: the length of the listen queue
@type backlog: C{str}
@return: a 2-tuple of (args, kwargs), describing the parameters to
L{IReactorTCP.listenTCP} (or, modulo argument 2, the factory, arguments
to L{TCP4ServerEndpoint}.
�r� r� )rL )r� r� r� r� s r_ � _parseTCPr� + s! � �,
��I�w� �y�S��\�!R� R�Rra c �` � || ft |d� t |� t t |� � d�fS )a�
Internal parser function for L{_parseServer} to convert the string
arguments for a UNIX (AF_UNIX/SOCK_STREAM) stream endpoint into the
structured arguments.
@param factory: the protocol factory being parsed, or L{None}. (This was a
leftover argument from when this code was in C{strports}, and is now
mostly None and unused.)
@type factory: L{IProtocolFactory} or L{None}
@param address: the pathname of the unix socket
@type address: C{str}
@param backlog: the length of the listen queue
@type backlog: C{str}
@param lockfile: A string '0' or '1', mapping to True and False
respectively. See the C{wantPID} argument to C{listenUNIX}
@return: a 2-tuple of (args, kwargs), describing the parameters to
L{twisted.internet.interfaces.IReactorUNIX.listenUNIX} (or,
modulo argument 2, the factory, arguments to L{UNIXServerEndpoint}.
� )r� r� r� )rL �bool)r� r� r� r� �lockfiles r_ �
_parseUNIXr� D s3 � �4
�'���T�1� �#�g�,�4��H�
�CV�W� � ra c � � ddl m} |�|}i }
|�t | j |� |
d< t |� j � } t |� j � } | j j | dz | z � }
|��t j dt t |� j � � t j �� }|D �cg c]' }| j j |� j ��) }}|st d|�d �� �d}|�$| j j! t |� � } | j" d |
j$ j |
j ||d
�|
��}t' |� | |f|t' |� d �fS c c}w )
aY
Internal parser function for L{_parseServer} to convert the string
arguments for an SSL (over TCP/IPv4) stream endpoint into the structured
arguments.
@param factory: the protocol factory being parsed, or L{None}. (This was a
leftover argument from when this code was in C{strports}, and is now
mostly None and unused.)
@type factory: L{IProtocolFactory} or L{None}
@param port: the integer port number to bind
@type port: C{str}
@param interface: the interface IP to listen on
@param backlog: the length of the listen queue
@type backlog: C{str}
@param privateKey: The file name of a PEM format private key file.
@type privateKey: C{str}
@param certKey: The file name of a PEM format certificate file.
@type certKey: C{str}
@param sslmethod: The string name of an SSL method, based on the name of a
constant in C{OpenSSL.SSL}.
@type sslmethod: C{str}
@param extraCertChain: The path of a file containing one or more
certificates in PEM format that establish the chain from a root CA to
the CA that signed your C{certKey}.
@type extraCertChain: L{str}
@param dhParameters: The file name of a file containing parameters that are
required for Diffie-Hellman key exchange. If this is not specified,
the forward secret C{DHE} ciphers aren't available for servers.
@type dhParameters: L{str}
@return: a 2-tuple of (args, kwargs), describing the parameters to
L{IReactorSSL.listenSSL} (or, modulo argument 2, the factory, arguments
to L{SSL4ServerEndpoint}.
r )�sslN�method�
z=(-----BEGIN CERTIFICATE-----\n.+?\n-----END CERTIFICATE-----))�flagszSpecified chain file 'z7' doesn't contain any valid certificates in PEM format.)�
privateKey� certificate�extraCertChain� dhParametersr� r� )�twisted.internetr� �getattr�SSLr3 �
getContentr< �loadPEM�re�findallr0 �DOTALLr9 �originalr� �DiffieHellmanParameters�fromFiler: r� rL )r� r� r� �certKey� sslmethodr� r� r� r� r� �kw�certPEM�keyPEM�privateCertificate�matches� chainCertPEM�chainCertificates�cfs r_ � _parseSSLr c s� � �h %��� �� �B�� � �s�w�w� �2��8� ��w� �*�*�,�G�
�j�
!�
,�
,�
.�F� �/�/�7�7��%��&�8P�Q���!��*�*� L� ��.�1�<�<�>� ?��)�)�
�� PW�
�?K�C�O�O� #� #�L� 1� :� :�
��
� !� �1?�B��
�
!��� ��2�2�;�;� �\� "�
� �
�� � �
�%�0�0�9�9�&�/�/�(�!�
�
�
�B� ��Y��� $�I�#�g�,�&W� X�X��-
s �,E?c � � e Zd ZdZdZd� Zd� Zy)�_StandardIOParserz�
Stream server endpoint string parser for the Standard I/O type.
@ivar prefix: See L{IStreamServerEndpointStringParser.prefix}.
�stdioc � � t |� S )z�
Internal parser function for L{_parseServer} to convert the string
arguments into structured arguments for the L{StandardIOEndpoint}
@param reactor: Reactor for the endpoint
)rL r� s r_ � _parseServerz _StandardIOParser._parseServer� s � � "�'�*�*ra c �$ � | j |� S rC �r �r[ r� r� �kwargss r_ �parseStreamServerz#_StandardIOParser.parseStreamServer� s � � � � ��)�)ra N�rf r~ r r� �prefixr r r� ra r_ r r � s � �� �F�+�*ra r c �j � e Zd ZdZ ej
� ZdZ d dede de
e de
e de f
d �Z d
� Z
y) �_SystemdParsera
Stream server endpoint string parser for the I{systemd} endpoint type.
@ivar prefix: See L{IStreamServerEndpointStringParser.prefix}.
@ivar _sddaemon: A L{ListenFDs} instance used to translate an index into an
actual file descriptor.
�systemdNr� �domain�indexr= r0 c � � |du |du k( r t d� �|�'| j j � t |� }n!|�J �| j j � | }t t d|z � }t |||� S )aW
Internal parser function for L{_parseServer} to convert the string
arguments for a systemd server endpoint into structured arguments for
L{AdoptedStreamServerEndpoint}.
@param reactor: An L{IReactorSocket} provider.
@param domain: The domain (or address family) of the socket inherited
from systemd. This is a string like C{"INET"} or C{"UNIX"}, ie
the name of an address family from the L{socket} module, without
the C{"AF_"} prefix.
@param index: If given, the decimal representation of an integer
giving the offset into the list of file descriptors inherited from
systemd. Since the order of descriptors received from systemd is
hard to predict, this option should only be used if only one
descriptor is being inherited. Even in that case, C{name} is
probably a better idea. Either C{index} or C{name} must be given.
@param name: If given, the name (as defined by C{FileDescriptorName}
in the C{[Socket]} section of a systemd service definition) of an
inherited file descriptor. Either C{index} or C{name} must be
given.
@return: An L{AdoptedStreamServerEndpoint} which will adopt the
inherited listening port when it is used to listen.
Nz/Specify exactly one of descriptor index or name�AF_)r� � _sddaemon�inheritedDescriptorsrL �inheritedNamedDescriptorsr� r rK )r[ r� r r r= r� r� s r_ r z_SystemdParser._parseServer� s� � �D
�T�M�t�t�|� ,� � N�O� O� � ��^�^�8�8�:�3�u�:�F�F��#� #�#��^�^�=�=�?��E�F� �����7�
�*�7�F�M�J�Jra c �. � | j |g|��i |��S rC r r
s r_ r z _SystemdParser.parseStreamServer s! � � !�t� � ��:�4�:�6�:�:ra )NN)rf r~ r r� r4 �fromEnvironmentr r r rK r rK r r r� ra r_ r r � so � �� *� �)�)�+�I�
�F� $� "� ,K� �,K� �,K� ��}� ,K�
�s�m� ,K�
%�
,K�\;ra r c �" � e Zd ZdZdZdd�Zd� Zy)�_TCP6ServerParserz�
Stream server endpoint string parser for the TCP6ServerEndpoint type.
@ivar prefix: See L{IStreamServerEndpointStringParser.prefix}.
�tcp6c �J � t |� }t |� }t ||||� S )a�
Internal parser function for L{_parseServer} to convert the string
arguments into structured arguments for the L{TCP6ServerEndpoint}
@param reactor: An L{IReactorTCP} provider.
@param port: The port number used for listening
@type port: int
@param backlog: Size of the listen queue
@type backlog: int
@param interface: The hostname to bind to
@type interface: str
)rL rD r� s r_ r z _TCP6ServerParser._parseServer) s' � � �4�y���g�,��!�'�4��)�D�Dra c �. � | j |g|��i |��S rC r r
s r_ r z#_TCP6ServerParser.parseStreamServer= s! � � !�t� � ��:�4�:�6�:�:ra Nr� r
r� ra r_ r r s � �� � �E�(;ra r )�tcp�unixr� r� c # �Z K � t d| � }t d| � }t d| � }t d| � }|}||z }|||z ||i}t t | � � }|D ]D } | t |� v r t |f�� t | f�� |}|| }�,| |k( r|t |� z
}�@|| z
}�F t |f�� y�w)a�
Tokenize a strports string and yield each token.
@param description: a string as described by L{serverFromString} or
L{clientFromString}.
@type description: L{str} or L{bytes}
@return: an iterable of 2-tuples of (C{_OP} or C{_STRING}, string). Tuples
starting with C{_OP} will contain a second element of either ':' (i.e.
'next parameter') or '=' (i.e. 'assign parameter value'). For example,
the string 'hello:greeting=world' would result in a generator yielding
these values::
_STRING, 'hello'
_OP, ':'
_STRING, 'greet=ing'
_OP, '='
_STRING, 'world'
r� r] �=�\N)r. r� r/ �_STRING�_OPr� )
� description�empty�colon�equals� backslash�current�ops�nextOps�iterdesc�ns
r_ � _tokenizer1 L s� � �� �(
�B� � ,�E� �C�� -�E�
�S�+�
.�F� �� �4�I��G�
�&�.�C��e�f�n�f�e�4�G��I�k�*�+�H�
� �� � �#�� ��7�"� "��q�&�L��G��!�*�C�
�)�^� �t�H�~� %�G� �q�L�G� � �7�
��s �B)B+c � ��� g i c��t d| � }��fd�}d}t | � D ]$ \ }}|t u r||fz
}�||k( s� ||� d}�& ||� ��fS )a
Convert a description string into a list of positional and keyword
parameters, using logic vaguely like what Python does.
@param description: a string as described by L{serverFromString} or
L{clientFromString}.
@return: a 2-tuple of C{(args, kwargs)}, where 'args' is a list of all
':'-separated C{str}s not containing an '=' and 'kwargs' is a map of
all C{str}s which do contain an '='. For example, the result of
C{_parse('a:b:d=1:c')} would be C{(['a', 'b', 'c'], {'d': '1'})}.
r] c �t �� t | � dk( r�j | d � y | d �t | d � < y )Nr5 r )�lenr� r0 )�sofarr� r� s ��r_ �addz_parse.<locals>.add� s5 �� � �u�:��?� �K�K��a�� !�).�q��B�|�E�!�H�%� &ra r� )r. r1 r% )r' r) r6 r5 �typer� r� r� s @@r_ �_parser8 v sx �� � �2�H�D�"� �C�� -�E�2�
�E� ��-� � ��e� �7�?� �e�X� �E�
�e�^� ��J��E� � ��J� ��8�Ora )r3 r� �UNIXc �� � t | � \ }}|d }t j |� }|�!t t t
� |� }||dd |fS |j
� f ||g|dd ��i |��z S )a�
Parse a strports description into a 2-tuple of arguments and keyword
values.
@param description: A description in the format explained by
L{serverFromString}.
@type description: C{str}
@param factory: A 'factory' argument; this is left-over from
twisted.application.strports, it's not really used.
@type factory: L{IProtocolFactory} or L{None}
@return: a 3-tuple of (plugin or name, arguments, keyword arguments)
r Nr5 )r8 �_serverParsers�get�_matchPluginToPrefixr+ r �upper)r' r� r� r� � endpointType�parser�plugins r_ r r � s� � � �k�"�H�D�"���7�L�
�
�
� �
-�F�
�~� &� �8� 9�<�
�� ��Q�R��"�%�%� � � � � "�V�G�%E�d�1�2�h�%E�"�%E� E�Era c � � |j � }| D ]- }t |j j � |� |k( s�+|c S t d|� d�� �)z!
Match plugin to prefix.
zUnknown endpoint type: 'r� )�lowerr. r r� )�pluginsr? rA s r_ r= r= � sY � � �%�%�'�L�� �� �6�=�=�.�.�0�,� ?�<� O��M�� �/� �~�Q�?�
@�@ra c � � t |d� \ }}}t |� t ur|} |j | g|��i |��S |}|dd |dd z }t | | g|��i |��S )a_
Construct a stream server endpoint from an endpoint description string.
The format for server endpoint descriptions is a simple byte string. It is
a prefix naming the type of endpoint, then a colon, then the arguments for
that endpoint.
For example, you can call it like this to create an endpoint that will
listen on TCP port 80::
serverFromString(reactor, "tcp:80")
Additional arguments may be specified as keywords, separated with colons.
For example, you can specify the interface for a TCP server endpoint to
bind to like this::
serverFromString(reactor, "tcp:80:interface=127.0.0.1")
SSL server endpoints may be specified with the 'ssl' prefix, and the
private key and certificate files may be specified by the C{privateKey} and
C{certKey} arguments::
serverFromString(
reactor, "ssl:443:privateKey=key.pem:certKey=crt.pem")
If a private key file name (C{privateKey}) isn't provided, a "server.pem"
file is assumed to exist which contains the private key. If the certificate
file name (C{certKey}) isn't provided, the private key file is assumed to
contain the certificate as well.
You may escape colons in arguments with a backslash, which you will need to
use if you want to specify a full pathname argument on Windows::
serverFromString(reactor,
"ssl:443:privateKey=C\:/key.pem:certKey=C\:/cert.pem")
finally, the 'unix' prefix may be used to specify a filesystem UNIX socket,
optionally with a 'mode' argument to specify the mode of the socket file
created by C{listen}::
serverFromString(reactor, "unix:/var/run/finger")
serverFromString(reactor, "unix:/var/run/finger:mode=660")
This function is also extensible; new endpoint types may be registered as
L{IStreamServerEndpointStringParser} plugins. See that interface for more
information.
@param reactor: The server endpoint will be constructed with this reactor.
@param description: The strports description to parse.
@type description: L{str}
@return: A new endpoint which can be used to listen with the parameters
given by C{description}.
@rtype: L{IStreamServerEndpoint<twisted.internet.interfaces.IStreamServerEndpoint>}
@raise ValueError: when the 'description' string cannot be parsed.
@since: 10.2
Nr5 r� )r r7 rK r �_endpointServerFactories)r� r' � nameOrPluginr� r� rA r= s r_ rB rB � s| � �| *�+�t� <��L�$�� �L���$� ��'�v�'�'��=�$�=�"�=�=��� ���8�d�1�2�h� �D� #�D� )�'� ?�D� ?�B� ?�?ra c �L � d\ }}||fD ] }| j |||z � } � | S )a�
Quote an argument to L{serverFromString} and L{clientFromString}. Since
arguments are separated with colons and colons are escaped with
backslashes, some care is necessary if, for example, you have a pathname,
you may be tempted to interpolate into a string like this::
serverFromString(reactor, "ssl:443:privateKey=%s" % (myPathName,))
This may appear to work, but will have portability issues (Windows
pathnames, for example). Usually you should just construct the appropriate
endpoint type rather than interpolating strings, which in this case would
be L{SSL4ServerEndpoint}. There are some use-cases where you may need to
generate such a string, though; for example, a tool to manipulate a
configuration file which has strports descriptions in it. To be correct in
those cases, do this instead::
serverFromString(reactor, "ssl:443:privateKey=%s" %
(quoteStringArgument(myPathName),))
@param argument: The part of the endpoint description string you want to
pass through.
@type argument: C{str}
@return: The quoted argument.
@rtype: C{str}
z\:)�replace)�argumentr+ r) �cs r_ �quoteStringArgumentrL s= � �: ��I�u�
��
� 6���#�#�A�y�1�}�5��6� �Ora c �h � t | � dk( rt | d � |d< | d |d< n,t | � dk( r d|v rt | d � |d< n| d |d< t |d � |d< t |d � |d< |d df|d< |S # t $ r Y �*w xY w# t $ r Y �'w xY w# t $ r Y |S w xY w)a$
Perform any argument value coercion necessary for TCP client parameters.
Valid positional arguments to this function are host and port.
Valid keyword arguments to this function are all L{IReactorTCP.connectTCP}
arguments.
@return: The coerced values as a C{dict}.
r� r5 r� r r r r )r4 rL �KeyError�r� r s r_ �_parseClientTCPrP 8 s� � � �4�y�A�~� �T�!�W� ��v�� �a���v�� �T��a� � �V� � ��a��\�F�6�N� !�!�W�F�6�N�
� �V�F�^�,��v��
� ��y� 1� 2��y��
�!'�
�!6�� :��}� � �M�� �
� �
��
�
� �
��
�
� � �M�
�s6 �B �(B �:
B$ � B�B� B!� B!�$ B1�0B1c � � i }| j � D ]~ }|j � j � j d� d j � dk( s�E |j � } t j |� }|||j � < �� t |j � � S # t $ r Y ��w xY w# t $ r Y ��w xY w)z�
Load certificate-authority certificate objects in a given directory.
@param directoryPath: a L{unicode} or L{bytes} pointing at a directory to
load .pem files from, or L{None}.
@return: an L{IOpenSSLTrustRoot} provider.
�.����pem)
�children�
asTextMode�basename�splitrC r� �OSErrorr9 r� �digest�SSLErrorr> �values)�
directoryPath�caCerts�childro �theCerts r_ �_loadCAsFromDirra _ s� � � �G� �'�'�)� 0��� � �!�*�*�,�2�2�3�7��;�A�A�C�u�L� � ��#�#�%�D� 0�!�)�)�$�/�G�
)0�G�G�N�N�$� %� 0� %�W�^�^�%5� 6�6�� � � � ��
� � � �s$ �B-�*B<�- B9�8B9�< C�Cc �0 � | �yt t | � � S )z�
Parse a string referring to a directory full of certificate authorities
into a trust root.
@param pathName: path name
@type pathName: L{unicode} or L{bytes} or L{None}
@return: L{None} or L{IOpenSSLTrustRoot}
N)ra r3 )�pathNames r_ �_parseTrustRootPathrd { s � � ��� �8�H�-� .�.ra c � � | �yt | � j � }|�t j |� S t j t j |� t
j t |� j � d� � S )ax
Parse a certificate path and key path, either or both of which might be
L{None}, into a certificate object.
@param certificatePath: the certificate path
@type certificatePath: L{bytes} or L{unicode} or L{None}
@param keyPath: the private key path
@type keyPath: L{bytes} or L{unicode} or L{None}
@return: a L{PrivateCertificate} or L{None}
Nr5 )r3 r� r< r� �fromCertificateAndKeyPairr9 r; �load)�certificatePath�keyPath� certBytess r_ �_privateCertFromPathsrk � ss � � � ��� �)�4�4�6�I���!�)�)�)�4�4�!�;�;� � � � � *� �L�L��'�*�5�5�7�� ;�
�
ra c �d � | j dd� }t | j dd� | j dd� � }t | j dd� � }|�t t |� ||�� }n7|�#|j
j }|j }nd}d}t |||�� }|| d< | S ) a�
Parse common arguments for SSL endpoints, creating an L{CertificateOptions}
instance.
@param kwargs: A dict of keyword arguments to be parsed, potentially
containing keys C{certKey}, C{privateKey}, C{caCertsDir}, and
C{hostname}. See L{_parseClientSSL}.
@type kwargs: L{dict}
@return: The remaining arguments, including a new key C{sslContextFactory}.
�hostnameNr� r� �
caCertsDir�� trustRoot�clientCertificate)rp r� r� r� )r� rk rd r= r7 r� r� r: )r rm rq rp �
configuration�privateKeyOpenSSL�certificateOpenSSLs r_ �_parseClientSSLOptionsru � s� � � �z�z�*�d�+�H�-��
�
�9�d�#�V�Z�Z� �d�%C��� $�F�J�J�|�T�$B�C�I���+� �h� � � /�
�
� � (� 1� <� <� E� E� �!2�!;�!;� � $� �!%� �*� �(�*�
�
�
#0�F� � � �Mra c �. � t | i |��}t |� S )a
Perform any argument value coercion necessary for SSL client parameters.
Valid keyword arguments to this function are all L{IReactorSSL.connectSSL}
arguments except for C{contextFactory}. Instead, C{certKey} (the path name
of the certificate file) C{privateKey} (the path name of the private key
associated with the certificate) are accepted and used to construct a
context factory.
Valid positional arguments to this function are host and port.
@keyword caCertsDir: The one parameter which is not part of
L{IReactorSSL.connectSSL}'s signature, this is a path name used to
construct a list of certificate authority certificates. The directory
will be scanned for files ending in C{.pem}, all of which will be
considered valid certificate authorities for this connection.
@type caCertsDir: L{str}
@keyword hostname: The hostname to use for validating the server's
certificate.
@type hostname: L{unicode}
@return: The coerced values as a L{dict}.
)rP ru rO s r_ �_parseClientSSLrw � s � �2 �d�
-�f�
-�F� !�&� )�)ra c �� � t | � dk( r| d |d< t t |j d� � � |d< t |d � |d< |S # t $ r Y � w xY w# t $ r Y |S w xY w)a�
Perform any argument value coercion necessary for UNIX client parameters.
Valid keyword arguments to this function are all L{IReactorUNIX.connectUNIX}
keyword arguments except for C{checkPID}. Instead, C{lockfile} is accepted
and has the same meaning. Also C{path} is used instead of C{address}.
Valid positional arguments to this function are C{path}.
@return: The coerced values as a C{dict}.
r5 r r� r� r� r )r4 r� rL r� rN rO s r_ �_parseClientUNIXry � s� � � �4�y�A�~� �a���v��
� !�#�f�j�j��&<�"=� >��z��
� ��y� 1� 2��y�� �M��
�
� �
�� �
� � �M�
�s" �&A �A! � A � A �! A.�-A.c � � t |� \ }}|j d� }|j � }|t vr/t t t � |� } |j | g|��i |��S t | |i |��}t | | fi |��S )a�
Construct a client endpoint from a description string.
Client description strings are much like server description strings,
although they take all of their arguments as keywords, aside from host and
port.
You can create a TCP client endpoint with the 'host' and 'port' arguments,
like so::
clientFromString(reactor, "tcp:host=www.example.com:port=80")
or, without specifying host and port keywords::
clientFromString(reactor, "tcp:www.example.com:80")
Or you can specify only one or the other, as in the following 2 examples::
clientFromString(reactor, "tcp:host=www.example.com:80")
clientFromString(reactor, "tcp:www.example.com:port=80")
or an SSL client endpoint with those arguments, plus the arguments used by
the server SSL, for a client certificate::
clientFromString(reactor, "ssl:web.example.com:443:"
"privateKey=foo.pem:certKey=foo.pem")
to specify your certificate trust roots, you can identify a directory with
PEM files in it with the C{caCertsDir} argument::
clientFromString(reactor, "ssl:host=web.example.com:port=443:"
"caCertsDir=/etc/ssl/certs")
Both TCP and SSL client endpoint description strings can include a
'bindAddress' keyword argument, whose value should be a local IPv4
address. This fixes the client socket to that IP address::
clientFromString(reactor, "tcp:www.example.com:80:"
"bindAddress=192.0.2.100")
NB: Fixed client ports are not currently supported in TCP or SSL
client endpoints. The client socket will always use an ephemeral
port assigned by the operating system
You can create a UNIX client endpoint with the 'path' argument and optional
'lockfile' and 'timeout' arguments::
clientFromString(
reactor, b"unix:path=/var/foo/bar:lockfile=1:timeout=9")
or, with the path as a positional argument with or without optional
arguments as in the following 2 examples::
clientFromString(reactor, "unix:/var/foo/bar")
clientFromString(reactor, "unix:/var/foo/bar:lockfile=1:timeout=9")
This function is also extensible; new endpoint types may be registered as
L{IStreamClientEndpointStringParserWithReactor} plugins. See that
interface for more information.
@param reactor: The client endpoint will be constructed with this reactor.
@param description: The strports description to parse.
@type description: L{str}
@return: A new endpoint which can be used to connect with the parameters
given by C{description}.
@rtype: L{IStreamClientEndpoint<twisted.internet.interfaces.IStreamClientEndpoint>}
@since: 10.2
r ) r8 r� r> �_clientParsersr= r+ r �parseStreamClient�_endpointClientFactories)r� r' r� r �anamer= rA s r_ rA rA s� � �P �+�&�L�D�&� �H�H�Q�K�E� �;�;�=�D� �>�!�%� �C� D�d�
�� (�v�'�'��A�$�A�&�A�A�
�D�
!�4�
2�6�
2�F� #�D� )�'� <�V� <�<ra c �R �� G �fd�dt � }| j |� � S )a�
Connect a protocol instance to an endpoint.
This allows using a client endpoint without having to create a factory.
@param endpoint: A client endpoint to connect to.
@param protocol: A protocol instance.
@return: The result of calling C{connect} on the endpoint, i.e. a
L{Deferred} that will fire with the protocol when connected, or an
appropriate error.
@since: 13.1
c � �� e Zd Z� fd�Zy)�'connectProtocol.<locals>.OneShotFactoryc � �� �S rC r� )r[ r� r� s �r_ r� z5connectProtocol.<locals>.OneShotFactory.buildProtocolo s �� ��Ora N)rf r~ r r� �r� s �r_ �OneShotFactoryr� n s �� � ra r� )r! r� )r� r� r� s ` r_ rP rP ] s% �� �" �� � � � �N� ,� -�-ra c � � e Zd ZdZd� Zd� Zy)�_WrapperEndpointz2
An endpoint that wraps another endpoint.
c � � || _ || _ y)z2
Construct a L{_WrapperEndpoint}.
N��_wrappedEndpoint�_wrapperFactory�r[ �wrappedEndpoint�wrapperFactorys r_ r` z_WrapperEndpoint.__init__{ � � � !0�� � -�� ra c �v � | j j | j |� � j d� � S )�K
Connect the given protocol factory and unwrap its result.
c � � | j S rC )r] r� s r_ r z*_WrapperEndpoint.connect.<locals>.<lambda>� s � �x�'?�'?� ra )r� r� r� r r� s r_ r� z_WrapperEndpoint.connect� s7 � � �$�$�,�,� � � � � 1�
�
�+�?�
@� Ara Nr r� ra r_ r� r� u s � ��.�Ara r� c � � e Zd ZdZd� Zd� Zy)�_WrapperServerEndpointz?
A server endpoint that wraps another server endpoint.
c � � || _ || _ y)z8
Construct a L{_WrapperServerEndpoint}.
Nr� r� s r_ r` z _WrapperServerEndpoint.__init__� r� ra c �V � | j j | j |� � S )r� )r� r� r� r� s r_ r� z _WrapperServerEndpoint.listen� s& � � �$�$�+�+�D�,@�,@� �,Q�R�Rra Nr� r� ra r_ r� r� � s � ��.�Sra r� c �D � � t � t d� �t |� fd�� S )a�
Wrap an endpoint which upgrades to TLS as soon as the connection is
established.
@since: 16.0
@param connectionCreator: The TLS options to use when connecting; see
L{twisted.internet.ssl.optionsForClientTLS} for how to construct this.
@type connectionCreator:
L{twisted.internet.interfaces.IOpenSSLClientConnectionCreator}
@param wrappedEndpoint: The endpoint to wrap.
@type wrappedEndpoint: An L{IStreamClientEndpoint} provider.
@return: an endpoint that provides transport level encryption layered on
top of C{wrappedEndpoint}
@rtype: L{twisted.internet.interfaces.IStreamClientEndpoint}
z6OpenSSL not available. Try `pip install twisted[tls]`.c � �� t �d| � S r� r? )r� �connectionCreators �r_ r z wrapClientTLS.<locals>.<lambda>� s �� � 3� �t�_�!
� ra )r@ �NotImplementedErrorr� )r� r� s ` r_ rQ rQ � s2 �� �& �"�!� D�
�
� ��
� � ra c
� � | r#t dt | j � � � �t |t � r|n|j d� }t |t � s|�|n|j d� }t
|� }t
|� }t t |t |� t ||� �� |�t | |� � S t | t |� |||� � S )a�
Internal method to construct an endpoint from string parameters.
@param reactor: The reactor passed to L{clientFromString}.
@param host: The hostname to connect to.
@type host: L{bytes} or L{unicode}
@param port: The port to connect to.
@type port: L{bytes} or L{unicode}
@param timeout: For each individual connection attempt, the number of
seconds to wait before assuming the connection has failed.
@type timeout: L{bytes} or L{unicode}
@param bindAddress: The address to which to bind outgoing connections.
@type bindAddress: L{bytes} or L{unicode}
@param certificate: a string representing a filesystem path to a
PEM-encoded certificate.
@type certificate: L{bytes} or L{unicode}
@param privateKey: a string representing a filesystem path to a PEM-encoded
certificate.
@type privateKey: L{bytes} or L{unicode}
@param endpoint: an optional string endpoint description of an endpoint to
wrap; if this is passed then C{host} is used only for certificate
verification.
@type endpoint: L{bytes} or L{unicode}
@return: a client TLS endpoint
@rtype: L{IStreamClientEndpoint}
z&unrecognized keyword arguments presentzutf-8ro )� TypeErrorr� �keysrt rK ru rL rQ r= rd rk rA rN r6 )
r� r r� r r r� r� �
trustRootsr� r s
r_ �_parseClientTLSr� � s� � �\ ��@�$�v�{�{�}�BU�V�V� �d�C�(�4�d�k�k�'�.B�D� �k�3� '�;�+>� �
�
�
��
(� �
�t�9�D��'�l�G� �� �)�*�5� 3�K�� L�
� � � ��(�+�
� � �g�z�$�'7��w� �
T� � ra c �$ � e Zd ZdZdZed� � Zy)�_TLSClientEndpointParserz�
Stream client endpoint string parser for L{wrapClientTLS} with
L{HostnameEndpoint}.
@ivar prefix: See
L{IStreamClientEndpointStringParserWithReactor.prefix}.
�tlsc � � t | g|��i |��S )a�
Redirects to another function L{_parseClientTLS}; tricks zope.interface
into believing the interface is correctly implemented, since the
signature is (C{reactor}, C{*args}, C{**kwargs}). See
L{_parseClientTLS} for the specific signature description for this
endpoint parser.
@param reactor: The reactor passed to L{clientFromString}.
@param args: The positional arguments in the endpoint description.
@type args: L{tuple}
@param kwargs: The named arguments in the endpoint description.
@type kwargs: L{dict}
@return: a client TLS endpoint
@rtype: L{IStreamClientEndpoint}
)r� )r� r� r s r_ r| z*_TLSClientEndpointParser.parseStreamClient s � �( �w�8��8��8�8ra N)rf r~ r r� r r$ r| r� ra r_ r� r� s � �� �F��9� �9ra r� )r� r� )�666r� T)z
server.pemNNr� r� NN)s 30NNNNN)�r� r� r� r ri �typingr r r � unicodedatar �zope.interfacer r r �
constantlyr
r � incrementalr r� r
r r r r �twisted.internet.abstractr r �twisted.internet.addressr r r r �twisted.internet.interfacesr r r r r r r r �twisted.internet.protocolr r! r" r# �twisted.internet.stdior$ r% � ImportError�twisted.internet._resolverr& �twisted.internet.deferr' �twisted.internet.taskr( �twisted.loggerr) �twisted.pluginr* r+ �twisted.pythonr, r- �twisted.python.compatr. r/ r0 �twisted.python.componentsr1 �twisted.python.failurer2 �twisted.python.filepathr3 �twisted.python.systemdr4 �_idnar6 r7 � OpenSSL.SSLr8 r[ �twisted.internet.sslr9 r: r; r< r= r> �twisted.protocols.tlsr@ �_TLSMemoryBIOFactory�__all__rS r� �IStreamServerEndpointrL �IProcessTransport� IConsumer�
IPushProducerr� r� r� rO �IStreamClientEndpointrM r� rC rD rE rF r( rN rI rJ rG rH rK r� r� r r r r r; �ranger& r% r1 r8 rF r} r r= rB rL rP ra rd rk ru rw ry r{ rA rP r� r� rQ r� r� r� ra r_ �<module>r� s ��
�
� �
� � +� +� !� B� B� +� � E� E� @�� � � � � X� W��>� 6� +� -� !� .� )� J� J� 7� *� ,� ,� (�/�-�� � R� /�� ��*N3�� N3�b\/�}� \/�~
�Z�
-�
-�.�
�
� /�
�8�� � �*�"6�"6�
�8P�8P��
��1���
� =8�_� =8�@ �E� �
�Z�
-�
-�.�@(� @(� /�@(�F
�Z�
-�
-�.�"
� "
� /�"
�JM�+� M�*M�+� M�*
�Z�
-�
-�.�, � , � /�, �^
�Z�
-�
-�.�F � F � /�F �R
�
� �D� D� �D�N
�Z�
-�
-�.�QY� QY� /�QY�h
�Z�
-�
-�.�'
� '
� /�'
�T
�Z�
-�
-�.�4 � 4 � /�4 �n
�Z�
-�
-�.�
�
� /�
�F
�Z�
-�
-�.�% � % � /�% �P
�Z�
-�
-�.�,#� ,#� /�,#�^S�2 �D � ��� ���ZY�z
�W�7�8�*� *� 9�*�0
�W�7�8�@;� @;� 9�@;�F
�W�7�8�";� ";� 9�";�L � � ��� �Q�x� ��W�'�T �F � � � � � � � � � �F�8A�F@�R �F$�N7�8 /�
�2%�P*�:�6 � � ���Q=�h.�0
�Z�
-�
-�.�A� A� /�A�*
�Z�
-�
-�.�S� S� /�S�& �F
�����
�A�H
�W�B�C� 9� 9� D� 9��cF � ��J��K���< � � �� �s$ �>O+ � O; �+ O8�7O8�;P�P
Mini Shell