protocol

type Code uint8

type Context interface {
	Packet() *radius.Request
	RootPayload() Payload
	State() string

	ProtocolSettings() interface{}

	GetProtocolState(p Type) interface{}
	SetProtocolState(p Type, s interface{})
	IsProtocolStart(p Type) bool

	// SessionValue / SetSessionValue access the session-scoped store shared by
	// every protocol handled under the same RADIUS State (see State.SessionData).
	SessionValue(key string) any
	SetSessionValue(key string, value any)

	ResponseModifier
	AddResponseModifier(func(r, q *radius.Packet) error)

	HandleInnerEAP(Payload, StateManager) (Payload, error)
	Inner(Payload, Type) Context
	EndInnerProtocol(Status)

	Log() Logger
}

type Inner interface {
	HasInner() Payload
}

type Logger interface {
	Debug(msg string, args ...interface{})
	Info(msg string, args ...interface{})
	Warn(msg string, args ...interface{})
	Error(msg string, args ...interface{})
	With(args ...interface{}) Logger
}

type Payload interface {
	Decode(raw []byte) error
	Encode() ([]byte, error)
	Handle(ctx Context) Payload
	Type() Type
	Offerable() bool
	String() string
}

type ProtocolConstructor func() Payload

type ResponseModifier interface {
	ModifyRADIUSResponse(r *radius.Packet, q *radius.Packet) error
}

type Settings struct {
	Protocols        []ProtocolConstructor
	ProtocolPriority []Type
	ProtocolSettings map[Type]interface{}
	Logger           Logger
}

type State struct {
	Protocols        []ProtocolConstructor
	ProtocolIndex    int
	ProtocolPriority []Type
	// TypeState holds each method's per-session state. It is shared by every
	// protocol handled under the same RADIUS State and is accessed both by the
	// request handler and by the background TLS handshake goroutine (via the
	// VerifyConnection / HandshakeSuccessful callbacks), so it must only be
	// touched through ProtocolState/SetProtocolState/IsProtocolStart, which guard
	// it with typeMu.
	TypeState map[Type]any

	// SessionData is a free-form, session-scoped store shared across every
	// protocol (outer and inner) handled under the same RADIUS State. Consumers
	// use Context.SessionValue/SetSessionValue to stash request-spanning data
	// (resolved identity, certificates, OTP progress, response attributes)
	// without maintaining a parallel, separately-locked map. Access it only
	// through SessionValue/SetSessionValue, which guard it with sessionMu so it
	// is safe to use from callbacks that run on the background TLS handshake
	// goroutine (e.g. VerifyConnection, HandshakeSuccessful).
	SessionData map[string]any
	// contains filtered or unexported fields
}

type StateManager interface {
	GetEAPSettings() Settings
	GetEAPState(string) *State
	SetEAPState(string, *State)
}

type Status int

type Type uint8