Functions — github.com/denoland/rustls-tokio-stream

hub / github.com/denoland/rustls-tokio-stream / functions

Functions181 in github.com/denoland/rustls-tokio-stream

⨍ Functions 181◇ Types & classes 19

↓ 28 callersMethodhandshake

(&mut self)

src/stream.rs:698

↓ 14 callersMethodshutdown

(&self, how: std::net::Shutdown)

src/stream.rs:202

↓ 12 callersFunctionexpect_eof_read

(stm: &mut (impl AsyncReadExt + Unpin))

src/stream.rs:1623

↓ 10 callersFunctiontls_pair

( )

src/connection_stream.rs:602

↓ 10 callersFunctiontls_pair_slow_handshake

( delay_handshake: bool, slow_server: bool, slow_client: bool, buffer: bool, )

src/stream.rs:1454

↓ 9 callersFunctionclone_error

Clones an [`io::Error`], assuming the inner error, if any, is a [`rustls::Error`].

src/adapter.rs:26

↓ 9 callersFunctionexpect_write_1

(conn: &mut ConnectionStream<TcpStream>)

src/connection_stream.rs:558

↓ 9 callersMethodinto_split

(self)

src/stream.rs:637

↓ 8 callersFunctionexpect_read_1

(conn: &mut ConnectionStream<TcpStream>)

src/connection_stream.rs:583

↓ 8 callersMethodflush

(&mut self)

src/adapter.rs:89

↓ 8 callersMethodwake

(&self)

src/stream.rs:72

↓ 7 callersFunctionclient_config

(alpn: &[&str])

src/stream.rs:1362

↓ 7 callersMethodlocal_addr

Returns the local address of this socket.

src/stream.rs:326

↓ 7 callersFunctiontcp_pair

()

src/stream.rs:1373

↓ 7 callersMethodunderlying_stream

If the stream is open or handshaking, returns the underlying TCP stream.

src/stream.rs:859

↓ 6 callersFunctionclone_result

Clones an [`io::Result`], assuming the inner error, if any, is a [`rustls::Error`].

src/adapter.rs:18

↓ 6 callersMethodinto_inner

(mut self)

src/stream.rs:669

↓ 6 callersFunctiontls_pair_buffer_size

( buffer_size: Option<NonZeroUsize>, )

src/stream.rs:1419

↓ 6 callersFunctiontls_pair_handshake

()

src/stream.rs:1619

↓ 6 callersMethodtry_handshake

Try to get the handshake, if one exists.

src/stream.rs:703

↓ 5 callersMethodclose

(mut self)

src/stream.rs:811

↓ 5 callersFunctionexpect_read_1_err

( conn: &mut ConnectionStream<TcpStream>, error: ErrorKind, )

src/connection_stream.rs:594

↓ 5 callersMethodfinalize_handshake

( &mut self, join_result: Result<io::Result<HandshakeResult<S>>, JoinError>, )

src/stream.rs:710

↓ 5 callersFunctionhandshake_task

Performs a handshake and returns the [`TcpStream`]/[`Connection`] pair if successful.

src/handshake.rs:89

↓ 5 callersMethodwritable

(&self)

src/stream.rs:198

↓ 5 callersMethodwrite

(&mut self, buf: &[u8])

src/adapter.rs:75

↓ 4 callersMethodaccept

( mut acceptor: Acceptor, tcp_handshake: &S, server_config_provider: ServerConfigProvider, )

src/stream.rs:404

↓ 4 callersMethodinto_inner

(self)

src/connection_stream.rs:107

↓ 4 callersFunctionnonblocking_tcp_drop

TLS 1.3 may yield a state where the client has sent a large stream of data and closed the connection before receiving anything from the server. The se

src/stream.rs:931

↓ 4 callersMethodpeer_addr

Returns the peer address of this socket.

src/stream.rs:313

↓ 4 callersMethodpoll_read_size

Polls the connection for read, writing as needed. As TLS may need to pump writes during reads, or pump reads during writes, we must ensure that the wa

src/connection_stream.rs:295

↓ 4 callersMethodpoll_shutdown

( self: Pin<&mut Self>, cx: &mut Context<'_>, )

src/stream.rs:1138

↓ 4 callersFunctionprivate_key

()

src/lib.rs:132

↓ 4 callersMethodreclaim

(self)

src/handshake.rs:66

↓ 4 callersFunctionserver_config

(alpn: &[&str])

src/stream.rs:1342

↓ 4 callersFunctiontls_pair

()

src/stream.rs:1394

↓ 4 callersFunctiontls_pair_alpn

( server_alpn: &[&str], server_buffer_size: Option<NonZeroUsize>, client_alpn: &[&str], client

src/stream.rs:1494

↓ 3 callersFunctionexpect_io_error

( e: Result<T, io::Error>, kind: io::ErrorKind, )

src/lib.rs:185

↓ 3 callersFunctionexpect_io_error_read

( stm: &mut (impl AsyncReadExt + Unpin), kind: io::ErrorKind, )

src/stream.rs:1629

↓ 3 callersMethodpoll_handshake

( &mut self, cx: &mut Context, )

src/stream.rs:679

↓ 3 callersMethodpoll_perform_write

( &mut self, cx: &mut Context<'_>, flushing: bool, f: impl Fn(&mut Connection) -> T, )

src/connection_stream.rs:432

↓ 3 callersMethodpoll_write

Polls the connection for writes, reading as needed. As TLS may need to pump writes during reads, or pump reads during writes, we must ensure that the

src/connection_stream.rs:370

↓ 3 callersMethodpoll_write_only

(&mut self, mut cx: PollContext)

src/connection_stream.rs:174

↓ 3 callersMethodread

(&mut self, buf: &mut [u8])

src/adapter.rs:55

↓ 3 callersMethodreadable

(&self)

src/stream.rs:194

↓ 3 callersFunctionrustls_to_io_error

Convert a [`rustls::Error`] to an [`io::Error`]

src/adapter.rs:13

↓ 3 callersMethodset_write_waker

src/stream.rs:96

↓ 3 callersFunctiontcp_pair

()

src/lib.rs:164

↓ 3 callersFunctiontrace_result

(result: io::Result<T>)

src/handshake.rs:15

↓ 3 callersMethodtry_read

Perform a read operation on this connection. Read as much as possible into the buffer.

src/connection_stream.rs:211

↓ 2 callersFunctionclient_config

()

src/lib.rs:153

↓ 2 callersMethodcx

( &'_ mut self, waker_ref: &'g mut Option<Waker>, f: impl Fn(&mut Context<'_>) -> R, )

src/connection_stream.rs:35

↓ 2 callersFunctionmake_config

( alpn: Result<&'static [&'static str], &'static str>, )

src/stream.rs:1517

↓ 2 callersMethodpoll_pending_handshake

If the handshake is complete, migrate from a pending handshake to the open state.

src/stream.rs:757

↓ 2 callersMethodpoll_read_only

(&mut self, mut cx: PollContext)

src/connection_stream.rs:129

↓ 2 callersMethodpoll_shutdown

Polls for completion of all the writes in the rustls [`Connection`]. Does not progress on reads at all.

src/connection_stream.rs:508

↓ 2 callersFunctionread_tls

( tcp: &S, tls: &mut Connection, )

src/adapter.rs:94

↓ 2 callersFunctionsend_handshake

( tcp: Arc<S>, tls: Result<Connection, io::Error>, test_options: TestOptions, handshake: Arc<Handshake

src/stream.rs:870

↓ 2 callersFunctionserver_config

()

src/lib.rs:146

↓ 2 callersFunctionserver_name

()

src/lib.rs:160

↓ 2 callersMethodset_linger

(&self, dur: Option<Duration>)

src/stream.rs:300

↓ 2 callersFunctiontls_pair_handshake_buffer_size

( server_buffer_size: Option<NonZeroUsize>, client_buffer_size: Option<NonZeroUsize>, )

src/stream.rs:1602

↓ 2 callersFunctiontls_with_tcp_server

( delay_handshake: bool, )

src/stream.rs:1436

↓ 2 callersFunctiontrace_error

(error: io::Error)

src/adapter.rs:38

↓ 2 callersFunctiontry_write

( tcp: &S, tls: &mut Connection, )

src/handshake.rs:45

↓ 2 callersMethodtry_write

(&self, buf: &[u8])

src/stream.rs:190

↓ 2 callersFunctionwrite_acceptor_alert

( tcp: &S, mut alert: AcceptedAlert, )

src/adapter.rs:118

↓ 2 callersMethodwrite_buf_fully

Fully write a buffer to the TLS stream, expecting it to write fully and not fail.

src/connection_stream.rs:493

↓ 2 callersFunctionwrite_tls

( tcp: &S, tls: &mut Connection, )

src/adapter.rs:102

↓ 1 callersFunctionalpn_handler

( client_hello: ClientHello, )

src/system_test/disconnect_test.rs:16

↓ 1 callersFunctionenable_byte_tracing

()

src/lib.rs:38

↓ 1 callersFunctionhandshake_task_internal

( tcp: Arc<S>, mut tls: Connection, test_options: TestOptions, )

src/handshake.rs:109

↓ 1 callersMethodinto_std

(self)

src/stream.rs:206

↓ 1 callersFunctionmake_config

( alpn: Result<&'static [&'static str], &'static str>, )

src/system_test/disconnect_test.rs:42

↓ 1 callersMethodpoll_flush

Polls for completion of all the writes in the rustls [`Connection`]. Does not progress on reads at all.

src/connection_stream.rs:500

↓ 1 callersMethodpoll_read_ready

(&self, cx: &mut Context<'_>)

src/stream.rs:178

↓ 1 callersMethodpoll_shutdown_or_abort

Shuts the connection down, optionally waiting for the handshake to complete.

src/stream.rs:771

↓ 1 callersMethodpoll_write

( mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], )

src/stream.rs:990

↓ 1 callersMethodpoll_write_ready

(&self, cx: &mut Context<'_>)

src/stream.rs:182

↓ 1 callersFunctionread_acceptor

( tcp: &S, acceptor: &mut Acceptor, )

src/adapter.rs:110

↓ 1 callersFunctionserver_config_alpn

(alpn: &[&str])

src/system_test/disconnect_test.rs:32

↓ 1 callersFunctionserver_config_protocol

( protocol: &'static SupportedProtocolVersion, )

src/stream.rs:1352

↓ 1 callersMethodset_read_waker

src/stream.rs:87

↓ 1 callersFunctiontls_pair_alpn_acceptor

( server_alpn: fn( ClientHello, ) -> Result<&'static [&'static str], &'static str>, server_b

src/stream.rs:1528

↓ 1 callersFunctiontls_pair_alpn_from_acceptor

( server_alpn: fn( ClientHello, ) -> Result<&'static [&'static str], &'static str>, server_b

src/stream.rs:1555

↓ 1 callersFunctiontls_pair_protocol

( buffer_size: Option<NonZeroUsize>, protocol: &'static SupportedProtocolVersion, )

src/stream.rs:1398

↓ 1 callersFunctiontry_read

( tcp: &S, tls: &mut Connection, )

src/handshake.rs:23

↓ 1 callersMethodtry_read

(&self, buf: &mut [u8])

src/stream.rs:186

↓ 1 callersMethodunsplit

Reunites with a previously split `TlsStreamWrite`.

src/stream.rs:1225

↓ 1 callersFunctionwait_for_peek

(conn: &mut ConnectionStream<TcpStream>)

src/connection_stream.rs:562

Functionalpn_handler

( client_hello: ClientHello, )

src/connection_stream.rs:112

Methodconnection

If the stream is open, returns the underlying rustls connection.

Functiondisconnect_test

()

src/system_test/disconnect_test.rs:54

(&self, f: &mut std::fmt::Formatter<'_>)

src/stream.rs:257

next →1–100 of 181, ranked by callers