controlplane

type Addr struct {
	// IA is the ISD-AS of the peer.
	IA addr.IA
	// Addr is the peer's underlay address.
	Addr netip.AddrPort
	// IfID is the local egress interface toward the peer; zero means it is
	// resolved from the link table on write.
	IfID uint16
	// Path is the full data-plane path to the peer, supplied by the path
	// provider; nil sends over a one-hop path resolved from the link table.
	// The hop-field MACs come from the segment, computed by each on-path AS
	// at beacon time, not by the sender.
	Path *scion.Decoded
}

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

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

type BeaconerConfig struct {
	// IA is the local ISD-AS.
	IA addr.IA
	// Engine signs AS entries and verifies received ones.
	Engine *trust.Engine
	// MACKey is the data-plane forwarding key, MACing created hop fields
	// with the same algorithm the processor verifies.
	MACKey []byte
	// Store is the in-memory beacon store for candidates.
	Store *BeaconStore
	// DB is the persistent path database for registered segments.
	DB pathdb.DB
	// Links maps each external interface ID to the IA of the neighbor.
	Links map[uint16]addr.IA
	// Neighbors returns the currently discovered neighbors; nil disables
	// sending beacons (reception still works).
	Neighbors func() map[uint16]Neighbor
	// Sender sends beacon and registration RPCs over the SCION-native
	// channel.
	Sender SegmentSender
	// CoreRoute resolves the core's endpoint — the one-hop path when the
	// core is a neighbor, else the provider's route.
	CoreRoute func() *Addr
	// Core marks the founding core, which originates beacons.
	Core bool
	// PropagationInterval and RegistrationInterval override the defaults;
	// zero keeps them.
	PropagationInterval  time.Duration
	RegistrationInterval time.Duration
	// Now is the clock; nil uses time.Now.
	Now func() time.Time
	// SendTimeout bounds each RPC; zero uses the default.
	SendTimeout time.Duration
}

type Candidate struct {
	// Ingress is the interface the beacon arrived on: the node's parent
	// side of that link (ADR-0004's emergent link roles).
	Ingress uint16
	// PCB is the candidate beacon.
	PCB *segment.PCB
}

type Client struct {
	control_planeconnect.SegmentCreationServiceClient
	control_planeconnect.TrustMaterialServiceClient
	control_planeconnect.SegmentRegistrationServiceClient
	control_planeconnect.SegmentLookupServiceClient
	control_planeconnect.ChainRenewalServiceClient
}

type ControlPlane interface {
	control_planeconnect.SegmentCreationServiceHandler
	control_planeconnect.TrustMaterialServiceHandler
	control_planeconnect.SegmentRegistrationServiceHandler
	control_planeconnect.SegmentLookupServiceHandler
	control_planeconnect.ChainRenewalServiceHandler
}

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

type CoreClientConfig struct {
	// Domain is the core's DNS domain, verified as the TLS server name.
	Domain string
	// Conn is the SCION connection QUIC rides to the core.
	Conn *SCIONConn
	// RootCAs anchors the TLS verification; nil means the system roots.
	RootCAs *x509.CertPool
	// Locator resolves the core's SCION address: its IA, underlay endpoint,
	// and path — the one-hop path when the core is a neighbor, else the
	// reversed freshest up segment (proposal 0004). It is consulted at dial
	// time, so later dials pick up fresh paths. Nil falls back to SetCore.
	Locator func() *Addr
}

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

type DiscoveryConfig struct {
	// IA is the local ISD-AS.
	IA addr.IA
	// ControlAddr is the underlay address to listen on and to advertise to
	// neighbors. It must be reachable from the neighbor ASes.
	ControlAddr string
	// MACKey is the forwarding key, shared with the data plane, used to MAC
	// the one-hop paths of outgoing greetings.
	MACKey []byte
	// InternalAddr is the router's internal underlay address.
	InternalAddr string
	// Links maps each external interface ID to the IA of the neighbor.
	Links map[uint16]addr.IA
	// Interval between greetings; defaults to 1s if zero.
	Interval time.Duration
}

type EndpointTLSConfig struct {
	// Domain is the core's WebPKI identity; clients offering it as the TLS
	// server name are served the bootstrap channel. Empty on non-core nodes,
	// which serve only the SCION-native channel.
	Domain string
	// WebPKI serves the bootstrap channel; typically from ManageTLSCert. Nil
	// disables the channel.
	WebPKI *tls.Config
	// Engine provides the node's AS chain for the SCION-native channel.
	Engine *trust.Engine
}

type EnrollmentConfig struct {
	// IA is the node's ISD-AS.
	IA addr.IA
	// DB holds the node's chains and the pinned TRC.
	DB trust.DB
	// Key is the node's AS key.
	Key crypto.Signer
	// Remote enrolls against the core's endpoint; nil on the founding
	// core, which self-issues through the Issuer.
	Remote trust.Remote
	// Issuer self-issues the core's chains.
	Issuer *trust.Issuer
	// RetryInterval and InspectInterval override the defaults; zero keeps
	// them.
	RetryInterval   time.Duration
	InspectInterval time.Duration
	// Timeout bounds one enrollment attempt; zero uses the default.
	Timeout time.Duration
	// Now is the clock for validity decisions; nil uses time.Now. Tests
	// advance it past a chain's validity to exercise re-enrollment.
	Now func() time.Time
}

type Greeting struct {
	// IA is the ISD-AS of the sender.
	IA addr.IA
	// IfID is the sender's interface ID of the link the greeting travels on.
	IfID uint16
	// ControlAddr is the underlay address of the sender's control service.
	ControlAddr netip.AddrPort
	// CoreIA and CoreAddr name the control endpoint of the core the sender
	// reaches — itself, on the core. Nodes relay what they learned, so a
	// node without a direct link to the core learns where its enrollment
	// fetch is aimed once beaconing supplies the path. Zero CoreIA omits
	// the fields.
	CoreIA   addr.IA
	CoreAddr netip.AddrPort
}

type LookupService struct {
	// IA is the local ISD-AS.
	IA addr.IA
	// DB is the local path database.
	DB pathdb.DB
	// IsCore selects the core's handler behavior.
	IsCore bool
	// Cores enumerates the core ASes of an ISD named by the pinned TRC; nil
	// cores mean the TRC is not pinned.
	Cores func(isd addr.ISD) []addr.IA
	// Fetch requests segments from a core's control service.
	Fetch func(ctx context.Context, peer *Addr, src, dst addr.IA) (*cppb.SegmentsResponse, error)
	// CoreRoute resolves the core's endpoint to fetch through.
	CoreRoute func() *Addr

	// Now is the clock; nil uses time.Now.
	Now func() time.Time
	// contains filtered or unexported fields
}

type Neighbor struct {
	// IA is the ISD-AS of the neighbor.
	IA addr.IA
	// IfID is the neighbor's interface ID of the direct link.
	IfID uint16
	// ControlAddr is the underlay address of the neighbor's control service.
	ControlAddr netip.AddrPort
	// LastSeen is the time of the last received greeting.
	LastSeen time.Time
}

type PathProvider struct {
	// IA is the local ISD-AS.
	IA addr.IA
	// DB holds the local up segments.
	DB pathdb.DB
	// Lookup resolves down segments, fetching them from the core's control
	// service with expiry-aware caching.
	Lookup *LookupService
	// Bootstrap yields the reversed data-plane path of the freshest
	// unverified beacon originating at a core: the enrollment route of a
	// node that has not pinned the TRC yet — the WebPKI-authenticated
	// channel protects that exchange (proposal 0004).
	Bootstrap func(core addr.IA) *scion.Decoded
	// Cores enumerates the core ASes of an ISD named by the pinned TRC.
	Cores func(isd addr.ISD) []addr.IA
}

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

type PeerClientConfig struct {
	// Engine provides the node's AS chain as the client certificate.
	Engine *trust.Engine
	// Conn is the SCION connection QUIC rides.
	Conn *SCIONConn
	// PathTo resolves the data-plane path to a destination that is not a
	// direct neighbor; nil, or a nil result, sends over a one-hop path.
	PathTo func(dst addr.IA) *scion.Decoded
}

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

type SCIONConnConfig struct {
	// IA is the local ISD-AS.
	IA addr.IA
	// Bind is the underlay "host:port" address to listen on and advertise.
	Bind string
	// InternalAddr is the router's internal underlay address.
	InternalAddr string
	// MACKey is the data-plane forwarding key, used to MAC one-hop paths.
	MACKey []byte
	// Links maps each external interface ID to the IA of the neighbor.
	Links map[uint16]addr.IA
}

type SegmentSender interface {
	// Beacon propagates the extended PCB to the peer's beacon service.
	Beacon(ctx context.Context, peer *Addr, pcb *control_plane.PathSegment) error
	// RegisterSegments registers down segments with the core's control
	// service.
	RegisterSegments(ctx context.Context, peer *Addr,
		segments []*control_plane.PathSegment) error
}

type SegmentService struct {
	// Beaconer receives and verifies beacons and registrations.
	Beaconer *Beaconer
	// Lookup serves segment requests.
	Lookup *LookupService
}

type Server struct {
	Handler http.Handler
}

type Services struct {
	*TrustService
	*SegmentService
}

type TLSCertConfig struct {
	// Domain is the DNS domain of the certificate. It is a TLS identity,
	// never resolved: the SCION link is the locator.
	Domain string
	// CertFile and KeyFile point at the certificate and key in PEM format;
	// when set, they take precedence over ACME. This is the fallback for
	// offline deployments.
	CertFile string
	KeyFile  string
	// Storage is the directory for ACME state, e.g. account keys and
	// obtained certificates. Empty defaults to certmagic's data directory.
	Storage string
}

type TrustService struct {
	control_planeconnect.UnimplementedSegmentCreationServiceHandler
	control_planeconnect.UnimplementedSegmentRegistrationServiceHandler
	control_planeconnect.UnimplementedSegmentLookupServiceHandler

	// DB serves trust material from the local trust database.
	DB trust.DB
	// Issuer signs certificate chains. It is nil on nodes that do not issue
	// chains — everything but the founding core, in this milestone.
	Issuer *trust.Issuer
	// AllowAS optionally restricts enrollment to the listed ISD-ASes; nil
	// means open enrollment.
	AllowAS map[addr.IA]bool

	// Now is the clock used for chain lookups; tests replace it.
	Now func() time.Time
}