B

���gU#�@s�dd
lm
Z

ddlZddlZddlZddlZddlmZ
ejrZddl	m
Z

ddlmZm
Z

ejdd	d
�ZejeefZe�d�
ZdZGd
d	�d	�ZdS)�)
�annotationsN�)
�ProxySchemeUnsupported)
�Literal�
)�_TYPE_PEER_CERT_RET�_TYPE_PEER_CERT_RET_DICT�_SelfT�SSLTransport)
�bound�_ReturnValuei@c	@sBeZ
dZd
Zeddd�dd��
Zdnd	dd
ddd�d
d�Zddd�dd�Zddd�dd�Zdd�
dd�Z	dodddd�dd �Z
dpdddd"�d#d$�Zdqd%d&dd'd(�d)d*�Zdrd+ddd,�d-d.�Z
dsd+ddd,�d/d0�Zdtdddd1�d2d&d
d
d
d3d4�d5d6�Zdd�
d7d8�Zdd�
d9d:�Zejdud<d=d>�d?d@��
ZejdAdBd>�dCd@��
ZdvddEd>�dFd@�Zd
d�
dGdH�ZdId�
dJdK�Zd
d�
dLdM�Zd
d�
dNdO�ZdPd�
dQdR�Zd
d�
dSdT�ZdUddV�dWdX�ZdUd�
dYdZ�Zdd�
d[d\�Zdwdd]dd�d^d_�Zejd`dda�dbdc��
Zejddd+dde�dfdc��
Zejdgdd]d+dh�didc��
Zdxdjdkd]dldh�dmdc�ZdS)yr
aL

    The SSLTransport wraps an existing socket and establishes an SSL connection.

    Contrary to Python's implementation of SSLSocket, it allows you to chain
    multiple TLS connections together. It's particularly useful if you need to
    implement TLS within TLS.

    The class supports most of the socket API operations.
    zssl.SSLContext�None)�ssl_context�returnc

Cst|d
�st
d�
�
dS)z�
        Raises a ProxySchemeUnsupported if the provided ssl_context can't be used
        for TLS in TLS.

        The only requirement is that the ssl_context provides the 'wrap_bio'
        methods.
        �wrap_biozXTLS in TLS requires SSLContext.wrap_bio() which isn't available on non-native SSLContextN)�hasattrr)
r�r�C/usr/local/lib/python3.7/site-packages/urllib3/util/ssltransport.py�$_validate_ssl_context_for_tls_in_tls"s



z1SSLTransport._validate_ssl_context_for_tls_in_tlsNTz
socket.socketz
str | None�bool)�socketr�server_hostname�suppress_ragged_eofsrcCsHt�
�|_t�
�|_||_|
|_|j|j|j|d
�|_|�|jj	�

dS)zV
        Create an SSLTransport around socket using the provided ssl_context.
        )
rN)
�ssl�	MemoryBIO�incoming�outgoingrrr�sslobj�_ssl_io_loop�do_handshake)�selfrrrrrrr�__init__2s





zSSLTransport.__init__r	)r rc


Cs|S)
Nr)
r rrr�	__enter__Is
zSSLTransport.__enter__z
typing.Any)�
_rc
Gs|��
dS)
N)
�close)r r#rrr�__exit__Ls
zSSLTransport.__exit__�int)
rc

Cs
|j�
�S)
N)r�fileno)
r rrrr'Os
zSSLTransport.fileno�ztyping.Any | Nonezint | bytes)�len�bufferrcCs|�|
|�S)
N)
�_wrap_ssl_read)r r)r*rrr�readRs
zSSLTransport.readr
)�buflen�flagsrcCs|d
krtd�
�
|�
|
�
S)Nr
z+non-zero flags not allowed in calls to recv)�
ValueErrorr+)r r-r.rrr�recvUs


zSSLTransport.recv�_WriteBufferz
int | NonezNone | int | bytes)r*�nbytesr.rcCs,|d
krtd�
�
|dkr t
|
�
}|�||
�S)Nr
z0non-zero flags not allowed in calls to recv_into)r/r)r,)r r*r2r.rrr�	recv_intoZs




zSSLTransport.recv_into�bytes)�datar.rc
Csr|d
krtd�
�
d
}t
|
�
�L}|�d�
�6}t|�
}x&||krX|�||d��
}||7}q4WWdQRXWdQRXdS)Nr
z.non-zero flags not allowed in calls to sendall�
B)r/�
memoryview�castr)�send)r r5r.�count�view�	byte_view�amount�
vrrr�sendallfs








zSSLTransport.sendallcCs |d
krtd�
�
|�
|jj|
�S)Nr
z+non-zero flags not allowed in calls to send)r/rr�write)r r5r.rrrr9ps


zSSLTransport.send)�encoding�errors�newline�strz1typing.BinaryIO | typing.TextIO | socket.SocketIO)�mode�	bufferingrArBrCrc
Cs
t|
�
d
ddhk
s"t
d|
�d��
�
d|
k}d
|
kp6|}|sD|sDt�
d|
k}d}	|r\|	d
7}	|rh|	d7}	t�||	�}
|jjd7_|dkr�d	}|d
kr�tj}|d
kr�|s�t
d�
�
|
S|r�|r�t�|
|
|�}n&|r�t�	|
|�}n|s�t�
t�
|
|�}|r�|St�||||�}|
|_|S)a

        Python's httpclient uses makefile and buffered io when reading HTTP
        messages and we need to support it.

        This is unfortunately a copy and paste of socket.py makefile with small
        changes to point to the socket directly.
        �
r�
w�
bz
invalid mode z (only r, w, b allowed)�rN���r
z!unbuffered streams must be binary)
�setr/�AssertionErrorr�SocketIO�_io_refs�io�DEFAULT_BUFFER_SIZE�BufferedRWPair�BufferedReader�BufferedWriter�
TextIOWrapperrE)
r rErFrArBrC�writing�reading�binary�rawmode�rawr*�textrrr�makefileus@



























zSSLTransport.makefilec

Cs|�|j
j�

dS)
N)rr�unwrap)
r rrrr]�s
zSSLTransport.unwrapc

Cs|j�
�
dS)
N)rr$)
r rrrr$�s
zSSLTransport.close.zLiteral[False]z_TYPE_PEER_CERT_RET_DICT | None)�binary_formrc
CsdS)
Nr)r r^rrr�getpeercert�szSSLTransport.getpeercertz
Literal[True]zbytes | Nonec
CsdS)
Nr)r r^rrrr_�sFrcCs|j�
|
�
S)
N)rr_)r r^rrrr_�s
c

Cs
|j�
�S)
N)r�version)
r rrrr`�s
zSSLTransport.versionztuple[str, str, int] | Nonec

Cs
|j�
�S)
N)r�cipher)
r rrrra�s
zSSLTransport.cipherc

Cs
|j�
�S)
N)r�selected_alpn_protocol)
r rrrrb�s
z#SSLTransport.selected_alpn_protocolc

Cs
|j�
�S)
N)r�selected_npn_protocol)
r rrrrc�s
z"SSLTransport.selected_npn_protocolz!list[tuple[str, str, int]] | Nonec

Cs
|j�
�S)
N)r�shared_ciphers)
r rrrrd�s
zSSLTransport.shared_ciphersc

Cs
|j�
�S)
N)r�compression)
r rrrre�s
zSSLTransport.compressionzfloat | None)�valuercCs|j�
|
�

dS)
N)r�
settimeout)r rfrrrrg�s
zSSLTransport.settimeoutc

Cs
|j�
�S)
N)r�
gettimeout)
r rrrrh�s
zSSLTransport.gettimeoutc

Cs|j�
�
dS)
N)r�_decref_socketios)
r rrrri�s
zSSLTransport._decref_socketioszbytearray | Nonec
CsTy|�|j
j|
|�Stjk
rN
}
z|jtjkr<|jr<d
S�Wdd}~XYnXdS)Nr
)rrr,r�SSLError�errno�
SSL_ERROR_EOFr)r r)r*�
errrr+�s




zSSLTransport._wrap_ssl_readztyping.Callable[[], None])�funcrc
CsdS)
Nr)r rnrrrr�szSSLTransport._ssl_io_loopztyping.Callable[[bytes], int])rn�arg1rc
CsdS)
Nr)r rnrorrrr�sz/typing.Callable[[int, bytearray | None], bytes])rnro�arg2rc
CsdS)
Nr)r rnrorprrrr�sz"typing.Callable[..., _ReturnValue]zNone | bytes | intrc	
Cs�d
}d}x�|r�d}y8|dkr,|dkr,|
�}n|dkr>|
|�
}n
|
||�}Wn@tj
k
r�
}
z |jtjtjfkrt|�
|j}Wdd}~XYnX|j��}|j�|�

|dkr�d}q
|tjkr
|j�	t
�
}|r�|j�|�

q
|j�
�
q
Wt�t|�S)z>Performs an I/O loop between incoming/outgoing and the socket.TNF)rrjrk�SSL_ERROR_WANT_READ�SSL_ERROR_WANT_WRITErr,rr?r0�
SSL_BLOCKSIZErr@�	write_eof�typingr8r)	r rnrorp�should_loop�retrkrm�bufrrrr�s0



















)NT)r(N)r(r
)Nr
)
r
)
r
)
N)
.)
F)
N)NN) �__name__�
__module__�__qualname__�__doc__�staticmethodrr!r"r%r'r,r0r3r?r9r\r]r$ru�overloadr_r`rarbrcrdrergrhrir+rrrrrr
sL	




-

)�
__future__rrPrrru�
exceptionsr�
TYPE_CHECKING�typing_extensionsr�ssl_rr�TypeVarr	�Union�	bytearrayr7r1rrsr
rrrr�<module>
s