greet

type AppLayer interface {
	// Name returns the protocol slug (e.g. "tls", "minecraft").
	Name() string

	// Description is a one-line human-readable summary.
	Description() string

	// DefaultPort is the well-known port for this application protocol.
	DefaultPort() int

	// BaseTransport declares which transport this layer requires (tcp or udp).
	BaseTransport() Transport

	// Handshake performs the application-level exchange over conn.
	// start is the shared timing anchor owned by the engine; TTFB and TTLB
	// must be measured as time.Since(start) so timings are relative to the
	// same origin as the transport RTT and any lower app layers.
	// host and port are the original target (not the resolved IP).
	// cfg is the per-layer config retrieved via GreetConfig.LayerConfig(name).
	// Returns the (possibly upgraded) connection to pass to the next layer,
	// protocol-specific data, timing anchored from the shared start, and any error.
	// The caller (engine) owns closing the original transport conn; layers that
	// upgrade conn (e.g. TLS) must not close it — the engine's defer handles it.
	Handshake(ctx context.Context, start time.Time, conn net.Conn, host string, port int, cfg *GreetConfig) (next net.Conn, data LayerData, timing LayerTiming, err error)
}

type DNSResult struct {
	Address string        // resolved IP address
	TTDR    time.Duration // time to DNS resolved
}

type Engine struct {
	// contains filtered or unexported fields
}

type ErrorCode string

type GreetConfig struct {
	// contains filtered or unexported fields
}

type GreetError struct {
	Code     ErrorCode
	Message  string
	Protocol string // protocol name; empty for common errors
	Cause    error  // underlying OS or network error
}

type GreetOption func(*GreetConfig)

type GreetResult struct {
	// Protocol is the name of the outermost (application) layer, e.g. "tls".
	// For a bare TCP probe this is "tcp".
	Protocol string

	// Transport is the base transport used (tcp or udp).
	Transport Transport

	// TTDR is the time to DNS resolution, shared across all layers.
	TTDR time.Duration

	// RTT is the time to establish the transport connection.
	RTT time.Duration

	// Success is true only when every layer in the stack succeeded.
	Success bool

	// Layers contains per-layer results in stack order. Layers[0] is always the
	// base transport (tcp/udp) with TTFB = TTLB = RTT, followed by each
	// application layer in execution order.
	Layers []LayerResult

	// Error is the error from the failing layer, if any.
	// When Success is false and Error is non-nil, the Layers slice contains
	// partial results up to and including the failed layer.
	Error error
}

type LayerConfig interface {
	LayerConfigName() string
}

type LayerData interface {
	LayerDataName() string
}

type LayerInfo struct {
	Name        string
	Description string
	DefaultPort int
	Transport   Transport
}

type LayerResult struct {
	// Name is the layer slug (e.g. "tcp", "tls", "minecraft").
	Name string

	// TTFB is the time from the shared start anchor to the first byte of the
	// layer's response. For the transport layer, TTFB equals RTT.
	TTFB time.Duration

	// TTLB is the time from the shared start anchor to the last byte of the
	// layer's response. For the transport layer, TTLB equals RTT.
	TTLB time.Duration

	// Success indicates whether this layer completed without error.
	Success bool

	// Data holds the protocol-specific payload for this layer (e.g. *tls.TLSResult).
	// Nil for transport-only layers (tcp, udp).
	Data LayerData
}

type LayerTiming struct {
	TTFB time.Duration
	TTLB time.Duration
}

type Stack struct {
	Transport TransportLayer
	Apps      []AppLayer
	// contains filtered or unexported fields
}

type Transport string

type TransportLayer interface {
	// Name returns the transport slug (e.g. "tcp", "udp").
	Name() string

	// DefaultPort is the fallback port when none is specified.
	DefaultPort() int

	// Transport returns TransportTCP or TransportUDP.
	Transport() Transport

	// Dial resolves host, establishes the connection, and returns it together
	// with DNS and RTT timings. The caller is responsible for closing conn.
	//
	// start is the shared timing anchor owned by the engine; RTT (and TTDR
	// where applicable) must be measured as time.Since(start) so every layer
	// in the stack reports timings relative to the same origin.
	Dial(ctx context.Context, start time.Time, host string, port int) (conn net.Conn, ttdr time.Duration, rtt time.Duration, err error)
}