Struct NativeIO 

pub struct NativeIO;

Default [ProtocolIO] implementation for native platforms.

Wraps TCP/TLS/QUIC for ordered streams, UDP for unreliable datagrams, and the system RNG. All existing protocol behaviour is preserved.

Trait Implementations

impl Clone for NativeIO

fn clone(&self) -> NativeIO

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PlatformOps for NativeIO

fn identify_nat_type( stun_servers: Option<Vec<String>>, ) -> impl Future<Output = Result<NatType, Error>> + ContextRequirements

Identify local NAT type via STUN servers. Default: returns NatType::offline() (appropriate for WASM).

fn quic_udp_channel( conn: Connection, local_addr: SocketAddr, ) -> Option<UdpSplittableTypes>

Create a UDP channel from an existing QUIC connection. Default: returns None (QUIC not available).

fn c2s_hole_punch<R>( stream: ReliableOrderedCompatStream<R>, ratchet: R, security_level: SecurityLevel, target_cid: u64, stun_servers: Option<Vec<String>>, node_type: RelativeNodeType, ) -> impl Future<Output = Result<Option<UdpSplittableTypes>, NetworkError>> + ContextRequirements

where R: Ratchet,

Perform C2S UDP hole punch via NetworkEndpoint + encrypted hole punch. Returns the resulting UDP interface, or None if unavailable. Default: returns Ok(None) (hole punching not available).

fn p2p_hole_punch<R>( session: CitadelSession<R, NativeIO>, peer_connection_type: PeerConnectionType, ticket: Ticket, peer_nat_info: PeerNatInfo, channel_signal: NodeResult<R>, hole_punch_compat_stream: ReliableOrderedCompatStream<R>, endpoint_ratchet: R, peer_cid: u64, sync_instant: Instant, node_type: RelativeNodeType, udp_mode: UdpMode, session_security_settings: SessionSecuritySettings, cancel_rx: Option<Receiver<()>>, ) -> impl Future<Output = Result<(), NetworkError>> + ContextRequirements

where R: Ratchet,

Orchestrate P2P hole punch: register endpoint, punch, establish connection, send channel_signal to kernel. On failure (or on WASM), sends channel_signal as TCP-only fallback.

fn open_and_validate_for_transfer( source_path: &Path, expected_metadata: Option<&VirtualObjectMetadata>, ) -> Result<TransferMetadata, NetworkError>

Open a file and validate it for transfer. Default: returns an error (file transfer not supported).

fn async_delete_file(source: PathBuf)

Asynchronously delete a file after transfer. Default: no-op.

fn spawn_udp_socket_loader<R>( session: CitadelSession<R, NativeIO>, v_target: VirtualConnectionType, udp_conn: UdpSplittableTypes, addr: TargettedSocketAddr, ticket: Ticket, tcp_conn_awaiter: Option<Receiver<()>>, )

where R: Ratchet,

Spawn the UDP socket loader for a session. On native: spawns an async task for the full UDP subsystem. Default: no-op.

impl ProtocolIO for NativeIO

type Addr = SocketAddr

Network address type (e.g. SocketAddr for native, URL for WASM).

type Stream = GenericNetworkStream

Bidirectional ordered reliable stream (TCP/TLS/QUIC in native, WebSocket in WASM).

type Listener = DualListener

Accepts incoming ordered connections, yielding (Stream, Addr) pairs.

type UnreliableSocket = NativeUdpSocket

Unreliable datagram socket (UDP in native, WebRTC DataChannel in WASM).

type OrderedReliableConfig = NativeOrderedReliableConfig

Config for ordered reliable transport without transport-level encryption (e.g. TCP for native, ws:// WebSocket for WASM).

type SecureConfig = NativeSecureConfig

Config for ordered reliable transport WITH transport-level encryption (e.g. TLS for native, wss:// WebSocket for WASM).

type P2PConfig = NativeP2PConfig

Config for P2P-capable transport with multiplexed streams (e.g. QUIC for native, WebRTC for WASM).

type ClientConfig = Arc<ClientConfig>

Client-side configuration (TLS client config, WebSocket options, etc.).

type Rng = ThreadRng

Random number generator type.

async fn bind( config: ServerMode<NativeIO>, addr: <NativeIO as ProtocolIO>::Addr, ) -> Result<(<NativeIO as ProtocolIO>::Listener, <NativeIO as ProtocolIO>::Addr), Error>

Bind a server listener to the given address.

async fn connect( config: &<NativeIO as ProtocolIO>::ClientConfig, addr: <NativeIO as ProtocolIO>::Addr, ) -> Result<<NativeIO as ProtocolIO>::Stream, Error>

Connect to a remote address (client side).

async fn bind_unreliable( addr: <NativeIO as ProtocolIO>::Addr, ) -> Result<<NativeIO as ProtocolIO>::UnreliableSocket, Error>

Create an unreliable datagram socket bound to the given address.

fn rng() -> <NativeIO as ProtocolIO>::Rng

Obtain a random number generator instance.

async fn default_client_config() -> Result<<NativeIO as ProtocolIO>::ClientConfig, Error>

Create a default client configuration for this transport.

fn server_identity(config: &ServerMode<NativeIO>) -> Option<String>

Extract a TLS/identity domain from the server configuration, if any.

fn local_addr( stream: &<NativeIO as ProtocolIO>::Stream, ) -> Result<<NativeIO as ProtocolIO>::Addr, Error>

Retrieve the local address of an established stream.

async fn default_server_config() -> Result<ServerMode<NativeIO>, Error>

Create a default server configuration for this transport.

fn config_warnings(config: &ServerMode<NativeIO>)

Log any warnings about the server configuration.

fn from_socket_addr(addr: SocketAddr) -> SocketAddr

Convert a standard socket address to this protocol’s address type.

fn to_socket_addr(addr: &SocketAddr) -> SocketAddr

Convert this protocol’s address to a standard socket address.

fn addr_port(addr: &SocketAddr) -> u16

Extract the port number from an address.

fn peer_addr(stream: &GenericNetworkStream) -> Result<SocketAddr, Error>

Get the peer address of an established stream.

fn take_p2p_connection( stream: &mut GenericNetworkStream, ) -> Option<Box<dyn Any + Send>>

Extract an opaque P2P connection handle from a stream (if present).

fn client_config_to_any( config: &Arc<ClientConfig>, ) -> Option<Box<dyn Any + Send>>

Extract an opaque handle from the client config for P2P operations.

async fn bind_with_websocket( primary: <NativeIO as ProtocolIO>::Listener, ws_bind_addr: Option<SocketAddr>, ) -> Result<<NativeIO as ProtocolIO>::Listener, Error>

Optionally bind an additional WebSocket listener and merge it with the primary listener.

impl ProtocolUpgrade<NativeIO> for TcpToQuicUpgrade

type Signal = QuicRedirectSignal

Redirect signal sent from server to client over the signaling channel.

fn build_signal( target_config: &ServerMode<NativeIO>, client_addr: SocketAddr, ) -> <TcpToQuicUpgrade as ProtocolUpgrade<NativeIO>>::Signal

Build the redirect signal for a connecting client.

fn serialize_signal( signal: &<TcpToQuicUpgrade as ProtocolUpgrade<NativeIO>>::Signal, ) -> Result<Bytes, Error>

Serialize the signal for wire transmission.

fn deserialize_signal( bytes: &[u8], ) -> Result<<TcpToQuicUpgrade as ProtocolUpgrade<NativeIO>>::Signal, Error>

Deserialize signal received from server.

async fn bind_upgrade_pair( target_config: ServerMode<NativeIO>, addr: SocketAddr, ) -> Result<UpgradeListenerPair<NativeIO>, Error>

Create both the signaling listener and the target listener.

async fn connect_target( signal: <TcpToQuicUpgrade as ProtocolUpgrade<NativeIO>>::Signal, local_addr: SocketAddr, remote_addr: SocketAddr, client_config: &Arc<ClientConfig>, ) -> Result<GenericNetworkStream, Error>

Client-side: given the redirect signal, connect to the target transport.

fn merge_upgrade_listeners( signal_listener: DualListener, target_listener: DualListener, ) -> DualListener

Merge a signaling listener and target listener into a composite listener.

fn bind_with_upgrade( target_config: ServerMode<T>, addr: <T as ProtocolIO>::Addr, ) -> impl Future<Output = Result<(<T as ProtocolIO>::Listener, <T as ProtocolIO>::Addr), Error>> + Send

Server: bind a composite listener that redirects on one transport and accepts real connections on another.

fn connect_with_upgrade( remote_addr: <T as ProtocolIO>::Addr, client_config: &<T as ProtocolIO>::ClientConfig, ) -> impl Future<Output = Result<<T as ProtocolIO>::Stream, Error>> + Send

Client: connect to the signaling transport, read the redirect signal, then connect to the target transport.

fn read_signal_from_stream( stream: <T as ProtocolIO>::Stream, ) -> impl Future<Output = Result<Self::Signal, Error>> + Send

Read a redirect signal from a connected signaling stream using length-delimited framing.

fn write_signal_to_stream( stream: <T as ProtocolIO>::Stream, signal: &Self::Signal, ) -> impl Future<Output = Result<(), Error>> + Send

Write a redirect signal to a signaling stream using length-delimited framing.