U
|
Z ±d©È ã @ sD d dl Z d dlZd dlZd dlZd dlmZ d dlZd dlZd dlZd dl Z d dl
|
Z
|
d dl m Z m Z dZdd Zdd Zd d
|
ZG d d d ejZG d d dejZG dd dZdZG dd deZdd Zdd Ze d¡Z e e dddZ e j G d d d Z!d d Z"d d! Z#e d"¡Z$e j G d#d$ d$Z%d%d& Z&d'd( Z'd)d* Z(e j G d+d, d,Z)e j G d-d. d.Z*e j G d/d0 d0Z+d1d2 Z,G d3d4 d4Z-d5Z.d6Z/d7Z0d8Z1d6Z2d9d: Z3d;d< Z4d=d> Z5d?d@ Z6dAdB Z7G dCdD dDZ8dEdF Z9dGdH Z:dIdJ Z;e j G dKdL dLZ<G dMdN dNe
|
j=j>e e dOZ?G dPdQ dQe dOZ@dS )Ré N)Úcount)ÚNoPublicConstructorÚFinali÷ÿ c C s | j tjjkrdS dS d S )Né é0 )ÚfamilyÚtrioÚsocketÚAF_INET©Úsock© r úAd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\trio/_dtls.pyÚpacket_header_overhead s r c C s* | j tjjkrdt| S dt| S d S )Ni@ i )r r r r
|
r r r r r Úworst_case_mtu! s r c C s dt | S )NiÜ )r r r r r Úbest_guess_mtu( s r c @ s e Zd ZdZdZdZdZdZdS )Ú ContentTypeé é é é é N)Ú__name__Ú
|
__module__Ú __qualname__Úchange_cipher_specÚalertÚ handshakeZapplication_dataZ heartbeatr r r r r / s
|
r c @ s` e Zd ZdZdZdZdZdZdZdZ dZ
|
dZ d Z d
|
Z d Zd Zd ZdZdZdZdZdZdZdZdS )Ú HandshakeTyper é é é é é é é é é é é r r r r r é é éþ N)r r r Z hello_requestÚ client_helloZ server_helloÚhello_verify_requestZnew_session_ticketZend_of_early_dataZencrypted_extensionsZ certificateZserver_key_exchangeZcertificate_requestZserver_hello_doneZcertificate_verifyZclient_key_exchangeÚfinishedZcertificate_urlZcertificate_statusZsupplemental_dataZ
|
key_updateZcompressed_certificateZekt_keyZ message_hashr r r r r 7 s* r c @ s$ e Zd ZeddgZeddgZdS )ÚProtocolVersionr, éÿ éý N)r r r ÚbytesÚDTLS10ZDTLS12r r r r r0 O s r0 l ø c @ s e Zd ZdS )Ú BadPacketN)r r r r r r r r5 \ s r5 c C s | dd
dkS )Nr! é s r ©Úpacketr r r Úpart_of_handshake_untrustedf s r9 c C s: z | d t jko | d tjkW S tk
|
r4 Y dS X d S )Nr r& F)r r r r- Ú
|
IndexErrorr7 r r r Úis_client_hello_untrustedm s þr; z!B2sQH)ÚdataÚreturnc C s | ¡ S ©N)Úhex)r< r r r Úto_hex s r@ c @ sF e Zd ZU eed< ejedZe ed< eed< ejedZ
|
e ed< dS )ÚRecordÚ content_type©ÚreprÚversionÚ epoch_seqnoÚpayloadN) r r r ÚintÚ__annotations__ÚattrÚibr@ rE r3 rG r r r r rA s
|
rA c
|
c s¤ d}|t | k r zt | |¡\}}}}W n. tjk
|
rV } ztd|W 5 d }~X Y nX |tj7 }| |||
}t ||krtd||7 }t||||V qd S )Nr zinvalid record headerz short record)ÚlenÚ RECORD_HEADERÚ unpack_fromÚstructÚerrorr5 ÚsizerA )r8 ÚiÚctrE rF Z payload_lenÚexcrG r r r Úrecords_untrusted s
|
rU c C s& t | j| j| jt| j¡}|| j S r> )rM ÚpackrB rE rF rL rG )ÚrecordÚheaderr r r Ú encode_record¢ s ürY z !B3sH3s3sc @ sJ e Zd ZU eed< eed< eed< eed< eed< ejedZe ed< dS ) ÚHandshakeFragmentÚmsg_typeÚmsg_lenÚmsg_seqÚ frag_offsetÚfrag_lenrC ÚfragN)
|
r r r rH rI rJ rK r@ r` r3 r r r r rZ µ s
|
rZ c
|
C s zt | ¡\}}}}}W n. tjk
|
rF } ztd|W 5 d }~X Y nX t |d¡}t |d¡}t |d¡} | t jd
}
|
t|
|
| krtdt ||||| |
|
S )Nz bad handshake message headerÚbigz5handshake fragment length doesn't match record length)
|
ÚHANDSHAKE_MESSAGE_HEADERrN rO rP r5 rH Ú
|
from_bytesrQ rL rZ ) rG r[ Ú msg_len_bytesr] Úfrag_offset_bytesÚfrag_len_bytesrT r\ r^ r_ r` r r r Ú#decode_handshake_fragment_untrusted¿ s2 úû úrg c
|
C s> t | j| j dd¡| j| j dd¡| j dd¡¡}|| j S )Nr! ra ) rb rV r[ r\ Úto_bytesr] r^ r_ r` )ZhsfZ hs_headerr r r Úencode_handshake_fragmentÝ s ûri c
|
C s zÜt t| }|jtjkr"tdt|j}|jt j
|
kr@td|j dkrRtd|j |j krftd|j}|d }d| }|| }|d }|| }|d |
} |||
}
|
||d
} t|
|
|krÌtd|j|
|
| | fW S tjtfk
|
r } ztd | W 5 d } ~ X Y nX d S )
|
Nznot a handshake recordznot a ClientHellor zfragmented ClientHelloé" é# r z short cookiezbad ClientHello)ÚnextrU rB r r r5 rg rG r[ r r- r^ r_ r\ r` rL rF rO rP r: ) r8 rW ÚfragmentÚbodyZsession_id_lenZcookie_len_offsetZ
|
cookie_lenZ cookie_startZ
|
cookie_endZ before_cookieÚcookieZ after_cookierT r r r Ú decode_client_hello_untrustedè s2
|
|
rp c @ sF e Zd ZU ejedZeed< e ed< e
|
ed< ejedZ e ed< dS )ÚHandshakeMessagerC Úrecord_versionr[ r] rn N) r r r rJ rK r@ rr r3 rI r rH rn Ú bytearrayr r r r rq - s
|
rq c @ s> e Zd ZU ejedZeed< e ed< ejedZ
|
eed< dS )ÚPseudoHandshakeMessagerC rr rB rG N) r r r rJ rK r@ rr r3 rI rH rG r r r r rt 7 s
|
rt c @ s e Zd ZU eed< dS )ÚOpaqueHandshakeMessagerW N)r r r rA rI r r r r ru C s
|
ru c C s g }i }t | D ]þ}|jt@ r.| t|¡ q|jtjtjfkrZ| t |j
|
|j|j ¡ q|jtj ksjt t|j }t|j}|j|kr¶t|j
|
||jt|j}| |¡ |||j< n
|
||j }|j|jksÐt |j|jksàt t|j|jksôt |j|j|j|j|j
< q|S r> )rU rF Ú
|
EPOCH_MASKÚappendru rB r r r rt rE rG r ÚAssertionErrorrg r r[ r] rq rs r\ rL rn r` r^ r_ )ZvolleyÚmessagesZmessages_by_seqrW rm r[ Úmsgr r r Údecode_volley_trustedL sF
|
ÿÿ
|
|
|
ü
|
|
þ
|
ÿr{ c @ s$ e Zd Zdd Zdd Zdd ZdS )Ú RecordEncoderc C s t | _d S r> ©r Ú _record_seq©Úselfr r r Ú__init__y s zRecordEncoder.__init__c C s t || _d S r> r} )r Únr r r Úset_first_record_number| s z%RecordEncoder.set_first_record_numberc
|
C s g }t }|D ]Þ}t|trjt|j}|t| t| dkrP| |¡ t }||7 }t||kshtqt|trè|t| t j
|
t|j }|dkr¨| |¡ t }|t |j |jt| jt|j ¡7 }||j 7 }t||ksætqt|j dd¡}d} d}
|
| t|jk s|
|
s|t| t j
|
tj
|
}|dkrL| |¡ t }q|j| | |
} | dd¡} t| dd¡} | t| 7 } |t tj|jt| jtj
|
t| ¡7 }|t |j||j| | ¡7 }|| 7 }|
|
d7 }
|
t||kstqq|r | |¡ |S )Nr r! ra r )rs Ú
|
isinstanceru rY rW rL rw rx rt rM rQ rG rV rB rr rl r~ rn rh rb r r r[ r] )r ry ZmtuÚpacketsr8 ÚmessageÚencodedÚspacerd r^ Z frags_encodedr` re rf r r r Ú encode_volley s|
|
|
|
|
|
|
ü
|
ÿþýÿ
|
|
üû
|
zRecordEncoder.encode_volleyN)r r r r r r r r r r r| x s r| é é Úsha256r# c C s t t ¡ t S r> )rH r Ú current_timeÚCOOKIE_REFRESH_INTERVALr r r r Ú_current_cookie_tick s r c G s8 g }| D ]$}| t dt|¡¡ | |¡ qd |¡S )Nú!Qó )rw rO rV rL Újoin)ÚfieldsÚoutÚfieldr r r Ú _signable s
|
r c C s^ t |tkstt | tks tt|t d|¡tdd |D |}|t | |t ¡ d t
|
S )Nr c s s | ]}t | ¡ V qd S r> )ÚstrÚencode)Ú.0Úpartr r r Ú <genexpr> s z _make_cookie.<locals>.<genexpr>) rL Ú
|
SALT_BYTESrx Ú KEY_BYTESr rO rV ÚhmacÚdigestÚ COOKIE_HASHÚ COOKIE_LENGTH)ÚkeyÚsaltÚtickÚaddressÚclient_hello_bitsZ signable_datar r r Ú _make_cookie s
|
ú r§ c C sh t |tkr`|d t
}t }t| ||||}t| |t|d d||}t ||¡t ||¡B S dS d S )Nr r F)rL r r r§ Úmaxr Úcompare_digest)r¢ ro r¥ r¦ r£ r¤ Z
|
cur_cookieZ
|
old_cookier r r Ú valid_cookie! s ÿ ÿrª c C sx t t¡}t }t| ||||}tjtt|g | }t t
|
j t|ddt||d}t |} t ttjtj|| }
|
|
|
S )Nr )r[ r\ r] r^ r_ r` )ÚosÚurandomr r r§ r0 r4 r3 rL rZ r r. ri rY rA r r ) r¢ r¥ rF r¦ r£ r¤ ro rn ZhsrG r8 r r r Ú challenge_for5 s"
|
úÿr c @ s e Zd Zdd ZdS )Ú_Queuec C s t |¡\| _| _d S r> )r Zopen_memory_channelÚsÚr)r Úincoming_packets_bufferr r r r ^ s z_Queue.__init__N)r r r r r r r r r® ] s r® c C sB g }z | d}W n t jk
|
r* Y q8Y nX | |¡ qd |¡S )Ni @ r )ÚSSLÚ WantReadErrorrw r )Zread_fnÚchunksÚchunkr r r Ú
|
_read_loopb s
|
r¶ c
|
à sz | j d krd S zt|\}}}W n tk
|
r6 Y d S X | jd krNt t¡| _t| j|||sÄt| j|||}z8| j 4 I d H | j
|
||¡I d H W 5 Q I d H R X W n t t jfk
|
rÀ Y nX n²t | || j ¡}|j |¡ z|j |¡ |j ¡ W n tjk
|
r Y d S X |j |¡ | j |¡}|d k rT|j||fkrLd S | ¡ ||f|_|| j|< | j j |¡ d S r> ) Ú_listening_contextrp r5 Ú_listening_keyr« r¬ r rª r Ú
|
_send_lockr ÚsendtoÚOSErrorr ÚClosedResourceErrorÚ DTLSChannelÚ_createÚ_record_encoderr Ú_sslÚ bio_writeZ DTLSv1_listenr² ÚErrorÚ_streamsÚgetÚ _client_helloÚ _set_replacedÚ_incoming_connections_qr¯ Ú send_nowait) Úendpointr¥ r8 rF ro ÚbitsZchallenge_packetÚstreamZ
|
old_streamr r r Ú handle_client_hello_untrustedm sH
|
|
ÿ(
|
|
|
rÌ c
|
à sh zz| t¡I d H \}}W n: tk
|
rV } z |jtjkrDW Y ¢
|
qn W 5 d }~X Y nX | }z|d krrW ¢W d S t|rt|||I d H nl||jkrú|j| }|jrÀt |rÀ|
|
¡ I d H qúz|j j |¡ W qú tjk
|
rö | jd7 _Y qúX n W 5 ~X qW n\ tjk
|
r Y d S tk
|
rb } z$|jtjtjfkrPW Y ¢
|
d S W 5 d }~X Y nX d S )Nr )ÚrecvfromÚMAX_UDP_PACKET_SIZEr» ÚerrnoÚ
|
ECONNRESETr; rÌ rà Ú_did_handshaker9 Ú_resend_final_volleyÚ_qr¯ rÈ r Z
|
WouldBlockÚ_packets_dropped_in_trior¼ ÚEBADFÚENOTSOCK)Z endpoint_refr r8 r¥ rT rÉ rË r r r Údtls_receive_loop¶ s:
|
|
|
|
|
|
r× c @ s e Zd ZU eed< dS )ÚDTLSChannelStatisticsZ incoming_packets_dropped_in_trioN)r r r rH rI r r r r rØ í s
|
rØ c @ s e Zd ZdZdd Zdd Zdd Zdd Zd
|
d Zd d Z dd Z
|
dd Z dd Z ddddZ dd Zdd Zd d Zd d Zd d! Zd"S )#r½ u` A 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.
|
|
c C s || _ || _d| _d | _d| _| tjtjB ¡ t |¡| _
|
d | _ | t | j j¡ d| _d| _t|j| _t ¡ | _t | _d S )Nr F)rÉ Ú peer_addressrÔ rÅ rÑ Z set_optionsr² ZOP_NO_QUERY_MTUÚOP_NO_RENEGOTIATIONÚ
|
ConnectionrÀ Ú_handshake_mtuÚset_ciphertext_mtur r Ú _replacedÚ_closedr® r± rÓ r ÚLockÚ_handshake_lockr| r¿ )r rÉ rÙ Úctxr r r r s
|
zDTLSChannel.__init__c C s d| _ | jj ¡ d S ©NT)rÞ rÓ r¯ Úcloser r r r rÆ s zDTLSChannel._set_replacedc C s | j rt d¡d S )Nz1peer tore down this connection to start a new one)rÞ r ZBrokenResourceErrorr r r r Ú_check_replaced s ÿzDTLSChannel._check_replacedc C s@ | j r
|
dS d| _ | jj | j¡| kr0| jj| j= | jj ¡ dS )uã Close 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É rà rÄ rÙ rÓ r° rä r r r r rä , s zDTLSChannel.closec C s | S r> r r r r r Ú __enter__A s zDTLSChannel.__enter__c G s | ¡ d S r> ©rä ©r Úargsr r r Ú__exit__D s zDTLSChannel.__exit__c à s | ¡ tj ¡ I dH dS )z¨Close this connection, but asynchronously.
|
|
This is included to satisfy the `trio.abc.Channel` contract. It's
|
identical to `close`, but async.
|
|
N)rä r ÚlowlevelÚ
|
checkpointr r r r ÚacloseG s zDTLSChannel.aclosec à sX | j || j¡}|D ]>}| jj4 I d H | jj || j¡I d H W 5 Q I d H R X qd S r> )r¿ r rÜ rÉ r¹ r rº rÙ )r Úvolley_messagesr
r8 r r r Ú _send_volleyQ s ÿzDTLSChannel._send_volleyc à s | | j¡I d H d S r> )rï Ú _final_volleyr r r r rÒ Y s z DTLSChannel._resend_final_volleyg ð?)Úinitial_retransmit_timeoutc s j 4 I dH ò jr,W 5 Q I dH R £ dS |}g d} fdd}z j ¡ W n tjk
|
rj Y nX | st d¡st ¡ ¡I dH j
|
¡ t |¡} jj2 zà3 dH W } j |¡ z j ¡ W n tjtjfk
|
r Y nBX d _| _ j¡I dH W 5 Q R £ W 5 Q I dH R £ dS | }|rÀt|d tr|d jtjkr |¡I dH qÀ||dkr|}d} q¸qÀ6 js°t ¡ W 5 Q R X |jrtd| d}|d 7 }|dkrt jt j
|
j _qW 5 Q I dH R X dS )
|
u Perform 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
|
<https://tlswg.org/dtls13-spec/draft-ietf-tls-dtls13.html#name-timer-values>`__.
|
|
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.
|
|
Nr c sJ t jj} t| }|rBrBt|d trB|d jd jkrBg S |S d S )Nr )r¶ rÀ Úbio_readr{ r rq r] )Z volley_bytesZnew_volley_messages©r rî r r Ú read_volley s ÿþ ýüz-DTLSChannel.do_handshake.<locals>.read_volleyz'something wrong with peer's ClientHelloTr g N@r ) rá rÑ rÀ Ú do_handshaker² r³ r rx rå rï rÉ Ú_ensure_receive_loopr Z move_on_afterrÓ r° rÁ rð r rt rB r r rÞ Zcancelled_caughtÚminrÜ r r )r rñ ÚtimeoutZvolley_failed_sendsrô Zcscoper8 Z maybe_volleyr ró r rõ \ sf
|
|
ÿþ
|
|
|
ÿzDTLSChannel.do_handshakec
|
à s | j r tj|std| js,| ¡ I dH | ¡ | j |¡ | j j
|
4 I dH & | j j t | jj| j¡I dH W 5 Q I dH R X dS )z Send a packet of data, securely.z2openssl doesn't support sending empty DTLS packetsN)rß r r¼ Ú
|
ValueErrorrÑ rõ rå rÀ ÚwriterÉ r¹ r rº r¶ rò rÙ )r r< r r r ÚsendÞ s
|
ÿzDTLSChannel.sendc à sz | j s| ¡ I dH z| jj ¡ I dH }W n( tjk
|
rR | jsFt| ¡ Y nX | j
|
|¡ t | j
|
j }|r|S qdS )a Fetch 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)rÑ rõ rÓ r° Úreceiver Z EndOfChannelrÞ rx rå rÀ rÁ r¶ Úread)r r8 Z cleartextr r r rü î s
|
|
zDTLSChannel.receivec C s || _ | j |¡ dS )uj Tells Trio the `largest amount of data that can be sent in a single packet to
|
this peer <https://en.wikipedia.org/wiki/Maximum_transmission_unit>`__.
|
|
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)rÜ rÀ rÝ )r Znew_mtur r r rÝ s z DTLSChannel.set_ciphertext_mtuc C s | j s tj| j ¡ S )zÈReturns 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.
|
|
)rÑ r ZNeedHandshakeErrorrÀ Úget_cleartext_mtur r r r rþ + s z DTLSChannel.get_cleartext_mtuc C s
|
t | jS )a Returns an object with statistics about this connection.
|
|
Currently 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Ø rÔ r r r r Ú
|
statistics6 s zDTLSChannel.statisticsN)r r r Ú__doc__r rÆ rå rä ræ rê rí rï rÒ rõ rû rü rÝ rþ rÿ r r r r r½ ò s"
|
# r½ )Ú metaclassc @ sf e Zd ZdZddddZdd Zdd Zd
|
d Zd d Zdd Z dd Z
|
e j dddZ dd ZdS )Ú DTLSEndpointaÛ A 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.
|
|
é
|
)r± c C s~ ddl ma d | _|jtjjkr(td|| _|| _tj ¡ | _
|
t ¡ | _ d | _d | _ttd| _t ¡ | _d| _d| _d S )Nr )r² z!DTLS requires a SOCK_DGRAM socketÚinfF)ZOpenSSLr² r Útyper Ú
|
SOCK_DGRAMrù r± rë Zcurrent_trio_tokenÚ_tokenÚweakrefÚWeakValueDictionaryrà r· r¸ r® ÚfloatrÇ rà r¹ rß Ú_receive_loop_spawned)r r r± r r r r ^ s
|
|
zDTLSEndpoint.__init__c C s( | j s$tj tt | ¡| j¡ d| _ d S rã )r r rë Zspawn_system_taskr× r Úrefr r r r r rö x s ÿz!DTLSEndpoint._ensure_receive_loopc C sV | j d krd S | jsRz| j | j¡ W n tk
|
r: Y nX tjd| t| d d S )Nzunclosed DTLS endpoint )Úsource) r rß r Z run_sync_soonrä Ú RuntimeErrorÚwarningsÚwarnÚResourceWarningr r r r Ú__del__ s
|
ÿzDTLSEndpoint.__del__c C s< d| _ | j ¡ t| j ¡ D ] }| ¡ q | jj ¡ dS )z}Close this socket, and all associated DTLS connections.
|
|
This object can also be used as a context manager.
|
|
TN)rß r rä Úlistrà ÚvaluesrÇ r¯ )r rË r r r rä s
|
|
|
zDTLSEndpoint.closec C s | S r> r r r r r ræ s zDTLSEndpoint.__enter__c G s | ¡ d S r> rç rè r r r rê ¡ s zDTLSEndpoint.__exit__c C s | j r tjd S r> )rß r r¼ r r r r Ú _check_closed¤ s zDTLSEndpoint._check_closed)Ú task_statusc
|
sÒ | ¡ | jdk r t d¡z| j ¡ W n tk
|
rF tdY nX | ¡ | dd ¡ zf|| _|
|
¡ fdd}t ¡ 4 I dH *}| j j 2 z3 dH W }| ||¡ q6 W 5 Q I dH R X W 5 d| _X dS )a Listen 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.
|
|
Nz!another task is already listeningz-DTLS socket must be bound before it can servec W s dS rã r )Ú_r r r Ú<lambda>Ñ r z$DTLSEndpoint.serve.<locals>.<lambda>c s( | | f I d H W 5 Q R X d S r> r )rË ©ré Úasync_fnr r Úhandler_wrapperÖ s z+DTLSEndpoint.serve.<locals>.handler_wrapper)r r· r ZBusyResourceErrorr Ú getsocknamer» r rö Zset_cookie_verify_callbackÚstartedZ open_nurseryrÇ r° Z
|
start_soon)r Ú ssl_contextr r ré r ZnurseryrË r r r Úserve¨ s"
|
|
$zDTLSEndpoint.servec C sJ | ¡ t | ||¡}|j ¡ | j |¡}|dk r<| ¡ || j|< |S )u Initiate 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
|
|
N)r r½ r¾ rÀ Zset_connect_staterà rÄ rÆ )r r¥ r ZchannelZ old_channelr r r Úconnectà s
|
|
zDTLSEndpoint.connectN)r r r r r rö r rä ræ rê r r ZTASK_STATUS_IGNOREDr r r r r r r F s
|
ÿ 8r )ArO r r« ÚenumÚ itertoolsr r rÏ r rJ r Z
|
trio._utilr r rÎ r r r ÚIntEnumr r r0 rv Ú Exceptionr5 r9 r; ÚStructrM r3 r r@ ÚfrozenrA rU rY rb rZ rg ri rp rq rt ru r{ r| r r r r r¡ r r r§ rª r r® r¶ rÌ r× rØ ÚabcZChannelr½ r r r r r Ú<module> sz
|
|
|
E ,| ( I7 V
|
