Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

TCP transport

TCP transport wrappers in dnet are intended for Tokio TCP streams and can be used for plain TCP or TLS-over-TCP.

Buffered constructors

The buffered variants are recommended when the transport sees many small messages or when you want to reduce syscall overhead. They wrap the underlying stream in buffered I/O and can improve throughput without changing framing behavior.

Examples

Plain TCP

Warning

We are creating an insecure (unencrypted) connection here.

Server

A server accepts a plain TCP connection, receives a String, then sends an i32 back.

use futures::SinkExt;
use tokio::net::TcpListener;
use dnet::{codecs::BincodeCodec, tcp::TcpTransport, Receive};

let listener = TcpListener::bind("127.0.0.1:8080").await?;
let (tcp_stream, _peer_addr) = listener.accept().await?;
let mut transport = TcpTransport::buffered(tcp_stream, BincodeCodec::default());

let name: String = transport.receive().await?;
transport.send(name.len() as i32).await?;

Client

A client connects over plain TCP, sends a String, and receives an i32 reply.

use futures::SinkExt;
use tokio::net::TcpStream;
use dnet::{codecs::BincodeCodec, tcp::TcpTransport, Receive};

let tcp_stream = TcpStream::connect("127.0.0.1:8080").await?;
let mut transport = TcpTransport::buffered(tcp_stream, BincodeCodec::default());

transport.send("hello".to_string()).await?;
let length: i32 = transport.receive().await?;

TLS

TLS (Transport Layer Security) encrypts and authenticates the TCP connection, protecting messages from eavesdropping and tampering. See Transport Layer Security for more details.

Warning

Cryptography is hard - make sure you know what you’re doing.

Server

A TLS server accepts the socket first, then upgrades it before wrapping it in TcpTransport.

use futures::SinkExt;
use native_tls::{Identity, TlsAcceptor};
use tokio_native_tls::TlsAcceptor as TokioTlsAcceptor;
use tokio::net::TcpListener;
use dnet::{codecs::BincodeCodec, tcp::TcpTransport, Receive};

let listener = TcpListener::bind("0.0.0.0:8443").await?;
let (tcp_stream, _peer_addr) = listener.accept().await?;

let identity = Identity::from_pkcs12(&pkcs12_bytes, "password")?;
let tls_acceptor = TlsAcceptor::new(identity)?;
let tokio_acceptor = TokioTlsAcceptor::from(tls_acceptor);
let tls_stream = tokio_acceptor.accept(tcp_stream).await?;

let mut transport = TcpTransport::buffered(tls_stream, BincodeCodec::default());
let message: String = transport.receive().await?;
transport.send(message.len() as i32).await?;

Client

A TLS client connects to the server and then negotiates TLS before wrapping the stream.

use futures::SinkExt;
use native_tls::TlsConnector;
use tokio_native_tls::TlsConnector as TokioTlsConnector;
use tokio::net::TcpStream;
use dnet::{codecs::BincodeCodec, tcp::TcpTransport, Receive};

let tcp_stream = TcpStream::connect("example.com:8443").await?;
let connector = TlsConnector::new()?;
let tokio_connector = TokioTlsConnector::from(connector);
let tls_stream = tokio_connector.connect("example.com", tcp_stream).await?;

let mut transport = TcpTransport::buffered(tls_stream, BincodeCodec::default());
transport.send("hello".to_string()).await?;
let length: i32 = transport.receive().await?;