Enum ServeTarget 

#[non_exhaustive]
pub enum ServeTarget {
    Accept,
    Proxy {
        to: String,
    },
    Text {
        body: String,
    },
    TcpForward {
        to: String,
    },
    Path {
        handlers: BTreeMap<String, ServeTarget>,
    },
    Redirect {
        to: String,
        status: u16,
    },
}

What to do with a stream once TLS is terminated (or, for ServeTarget::TcpForward, a raw TCP stream with no TLS).

Mirrors the handler shapes of upstream ipn.ServeConfig’s HTTPHandler/TCPPortHandler (Proxy/Text/TCPForward/Path/Redirect), plus an Accept hand-back the in-process Rust embedder uses in place of Go’s net.Listener.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Accept

Hand the accepted, decrypted stream back to the embedder (like tsnet’s ListenTLS returning a net.Listener).

Proxy

Reverse-proxy the decrypted stream to a local address (like a Serve Proxy handler). The address is a real OS socket target on this host.

Fields

to: String

host:port to dial for the proxied backend.

Text

Serve a fixed plaintext body to every connection, then close (Go HTTPHandler.Text). The bytes are written as-is after TLS termination — the embedder supplies any HTTP framing.

Fields

body: String

The exact bytes to write to each accepted stream.

TcpForward

Forward the raw (non-TLS-terminated) TCP stream to a local backend (Go TCPPortHandler.TCPForward). Unlike ServeTarget::Proxy, no TLS is terminated — bytes are spliced through verbatim to to (a real OS socket on this host).

Fields

to: String

host:port to dial for the raw-TCP backend.

Path

HTTP path-prefix mux (Go HTTPHandler path map). Terminates TLS, reads the request line, and dispatches the longest-matching path prefix’s nested target on the already-decrypted stream.

Fields

handlers: BTreeMap<String, ServeTarget>

Path-prefix → nested target. Longest-prefix wins at dispatch; an unmatched path is a fail-closed 404. Nested Path is rejected by validate to bound recursion (one level of nesting only).

Redirect

HTTP redirect response (Go HTTPHandler redirect). Terminates TLS, then writes a bodyless status/Location: to response and closes.

Fields

to: String

Absolute or relative Location header value.

status: u16

HTTP redirect status; validate rejects anything outside 300..=399.

Implementations

impl ServeTarget

pub fn terminates_tls(&self) -> bool

Whether this target requires TLS termination on the serve port. Accept/Proxy/Text/ Path/Redirect ride an HTTPS port and terminate TLS; only TcpForward is a raw passthrough with no TLS. Explicit arms (not a single matches!) so the #[non_exhaustive] intent — every future variant must declare its TLS posture deliberately — is clear at the call site.

Trait Implementations

impl Clone for ServeTarget

fn clone(&self) -> ServeTarget

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ServeTarget

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ServeTarget

fn deserialize<__D>( __deserializer: __D, ) -> Result<ServeTarget, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ServeTarget

impl PartialEq for ServeTarget

fn eq(&self, other: &ServeTarget) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ServeTarget

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ServeTarget