h? SrSSKJr SSKrSSKrSSKrSSKrSSKJrJ r J r J r J r J r JrJrJr SSKJr SSKJrJr SSKJrJr SSKJr SS KJrJrJrJrJ r SS K!J"r" SS K#J$r$J%r%J&r&J'r' SS K(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4 SS K5J6r6J7r7J8r8J9r9 SSK:J;r;JJ?r? SSK@JArA SSKBJCrC SSKDJErE SSKFJGrGJHrH SSKIJJrJJKrK SSKLJMrMJNrNJOrO SSKPJQrQ SSKRJSrS SSKTJUrU SSKVJWrW SSKXJYrYJZrZ SSK[J\r] SSK^J_r_J`r`JaraJbrbJcrcJdrd SSKeJfrg \grf/SQrh"S S!\95ri"S"S#\65rj\"\R5"S$S%55rl"S&S'\R\R\R5rp"S(S)\Q"\pS*55rq"S+S,\85rr"S-S.\5rs\"\Rd5"S/S055rt\"\R5"S1S255ru"S3S4\u5rv"S5S6\u5rw\"\Rd5"S7S855rx\"\Rd5"S9S:55ry\ \\R\R\|\}\\\}\|4\\}\|\|\|444r~\"\*5"S;S<55r\"\Rd5"S=S>55r\"\R5"S?S@55r\"\Rd5"SASB55r\"\R5"SCSD55r\"\Rd5"SESF55r\"\R5"SGSH55rSlSIjrSmSJjrSnSKjr\"\G\45"SLSM55r\"\G\45"SNSO55r\"\G\45"SPSQ55r\\\SR.r\"SS5urrSTrSUr\v\\SV.r\x\\SV.rSWrSXrSYrSZrS[rS\rS]rS^rS_rS`rSar\\\SV.rSbrScr\"\Rd5"SdSe55r\"\R5"SfSg55rSoShjrSpSqSijjr\"\G\35"SjSk55rg!\=a Sr)>?rlc8URRU5$)z= Proxy C{dataReceived} calls to our C{self._wrappedProtocol} )r` dataReceived)redatas rir{_WrappingProtocol.dataReceiveds$$11$77rlc8URRU5$)zG Proxy C{fileDescriptorReceived} calls to our C{self._wrappedProtocol} )r`fileDescriptorReceived)re descriptors rir(_WrappingProtocol.fileDescriptorReceiveds$$;;JGGrlc8URRU5$)z? Proxy C{connectionLost} calls to our C{self._wrappedProtocol} )r`connectionLostrereasons rir _WrappingProtocol.connectionLosts$$33F;;rlc8URR5 g)zT Proxy L{IHalfCloseableProtocol.readConnectionLost} to our C{self._wrappedProtocol} N)r`readConnectionLostrrs rir$_WrappingProtocol.readConnectionLost 002rlc8URR5 g)zU Proxy L{IHalfCloseableProtocol.writeConnectionLost} to our C{self._wrappedProtocol} N)r`writeConnectionLostrrs rir%_WrappingProtocol.writeConnectionLosts 113rlc8URR5 g)zI Proxy L{interfaces.IHandshakeListener} to our C{self._wrappedProtocol}. N)r`handshakeCompletedrrs rir$_WrappingProtocol.handshakeCompletedrrl)r_r`N)rq __module__ __qualname____firstlineno____doc__rjrorxr{rrrrr__static_attributes__rlrir\r\os6 .&8@8 H < 343rlr\cJ\rSrSrSr\rS SjrSrSr Sr Sr Sr S r S rg ) _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 } that is managing the current or previous connection attempt. cVXl[R"URS9Ulg)z @param wrappedFactory: A provider of I{IProtocolFactory} whose buildProtocol method will be called and whose resulting protocol will be wrapped.  cancellerN)_wrappedFactoryrr0 _canceller _onConnection)rewrappedFactorys rirj_WrappingFactory.__init__s" .8=oo9 rlcXlg)zf A connection attempt was started. Remember the connector which started said attempt, for use later. N) _connector)re connectors ristartedConnecting"_WrappingFactory.startedConnectings $rlcUR[R"URR 555 URR 5 g)a The outgoing connection attempt was cancelled. Fail that L{Deferred} with an L{error.ConnectingCancelledError}. @param deferred: The L{Deferred } that was cancelled; should be the same as C{self._onConnection}. @type deferred: L{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 } is returned to C{connect()}'s caller. @return: L{None} N)errbackrConnectingCancelledErrorrgetDestinationstopConnecting)redeferreds rir_WrappingFactory._cancellers?&   * *4??+I+I+K L  &&(rlc8URR5 g)zI Start notifications are passed straight through to the wrapped factory. N)rdoStartrrs rir_WrappingFactory.doStarts $$&rlc8URR5 g)zH Stop notifications are passed straight through to the wrapped factory. N)rdoStoprrs rir_WrappingFactory.doStops ##%rlcURRU5nUc[R"5eUR UR U5$![ a UR R5 gf=f)z 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 NoProtocolprotocolr BaseExceptionr)readdrprotos rir_WrappingFactory.buildProtocolsr <((66ta 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. rNrqrrrrrrrlrirr>srlrc\rSrSrSrSrg)_ProcessEndpointTransportiIaR 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 rNrrrlrirrIs rlr_processc0\rSrSrSrSrSrSrSrSr g) _WrapIProtocoliYz 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(XlX0lX lg)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)rerrFlag executable)rerrrs rirj_WrapIProtocol.__init__cs  $rlcl[U5UlURRUR5$)z Call L{IProtocol} provider's makeConnection method with an L{ITransport} provider. @param process: An L{IProcessTransport} provider. )rrvrru)reprocesss riru_WrapIProtocol.makeConnectionns)37;}}++DNN;;rlcUS:XaURRU5$US:XaKUR[R:Xa,[ R "SURURUS9 ggg)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. r>zGProcess %(executable)r wrote stderr unhandled by %(protocol)s: %(data)s)formatrrr|N)rr{rrXLOGr6msgr)rechildFDr|s richildDataReceived _WrapIProtocol.childDataReceivedxsc a<==--d3 3 \dll.C.G.GG GG)??  H\rlc<UR[R5[R:XaQURRS:Xa7UR R [[R"555$UR R U5$)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 ProcessDonevaluestatusrrr;ConnectionDoners ri processEnded_WrapIProtocol.processEndedsk LL** +u/@/@ @ LL  1 $==//8L8L8N0OP P==//7 7rl)rrrrvN) rqrrrrrjrurrrrrlrirrYs %<" 8rlrc4\rSrSrSr\"5r\"5rSrg)rXiz 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 rN) rqrrrrrrDROPrrrlrirXrXs /C ?DrlrXcL\rSrSrSrS0SSSSS\R 4SjrSrSr g) rViz| An endpoint for child processes @ivar _spawnProcess: A hook used for testing the spawning of child process. @since: 13.1 rNrc XlX lX0lX@lXPlX`lXplXlXlXl URRUl g)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) rerrargsenvpathuidgidusePTYchildFDsrs rirjProcessEndpoint.__init__sI& %      ! !]]77rlc UR[55nUR[X RUR 5URUR URURURURURUR5 [R"U5$![a [R "5s$f=f)a  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. )rrrrrrrrrrrrrrsucceedrfail)reprotocolFactoryrs riconnectProcessEndpoint.connects --o.?@ (   u&6&6 F         ==' ' ::<  sBB88CC) rrrrrrrrrrr) rqrrrrrXrrjr rrrlrirVrVs1    %))8>(rlrVc$\rSrSrSrSrSrSrg)_TCPServerEndpointiz! A TCP server endpoint interface c4XlX lX0lX@lg)z @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 _interfacererportbacklog interfaces rirj_TCPServerEndpoint.__init__s   #rlc[R"URRURUUR UR S9$)zE Implement L{IStreamServerEndpoint.listen} to listen on a TCP socket )rr)rrr listenTCPrrrrers rir_TCPServerEndpoint.listens: }} MM # # JJ MMoo   rl)rrrrNrqrrrrrjrrrrlrir r s$$  rlr c"\rSrSrSrSSjrSrg)rLiz; Implements TCP server endpoint with an IPv4 configuration c2[RXX#U5 g)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, defaults to '' (all) @type interface: str Nr rjrs rirjTCP4ServerEndpoint.__init__ ##D4)LrlrN2rqrrrrrjrrrlrirLrL  MrlrLc"\rSrSrSrSSjrSrg)rMi&z; Implements TCP server endpoint with an IPv6 configuration c2[RXX#U5 g)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, defaults to C{::} (all) @type interface: str Nrrs rirjTCP6ServerEndpoint.__init__+rrlrNr!z::r#rrlrirMrM&r$rlrMcJ\rSrSrSrSSSjjrS SjrSrg) rNi;z1 TCP client endpoint with an IPv4 configuration. Nc@XlX lX0lX@lXPlg)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 Nr_hostr_timeout _bindAddressrerhostrtimeout bindAddresss rirjTCP4ClientEndpoint.__init__As2    'rlc[U5nURRURURUUR UR S9 UR$![a [R"5s$f=f)z@ Implement L{IStreamClientEndpoint.connect} to connect via TCP. r1r2) rr connectTCPr,rr-r.rrrrrerwfs rir TCP4ClientEndpoint.connect`sr !/2B MM $ $    -- % ## # ::<  sAAB?Br.r,rrr-N) rrr0strrintr1floatr2z$str | tuple[bytes | str, int] | Nonerrrr"rDeferred[IProtocol]rqrrrrrjr rrrlrirNrN;sS<@ ((( (  ( : ( (> rlrNc\rSrSrSr\"\R5r\"\ R5r Sr Sr S SjrSrSrS S jrS rg) rOirag 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}. rNc@XlX lX0lX@lXPlg)z @param host: An IPv6 address literal or a hostname with an IPv6 address @see: L{twisted.internet.interfaces.IReactorTCP.connectTCP} Nr+r/s rirjTCP6ClientEndpoint.__init__s    'rlc^[TR5(aTRTRU5nU$TRTR5nUR U4Sj5 UR TRU5 U$)zf Implement L{IStreamClientEndpoint.connect} to connect via TCP, once the hostname resolution is done. cB>USTRTR$)Nr) _GAI_ADDRESS_GAI_ADDRESS_HOST)resultres ri,TCP6ClientEndpoint.connect..svay):):;D 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. cXlg)z/ Create a L{_SimpleHostnameResolver} instance. NrO)renameResolutions rirj _SimpleHostnameResolver.__init__s .rlNc^^^[T5nTRU5 TRTU5nU4SjnUU4Sjn URU5 UR U 5 UR U4Sj5 U$)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>UHiupp4nU[R:XaTR[S/UQ765 M8U[R:XdMNTR[ S/UQ765 Mk g)NTCP)rVrWaddressResolvedrAF_INETr) gairesultfamilysocktyper canonnamesockaddrresolutionReceivers ri cbDeliver:_SimpleHostnameResolver.resolveHostName..cbDelivers^@I<%HV__,&66{57T87TUv~~-&66{57T87TU AJrlcR>TRRSUTTRS9 g)Nz'while looking up {name} with {callable})namecallable)_logfailurerO)rhostNameres riebLog6_SimpleHostnameResolver.resolveHostName..ebLog s, II  9--  rlc$>TR5$N)resolutionComplete)ignoredrps rirL9_SimpleHostnameResolver.resolveHostName..s"4"G"G"Irl)r/resolutionBeganrOrP addErrbackaddBoth) rerprx portNumber addressTypestransportSemantics resolutionrQrqrys ``` riresolveHostName'_SimpleHostnameResolver.resolveHostNamesg4$H- **:6  : 6 V  i  U IJrlrc)rdz*Callable[[str, int], Deferred[_gairesult]]rr)rNrh) rpr%rxr=rr>rz"Optional[Sequence[Type[IAddress]]]rr=rr) rqrrrrr2rvrjrrrrlrirarast  8D.H. .;?"' 0/00 0 9 0  0 00rlrac\rSrSrSr\"\R5r\"\ R5r Sr S S Sjjr SSjrSSjr\SSj5rSS jrS rS rg)rWiaS 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 _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?NclXlURU5 URU5uUlUlUlX0lX@lUbO[U[[45(aUS4n[US[5(aUSR5US4nXPl Uc URnX`lg)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{str} @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 client socket normally uses whatever local interface (eth0, en0, lo, etc) is best suited for the target address, and a randomly-assigned port. This argument allows that local address/port to be overridden. Providing just an address (as a str) will bind the client socket to whichever interface is assigned that address. Providing a tuple of (str, int) will bind it to both an interface and a specific local port. To bind the port, but leave the interface unbound, use a tuple of ("", port), or ("0.0.0.0", port) for IPv4, or ("::0", port) for IPv6. To leave both interface and port unbound, just use None. @type bindAddress: L{str}, L{tuple}, or None @param attemptDelay: The number of seconds to delay between connection attempts. @type attemptDelay: L{float} @see: L{twisted.internet.interfaces.IReactorTCP.connectTCP} Nrr>)r_getNameResolverAndMaybeWarn_hostAsBytesAndText _badHostname _hostBytes _hostTextrr- isinstancebytesr=decoder._DEFAULT_ATTEMPT_DELAY _attemptDelay)rerr0rr1r2 attemptDelays rirjHostnameEndpoint.__init__6s\  ))'2?C?W?W @ < DOT^   "+s|44*A. +a.%00*1~446 AG '  66L)rlcUR(a UROD[UR5(aSURS3OURR S5nSUSUR S3$)zP Produce a string representation of the L{HostnameEndpoint}. @return: A L{str} []asciiz)rrrrrrrXs ri__repr__HostnameEndpoint.__repr__sn   NN !00DNN#1% __++G4 $D64::,a88rlc [R"U5(d\[R"UR[ SSSS5SSS9n[ R"U[SS 9 [UR5$UR$) z 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. TwistedrzPassing HostnameEndpoint a reactor that does not provide IReactorPluggableNameResolver (%(fqpn)s) was deprecated in %(version)sz5a reactor that provides IReactorPluggableNameResolver)r replacement) stacklevel) r#rdr5getDeprecationWarningStringrprwarningswarnDeprecationWarningra_fallbackNameResolution nameResolver)rer warningStrings rir-HostnameEndpoint._getNameResolverAndMaybeWarnsw-77@@%AA!! 2q!,5 O M MM-); J*4+G+GH H###rlcSn[U[5(aUn[U5nO:[ SU5n[ U5(aURS5nO [U5nU(a#URSS5nUR S5nUWU4$![a& UR S5n[ U5(dSnN^f=f![a SnNpf=f)a8 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. @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}. FcharmapTNFCrbackslashreplace) rrr@ UnicodeErrorrrr encoder?)r0invalid hostByteshostTexts rir$HostnameEndpoint._hostAsBytesAndTexts& dE " "I #$Y/ !-HX&&$OOG4 # *8 4I  1CDI ''0H 8++!  #$++I6$X.."G #$#"G#s# B C-C?C CCcD^^^^ ^ TR(a,[R"[STR355$[ 5m /m [ [5"U U 4SjS55nTRTR5nURU"5TRTRS9 T RU4Sj5 S U4SjjnT RU5nUR[5nS U4SjjmS UUU4SjjnURU5$) 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} @return: A L{Deferred} that fires with the connected protocol or fails a connection-related error. zinvalid hostname: c`>\rSrSr\SSj5r\SU4Sjj5r\S UU4Sjj5rSrg) 2HostnameEndpoint.connect..EndpointReceivericgr|r)resolutionInProgresss rirBHostnameEndpoint.connect..EndpointReceiver.resolutionBegansrlc(>TRU5 gr|append)address addressess ririBHostnameEndpoint.connect..EndpointReceiver.addressResolveds  )rlc(>TRT5 gr|rwrresolvedsrir}EHostnameEndpoint.connect..EndpointReceiver.resolutionCompletes!!),rlrN)rrrr)rrrrrr) rqrrrr]rrir}rrsriEndpointReceiverrs=    * * - -rlr)rct>[R"[R"STRS355$)NzCouldn't find the hostname '')rrrDNSLookupErrorr)r~res rirL*HostnameEndpoint.connect..s,EJJ$$'CDNNCSST%UVrlc3># UHn[U[5(aC[TRURUR TR TR5v [U[5(dMr[TRURUR TR TR5v M g7fr|) rrrOrr0rr-r.rrN)r eachAddressres riresolvedAddressesToEndpoints>HostnameEndpoint.connect..resolvedAddressesToEndpoints s ) k;77, #((#(( )) k;77, #((#(( ))  )s A1C8ACc>UR[R"[TRTR 555 gr|)rrrrrr) cancelledres rir,HostnameEndpoint.connect.._canceller"s3   ..#DOOTZZ@ rlc >^^^^^^^^ U(d#[R"ST R35e[U5m/m/m[R "T S9m SmSmSUUUUU 4Sjjm[ SUUUUUU U 4Sjj5mT RTlTRT R5 S UUU4SjjnT RU5$) a 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: rFTcp>T(dT(dT(agTRTR55 gr|)rpop)checkDoneCompletedcheckDoneEndpointsLeftfailurespendingwinnersri checkDoneLHostnameEndpoint.connect..startConnectionAttempts..checkDoneNs!04Jx||~.rlc>^[T S5nUc SmT"5 gURT 5mT RT5 SUU 4SjjnTRU5nSU 4SjjnUR U5 UU4SjnUR U5 g)NFc*>TRT5 U$r|)remove)rK eachAttemptrs rinoLongerPendingkHostnameEndpoint.connect..startConnectionAttempts..iterateEndpoint..noLongerPending`sNN;/!Mrlc(>TRU5 gr|r)rKrs ri succeededeHostnameEndpoint.connect..startConnectionAttempts..iterateEndpoint..succeededfsOOF+rlc6>TRU5 T"5 gr|r)rrrs rifailedbHostnameEndpoint.connect..startConnectionAttempts..iterateEndpoint..failedksOOF+KrlrKIProtocol | Failurerr)rKr!rr)nextr rrrPr) endpointr successStaterrrrrr iterEndpointsrrrs @riiterateEndpointRHostnameEndpoint.connect..startConnectionAttempts..iterateEndpointSs t4#-2*K&..? {+"" +22?C ,((3 ''/rlc>SmTSSHnUR5 M TR(aTR5 U$NT)cancelrunningstop)rK remainingrrrs ricancelRemainingPendingYHostnameEndpoint.connect..startConnectionAttempts..cancelRemainingPendingts?&*"!(I$$&","**#((* rlrr) rrriterrr0r1rclockstartrr) endpointsrrrrrrrrrrrres @@@@@@@@ristartConnectionAttempts9HostnameEndpoint.connect..startConnectionAttempts.s(**6t~~6FG!OM79G&(H050TF!& %) " / /  0 0 0:%)MMO !  ! !$"4"4 5 + $  >>"89 9rl)rzIterable[IAddress]rz1Iterable[TCP6ClientEndpoint | TCP4ClientEndpoint])rrArr)rz-list[TCP6ClientEndpoint | TCP4ClientEndpoint]rrA)rrr ValueErrorrr0rr%rrrrrrPlist) rerrrriterdlistdrrrrs `` @@@rir HostnameEndpoint.connects   ::j+=dnn=M)NOP P-5Z$& ( ) - - * -88G $$  4:: %     )  > ,$$%AB!!$' Q :DQ : Q :Q :f  !899rlcZURURXS[R5$)aV 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)rTrUrV SOCK_STREAM)rer0rs rir(HostnameEndpoint._fallbackNameResolutions'""4#4#4d!VEWEWXXrl)rrr.rrrrr-)r<NN)rrr0z str | bytesrr>r1r?r2z,bytes | str | tuple[bytes | str, int] | Nonerz float | Nonerr)rr=)robjectrr)r0 bytes | strrztuple[bool, bytes, str]r@)rqrrrrr]rVr^rUrr_rTrrjrrrr rrrrlrirWrWs.  2 23L!'"7"78N DH%)H*H*H* H*  H* B H*#H* H*T90$6',',Rd:L YrlrWc(\rSrSrSrSSjrSrSrg)rRiz= SSL secured TCP server endpoint with an IPv4 configuration. c@XlX lX0lX@lXPlg)aU @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)rr_sslContextFactoryrr)rerrsslContextFactoryrrs rirjSSL4ServerEndpoint.__init__s   "3 #rlc [R"URRURUUR UR URS9$)zN Implement L{IStreamServerEndpoint.listen} to listen for SSL on a TCP socket. )contextFactoryrr)rrr listenSSLrrrrrs rirSSL4ServerEndpoint.listensC }} MM # # JJ 22MMoo   rl)rrrrrNr rrrlrirRrRs$,  rlrRc*\rSrSrSrSSjrSrSrg)rSiz< SSL secured TCP client endpoint with an IPv4 configuration NcLXlX lX0lX@lXPlX`lg)a @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)rr,rrr-r.)rerr0rrr1r2s rirjSSL4ClientEndpoint.__init__s$.   "3 'rlc [U5nURRURURUUR UR URS9 UR$![a [R"5s$f=f)zJ Implement L{IStreamClientEndpoint.connect} to connect with SSL over TCP. r5) rr connectSSLr,rrr-r.rrrrr7s rir SSL4ClientEndpoint.connects{ !/2B MM $ $  ''  -- % ## # ::<  sA&A))B  B )r.r,rrrr-r;rBrrlrirSrSs OS(< rlrSc(\rSrSrSrSSjrSrSrg)rPiz UnixSocket server endpoint. c@XlX lX0lX@lXPlg)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)rerrrmodewantPIDs rirjUNIXServerEndpoint.__init__s     rlc [R"URRURUUR UR URS9$)zG Implement L{IStreamServerEndpoint.listen} to listen on a UNIX socket. )rr r!)rrr listenUNIXrrrrrs rirUNIXServerEndpoint.listen sA}} MM $ $ MM MMMM   rl)rrrrrN)r!irrrrlrirPrPs  rlrPc(\rSrSrSrSSjrSrSrg)rQiz UnixSocket client endpoint. c4XlX lX0lX@lg)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)rrr- _checkPID)rerrr1checkPIDs rirjUNIXClientEndpoint.__init__ s   !rlc[U5nURRURX RUR S9 UR $![a [R"5s$f=f)zI Implement L{IStreamClientEndpoint.connect} to connect via a UNIX Socket )r1r)) rr connectUNIXrr-r(rrrrr7s rir UNIXClientEndpoint.connect4sd  !/2B MM % % B  & ## # ::<  sAAA43A4)r(rrr-N)r<rrBrrlrirQrQs"(  rlrQc`\rSrSrSr\R r\"\ R5r Sr Sr Srg)rTiCz 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. c6XlX lX0lSUlg)z @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)rfileno addressFamily_used)rerr0r1s rirj$AdoptedStreamServerEndpoint.__init__Ps  * rlcUR(a)[R"[R"55$SUlUR UR 5 URRUR URU5nURUR 5 [R"U5$![a [R"5s$f=f)zc Implement L{IStreamServerEndpoint.listen} to start listening on, and then close, C{self._fileno}. T) r2rrrAlreadyListened_setNonBlockingr0radoptStreamPortr1_closerr)refactoryrs rir"AdoptedStreamServerEndpoint.listen_s ::::e3356 6    -<<// T//D KK $}}T"" ::<  sA'CC"!C")r2r1r0rN)rqrrrroscloser8r]rsetNonBlockingr6rjrrrrlrirTrTCs,XXF"5#7#78O #rlrTc8[U5U4U[U5S.4$)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}. rr)r>)r9rrrs ri _parseTCPr@ss!, Iw yS\!R RRrlc^X4[US5[U5[[U55S.4$)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 rr!)r>bool)r9rr rlockfiles ri _parseUNIXrEs14 T1#g,4H CVW rlc SSKJn UcUn0n Ub[U RU5U S'[ U5R 5n [ U5R 5n U R RU S-U -5n Ub[R"S[[ U5R 55[RS9nUVs/sH'oRRU5RPM) nnU(d[SU<S 35eOSnUb$U RR![ U55nU R""S U R$RU RUUS .U D6n['U5UU4U['U5S .4$s snf) a 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)sslNmethod z=(-----BEGIN CERTIFICATE-----\n.+?\n-----END CERTIFICATE-----))flagszSpecified chain file 'z7' doesn't contain any valid certificates in PEM format.) privateKey certificateextraCertChain dhParametersr?r)twisted.internetrGgetattrSSLr< getContentrEloadPEMrefindallr9DOTALLrBoriginalrDiffieHellmanParametersfromFilerCrKr>)r9rrKcertKey sslmethodrrrMrNrGkwcertPEMkeyPEMprivateCertificatematches chainCertPEMchainCertificatescfs ri _parseSSLrdsh% Bsww 28 w**,G j ! , , .F//77%&8PQ!** L .1<<> ?))  PW OV|OO # #L 1 : :w  !1?B ! !22;; \ "    %0099&//(!    BY $I#g,&W XX- s.F c(\rSrSrSrSrSrSrSrg)_StandardIOParseriz Stream server endpoint string parser for the Standard I/O type. @ivar prefix: See L{IStreamServerEndpointStringParser.prefix}. stdioc[U5$)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 )rUrs ri _parseServer_StandardIOParser._parseServers"'**rlc$URU5$r|rirerrkwargss riparseStreamServer#_StandardIOParser.parseStreamServers  ))rlrN rqrrrrprefixrirorrrlrirfrfs F+*rlrfch\rSrSrSr\R "5rSrSS Sjjr Sr Sr g) _SystemdParseri!z 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. systemdNcUSLUSL:Xa [S5eUb'URR5[U5nO"UceURR 5Un[ [ SU-5n[XU5$)a 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 nameAF_)r _sddaemoninheritedDescriptorsr>inheritedNamedDescriptorsrPrVrT)rerdomainindexrtr0r1s riri_SystemdParser._parseServer0sD TMtt| ,NO O  ^^88:3u:FF# ##^^==?EF7 *7MJJrlc.UR"U/UQ70UD6$r|rlrms riro _SystemdParser.parseStreamServer^s  :4:6::rlr)NN) rr$r{r=r| Optional[str]rtrrrT) rqrrrrr=fromEnvironmentrxrrrirorrrlrirtrt!se))+I F $" ,K,K,K ,K  ,K % ,K\;rlrtc,\rSrSrSrSrSSjrSrSrg) _TCP6ServerParseriez Stream server endpoint string parser for the TCP6ServerEndpoint type. @ivar prefix: See L{IStreamServerEndpointStringParser.prefix}. tcp6cF[U5n[U5n[XX45$)aq 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 )r>rMrs riri_TCP6ServerParser._parseServerqs# 4yg,!'DDrlc.UR"U/UQ70UD6$r|rlrms riro#_TCP6ServerParser.parseStreamServers  :4:6::rlrNr(rqrrlrirres  E(;rlr)tcpunixrGrc#\# [SU5n[SU5n[SU5n[SU5nUnX#-nX"U-X20n[[U55nUHGn U [U5;a[U4v [U 4v UnXynM.X:XaU[ U5- nMCXY- nMI [U4v g7f)aj 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)r7rr8_STRING_OPr) descriptionemptycolonequals backslashcurrentopsnextOpsiterdescns ri _tokenizers( B ,E C -E S+ .F 4IG .Cfnf4GIk*+H  # 7" "q&LG*C ^ tH~ %G LG 7 sB*B,c^^/0smm[SU5nUU4SjnSn[U5H&upEU[LaX54- nMXQ:XdMU"U5 SnM( U"U5 TT4$)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'})}. rcv>[U5S:XaTRUS5 gUST[US5'g)Nr>r)lenrr9)sofarrr\s riadd_parse..adds5 u:? KKa !).qB|E!H% &rlr)r7rr)rrrrtyperrr\s @@ri_parsersm2HD" C -E2 E -  7? X E ^ JE . J 8Orl)rhrQUNIXc[U5up#USn[RU5nUc [[ [ 5U5nXbSSU4$UR 54U"U/USSQ70UD6-$)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) rNr>)r_serverParsersget_matchPluginToPrefixr4r(upper)rr9rr\ endpointTypeparserplugins riririsk"HD7L    -F ~& 8 9< QR"%%    "VG%Ed12h%E"%E EErlcUR5nUH/n[URR5U5U:XdM-Us $ [SUS35e)z Match plugin to prefix. zUnknown endpoint type: 'r)lowerr7rrr)pluginsrrs rirr sT %%'L 6==..0, ?< OM / ~Q? @@rlc[US5up#n[U5[LaUnUR"U/UQ70UD6$UnUSSUSS-n[U"U/UQ70UD6$)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} @raise ValueError: when the 'description' string cannot be parsed. @since: 10.2 Nr>r)rirr=ro_endpointServerFactories)rr nameOrPluginrr\rrts rirKrKsx|*+t<L L$''=$="== 8d12h D #D )' ?D ?B ??rlcJSupX4HnURX1U-5nM U$)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)argumentrrcs riquoteStringArgumentr]s2:I  ##A1}5 Orlcv[U5S:Xa[US5US'USUS'O/[U5S:Xa SU;a[US5US'OUSUS'[US5US'[US5US'USS4US'U$![a N+f=f![a N)f=f![a U$f=f)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}. rr>rrr0r1r2)rr>KeyErrorrrns ri_parseClientTCPrs 4yA~T!Wvav Ta V  a\F6N!!WF6N VF^,v y 12y !' !6 :} M         M s6B ,B> B* BB B'&B'* B87B8c0nUR5HnUR5R5RS5SR 5S:XdMGUR 5n[R"U5nXAUR5'M [UR55$![ a Mf=f![a Mf=f)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 asTextModebasenamesplitrrROSErrorrBrSdigestSSLErrorrGvalues) directoryPathcaCertschildr|theCerts ri_loadCAsFromDirrsG'')!**,2237;AACuL  ##%D 0!))$/G )0GNN$ %* %W^^%5 66       s$B1,C1 B?>B? CCc2Ucg[[U55$)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)rr<)pathNames ri_parseTrustRootPathrs 8H- ..rlcUcg[U5R5nUc[R"U5$[R"[ R"U5[ R"[U5R5S55$)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} Nr>)r<rRrErSfromCertificateAndKeyPairrBrDload)certificatePathkeyPath certBytess ri_privateCertFromPathsrss)446I!)))44!;;    * LL'*557 ;  rlcZURSS5n[URSS5URSS55n[URSS55nUb[[ U5UUS9nO5Ub#UR R nUR nOSnSn[UUUS9nX@S'U$) al 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}. hostnameNrZrK caCertsDir trustRootclientCertificate)rrKrLr)rrrrFr@rKrWrC)rnrrr configurationprivateKeyOpenSSLcertificateOpenSSLs ri_parseClientSSLOptionsrszz*d+H- 9d#VZZ d%C$FJJ|T$BCI+ h /   ( 1 < < E E !2!;!;  $ !% *(* #0  Mrlc.[U0UD6n[U5$)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}. )rrrs ri_parseClientSSLrs2d -f -F !& ))rlc[U5S:XaUSUS'[[URS555US'[US5US'U$![a N f=f![a U$f=f)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}. r>rrrDr)r1)rrCr>rrrs ri_parseClientUNIXr0s 4yA~av !#fjj&<"=>z y 12y M       M s#&AA# A A # A10A1c[U5up#URS5nUR5nU[;a/[ [ [ 5U5nUR"U/UQ70UD6$[U"U0UD6n[U"U40UD6$)a3 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} @since: 10.2 r) rrr_clientParsersrr4r'parseStreamClient_endpointClientFactories)rrrrnanamertrs rirJrJQsP+&LD HHQKE ;;=D >!% C Dd ''A$A&AA D !4 26 2F #D )' \rSrSrU4SjrSrg)'connectProtocol..OneShotFactoryic>T$r|r)rerrs rir5connectProtocol..OneShotFactory.buildProtocolsOrlrN)rqrrrrrrsriOneShotFactoryrs   rlr)r*r )rrrs ` rirYrYs%"   N, --rlc$\rSrSrSrSrSrSrg)_WrapperEndpointiz* An endpoint that wraps another endpoint. cXlX lg)z" Construct a L{_WrapperEndpoint}. N_wrappedEndpoint_wrapperFactoryrewrappedEndpointwrapperFactorys rirj_WrapperEndpoint.__init__!0-rlcvURRURU55RS5$); Connect the given protocol factory and unwrap its result. cUR$r|)rgrs rirL*_WrapperEndpoint.connect..s x'?'?rl)rr rrPrs rir _WrapperEndpoint.connects7$$,,   1 +? @ ArlrNrBrrlrirrs.Arlrc$\rSrSrSrSrSrSrg)_WrapperServerEndpointiz7 A server endpoint that wraps another server endpoint. cXlX lg)z( Construct a L{_WrapperServerEndpoint}. Nrrs rirj_WrapperServerEndpoint.__init__rrlcVURRURU55$)r)rrrrs rir_WrapperServerEndpoint.listens&$$++D,@,@,QRRrlrNrrrlrirrs.SrlrcH^[c [S5e[UU4Sj5$)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>[TSU5$rrH)rconnectionCreators rirLwrapClientTLS.. s 3 t_! rl)rINotImplementedErrorr)rrs` rirZrZs2,"! D     rlc U (a#[S[U R555e[U[5(aUOUR S5n[U[5(dUcUOUR S5n[ U5n [ U5n [[U[U5[XV5S9Ub[X55$[U[U5U U UcSOUS455$)aN 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-8Nrr) TypeErrorrkeysrr=rr>rZrFrrrJrWr?) rr0rr1r2rLrK trustRootsrrnportint timeoutints ri_parseClientTLSr s\@$v{{}BUVVdC((4dkk'.BD k3 ' ';+>     ( $iGWJ  )*53KL # W / "4 #++q1A  rlc,\rSrSrSrSr\S5rSrg)_TLSClientEndpointParseriU z Stream client endpoint string parser for L{wrapClientTLS} with L{HostnameEndpoint}. @ivar prefix: See L{IStreamClientEndpointStringParserWithReactor.prefix}. tlsc [U/UQ70UD6$)aB 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)rrrns rir*_TLSClientEndpointParser.parseStreamClienta s(w8888rlrN) rqrrrrrrr]rrrrlrirrU s F99rlr)r"r!)666r!T)z server.pemNNr"r!NN)rr rr&rr)s30NNNNN)rrr0r rr r1r r2bytes | str | NonerLrrKrrrrrrnr rr&)r __future__rr;rTrVrtypingrrrrrr r r r unicodedatar zope.interfacerr constantlyrr incrementalrrOrrrrrtwisted.internet.abstractrtwisted.internet.addressrrrrtwisted.internet.interfacesrrrr r!r"r#r$r%r&r'r(twisted.internet.protocolr)r*r+r,twisted.internet.stdior-r. ImportErrortwisted.internet._resolverr/twisted.internet.deferr0twisted.internet.taskr1twisted.loggerr2twisted.pluginr3r4twisted.pythonr5r6twisted.python.compatr7r8r9twisted.python.componentsr:twisted.python.failurer;twisted.python.filepathr<twisted.python.systemdr=_idnar?r@ OpenSSL.SSLrArtwisted.internet.sslrBrCrDrErFrGtwisted.protocols.tlsrI_TLSMemoryBIOFactory__all__r\rIStreamServerEndpointrUIProcessTransport IConsumer IPushProducerrrrrXrVr rLrMrNrO AddressFamily SocketKindr>r= _gairesultrarWrRrSrPrQrTr@rErdrfrtrrrangerrrrrrrirrKrrrrrrrrrrJrYrrrZrrrrlrir>s # XXX!8+EE3    XW> 6+-!.)JJ7*,,(/-R/ *N3N3b^/}^/B Z - -.  / 8  *"6"6 8P8P 1  =8_=8@ E  Z - -.@(@(/@(F Z - -." " /" JM+M*M+M* Z - -.3 3 /3 l Z - -.H H /H V    #s(O #sC$ % '       FF FR Z - -.vYvY/vYr  Z - -.' ' /' T Z - -.4 4 /4 n Z - -.   /  F Z - -.% % /% P Z - -.,#,#/,#^S2D  ZYz W78**9*0 W78@;@;9@;F W78";";9";L    Qx W'TF      F8AF@R F$N78 / 2%P*:6   Q=h.0 Z - -.AA/A* Z - -.SS/S&6*L!&*&*%)%)#'I I I I I $ I $ I#I#I!IIIX WBC99D9HJK<s$Q/Q( Q%$Q%(Q43Q4