client

type ARQAction int

type ARQMessage struct {
	// MessageType distinguishes between envelope operations and copy commands.
	// This determines how the reply is processed.
	MessageType ARQMessageType

	// AppID identifies the application sending/receiving the message/reply.
	AppID *[AppIDLength]byte

	// QueryID is used for correlating replies with the original request.
	QueryID *[thin.QueryIDLength]byte

	// EnvelopeHash is the persistent identifier for this message.
	// Used to cancel resending via CancelResendingEncryptedMessage.
	// For copy commands, this is a hash of the WriteCap.
	EnvelopeHash *[32]byte

	// DestinationIdHash is 32 byte hash of the destination Courier's identity public key.
	DestinationIdHash *[32]byte

	// RecipientQueueID is the Courier queue identity.
	RecipientQueueID []byte

	// Payload is the MessageCiphertext (CourierQuery bytes) to send.
	Payload []byte

	// SURBID is the current SURB identifier.
	SURBID *[sConstants.SURBIDLength]byte

	// SURBDecryptionKeys is the SURB decryption keys for the current send.
	SURBDecryptionKeys []byte

	// Retransmissions counts the number of times this has been resent (for logging).
	Retransmissions uint32

	// SentAt contains the time the message was last sent.
	SentAt time.Time

	// ReplyETA is the expected round trip time to receive a response.
	ReplyETA time.Duration

	// EnvelopeDescriptor contains the key material to decrypt replies.
	EnvelopeDescriptor []byte

	// IsRead indicates whether this is a read operation (true) or write (false).
	IsRead bool

	// State tracks the current state in the stop-and-wait ARQ protocol.
	State ARQState

	// ReadCap is the read capability for BACAP decryption (only for read operations).
	ReadCap *bacap.ReadCap

	// MessageBoxIndex is the current message box index being operated on (only for read operations).
	MessageBoxIndex []byte

	// NoRetryOnBoxIDNotFound disables automatic retries on BoxIDNotFound for read operations.
	// When true, BoxIDNotFound is returned immediately. When false (default), reads retry
	// up to 10 times to handle replication lag.
	NoRetryOnBoxIDNotFound bool

	// NoIdempotentBoxAlreadyExists disables treating BoxAlreadyExists as idempotent success
	// for write operations. When true, BoxAlreadyExists is returned as an error.
	// When false (default), BoxAlreadyExists is treated as success (the write already happened).
	NoIdempotentBoxAlreadyExists bool
}

type ARQMessageType uint8

type ARQState uint8

type ARQTransitionResult struct {
	NewState     ARQState
	Action       ARQAction
	ShouldRemove bool
	ErrorCode    uint8
}

type CachedDoc struct {
	Doc  *cpki.Document
	Blob []byte
}

type Client struct {
	worker.Worker
	sync.RWMutex

	PKIClient cpki.Client

	// DialContextFn is the optional alternative Dialer.DialContext function
	// to be used when creating outgoing network connections.
	DialContextFn func(ctx context.Context, network, address string) (net.Conn, error)
	// contains filtered or unexported fields
}

type ConnectError struct {
	// Err is the original error that caused the connect attempt to fail.
	Err error
}

type ConsensusGetter interface {
	GetConsensus(ctx context.Context, epoch uint64) (*commands.Consensus2, error)
}

type Daemon struct {
	worker.Worker
	// contains filtered or unexported fields
}

type DisconnectedSession struct {
	AppID         *[AppIDLength]byte
	Token         [16]byte
	DisconnectAt  time.Time
	CleanupTimer  *time.Timer
	QueuedReplies []*Response
}

type EnvelopeDescriptor struct {
	// Epoch is the Katzenpost epoch in which the ReplyIndex is valid.
	Epoch uint64

	// ReplicaNums are the replica numbers used for this envelope.
	ReplicaNums [2]uint8

	// EnvelopeKey is the Private NIKE Key used with our MKEM scheme.
	EnvelopeKey []byte
}

type PKIError struct {
	// Err is the original PKI error.
	Err error
}

type ProtocolError struct {
	// Err is the original error that triggered connection termination.
	Err error
}

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

type Request struct {
	// AppID must be a unique identity for the client application
	// that is sending this Request.
	AppID *[AppIDLength]byte

	NewKeypair *thin.NewKeypair

	EncryptRead *thin.EncryptRead

	EncryptWrite *thin.EncryptWrite

	StartResendingEncryptedMessage *thin.StartResendingEncryptedMessage

	CancelResendingEncryptedMessage *thin.CancelResendingEncryptedMessage

	StartResendingCopyCommand *thin.StartResendingCopyCommand

	CancelResendingCopyCommand *thin.CancelResendingCopyCommand

	NextMessageBoxIndex *thin.NextMessageBoxIndex

	GetMessageBoxIndexCounter *thin.GetMessageBoxIndexCounter

	CreateCourierEnvelopesFromPayload *thin.CreateCourierEnvelopesFromPayload

	CreateCourierEnvelopesFromPayloads *thin.CreateCourierEnvelopesFromPayloads

	CreateCourierEnvelopesFromTombstoneRange *thin.CreateCourierEnvelopesFromTombstoneRange

	SessionToken *thin.SessionToken

	ThinClose *thin.ThinClose

	SendLoopDecoy *SendLoopDecoy

	SendMessage *thin.SendMessage

	// ResendARQ carries a SURB ID that the ARQ timer wants to retransmit.
	// Emitted by the listener's scheduler (never from a thin client), so
	// resends travel through the same fair, Poisson-gated path as fresh
	// sends. egressWorker routes it to arqDoResend.
	ResendARQ *[sphinxConstants.SURBIDLength]byte
}

type Response struct {
	// AppID must be a unique identity for the client application
	// that is receiving this Response.
	AppID *[AppIDLength]byte

	SessionTokenReply *thin.SessionTokenReply

	ShutdownEvent *thin.ShutdownEvent

	ConnectionStatusEvent *thin.ConnectionStatusEvent

	NewPKIDocumentEvent *thin.NewPKIDocumentEvent

	MessageSentEvent *thin.MessageSentEvent

	MessageReplyEvent *thin.MessageReplyEvent

	MessageIDGarbageCollected *thin.MessageIDGarbageCollected

	NewKeypairReply *thin.NewKeypairReply

	EncryptReadReply *thin.EncryptReadReply

	EncryptWriteReply *thin.EncryptWriteReply

	StartResendingEncryptedMessageReply *thin.StartResendingEncryptedMessageReply

	CancelResendingEncryptedMessageReply *thin.CancelResendingEncryptedMessageReply

	StartResendingCopyCommandReply *thin.StartResendingCopyCommandReply

	CancelResendingCopyCommandReply *thin.CancelResendingCopyCommandReply

	NextMessageBoxIndexReply *thin.NextMessageBoxIndexReply

	GetMessageBoxIndexCounterReply *thin.GetMessageBoxIndexCounterReply

	CreateCourierEnvelopesFromPayloadReply *thin.CreateCourierEnvelopesFromPayloadReply

	CreateCourierEnvelopesFromPayloadsReply *thin.CreateCourierEnvelopesFromPayloadsReply

	CreateCourierEnvelopesFromTombstoneRangeReply *thin.CreateCourierEnvelopesFromTombstoneRangeReply
}

type SendLoopDecoy struct {
}

type TimerQueue struct {
	worker.Worker
	// contains filtered or unexported fields
}