mtp

type AddressEmail struct {
	Username string
	Host     string
}

type AuthorizationHandler func(username string, password string) (bool, error)

type Client struct {
	// current customer number at the time of connection
	CurrentClientNo int32

	WhenConnected time.Time
	//	Listener                *LocalSmtpServer
	Helo                    string
	ListenerReverseHostname string
	ListenerAppName         string
	Flags                   bitmask.Flag64
	DidStartTlsNotAllowed   bool
	UseEhlo                 bool
	DidHeloCmd              bool
	WeClose                 bool
	Username                string
	Password                string
	RejectInfo              []string
	MaxErrorsPerConnection  int
	MaxRecipientsPerMessage int
	MaxMessageSizeInBytes   int64
	// copy of listener.DataStartReceivingTimeoutDuration
	DataStartReceivingTimeoutDuration time.Duration
	// copy of listener.DataStartReceivingTimeoutDuration because we set it after each data reception
	ProtocolTimeoutDuration time.Duration

	Con  net.Conn
	Text *textproto.Conn

	ErrorsCount int
	Session     Session

	Info ConnectionInfo
	// contains filtered or unexported fields
}

type CommandHandler func(c *Client, supervisor api.Supervisor, args string)

type Connection interface {
	GetInfo() ConnectionInfo
	GetHello() string
	GetUsername() string
	GetPassword() string
}

type ConnectionInfo struct {
	StartConnection time.Time
	Flags           bitmask.Flag64
	// instance no
	InstanceId int
	// another customer number since launch
	Id int64
	// it should be unique in the long run
	UUId            string
	LocalAddr       string
	RemoteAddr      string
	ReverseHostName string
}

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

type Decision string

type Delivery struct {
	// another message number from the moment the application was launched
	MessageNo uint32
	// unique id of this message
	UniqueId string
	From     AddressEmail
	To       AddressEmail
	// where to deliver, to which folder on disk
	Mailbox Maildir
	// If mailbox = Custom, here is its physical name.
	// If you want to filter mail independently based on folders,
	// set Mailbox = Custom in CustomMailbox = ".Notifications"
	// like in gmail
	CustomMailbox string
	Flags         ImapFlag

	// if true, it will be placed in the "${MAILBOX}/new" folder,
	// otherwise in "${MAILBOX}/cur"
	// do not confuse it with the //Recent flag, which should not be used in ImapFlags
	// because it is a session flag assigned by the IMAP server at the session opening level ( RFC3501 )
	IsRecent bool

	// When the message was forwarded
	IsPassed bool
	// contains filtered or unexported fields
}

type DeliveryProxy interface {
	GetUniqueId() string
	GetFrom() AddressEmail
	GetTo() AddressEmail
	GetMailbox() Maildir
	GetCustomMailbox() string
	GetImapFlags() ImapFlag
	IsRecent() bool
	Filesize() int
	AddHeader(name, value string)
	DelHeader(name string)
	SetHeader(name string, value string)
}

type EmailAddressType int

type ImapFlag map[string]bool

type Listener struct {
	MaxConnections int
	// MaxMessageSizeInBytes   int
	MaxErrorsPerConnection  int
	MaxRecipientsPerMessage int
	MaxMessageSizeInBytes   int64

	ProtocolTimeoutDuration           time.Duration
	DataReceivingTimeoutDuration      time.Duration
	DataStartReceivingTimeoutDuration time.Duration
	// contains filtered or unexported fields
}

type Maildir string

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

type MessageReceiverProxy interface {
	InitialMessageSize() int
	GetBodyOffset() int64
	GetMessage() *mail.Message
	GetBuffer() *filebuf.Buf
	MoveBufferPosToStart() error
	ArrivalTime() time.Time
	MoveBufferPosToMessageStartLine() error
}

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

type PostmasterHolder interface {
	MailerDaemonEmailAddress() string
}

type RejectBehaviour struct {
	Message string
	Close   bool
}

type RejectErr struct {
	Code            RejectErrCode
	AppendMessage   string
	CloseConnection bool
}

type RejectErrCode int

type Session interface {
	IsLoggedIn() bool

	// From The address from the from header but also the login of the logged-in person (if so)
	From() AddressEmail

	MaxMessageSize() uint64

	// IsAllowSendAs Can a user send a message from this address only to logged in users?
	IsAllowSendAs(addressEmailInAsciiLowerCase AddressEmail) (bool, error)

	// OnAuthorization Login authorization
	// @username is already IDN decoded value as lowercase ASCII
	// @password is plain text value received from client (we don't support anything other than plain text at this time)
	// @service service type
	// @useSsl connection use ssl
	OnAuthorization(username string, password string, service api.Service, useSsl api.Maybe) (bool, error)

	// ResetMessageReceivingStatus Consider the shipment, if any, as not yet there and will be prepared to pick up another
	ResetMessageReceivingStatus() error

	// AcceptMessageFromEmail The client wants to send us a new message, if you return an error,
	// you will not accept the message,
	// at this stage you can already check the sender of the message
	// because it is the actual so-called Envelope lowercase and already in ascii
	AcceptMessageFromEmail(senderAscii AddressEmail) error

	// AcceptRecipient Do you accept the recipient of this message? is already in ASCII format,
	// you can treat it as caching to load all mailboxes to which it will deliver the message
	AcceptRecipient(recipientAscii AddressEmail) error

	// AcceptMessage AcceptMessage: At this stage, you need to decide whether you will accept the message to all recipients or reject
	// it for everyone. If you can accept only some users, the rejection will always apply to the sender,
	// in the sense that we do not accept from him because he is a spammer.
	// You can return your own message, e.g. with message tracking or a link to a website that explains the reason,
	AcceptMessage(message *mail.Message) error

	// ProcessDelivery Physically deliver the message to the user's inbox
	ProcessDelivery(proxy MessageReceiverProxy, delivery Delivery, revHostname string) error

	Close()
}

type State int

type Super interface {
	// Hostname Default hostname
	Hostname() string
	// Name visible when logging in
	Name() string
	// Version Software number (visible reporting processes)
	Version() string

	Flags() bitmask.Flag64

	// DefaultMaxMessageSizeInBytes Used at the stage when we do not yet know or cannot determine the quota of the actual user
	DefaultMaxMessageSizeInBytes() int64
	DefaultMaxRecipientsPerMessage() int
}

type SupervisorExt interface {
	api.Supervisor
	api.MaildirStorage

	// OpenSession Opening or ending the session.
	// If we don't want to connect, we need to give the content to rejectMessage
	OpenSession(ci ConnectionInfo, l *slog.Logger) (session Session, err error)
	CloseSession(session Session)
}