
    F2j                    R   U d Z ddlmZ ddlZddlZddlZddlZddlZddlm	Z	 ddl
Z
ddlmZmZ dZ ej        d          Zd	ed
<    ej        d          Zd	ed<   dZd	ed<   dZd	ed<   dZd	ed<   dZd	ed<   dZd	ed<   dZd	ed<   dZd	ed<   ej        dk    Zd	ed<   ej        dv Zd	ed<    eedd           Zd	ed!<    eed"d          Zd	ed#<    eed$d          Z d	ed%<    e!ed&          r ej"        ej#                  Z$d	ed'<   ndZ$dpd,Z%dpd-Z&dqd3Z'drd5Z(dsd8Z)dtd<Z*	 dudvdAZ+ G dB dCe,          Z- e.dD  eedEd           eedFd           eedGd           eedHd          fD                       Z/d	edI<    e.dJ  eedKd           eedLd          fD                       Z0d	edM<   dNZ1d	edO<   dwdRZ2dxdUZ3dydVZ4 G dW dXej5                  Z6ddej7        dYd=ddZdzdfZ8 G dg dh          Z9 G di dj          Z: G dk dlej;                  Z<	 d{dej7        dd=dmd|doZ=dS )}a(  
High-performance asyncio DatagramTransport with Linux-specific UDP
receive/send coalescing:

  - GRO (receive): ``setsockopt(SOL_UDP, UDP_GRO)`` + ``recvmsg`` cmsg
  - GSO (send):    ``sendmsg`` with ``UDP_SEGMENT`` cmsg

All other platforms fall back to the standard asyncio DatagramTransport.
    )annotationsN)deque   )UDP_LINUX_GROUDP_LINUX_SEGMENT)create_udp_endpointopen_dgram_connectionsync_recv_grosync_sendmsg_gsosync_send_dgram GenericSegmentOffloadUnsupportedDatagramReaderDatagramWriterz=Hztyping.Final_UINT16z@i	_GRO_CMSGi  _DEFAULT_GRO_BUFi   _MAX_GRO_BUFi   _HIGH_WATERMARKi @  _LOW_WATERMARK@   _GSO_MAX_SEGMENTSi  _GSO_MAX_PAYLOAD    _RECV_BURST_LIMITlinux	_IS_LINUX>   iosdarwin
_IS_DARWINSOL_UDP   _SOL_UDP	MSG_TRUNC
_MSG_TRUNC
MSG_CTRUNC_MSG_CTRUNC
CMSG_SPACE_ANCBUFSIZEsocksocket.socketreturnboolc                    t           sdS 	 |                     t          t                    dk    S # t          $ r Y dS w xY w)aa  Return True if UDP_GRO is enabled on *sock* (Linux only).

    The caller is responsible for having previously enabled it via
    ``setsockopt(SOL_UDP, UDP_GRO, 1)``. On non-Linux platforms the
    SOL_UDP option number 104 may collide with an unrelated option;
    we guard explicitly so we never mistakenly enable the GRO code
    path off-Linux.
    F   )r   
getsockoptr"   r   OSErrorr)   s    `/home/thesage/.hermes/hermes-agent/venv/lib/python3.11/site-packages/urllib3/contrib/ssa/_gro.py_sock_has_gror3   U   sQ      ux771<<   uus   #/ 
==c                    t           sdS 	 t          |                     t          t                              S # t
          $ r Y dS w xY w)z<Return True if the kernel supports UDP_SEGMENT (Linux only).F)r   r,   r/   r"   r   r0   r1   s    r2   _sock_has_gsor5   f   sS     uDOOH.?@@AAA   uus   ,8 
AAbufbytessegment_sizeintlist[bytes]c                ~     t                     }dk    s|k    r gS  fdt          d|          D             S )zSplit a GRO-coalesced buffer into individual datagrams.

    For ``bytes`` input, direct slicing is the fastest option in CPython:
    each slice is a single C-level memcpy with no Python-level overhead.
    r   c                *    g | ]}||z            S  r=   ).0ir6   r8   s     r2   
<listcomp>z%_split_gro_buffer.<locals>.<listcomp>y   s(    III!CA$$%III    )lenrange)r6   r8   ns   `` r2   _split_gro_bufferrE   p   sV     	CAqA--uIIIIIuQ</H/HIIIIrA   sizec                h    | dk    rt           S t          | z  }|dk     rdS |t           k     r|nt           S )zBReturn how many segments of *size* bytes fit in a single GSO call.r   r.   )r   r   )rF   caps     r2   _max_segments_forrI   |   s?    qyy  
d
"C
Qwwq)))33/@@rA   	datagramslist[tuple[int, list[bytes]]]c                   | sg S g }| d         }t          |          }|g}t          |          }| dd         D ]}t          |          }||k    r)t          |          |k     r|                    |           @||k     rDt          |          |k     r1|                    |           |                    ||f           g }d}|r|                    ||f           |}|g}t          |          }|r|                    ||f           |S )aH  Group consecutive same-size datagrams for Linux UDP GSO.

    GSO requires every segment in a single ``sendmsg`` to be exactly
    ``segment_size`` bytes, except the very last which may be shorter.
    The kernel further caps a single call at ``_GSO_MAX_SEGMENTS``
    segments and ~64 KiB of payload, whichever is smaller.
    r   r.   N)rB   rI   append)rJ   groupsfirstcurrent_sizecurrent_grouprH   dgramrF   s           r2   _group_by_segment_sizerS      sH     	,.FaLEu::L"'M
L
)
)C122 2 25zz<C$6$6$<$<  ''''L  S%7%7#%=%=   '''MM<7888MLL =|];<<<L"GM#L11CC 5|]3444MrA   ancdatalist[tuple[int, int, bytes]]
int | Nonec                h   | D ]\  }}}|t           k    r|t          k    rt          |          }|t          j        k    r0t          t                              |d          d                   c S |t          j        k    r0t          t                              |d          d                   c S  dS dS )zExtract the GRO segment size from recvmsg ancillary data.

    Returns ``None`` if no UDP_GRO cmsg is present (single datagram).
    r   N)r"   r   rB   r   rF   r9   unpack_fromr   )rT   
cmsg_level	cmsg_type	cmsg_datarD   s        r2   _parse_gro_segment_sizer\      s    
 -4  (
Iy!!i=&@&@IAIN""900A>>qABBBBBGL  7..y!<<Q?@@@@@114rA      bufsizegro_segment_sizebytes | list[bytes]c                    |                      |t                    \  }}}}|t          z  rt          d| d          |sdS |t          z  r|S t          |          }||S |dk    r|n|}t          |          |k    r|S t          ||          S )a/  Blocking ``recvmsg`` with GRO cmsg parsing.

    Returns the raw datagram (``bytes``) when no GRO coalescing took
    place, or a list of segments (``list[bytes]``) when the kernel
    delivered a coalesced buffer.

    Raises ``OSError`` on payload truncation so callers can grow their
    buffer.
    z#recvmsg payload truncated; bufsize=z' too small for the coalesced GRO bufferrA   Nr   )recvmsgr(   r$   r0   r&   r\   rB   rE   )	r)   r^   r_   datarT   flags_addrparsedr8   s	            r2   r
   r
      s     #',,w"D"DD'5%z 
(' ( ( (
 
 	
  s{  $W--F~#aZZ66-=L
4yyL  T<000rA   c                      e Zd ZdZdS )r   ah  Raised when a UDP GSO send is rejected by the kernel/driver
    because the NIC does not actually support segmentation offload,
    even though Kernel support it.

    Callers should disable GSO on the affected socket for the rest of
    the connection and re-send the failing batch without GSO. This
    mirrors the fallback strategy used by ``quic-go``.
    N)__name__
__module____qualname____doc__r=   rA   r2   r   r      s           rA   r   c              #     K   | ]}||V  	d S Nr=   r>   es     r2   	<genexpr>rp      s4       	2 	2	 	}  }}}	2 	2rA   EIOENOTSUP
EOPNOTSUPPENOPROTOOPT_GSO_UNSUPPORTED_ERRNOSc              #     K   | ]}||V  	d S rm   r=   rn   s     r2   rp   rp     s4       . .	 	} 
 }}}. .rA   EMSGSIZEWSAEMSGSIZE_MSG_TOO_BIG_ERRNOSi8'  _WSAEMSGSIZE_WINERRORexcr0   c                V    | j         t          v rdS t          | dd          t          k    S )z@Return True when *exc* means the datagram exceeded the path MTU.TwinerrorN)errnory   getattrrz   )r{   s    r2   _is_msg_too_bigr     s-    
y'''t3
D))-BBBrA   rc   Nonec                    	 |                      |           dS # t          $ r}t          |          s Y d}~dS d}~ww xY w)a  Send a single datagram, dropping it if it is oversized.

    A datagram the kernel rejects with ``EMSGSIZE`` is silently dropped:
    it is an over-large qh3 DPLPMTUD probe that is meant to fail, not a
    fatal connection error (see issue #377). Any other error propagates.

    ``send`` (not ``sendall``) is used deliberately: a UDP datagram is
    sent atomically, so the stream-oriented retry loop of ``sendall``
    would be meaningless here (and would re-send a leftover tail as a
    corrupt second datagram if it ever triggered).
    N)sendr0   r   )r)   rc   r{   s      r2   r   r     sj    		$   s## 		 	 	 	 	 	s    
>9>c           	     J   t          |          D ]\  }}t          |          dk    rE	 |                     |d                    n'# t          $ r}t	          |          s Y d}~nd}~ww xY w^	 |                     |t          t          t          	                    |          fg           # t          $ rj}|j
        t          v rt                      ||D ]?}	 |                     |           # t          $ r}t	          |          s Y d}~8d}~ww xY wY d}~d}~ww xY wdS )a  Batch-send datagrams using GSO. Falls back to individual sends.

    Raises :class:`GenericSegmentOffloadUnsupported` if the kernel/driver
    rejects the GSO send because the underlying NIC does not actually
    support UDP segmentation offload (e.g. ``EIO`` from ``sendmsg``).
    The current group is not sent in that case; callers are expected to
    disable GSO for the connection and re-send the batch without GSO.
    Duplicate delivery of any earlier group is harmless for QUIC
    (the receiver de-duplicates by packet number).
    r.   r   N)rS   rB   r   r0   r   sendmsgr"   r   r   packr~   ru   r   )r)   rJ   r8   groupr{   rR   inners          r2   r   r   +  s     6i@@  eu::??		%(####   &s++      	 LL-w||L/I/IJK     	 	 	y333688cA   IIe$$$$   *511         	# sY   A
A*A%%A*/<B,,
D 6!DC.-D.
D	8D	DD	DD c                       e Zd ZdZd7 fdZd8d9dZd:dZd;dZd<dZd=dZ	d>dZ
d>dZd?d!Zd>d"Zd>d#Zd>d$Zd>d%Zd@d)Zd8d@d*ZdAd-ZdAd.Zd@d/Zd>d0Zd>d1Zd>d2Zd>d3Zd>d4Zd>d5Zd>d6Z xZS )B!_NativeOptimizedDatagramTransport)_loop_sock_sock_fd	_protocol_address
_connected_gro_enabled_gso_enabled_gro_segment_size_recv_buf_size_closing_closed_closed_fut_extra_paused_write_ready_send_queue_buffer_size_protocol_paused_writer_registered_reader_registered_protocol_supports_batchloopasyncio.AbstractEventLoopr)   r*   protocolasyncio.DatagramProtocoladdresstuple[str, int] | Nonegro_enabledr,   gso_enabledr_   r9   r+   r   c                   t                                                       || _        || _        |                                | _        || _        || _        	 |                                 d| _	        n# t          $ r
 d| _	        Y nw xY w|| _        || _        || _        d| _        d| _        |                                | _        d| _        d| _        d| _        d| _        t-                      | _        d| _        d| _        |rt4          nt7          |d          | _        t;          |d          | _        	 |                                }n# t          $ r d }Y nw xY w||||j         |j!        d| _"        d S )NTFr   i  datagrams_received)peernamesocketsocknamefamilytype)#super__init__r   r   filenor   r   r   getpeernamer   r0   r   r   r   r   r   create_futurer   r   r   r   r   r   r   r   r   r   maxr   hasattrr   getsocknamer   r   r   )
selfr   r)   r   r   r   r   r_   r   	__class__s
            r2   r   z*_NativeOptimizedDatagramTransport.__init__z  s    	

!	$"DOO 	$ 	$ 	$#DOOO	$ ('!1151C1C1E1E "'"' IN %
 !,L5Et1L1L 	 )0:N(O(O%	''))HH 	 	 	HHH	   kI
 
s$   A4 4BB8E EENnamestrdefault
typing.Anyc                8    | j                             ||          S rm   )r   getr   r   r   s      r2   get_extra_infoz0_NativeOptimizedDatagramTransport.get_extra_info  s    {tW---rA   c                    | j         S rm   )r   r   s    r2   
is_closingz,_NativeOptimizedDatagramTransport.is_closing  s
    }rA   asyncio.BaseProtocolc                    | j         S rm   )r   r   s    r2   get_protocolz._NativeOptimizedDatagramTransport.get_protocol  s
    ~rA   c                >    || _         t          |d          | _        d S )Nr   )r   r   r   )r   r   s     r2   set_protocolz._NativeOptimizedDatagramTransport.set_protocol  s"    !(/:N(O(O%%%rA   c                    | j         S rm   )r   r   s    r2   get_write_buffer_sizez7_NativeOptimizedDatagramTransport.get_write_buffer_size  s      rA   c                    | j         rd S d| _         |                                  | j        s"| j                            | j        d            d S d S NT)r   _unregister_readerr   r   	call_soon_call_connection_lostr   s    r2   closez'_NativeOptimizedDatagramTransport.close  sc    = 	F!!! 	CJ  !;TBBBBB	C 	CrA   c                    | j         rd S d| _         | j                                         d| _        | j                            | j        d            d S )NTr   )r   r   clearr   r   r   r   r   s    r2   abortz'_NativeOptimizedDatagramTransport.abort  sX    = 	F 	   
T7>>>>>rA   r{   Exception | Nonec                x   | j         rd S d| _         |                                  |                                  	 | j                            |           n!# t
          t          f$ r  t          $ r Y nw xY w	 | j        	                                 n# t          $ r Y nw xY w| j                                        s| j                            d            d S d S # 	 | j        	                                 n# t          $ r Y nw xY w| j                                        s| j                            d            w w xY wr   )r   r   _unregister_writerr   connection_lostKeyboardInterrupt
SystemExitBaseExceptionr   r   r0   r   done
set_resultr   r{   s     r2   r   z7_NativeOptimizedDatagramTransport._call_connection_lost  s   < 	F!!!!!!	2N**3////!:. 	 	 	 	 	 	D	
  """"   #((** 2 ++D111112 2	
  """"   #((** 2 ++D11112s_   A C A30C 2A33C 7B 
BBD9C43D94
D>D9 D8D9c                    | j         s| j        rd S 	 | j                            | j        | j                   d| _         d S # t          t          f$ r Y d S w xY wr   )r   r   r   
add_readerr   _on_readabler0   
ValueErrorr   s    r2   _register_readerz2_NativeOptimizedDatagramTransport._register_reader  sr    " 	dl 	F	J!!$-1BCCC&*D###$ 	 	 	DD	   ,A   AAc                    | j         sd S d| _         	 | j                            | j                   d S # t          t
          f$ r Y d S w xY wNF)r   r   remove_readerr   r0   r   r   s    r2   r   z4_NativeOptimizedDatagramTransport._unregister_reader  d    & 	F"'	J$$T]33333$ 	 	 	DD	   3 AAc                    | j         s| j        rd S 	 | j                            | j        | j                   d| _         d S # t          t          f$ r Y d S w xY wr   )r   r   r   
add_writerr   _on_write_readyr0   r   r   s    r2   _register_writerz2_NativeOptimizedDatagramTransport._register_writer  sr    " 	dl 	F	J!!$-1EFFF&*D###$ 	 	 	DD	r   c                    | j         sd S d| _         	 | j                            | j                   d S # t          t
          f$ r Y d S w xY wr   )r   r   remove_writerr   r0   r   r   s    r2   r   z4_NativeOptimizedDatagramTransport._unregister_writer  r   r   rc   r7   addrc                    | j         r| j                            |           dS ||n| j        }|| j                            |           dS | j                            ||           dS )zIssue a single send/sendto on the underlying socket.

        Picks the right syscall based on whether the socket is
        ``connect()``-ed: a connected UDP socket rejects ``sendto`` with
        ``EISCONN`` on Linux and macOS.
        N)r   r   r   r   sendto)r   rc   r   targets       r2   	_raw_sendz+_NativeOptimizedDatagramTransport._raw_send  su     ? 	0JOOD!!!!!!-TT4=F~
%%%%%
!!$/////rA   c                   | j         rt          d          ||n| j        }| j        r| j        r|                     ||           d S 	 |                     ||           d S # t          $ r Y nt          $ rj 	 |                     ||           Y d S # t          $ r Y nAt          $ r5}t          |          s| j
                            |           Y d }~Y d S d }~ww xY wY n@t          $ r4}t          |          s| j
                            |           Y d }~d S d }~ww xY wd| _        |                                  |                     ||           d S )NTransport is closingF)r   r0   r   r   r   _queue_writer   BlockingIOErrorInterruptedErrorr   r   error_receivedr   )r   rc   r   r   r{   s        r2   r   z(_NativeOptimizedDatagramTransport.sendto&  s   = 	20111)t}   	D$4 	dF+++F	NN4(((F 	 	 	D 
	 
	 
	tV,,,"      &s++ 7N11#666 
  	 	 	"3'' 3--c222FFFFF	 "$'''''sT   	A! !
D-	D7B
CD	C%)CDCD	D()DDrJ   r:   c                0   | j         rt          d          |sdS | j        r| j        r$| j        }|D ]}|                     ||           dS | j        r|                     |           dS |D ](}|                     |           | j         s| j	        r dS )dS )a)  Send multiple datagrams, using GSO when available.

        Falls back to individual ``sendto`` calls when GSO is not
        supported or the socket write buffer is full. Guarantees that
        *every* input datagram is either transmitted or queued -- none
        are silently dropped.
        r   N)
r   r0   r   r   r   r   r   _send_linux_gsor   r   )r   rJ   r   rR   s       r2   sendto_manyz-_NativeOptimizedDatagramTransport.sendto_manyL  s     = 	20111 	F   	D$4 	]F" 1 1!!%0000F 	  +++++"  E"""= DL FF rA   c           
        t          |          }| j        }| j        }t          |          D ]\  }\  }}	 t	          |          dk    r|                     |d         |           n<|                    |t          t          t          
                    |          fg           w# t          $ rK d| _        |                                  ||d         D ] \  }}	|	D ]}
|                     |
|           !Y  dS t          $ rK ||d         D ] \  }}	|	D ]}
|                     |
|           !d| _        |                                  Y  dS t           $ r}t	          |          dk    r?|j        t$          v rd| _        |D ]%}
	 |                     |
|           # t          $ r d| _        |                                  |                     |
|           |                    |
          dz   }||d         D ]}|                     ||           ||dz   d         D ] \  }}	|	D ]}|                     ||           !Y  Y d}~ dS t           $ rS}t+          |          rY d}~| j                            |           | j        s| j        rY d}~ Y d}~ dS Y d}~d}~ww xY wnDt+          |          rY d}~| j                            |           | j        s| j        rY d}~ dS Y d}~d}~ww xY wdS )a.  Send a list of datagrams using UDP_SEGMENT.

        On EAGAIN at any point, *all* not-yet-sent datagrams (including
        the failing group's contents) are pushed into the write queue
        in order, the writer is armed, and the function returns. Nothing
        is ever silently dropped.
        r.   r   FN)rS   r   r   	enumeraterB   r   r   r"   r   r   r   r   r   r   r   r   r0   r~   ru   r   indexr   r   r   r   r   )r   rJ   rN   r   r)   r?   r8   r   _szgrR   r{   idxtaildr   s                   r2   r   z1_NativeOptimizedDatagramTransport._send_linux_gsoj  s    (	22}z(1&(9(9 J	 J	$A$eIu::??NN58T2222 LL !) 1 '\ : :	 	 	 #   $)!%%''' %QRRj 7 7FC!" 7 7))%66667#    %QRRj 7 7FC!" 7 7))%66667$)!%%''' ' ' ' u::>> y$;;;,1)!& ' '' NN5$7777. # # #05D- 11333 --eT:::"'++e"4"4q"8C(-cdd > > $ 1 1$ = = = =*0Q/ ? ?Q)* !? !?A$($5$5a$>$>$>$>!?"FFFFFFFF& ' ' '  /u55 ) ( N99%@@@#} ' ' &' ' ' ' '''2 's++ ! N11#666}  O'GJ	 J	su   A,B$$AK78AK7
K7.K2FK2B$J$	?K2	J$	J	 K2%(J	K2K2J$	$K2=(K22K7c                4   | j                             ||f           | xj        t          |          z  c_        | j        t          k    rL| j        sGd| _        	 | j                                         d S # t          t          f$ r  t          $ r Y d S w xY wd S d S r   )r   rM   r   rB   r   r   r   pause_writingr   r   r   r   rc   r   s      r2   r   z._NativeOptimizedDatagramTransport._queue_write  s    t---SYY&//8M/$(D!,,.....%z2        0///s   A4 4BBc                    | j         rU| j        t          k    rGd| _         	 | j                                         d S # t
          t          f$ r  t          $ r Y d S w xY wd S d S r   )r   r   r   r   resume_writingr   r   r   r   s    r2   _maybe_resume_protocolz8_NativeOptimizedDatagramTransport._maybe_resume_protocol  s      	T%6.%H%H$)D!--/////%z2       	 	%H%Hs   ; AAc                0   | j         }| j        }|r3|d         \  }}	  |||           n# t          $ r Y dS t          $ r Y 4t          $ r}|                                 | xj        t          |          z  c_        |                                  t          |          s=	 | j
                            |           n!# t          t          f$ r  t          $ r Y nw xY w| j        s| j        rY d}~nUY d}~d}~ww xY w|                                 | xj        t          |          z  c_        |                                  |3|sKd| _        |                                  | j        r+| j        s&| j                            | j        d           dS dS dS dS )z9Drain the write backlog when the socket becomes writable.r   NT)r   r   r   r   r0   popleftr   rB   r  r   r   r   r   r   r   r   r   r   r   r   r   r   )r   queueraw_sendrc   r   r{   s         r2   r   z1_NativeOptimizedDatagramTransport._on_write_ready  s"    > 	*qJD$t$$$$"   #       !!SYY.!!++--- 's++ 55c::::-z:   (   = DL EEEE%( MMOOOT*'')))?  	*F  	G $D##%%%} GT\ G
$$T%?FFFFF	G 	GG G G GsE   + 
C:	C:	C:AC5!B<;C5<CC5CC55C:c                N    | j         sd| _         |                                  d S d S r   )r   r   r   s    r2   pause_readingz/_NativeOptimizedDatagramTransport.pause_reading  s5    | 	&DL##%%%%%	& 	&rA   c                N    | j         rd| _         |                                  d S d S r   )r   r   r   s    r2   resume_readingz0_NativeOptimizedDatagramTransport.resume_reading  s5    < 	$ DL!!#####	$ 	$rA   c                x    | j                             | j        j        |            |                                  d S rm   )r   r   r   connection_mader   r   s    r2   _startz(_NativeOptimizedDatagramTransport._start  s7    
T^;TBBBrA   c                @    | j         rd S |                                  d S rm   )r   _recv_linux_gror   s    r2   r   z._NativeOptimizedDatagramTransport._on_readable  s)    = 	FrA   c                D   | j         j        }| j        }|j        }| j        r|j        nd }| j        }t          }t          t                    D ]}	  || j
        |          \  }}	}
}ni# t          $ r Y  d S t          $ r Y 4t          $ rD}	 |                    |           n!# t          t           f$ r  t"          $ r Y nw xY wY d }~ d S d }~ww xY w|s d S |
t$          z  rz| j
        }	 |                    t          d| d                     n!# t          t           f$ r  t"          $ r Y nw xY w|t&          k     rt)          |dz  t&                    | _
        |
t*          z  r |||           %t-          |	          }| |||           D|dk    r|n|}t/          |          |k    r |||           ot1          ||          }| |||           |D ]} |||           | j        s(| j        r#| j                            | j                   d S d S d S )Nz(recvmsg payload truncated; recv buffer (z+) is too small for the coalesced GRO buffer   r   )r   rb   r   datagram_receivedr   r   r   r(   rC   r   r   r   r   r0   r   r   r   r   r$   r   minr&   r\   rB   rE   r   r   r   r   r   )r   sock_recvmsgr   r  batch_cbdefault_segment_size
ancbufsize_rc   rT   rd   r   r{   r^   rf   r8   segmentssegs                     r2   r  z1_NativeOptimizedDatagramTransport._recv_linux_gro  s7   z)>$6 ,H'' 	
  $5 
()) A	1 A	1A-9\'. .*gudd #   #      ++C0000):6   $   D  
 z! -++* '* * *     *:6   $   D \))*-gk<*H*HD'{"  "!$---,W55F~!!$---%+aZZ665IL4yyL((!!$---(|<<H#4((((# 1 1C%%c400001 } 	4!8 	4J  !233333	4 	4 	4 	4sT   A((
C6	C	CB! C	!B?<C	>B??C		C(&DD-,D-)r   r   r)   r*   r   r   r   r   r   r,   r   r,   r_   r9   r+   r   rm   r   r   r   r   r+   r   r+   r,   )r+   r   )r   r   r+   r   )r+   r9   r+   r   )r{   r   r+   r   )rc   r7   r   r   r+   r   rJ   r:   r+   r   )rh   ri   rj   	__slots__r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r   r  r  r  r   r  __classcell__)r   s   @r2   r   r   `  sJ       I2>
 >
 >
 >
 >
 >
@. . . . .      P P P P! ! ! !C C C C? ? ? ?2 2 2 2(            0 0 0 0"$( $( $( $( $(L   <V V V Vp
 
 
 
   -G -G -G -G^& & & &
$ $ $ $
          
R4 R4 R4 R4 R4 R4 R4 R4rA   r   F)
local_addrremote_addrr   
reuse_portr_   r)   r   r   protocol_factory-typing.Callable[[], asyncio.DatagramProtocol]r*  r   r+  r   r,  socket.socket | None:tuple[asyncio.DatagramTransport, asyncio.DatagramProtocol]c          	     ,  K   |*	 |                                 }nP# t          $ r d }Y nAw xY w|t          j        k    rU|p|}	|	rC|                     |	d         |	d         t          j                   d {V }
|
d         d         }nt          j        }t          j        |t          j                  }	 |                    d           |rD	 |                    t          j	        t          j
        d           n# t          t          f$ r Y nw xY w|r|                    |           d }|r|                     ||           d {V  |}n## t          $ r |                                  w xY wt!          |          }t#          |          }t$          s$t&          s|                     ||           d {V S t$          r	 ddlm} n# t.          $ r
 t0          }Y nw xY wt0          } |            } || ||||||          }|                                 ||fS )Nr   r.   )r   Fr1   )OptimizedDatagramTransport)r   r)   r   r   r   r   r_   )r   r0   r   	AF_UNSPECgetaddrinfo
SOCK_DGRAMAF_INETsetblocking
setsockopt
SOL_SOCKETSO_REUSEPORTAttributeErrorbindsock_connectr   r   r3   r5   r   r   create_datagram_endpointqh3.asyncio._transportr2  ImportErrorr   r  )r   r-  r*  r+  r   r,  r_   r)   connected_addrtarget_addrinfosr   r   _TransportImplr   	transports                   r2   r   r   o  s      	"!--//NN 	" 	" 	"!NNN	" V%%%$3K ("..NKN9J /         q! }VV%677	U### OOF$5v7JANNNN&0   D &		*%%%!N -''k:::::::::!, 	 	 	JJLLL	  %%K%%K  PZ P 223C$2OOOOOOOOO  ;	?        	? 	? 	?>NNN	? ;!!H)  I hsN    ,,4E	 +C8 7E	 8D	E	 D<E	 	 E)=G GGc                  X    e Zd ZdZdZddZdd
ZddZddZddZ	d dZ
d!dZd"d#dZdS )$r   a  API-compatible with ``asyncio.StreamReader`` (duck-typed) so that
    ``AsyncSocket`` can assign an instance to ``self._reader`` and the
    existing ``recv()`` code works unchanged.

    When GRO delivers multiple coalesced segments in a single syscall,
    ``feed_datagrams()`` stores them as a single ``list[bytes]`` entry.
    ``read()`` then returns that list directly so the caller can feed
    all segments to the QUIC state-machine in one pass before probing --
    avoiding the per-datagram recv->feed->probe round-trip overhead.
    )_buffer_waiter
_exception_eofr+   r   c                V    t                      | _        d | _        d | _        d| _        d S r   )r   rG  rH  rI  rJ  r   s    r2   r   zDatagramReader.__init__  s&    38774804			rA   rc   r7   r   r   c                    | j         rdS | j                            |           | j        }|+|                                s|                    d           dS dS dS )z'Feed a single (non-coalesced) datagram.NrJ  rG  rM   rH  r   r   r   rc   r   waiters       r2   feed_datagramzDatagramReader.feed_datagram  si    9 	FD!!!fkkmmd##### rA   r:   c                    | j         s|sdS | j                            |           | j        }|+|                                s|                    d           dS dS dS )z6Feed a batch of coalesced datagrams as a single entry.NrM  rN  s       r2   feed_datagramszDatagramReader.feed_datagrams  sp    9 	D 	FD!!!fkkmmd##### rA   r{   r   c                    || _         | j        }|+|                                s|                    d            d S d S d S rm   )rI  rH  r   r   r   r{   rO  s      r2   set_exceptionzDatagramReader.set_exception  sK    fkkmmd##### rA   BaseException | Nonec                    d| _         || j        || _        | j        }|+|                                s|                    d            d S d S d S r   )rJ  rI  rH  r   r   rT  s      r2   r   zDatagramReader.connection_lost  s^    	?t6!DOfkkmmd##### rA   r,   c                     | j         o| j         S rm   )rJ  rG  r   s    r2   at_eofzDatagramReader.at_eof  s    y---rA   r`   c                   g }| j         D ]B}t          |t                    r|                    |           -|                    |           C| j                                          t          |          dk    r|d         S |S )Nr.   r   )rG  
isinstancer7   rM   extendr   rB   )r   rJ   entrys      r2   
_drain_bufzDatagramReader._drain_buf  s    !#	\ 	( 	(E %'' (  ''''  '''' y>>QQ<rA   rD   r9   c                  K   | j         r|                                 S | j        | j        dc}| _        || j        rdS | j        t          d          t          j                                                    }|| _        	 | d{V  d| _        n# d| _        w xY w| j         r|                                 S | j        | j        dc}| _        |dS )a  Return the next entry from the buffer.

        * ``bytes``       -- a single datagram (non-coalesced).
        * ``list[bytes]`` -- a batch of coalesced datagrams from one
          GRO syscall.
        * ``b""``         -- EOF.

        Buffered data is delivered first, *before* any pending exception
        is raised, so callers can drain the stream cleanly on shutdown.
        NrA   z=DatagramReader.read() called concurrently from two coroutines)	rG  r^  rI  rJ  rH  RuntimeErrorasyncioget_running_loopr   )r   rD   r{   rO  s       r2   readzDatagramReader.read  s       < 	%??$$$?&#'?D CI9 	3<#O   )++99;;	 LLLLLLLDLL4DL< 	%??$$$?&#'?D CIss   B 	BNr&  )rc   r7   r   r   r+   r   )rc   r:   r   r   r+   r   )r{   r   r+   r   r{   rV  r+   r   r%  )r+   r`   )r_  )rD   r9   r+   r`   )rh   ri   rj   rk   r(  r   rP  rR  rU  r   rY  r^  rd  r=   rA   r2   r   r     s        	 	 =I   $ $ $ $$ $ $ $$ $ $ $$ $ $ $. . . .    ( ( ( ( ( ( (rA   r   c                      e Zd ZdZdZddZedd            ZddZddZ	d dZ
d dZd!dZd dZd"d#dZd dZd dZdS )$r   zAPI-compatible with ``asyncio.StreamWriter`` (duck-typed) so that
    ``AsyncSocket`` can assign an instance to ``self._writer`` and the
    existing ``sendall()``, ``close()``, ``wait_for_close()`` code works
    unchanged.
    )
_transportr   _closed_eventr   _drain_waiters_supports_batchrE  asyncio.DatagramTransportr+   r   c                    || _         |                    d          | _        t          j                    | _        d| _        g | _        t          |d          | _	        d S )Nr   Fr   )
rg  r   r   rb  Eventrh  r   ri  r   rj  r   rE  s     r2   r   zDatagramWriter.__init__J  sU    #090H0H0T0T$]__ ;=&y-@@rA   c                    | j         S rm   )rg  r   s    r2   rE  zDatagramWriter.transportT  s
    rA   rc   ,bytes | bytearray | memoryview | list[bytes]c                l   | j         }|                                rd S t          |t                    rB| j        r|                    |           d S | j        }|D ]}|                    ||           d S t          |t                    st          |          }|                    || j                   d S rm   )	rg  r   r[  listrj  r   r   r   r7   )r   rc   rE  r   rR   s        r2   writezDatagramWriter.writeX  s    O	!! 	FdD!! 	2# 2%%d+++++ }! 2 2E$$UD11112 2 dE** #T{{T4=11111rA   rJ   r:   c                0    |                      |           dS )z=Send a batch of datagrams. ``StreamWriter``-compatible alias.N)rs  )r   rJ   s     r2   
writelineszDatagramWriter.writelinesi  s    

9rA   c                h  K   | j         sd S t          j                    }|                                }| j                            |           	 | d {V  	 | j                            |           d S # t          $ r Y d S w xY w# 	 | j                            |           w # t          $ r Y w w xY wxY wrm   )r   rb  rc  r   ri  rM   remover   )r   r   rO  s      r2   drainzDatagramWriter.drainm  s      | 	F'))'+'9'9';';""6***	LLLLLLL#**622222   #**62222   sB   B A3 3
B BB1B! B1!
B.+B1-B..B1c                8    | j                                          d S rm   )rg  r   r   s    r2   r   zDatagramWriter.close{  s    rA   r,   c                4    | j                                         S rm   )rg  r   r   s    r2   r   zDatagramWriter.is_closing~  s    ))+++rA   c                H   K   | j                                          d {V  d S rm   )rh  waitr   s    r2   wait_closedzDatagramWriter.wait_closed  s3       %%'''''''''''rA   Nr   r   r   r   c                8    | j                             ||          S rm   )rg  r   r   s      r2   r   zDatagramWriter.get_extra_info  s    --dG<<<rA   c                    d| _         d S r   )r   r   s    r2   _pause_writingzDatagramWriter._pause_writing  s    rA   c                    d| _         | j        }g | _        |D ]+}|                                s|                    d            ,d S r   )r   ri  r   r   )r   waitersws      r2   _resume_writingzDatagramWriter._resume_writing  sW     %  	# 	#A6688 #T"""	# 	#rA   )rE  rk  r+   r   )r+   rk  )rc   rp  r+   r   r'  r&  r%  rm   r$  )rh   ri   rj   rk   r(  r   propertyrE  rs  ru  rx  r   r   r}  r   r  r  r=   rA   r2   r   r   :  s        IA A A A    X2 2 2 2"             , , , ,( ( ( (= = = = =   # # # # # #rA   r   c                  V    e Zd ZdZdZddZdd
ZddZddZddZ	ddZ
d dZd dZdS )!_DatagramBridgeProtocolzcBridges ``asyncio.DatagramProtocol`` callbacks to ``DatagramReader``
    / ``DatagramWriter``.
    _reader_writerreaderr   r+   r   c                "    || _         d | _        d S rm   r  )r   r  s     r2   r   z _DatagramBridgeProtocol.__init__  s    .2rA   rE  asyncio.BaseTransportc                    d S rm   r=   rn  s     r2   r  z'_DatagramBridgeProtocol.connection_made  s    rA   rc   r7   r   tuple[str, int]c                <    | j                             ||           d S rm   )r  rP  r  s      r2   r  z)_DatagramBridgeProtocol.datagram_received  s     ""4.....rA   r:   c                <    | j                             ||           d S rm   )r  rR  r  s      r2   r   z*_DatagramBridgeProtocol.datagrams_received  s     ##D$/////rA   r{   	Exceptionc                :    | j                             |           d S rm   )r  rU  r   s     r2   r   z&_DatagramBridgeProtocol.error_received  s      	""3'''''rA   rV  c                    | j                             |           | j        }|/|j                                         |                                 d S d S rm   )r  r   r  rh  setr  )r   r{   writers      r2   r   z'_DatagramBridgeProtocol.connection_lost  sZ    $$S))) $$&&&""$$$$$ rA   c                J    | j         | j                                          d S d S rm   )r  r  r   s    r2   r  z%_DatagramBridgeProtocol.pause_writing  s,    <#L''))))) $#rA   c                J    | j         | j                                          d S d S rm   )r  r  r   s    r2   r
  z&_DatagramBridgeProtocol.resume_writing  s,    <#L((***** $#rA   N)r  r   r+   r   )rE  r  r+   r   )rc   r7   r   r  r+   r   )rc   r:   r   r  r+   r   )r{   r  r+   r   re  r&  )rh   ri   rj   rk   r(  r   r  r  r   r   r   r  r
  r=   rA   r2   r  r    s          'I3 3 3 3   / / / /0 0 0 0( ( ( (% % % %* * * *+ + + + + +rA   r  )r*  r   r)   r_   %tuple[DatagramReader, DatagramWriter]c          	        
K   t          j                    }t                      }t          |          
t	          |
fd|| |||           d {V \  }}t          |          }	|	
_        ||	fS )Nc                      S rm   r=   )r   s   r2   <lambda>z'open_dgram_connection.<locals>.<lambda>  s     rA   )r*  r+  r   r_   r)   )rb  rc  r   r  r   r   r  )r+  r*  r   r)   r_   r   r  rE  r!  r  r   s             @r2   r	   r	     s       #%%DF&v..H,)        LIq I&&FH6>rA   )r)   r*   r+   r,   )r6   r7   r8   r9   r+   r:   )rF   r9   r+   r9   )rJ   r:   r+   rK   )rT   rU   r+   rV   )r]   )r)   r*   r^   r9   r_   r9   r+   r`   )r{   r0   r+   r,   )r)   r*   rc   r7   r+   r   )r)   r*   rJ   r:   r+   r   )r   r   r-  r.  r*  r   r+  r   r   r9   r,  r,   r_   r9   r)   r/  r+   r0  rm   )r+  r   r*  r   r   r9   r)   r/  r_   r9   r+   r  )>rk   
__future__r   rb  r~   r   structsyscollectionsr   typing	_constantr   r   __all__Structr   __annotations__r   r   r   r   r   r   r   r   platformr   r   r   r"   r$   r&   r   r'   rF   r(   r3   r5   rE   rI   rS   r\   r
   r  r   	frozensetru   ry   rz   r   r   r   DatagramTransportr   r3  r   r   r   DatagramProtocolr  r	   r=   rA   r2   <module>r     s     # " " " " "     



        : 9 9 9 9 9 9 9	 &d++ + + + + (&---	 - - - - "'  & & & &
 $ # # # # !* ) ) ) )( ( ( ( (
 #%  $ $ $ $!&  & & & & #%  $ $ $ $,'1	 1 1 1 1<+<<
 < < < < !B77 7 7 7 7"76;::
 : : : :#GFL!<< < < < < 76<    1 1). A AKAAAAA K   "   	J 	J 	J 	JA A A A' ' ' 'T   $ @D"1 "1 "1 "1 "1J    y    )2	 	2 	2 	ud##y$''|T**}d++		2 	2 	2 	) 	)  	 	 	 	  %.I . . 	z4((}d++. . . % %      ',  + + + +C C C C   &* * * *jL4 L4 L4 L4 L4(A L4 L4 L4f *.*." !%V V V V V Vro o o o o o o odX# X# X# X# X# X# X# X#v)+ )+ )+ )+ )+g6 )+ )+ )+Z +/ *."!%        rA   