vKg%SSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK J r SSK J r JrJrJrJrJrJrJrJr SSK JrJr SSKrSSKrSSKJrJr \ (a&SSKJr SS KJ q SS K!J"r"J#r#J$r$J%r% SS K&J'r' \$"S 5r(S r)SISjr*SISjr+SISjr,"SS\RZ5r."SS\RZ5r/"SS5r0Sr1"SS\25r3SJSjr4SJSjr5\Rl"S5r7SKSjr8\Rr"SS55r:SLS jr;SMS!jr<\Rl"S"5r=\Rr"S#S$55r>SNS%jr?SOS&jr@SPS'jrA\Rr"S(S)55rB\Rr"S*S+55rC\Rr"S,S-55rD\\B\C\D4rES.\FS/'SQS0jrG"S1S25rHS3rIS4rJS5rKS6rLS4rMSRS7jrNSSS8jrOSTS9jrPSUS:jrQSVS;jrR\"S<5rS"S=S>\\S5rTSWS?jrUSXSAjrVSYSBjrW\Rr"SCSD55rX\"SESF\RR\[\SG95r\\"SHS@55r]g)Z) annotationsN)count) TYPE_CHECKINGAny AwaitableCallableGenericIterableIteratorTypeVarUnion) ReferenceTypeWeakValueDictionary)NoPublicConstructorfinal) TracebackTypeSSL)Self TypeAlias TypeVarTupleUnpack) SocketTypePosArgsTicVUR[RR:Xagg)N0)familytriosocketAF_INETsocks J/var/www/highfloat_scraper/venv/lib/python3.13/site-packages/trio/_dtls.pypacket_header_overheadr&5s {{dkk)))cUR[RR:XaS[ U5- $S[ U5- $)Ni@i)rr r!r"r&r#s r%worst_case_mtur)<s: {{dkk)))+D111,T222r'cS[U5- $)Ni)r&r#s r%best_guess_mtur+Cs (. ..r'c(\rSrSrSrSrSrSrSrSr g) ContentTypeJN) __name__ __module__ __qualname____firstlineno__change_cipher_specalert handshakeapplication_data heartbeat__static_attributes__r4r'r%r-r-Js EIIr'r-ch\rSrSrSrSrSrSrSrSr Sr Sr S r S r S rS rS rSrSrSrSrSrSrSrSrSrg) HandshakeTypeRrr r/r0r1r2r3r4N)r5r6r7r8 hello_request client_hello server_hellohello_verify_requestnew_session_ticketend_of_early_dataencrypted_extensions certificateserver_key_exchangecertificate_requestserver_hello_donecertificate_verifyclient_key_exchangefinishedcertificate_urlcertificate_statussupplemental_data key_updatecompressed_certificateekt_key message_hashr>r4r'r%r@r@RswMLLKHOJGLr'r@c<\rSrSr\"SS/5r\"SS/5rSrg)ProtocolVersionjrNr4N)r5r6r7r8bytesDTLS10DTLS12r>r4r'r%rerejs C: F C: Fr'relc\rSrSrSrg) BadPacketwr4N)r5r6r7r8r>r4r'r%rmrmwsr'rmcUSSS:H$)NrCsr4packets r%part_of_handshake_untrustedrss !A;+ %%r'cUS[R:H=(a US[R:H$![a gf=f)NrrHF)r-r;r@rP IndexErrorrqs r%is_client_hello_untrustedrvsI 1I.. . 9r m888  s25 AAz!B2sQHc"UR5$N)hex)datas r%to_hexr{s 88:r'c~\rSrSr%S\S'\R "\S9rS\S'S\S'\R "\S9r S\S'S r g ) Recordint content_typereprriversion epoch_seqnopayloadr4N) r5r6r7r8__annotations__attrsfieldr{rrr>r4r'r%r}r}s4[[f-GU-[[f-GU-r'r}c#^# SnU[U5:ap[RX5up#pEU[R - nXX-n[U5U:wa [ S5eX- n[X#XG5v U[U5:aMogg![Ran[ S5UeSnAff=f7f)Nrzinvalid record headerz short record)len RECORD_HEADER unpack_fromstructerrorrmsizer})rrictrr payload_lenexcrs r%records_untrustedrs A c&k/ >4A4M4Mf4X 1B ]  Q_- w<; &N+ + R+77 c&k/ || >34# = >s.B-BAB-B-B* B%%B**B-c[RURURUR[ UR 55nXR -$rx)rpackrrrrr)recordheaders r% encode_recordrsF    FNN F NN ""r'z !B3sH3s3scr\rSrSr%S\S'S\S'S\S'S\S'S\S'\R "\S9rS \S 'S r g ) HandshakeFragmentrmsg_typemsg_lenmsg_seq frag_offsetfrag_lenrrifragr4N) r5r6r7r8rrrr{rr>r4r'r%rrs/M L LM++6*D%*r'rc[RU5unnnnn[ R US5n[ R US5n[ R US5n U[RSn [U 5U :wa [ S5e[UUUUU U 5$![Ran[ S5UeSnAff=f)Nzbad handshake message headerbigz5handshake fragment length doesn't match record length) HANDSHAKE_MESSAGE_HEADERrrrrmr from_bytesrrr) rr msg_len_bytesrfrag_offset_bytesfrag_len_bytesrrrrrs r%#decode_handshake_fragment_untrustedrs A % 0 0 9       nn]E2G..!2E:K~~ne4H +002 3D 4yHOPP    <<A67S@AsBC0 B<<Cc [RURURR SS5UR UR R SS5URR SS55nXR-$)NrCr) rrrrto_bytesrrrr)hsf hs_headers r%encode_handshake_fragmentrsk(--  Q&    E* a' I xx r'c[[U55nUR[R:wa [ S5e[ UR5nUR[R:wa [ S5eURS:wa [ S5eURUR:wa [ S5eURnUSnSU-nX5nUS-nXv-nUSUn X7Un X8Sn [U 5U:wa [ S5eUR XU -4$!["R$[&4an [ S 5U eSn A ff=f) Nznot a handshake recordznot a ClientHellorzfragmented ClientHello"#rz short cookiezbad ClientHello)nextrrr-r;rmrrrr@rPrrrrrrrrru) rrrfragmentbodysession_id_lencookie_len_offset cookie_len cookie_start cookie_end before_cookiecookie after_cookiers r%decode_client_hello_untrustedrsT>4'/0   +"7"7 745 56v~~F    : : :/0 0   1 $45 5    0 0 045 5 }}f&7, (1, !. //0 :.K( v;* $N+ +""FL,HII LL* %4)*34sDDE2 D>>Ec~\rSrSr%\R "\S9rS\S'S\S'S\S'\R "\S9r S \S 'S r g ) HandshakeMessageiHrrirecord_versionr@rrr bytearrayrr4N) r5r6r7r8rrr{rrrr>r4r'r%rrHs3!KKV4NE4 Lkkv.D).r'rct\rSrSr%\R "\S9rS\S'S\S'\R "\S9r S\S'Sr g ) PseudoHandshakeMessageiRrrirrrrr4N) r5r6r7r8rrr{rrrr>r4r'r%rrRs.!KKV4NE4[[f-GU-r'rc \rSrSr%S\S'Srg)OpaqueHandshakeMessagei^r}rr4N)r5r6r7r8rr>r4r'r%rr^s Nr'rr_AnyHandshakeMessagec /n0n[U5GHnUR[-(aUR[ U55 M8UR [ R[ R4;a<UR[URUR UR55 MUR [ R:Xde[UR5n[UR5nUR U;aU[#URUUR [%UR&55nURU5 XbUR 'OX$R nURUR:XdeUR UR :Xde[)UR*5UR&:XdeUR,UR*UR.UR.UR0-&GM U$rx)rr EPOCH_MASKappendrrr-r9r:rrrr;rr@rrrrrrrrrr)volleymessagesmessages_by_seqrrrmsgs r%decode_volley_trustedrns,.HO#F+    * OO26: ;  [%C%C[EVEV$W W OO&NN''NN &&+*?*?? ??:6>>JH$X%6%67H6&NN$$h../  $47 0 01%&6&67<<8#4#44 44;;("2"22 22sxx=H$4$44 44  HH$$x';';h>O>O'O I,P Or'c>\rSrSrSSjrSSjrS SjrSrg) RecordEncoderic"[5Ulgrxr _record_seqselfs r%__init__RecordEncoder.__init__s  7r'c$[U5Ulgrxr)rns r%set_first_record_number%RecordEncoder.set_first_record_numbers 8r'c /n[5nUGHn[U[5(ae[UR5nU[ U5- [ U5- S::aUR U5 [5nXF- n[ U5U::deM~[U[5(aU[ U5- [R- [ UR5- nUS::aUR U5 [5nU[RURUR[UR5[ UR55- nXER- n[ U5U::deGM`[ UR 5R#SS5nSn Sn U [ UR 5:d U (aGMU[ U5- [R- [$R- nUS::aUR U5 [5nMvUR XU-n U R#SS5n [ U 5R#SS5n U [ U 5- n U[R[&R(UR[UR5[$R[ U 5-5- nU[$RUR*UUR,U U 5- nXK- nU S- n [ U5U::deU [ UR 5:aGMeU (dGMoGM U(aUR U5 U$)NrrCrr)r isinstancerrrrrrrrrrrrrrrrrr-r;rr)rrmtupacketsrrmessageencodedspacerr frags_encodedrrrs r% encode_volleyRecordEncoder.encode_volleys G'#9::'7V$s7|3q8NN6*&[F!6{c)))G%;<<c&k)M,>,>>W__AUUA:NN6*&[F-,,((**))*(  //)6{c))) #GLL 1 : :1e D  ! "C $55]]f+&',,-3778 zv.!* "<< E6IJD(3(<(r4r'r%rrs1#$I0II  Ir'r sha256rEcL[[R"5[- 5$rx)rr current_timeCOOKIE_REFRESH_INTERVALr4r'r%_current_cookie_tickr-s t  "%<< ==r'c /nUHCnUR[R"S[U555 URU5 ME SR U5$)N!Qr')rrrrjoin)fieldsoutrs r% _signabler3sH C 6;;tSZ01 5 88C=r'c[U5[:Xde[U5[:Xde[U[R "SU5[SU56U5nU[ R"X[5-S[$)Nrc3R# UHn[U5R5v M g7frx)strencode).0parts r% _make_cookie..Js ;74CI$$&&7s%') r SALT_BYTES KEY_BYTESrrrhmacdigest COOKIE_HASH COOKIE_LENGTH)keysalttickaddressclient_hello_bits signable_datas r% _make_cookier ;su t9 "" " s8y    D$ ;7;< M 4;;s;? ?- PPr'c[U5[:ajUS[n[5n[XXRU5n[UU[ US- S5UU5n[ R "X5[ R "UU5-$g)NrrF)rrrr maxrcompare_digest)rrrr rr cur_cookie old_cookies r% valid_cookierQs  6{Zkz"#%!#Tr4r'r%rrsOr'rc/nU"S5nURU5 M![Ra Of=fSRU5$)Ni@r')r WantReadErrorrr)read_fnchunkschunks r% _read_loopr%sV F  ENE  e       88F s  77 DTLSEndpointc# URcg[U5up4nURc[R "[ 5Ul[URXAU5(db[URUUU5nURIShvN URRXa5IShvN SSS5IShvN g[R!XUR5nUR"R%U5 UR&R)U5 UR&R+5 UR&R)U5 UR0R3U5nUb"UR4XE4:XagUR75 XE4UlXpR0U'UR8R:R=U5 g![a gf=fGNQGN1GN$!,IShvN (df  g=f![[R4a gf=f![,R.a gf=f7frx)_listening_contextrrm_listening_keyrrrrr _send_lockr!sendtoOSErrorr ClosedResourceError DTLSChannel_create_record_encoderr_ssl bio_write DTLSv1_listenrError_streamsget _client_hello _set_replaced_incoming_connections_qr send_nowait) endpointrrrrrbitschallenge_packetstream old_streams r%handle_client_hello_untrustedr@s""*$A&$I! T&"$**Y"7 //$ G G(  # #       ***oo,,-=GGG+** $$X8S8ST 66{C  KK ! !& ) KK % % '*  f%&&**73  !''F>9((* &~%+'"((**66v>G +G+***112   $yy   sH?GA H?HG"HG+4G%5G+9 HG(H HH?HH"H?!H""H?%H<9H?;H<<H?cV# UR[5IShvN up#U"5nUcAg[ U5(a[ XSU5IShvN OX5R;apURUnUR(a)[U5(aUR5IShvN O(URRRU5 OAMN![a+nUR[R:XaSnAGMeSnAff=fNNl![Ra U=R S- slNlf=f!Af=f![R"a g[a9nUR[R$[R&4;aSnAgeSnAff=f7f)Nr)recvfromMAX_UDP_PACKET_SIZEr,errno ECONNRESETrvr@r5_did_handshakers_resend_final_volley_qrr:r WouldBlock_packets_dropped_in_trior-EBADFENOTSOCK) endpoint_refr$rrrrr;r>s r%dtls_receive_looprNss4 (, 6I(J"J$~H #0/-V4476RRR 1 11%..w7F,,1LV1T1T%99;;;A"IIKK33F; S"J 99 0 00  S< $A";;q@;A   # #  99enn5 5   sF)ECCCEEEF)EDAE*D+E1%DEEC D'D E D  DEEE)EEEEE  EF&"F)$ F&-.F!F) F!!F&&F)c$\rSrSr%SrS\S'Srg)DTLSChannelStatisticsi?aCurrently this has only one attribute: - ``incoming_packets_dropped_in_trio`` (``int``): Gives a count of the number of incoming packets from this peer that Trio successfully received from the network, but then got dropped because the internal channel buffer was full. If this is non-zero, then you might want to call ``receive`` more often, or use a larger ``incoming_packets_buffer``, or just not worry about it because your UDP-based protocol should be able to handle the occasional lost packet, right? r incoming_packets_dropped_in_trior4N)r5r6r7r8__doc__rr>r4r'r%rPrP?s '*)r'rPc\rSrSrSrSSjrSSjrSSjrSSjrSSjr SSjr SS jr SS jr SS jr S S .SSjjrSSjrSSjrSSjrSSjrS SjrSrg)!r.iOuDA DTLS connection. This class has no public constructor – you get instances by calling `DTLSEndpoint.serve` or `~DTLSEndpoint.connect`. .. attribute:: endpoint The `DTLSEndpoint` that this connection is using. .. attribute:: peer_address The IP/port of the remote peer that this connection is associated with. cXlX lSUlSUlSUlUR [ R[ R-5 [ R"U5Ul SUl UR[URR55 SUlSUl["[$"UR&5Ul[*R,"5Ul[15Ul/Ulg)NrF)r; peer_addressrJr7rF set_optionsrOP_NO_QUERY_MTUOP_NO_RENEGOTIATION Connectionr1_handshake_mtuset_ciphertext_mtur+r! _replaced_closedrrirrHr Lock_handshake_lockrr0 _final_volley)rr;rUctxs r%rDTLSChannel.__init__`s ! (()%!#    #"9"9 9 NN3'  t}}/C/C DE - @ @A#yy{.;o9;r'cZSUlURRR5 gNT)r\rHrclosers r%r8DTLSChannel._set_replaceds  r'cRUR(a[R"S5eg)Nz1peer tore down this connection to start a new one)r\r BrokenResourceErrorrs r%_check_replacedDTLSChannel._check_replaceds$ >>**C  r'c$UR(agSUlURRRUR5ULa!URRUR UR R R5 g)uClose this connection. `DTLSChannel`\s don't actually own any OS-level resources – the socket is owned by the `DTLSEndpoint`, not the individual connections. So you don't really *have* to call this. But it will interrupt any other tasks calling `receive` with a `ClosedResourceError`, and cause future attempts to use this connection to fail. You can also use this object as a synchronous or asynchronous context manager. NT)r]r;r5r6rUrHrrers r%reDTLSChannel.closesd <<  == ! ! % %d&7&7 8D @ &&t'8'89  r'cU$rxr4rs r% __enter__DTLSChannel.__enter__ r'c"UR5$rxrerexc_type exc_value tracebacks r%__exit__DTLSChannel.__exit__ zz|r'c|# UR5 [RR5IShvN gN7f)zClose this connection, but asynchronously. This is included to satisfy the `trio.abc.Channel` contract. It's identical to `close`, but async. N)rer lowlevel checkpointrs r%acloseDTLSChannel.acloses& mm&&(((s 2<:<cx# URRUUR5nUHinURRIShvN URR R X0R5IShvN SSS5IShvN Mk gNPNN !,IShvN (df  M=f7frx)r0rrZr;r*r!r+rU)rvolley_messagesrrrs r% _send_volleyDTLSChannel._send_volleys&&44     F}}///mm**11&:K:KLLL0///L0///sZAB:B B: 3B?BB B:B B:BB:B7 %B(& B7 2B:cV# URUR5IShvN gN7frx)rr`rs r%rG DTLSChannel._resend_final_volleys 2 2333s )')g?)initial_retransmit_timeoutc|^^# TRIShvN TR(aSSS5IShvN gUn/mSnS UU4Sjjn[R"[R 5 TR R5 SSS5 U"5mT(d[R"S5eT(deTR5 TRT5IShvN TRR5 [R"U5nTRR ShvN nTR R#U5 TR R5 STlU"5TlTRTR$5IShvN SSS5 SSS5IShvN gGNGN!,(df  GNB=fNNN:N#![R [R4a Of=fU"5nU(dM['US[(5(a>USR*[,R.:XaTRU5IShvN GM?UmUS:XaUnSn O$ TR0(deTR5 SSS5 O!,(df  O=fWR2(aR[5SU-S5nUS- nUS:Xa8[5TR6[9TRR:55TlGMj!,IShvN (df  g=f7f) uPerform the handshake. Calling this is optional – if you don't, then it will be automatically called the first time you call `send` or `receive`. But calling it explicitly can be useful in case you want to control the retransmit timeout, use a cancel scope to place an overall timeout on the handshake, or catch errors from the handshake specifically. It's safe to call this multiple times, or call it simultaneously from multiple tasks – the first call will perform the handshake, and the rest will be no-ops. Args: initial_retransmit_timeout (float): Since UDP is an unreliable protocol, it's possible that some of the packets we send during the handshake will get lost. To handle this, DTLS uses a timer to automatically retransmit handshake packets that don't receive a response. This lets you set the timeout we use to detect packet loss. Ideally, it should be set to ~1.5 times the round-trip time to your peer, but 1 second is a reasonable default. There's `some useful guidance here `__. This is the *initial* timeout, because if packets keep being lost then Trio will automatically back off to longer values, to avoid overloading the network. Nrc>[TRR5n[U5nU(aYT(aR[ US[ 5(a:[ TS[ 5(a"USR TSR :Xa/$U$)Nr)r%r1bio_readrrrr) volley_bytesnew_volley_messagesrrs r% read_volley-DTLSChannel.do_handshake..read_volleysz)$))*<*<= &;L&I#''"#6q#9;KLL"?1#57GHH+A.66/!:L:T:TTI..r'z'something wrong with peer's ClientHelloTrBgN@r)rlist[_AnyHandshakeMessage])r_rF contextlibsuppressrr!r1 do_handshaker4rirr;_ensure_receive_loopr move_on_afterrHrr2r`rrrr-r:r\cancelled_caughtminrZr)r!) rrtimeoutvolley_failed_sendsrcscoperr maybe_volleyrs ` @r%rDTLSChannel.do_handshakes8'''""(''1G:5G 6I>9J+G 01J+!G "J+'L"/ L<:G;L<L< G  L"I>J+L< $H J+H J+A J+'I* (:J+" L"+ J9 5A-L""L9(L+ ) L95L<cf# UR(a[ReU(d [S5eUR(dUR 5IShvN UR 5 URRU5 URRIShvN URRR[URR5UR5IShvN SSS5IShvN gNNlNN !,IShvN (df  g=f7f)z Send a packet of data, securely.z2openssl doesn't support sending empty DTLS packetsN)r]r r- ValueErrorrFrrir1writer;r*r!r+r%rrU)rrzs r%sendDTLSChannel.sendKs <<** *QR R""##% % %  ==+++--&&--499--.!!  ,++ &, ,+++snAD1DA D1$D%D1(AD9D:D> D1 D D1D1DD1D.D  D.*D1c# UR(dUR5IShvN URRR 5IShvN nURRW5 [URR5nU(aU$MrNwNK![ R a& UR(deUR5 Nf=f7f)aZFetch the next packet of data from this connection's peer, waiting if necessary. This is safe to call from multiple tasks simultaneously, in case you have some reason to do that. And more importantly, it's cancellation-safe, meaning that cancelling a call to `receive` will never cause a packet to be lost or corrupt the underlying connection. N) rFrrHrreceiver EndOfChannelr\rir1r2r%read)rrr cleartexts r%rDTLSChannel.receive\s""##% % % '#wwyy0022 II   '"499>>2I   & 3$$ '~~%~$$& 'sE%C BC 'B#B!B#AC !B##7CC CC cFXlURRU5 g)uTells Trio the `largest amount of data that can be sent in a single packet to this peer `__. Trio doesn't actually enforce this limit – if you pass a huge packet to `send`, then we'll dutifully encrypt it and attempt to send it. But calling this method does have two useful effects: - If called before the handshake is performed, then Trio will automatically fragment handshake messages to fit within the given MTU. It also might fragment them even smaller, if it detects signs of packet loss, so setting this should never be necessary to make a successful connection. But, the packet loss detection only happens after multiple timeouts have expired, so if you have reason to believe that a smaller MTU is required, then you can set this to skip those timeouts and establish the connection more quickly. - It changes the value returned from `get_cleartext_mtu`. So if you have some kind of estimate of the network-level MTU, then you can use this to figure out how much overhead DTLS will need for hashes/padding/etc., and how much space you have left for your application data. The MTU here is measuring the largest UDP *payload* you think can be sent, the amount of encrypted data that can be handed to the operating system in a single call to `send`. It should *not* include IP/UDP headers. Note that OS estimates of the MTU often are link-layer MTUs, so you have to subtract off 28 bytes on IPv4 and 48 bytes on IPv6 to get the ciphertext MTU. By default, Trio assumes an MTU of 1472 bytes on IPv4, and 1452 bytes on IPv6, which correspond to the common Ethernet MTU of 1500 bytes after accounting for IP/UDP overhead. N)rZr1r[)rnew_mtus r%r[DTLSChannel.set_ciphertext_mtuvs@& $$W-r'cxUR(d[ReURR 5$)zReturns the largest number of bytes that you can pass in a single call to `send` while still fitting within the network-level MTU. See `set_ciphertext_mtu` for more details. )rFr NeedHandshakeErrorr1get_cleartext_mturs r%rDTLSChannel.get_cleartext_mtus,"")) )yy**,,r'c,[UR5$)zOReturns a `DTLSChannelStatistics` object with statistics about this connection.)rPrJrs r% statisticsDTLSChannel.statisticss$T%B%BCCr') r7r]rFr`r_rZrJrHr0r\r1r;rUN)r;r&rUrra SSL.Contextrrrrrrtztype[BaseException] | NoneruzBaseException | NonervzTracebackType | Nonerr)rrrr)rfloatrr)rzrirr)rri)rrrrrr)rrP)r5r6r7r8rRrr8rirernrwr}rrGrrrr[rrr>r4r'r%r.r.Os <<< <  <@ *,((   )M4IL@D"!4!.F -Dr'r.) metaclassc\rSrSrSrSS.SSjjrSSjrSSjrSSjrSS jr SS jr SS jr \ RS .SS jjrSSjrSrg)r&iaA DTLS endpoint. A single UDP socket can handle arbitrarily many DTLS connections simultaneously, acting as a client or server as needed. A `DTLSEndpoint` object holds a UDP socket and manages these connections, which are represented as `DTLSChannel` objects. Args: socket: (trio.socket.SocketType): A ``SOCK_DGRAM`` socket. If you want to accept incoming connections in server mode, then you should probably bind the socket to some known port. incoming_packets_buffer (int): Each `DTLSChannel` using this socket has its own buffer that holds incoming packets until you call `~DTLSChannel.receive` to read them. This lets you adjust the size of this buffer. `~DTLSChannel.statistics` lets you check if the buffer has overflowed. .. attribute:: socket incoming_packets_buffer Both constructor arguments are also exposed as attributes, in case you need to access them later. )rcSSKJq SUlUR[R R :wa [S5eSUlXlX l[RR5Ul [5Ul SUlSUl[ [""[%S55Ul[R("5UlSUlSUlg)NrrFz!DTLS requires a SOCK_DGRAM socketTinf)OpenSSLr _initializedtyper r! SOCK_DGRAMrrr{current_trio_token_tokenrr5r(r)rr.rr9r^r*r]_receive_loop_spawned)rr!rs r%rDTLSEndpoint.__init__s #( ;;$++00 0@A A "( '>$mm668 @S?T 6:,0'-k':5<'H$))+ %*"r'cUR(dK[RR[[ R "U5UR5 SUlggrd)rr r{spawn_system_taskrNweakrefrefr!rs r%r!DTLSEndpoint._ensure_receive_loopsD)) MM + +! D!   *.D & *r'c<UR(dgUR(dh[R"[5 UR R UR5 SSS5 [R"SU<3[USS9 gg!,(df  N/=f)Nzunclosed DTLS endpoint r)source stacklevel) rr]rr RuntimeErrorr run_sync_soonrewarningswarnResourceWarningrs r%__del__DTLSEndpoint.__del__sm  ||$$\2 ))$**53 MM)$2   22s &B  BcSUlURR5 [URR 55HnUR5 M UR RR5 g)zmClose this socket, and all associated DTLS connections. This object can also be used as a context manager. TN)r]r!relistr5valuesr9r)rr>s r%reDTLSEndpoint.closesX   4==//12F LLN3 $$&&,,.r'cU$rxr4rs r%rnDTLSEndpoint.__enter__ rpr'c"UR5$rxrrrss r%rwDTLSEndpoint.__exit__ryr'cFUR(a[Regrx)r]r r-rs r% _check_closedDTLSEndpoint._check_closeds <<** * r') task_statusc^^# UR5 URb[R"S5eURR 5 UR5 URS5 XlUR5 SUU4Sjjn[R"5IShvN nURRShvN nURXW5 M![ a [S5Sef=fNPN3 SSS5IShvN O!,IShvN (df  O=fSUlg!SUlf=f7f)a5Listen for incoming connections, and spawn a handler for each using an internal nursery. Similar to `~trio.serve_tcp`, this function never returns until cancelled, or the `DTLSEndpoint` is closed and all handlers have exited. Usage commonly looks like:: async def handler(dtls_channel): ... async with trio.open_nursery() as nursery: await nursery.start(dtls_endpoint.serve, ssl_context, handler) # ... do other things here ... The ``dtls_channel`` passed into the handler function has already performed the "cookie exchange" part of the DTLS handshake, so the peer address is trustworthy. But the actual cryptographic handshake doesn't happen until you start using it, giving you a chance for any last minute configuration, and the option to catch and handle handshake errors. Args: ssl_context (OpenSSL.SSL.Context): The PyOpenSSL context object to use for incoming connections. async_fn: The handler function that will be invoked for each incoming connection. *args: Additional arguments to pass to the handler function. Nz!another task is already listeningz-DTLS socket must be bound before it can servecgrdr4)_s r%$DTLSEndpoint.serve..Ls$r'cl># U T"U/TQ76IShvN SSS5 gN !,(df  g=f7frxr4)r>argsasync_fns r%handler_wrapper+DTLSEndpoint.serve..handler_wrapperQs-"61D111V1Vs 4 #!# 4# 14)r>r.rr)rr(r BusyResourceErrorr! getsocknamer,rrset_cookie_verify_callbackstarted open_nurseryr9r start_soon)r ssl_contextrrrrnurseryr>s ` ` r%serveDTLSEndpoint.servesH   " " .(()LM M  KK # # % !!# ..? +&1 #    ! 2 2((**g$($@$@$B$B@&&&?' ?  "+@$B+*****'+D #dD #s4EC%"E68D8.C?/D82D D DDD%C<<E?D8DD D8DD8D-D  D-)D80E8 EEcUR5 [RXU5nURR 5 UR R U5nUbUR5 X0R U'U$)u7Initiate an outgoing DTLS connection. Notice that this is a synchronous method. That's because it doesn't actually initiate any I/O – it just sets up a `DTLSChannel` object. The actual handshake doesn't occur until you start using the `DTLSChannel`. This gives you a chance to do further configuration first, like setting MTU etc. Args: address: The address to connect to. Usually a (host, port) tuple, like ``("127.0.0.1", 12345)``. ssl_context (OpenSSL.SSL.Context): The PyOpenSSL context object to use for this connection. Returns: DTLSChannel )rr.r/r1set_connect_stater5r6r8)rrrchannel old_channels r%connectDTLSEndpoint.connect[si2 %%d[A &&(mm''0  "  % % '!( gr') r]r9rr(r)rr*r5rrr!N)r!rrrrrrrr) rrrzr4r'r%r&r&s6(* ++"% +  +B ." /,((   +.2-E-E >+ >+O>+ >+ + >+  >+@   !   r')r$rrr)rrrirbool)rzrirr)rrrirzIterator[Record])rr}rri)rrirr)rrrri)rrrirztuple[int, bytes, bytes])rrirrr)rrirri) rrirrirrrrr rirri) rrirrirrr rirr) rrirrrrr rirri)r"zCallable[[int], bytes]rri)r;r&rrrrrirr)rMzReferenceType[DTLSEndpoint]r$rrr)^ __future__rrenumrDrrrrr itertoolsrtypingrrrrr r r r r rrrr _utilrrtypesrrrtyping_extensionsrrrr trio.socketrrrCr&r)r+IntEnumr-r@rer ExceptionrmrsrvStructrr{frozenr}rrrrrrrrrrrrrrrrrrrrrr rrrrr%r@rNrPabcChannelrir.r&r4r'r%rs#    7 -#GG&J'H3/$,,DLL0    &( h' ...8$# "==5+++< B4J///...#(#i- --`PP@     > Q Q Q Q Q  Q  Q,     <* * ** *  *Z T]OWR[O R?R? R? R? R?j8-8 8 8v * * *VD$((""5)5HVDVDr QQQr'