skymail

type Age time.Duration

type Attachment struct {
	Name        string `json:"name"`
	ContentType string `json:"content_type"`
	Size        int    `json:"size"`
}

type AttachmentData struct {
	Name        string `json:"name"`
	ContentType string `json:"content_type"`
	Data        []byte `json:"data"`
}

type Config struct {
	// Dir is the Maildir root. Inbox lives here, Sent in Dir/.Sent.
	Dir string
	// PK is the mailbox owner: mail is accepted only for <x>@<PK>.
	PK cipher.PubKey
	// PeerPK names the authenticated remote PK of an inbound
	// connection. The visor supplies it (dmsg and skynet addresses
	// differ); ok=false means the caller cannot be identified.
	PeerPK func(net.Conn) (cipher.PubKey, bool)
	// Dialers reach a peer's port 25, keyed by address suffix. A
	// suffix with no dialer cannot be sent to.
	Dialers map[string]skymailbridge.Dialer
	// Limits bound what the mailbox keeps; zero fields take defaults.
	Limits Limits
	// Outbox queues mail for a recipient that cannot take it yet and
	// retries it (RunOutbox). Off, such a send fails at once.
	Outbox bool
	// Sealer, when set, seals and opens envelopes as PK. The mailbox then
	// opens sealed envelopes (sealed.go) that any visor delivers, and files
	// them under the PK that signed them.
	Sealer Sealer
	// Helpers, with Sealer and the Outbox, names the visors that get a
	// sealed copy of queued mail to deliver too (helpers.go).
	Helpers func() []cipher.PubKey
	// Parker, with Sealer and the Outbox, parks queued mail on the recipient's
	// dmsg-async inbox hosts and fetches the mail parked for this visor
	// (parked.go).
	Parker Parker
	// RelayFor, with Sealer and the Outbox, reports whether this mailbox
	// carries sealed mail that pk hands over for someone else.
	RelayFor func(pk cipher.PubKey) bool
	// OnDeliver, when set, is told of each message the network files in the
	// inbox, once it is stored. It must not block.
	OnDeliver func(Delivered)
	Log       logrus.FieldLogger
}

type Control struct {
	Do func(*http.Request) (*http.Response, error)
}

type Delivered struct {
	ID      string
	From    string
	Subject string
	PeerPK  cipher.PubKey
}

type Host struct {
	PK cipher.PubKey
	// Listen opens Port on one of the Networks.
	Listen func(network string) (net.Listener, error)
	// Dialers reach a peer's Port, keyed by address suffix.
	Dialers map[string]skymailbridge.Dialer
	// PeerPK names the authenticated remote PK of an inbound connection.
	PeerPK func(net.Conn) (cipher.PubKey, bool)
	// Sealer seals and opens envelopes as PK. Nil turns sealed mail off.
	Sealer Sealer
	// Peers are the visors this one manages as a hypervisor and its own
	// hypervisors, the default helpers and relay-for lists.
	Peers func() (managed, hypervisors []cipher.PubKey)
	// Parker reaches the visor's dmsg-async inbox. Nil turns parking off.
	Parker    Parker
	OnDeliver func(Delivered)
	Log       logrus.FieldLogger
}

type KeySealer cipher.SecKey

type Limits struct {
	MaxMessageSize int64         `json:"max_message_size"`
	MaxTotalSize   int64         `json:"max_total_size"`
	MaxAge         time.Duration `json:"max_age"`
}

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

type Outgoing struct {
	// From is a local part ("me") or a full address of this mailbox.
	// Empty means "mail".
	From      string   `json:"from,omitempty"`
	To        []string `json:"to"`
	Cc        []string `json:"cc,omitempty"`
	Subject   string   `json:"subject"`
	Body      string   `json:"body"`
	InReplyTo string   `json:"in_reply_to,omitempty"`
	// Attachments go after the text as a multipart/mixed message.
	Attachments []OutgoingAttachment `json:"attachments,omitempty"`
}

type OutgoingAttachment struct {
	Name        string `json:"name"`
	ContentType string `json:"content_type,omitempty"` // default application/octet-stream
	Data        []byte `json:"data"`
}

type Parked struct {
	ID   string
	Host cipher.PubKey
	From cipher.PubKey
	Body []byte
}

type Parker interface {
	// Park leaves env, sealed for rcpt, on rcpt's inbox hosts and returns the
	// host that took it. ref names the message across retries.
	Park(ctx context.Context, rcpt cipher.PubKey, env []byte, ref string) (cipher.PubKey, error)
	// Unpark returns the mail parked for this visor without removing it.
	Unpark(ctx context.Context) ([]Parked, error)
	// Ack removes parked mail.
	Ack(ctx context.Context, done []Parked) error
}

type Queued struct {
	// Pending are the recipients still to reach.
	Pending     []string  `json:"pending"`
	Attempts    int       `json:"attempts"`
	LastError   string    `json:"last_error,omitempty"`
	NextAttempt time.Time `json:"next_attempt"`
	// GiveUp is when the Outbox stops trying. Zero means never.
	GiveUp time.Time `json:"give_up,omitzero"`
	// Handed are the helpers that hold a sealed copy to deliver too.
	Handed []string `json:"handed,omitempty"`
	// CarriedFor is set on sealed mail this visor delivers for the
	// visor that signed it. This visor cannot read it.
	CarriedFor string `json:"carried_for,omitempty"`
	// Parked are the recipient visors whose inbox hosts hold a sealed copy.
	Parked []string `json:"parked,omitempty"`
}

type RcptResult struct {
	Rcpt   string `json:"rcpt"`
	Err    string `json:"error,omitempty"`
	Queued bool   `json:"queued,omitempty"`
	// Via is the network that carried it: "skynet", "dmsg", or "local"
	// for this mailbox's own PK.
	Via string `json:"via,omitempty"`
}

type Relay struct {
	Helpers  *[]cipher.PubKey `json:"helpers,omitempty"`
	RelayFor *[]cipher.PubKey `json:"relay_for,omitempty"`
}

type Rendered struct {
	From        string       `json:"from"`
	To          string       `json:"to"`
	Cc          string       `json:"cc,omitempty"`
	Subject     string       `json:"subject"`
	Date        string       `json:"date"`
	MessageID   string       `json:"message_id,omitempty"`
	PeerPK      string       `json:"peer_pk,omitempty"`
	Verified    bool         `json:"from_verified"`
	RelayPK     string       `json:"relay_pk,omitempty"`
	Text        string       `json:"text"`
	FromHTML    bool         `json:"from_html,omitempty"` // Text was reduced from an HTML-only part
	Attachments []Attachment `json:"attachments,omitempty"`
}

type Sealer interface {
	Seal(msg []byte, rcpt cipher.PubKey) ([]byte, error)
	Open(body []byte) ([]byte, cipher.PubKey, error)
}

type SendReply struct {
	Result *SendResult `json:"result,omitempty"`
	Error  string      `json:"error,omitempty"`
}

type SendResult struct {
	ID         string       `json:"id,omitempty"`        // the Sent copy, when anything was delivered
	OutboxID   string       `json:"outbox_id,omitempty"` // the Outbox copy, when anything was queued
	MessageID  string       `json:"message_id"`
	Recipients []RcptResult `json:"recipients"`
}

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

type ServiceConfig struct {
	Host
	// Dir is the Maildir root, which also holds SettingsFile.
	Dir string
	// Base are the limits SettingsFile overrides.
	Base Limits
	// Outbox queues mail for a visor that cannot take it yet.
	Outbox bool
}

type Settings struct {
	Enable         *bool  `json:"enable,omitempty"`
	MaxMessageSize *int64 `json:"max_message_size,omitempty"`
	MaxTotalSize   *int64 `json:"max_total_size,omitempty"`
	MaxAge         *Age   `json:"max_age,omitempty"`
	Relay
}

type Status struct {
	Address     string          `json:"address"`
	AddressDmsg string          `json:"address_dmsg"`
	Dir         string          `json:"dir"`
	Limits      Limits          `json:"limits"`
	Usage       int64           `json:"usage"`
	Whitelist   []cipher.PubKey `json:"whitelist"`
	Unread      int             `json:"unread"`
	Total       int             `json:"total"`
	HasOutbox   bool            `json:"has_outbox"`
	Outbox      int             `json:"outbox"`
	Sealing     bool            `json:"sealing"`

	Helpers         []cipher.PubKey `json:"helpers"`
	HelpersDefault  bool            `json:"helpers_default"`
	RelayFor        []cipher.PubKey `json:"relay_for"`
	RelayForDefault bool            `json:"relay_for_default"`
}

type Summary struct {
	ID      string    `json:"id"`
	Folder  string    `json:"folder"`
	From    string    `json:"from"`
	To      string    `json:"to"`
	Subject string    `json:"subject"`
	Date    time.Time `json:"date"`
	Seen    bool      `json:"seen"`
	Size    int64     `json:"size"`
	// PeerPK is the sender PK the transport authenticated (inbox only).
	PeerPK string `json:"peer_pk,omitempty"`
	// FromVerified is true when the From address names PeerPK itself.
	FromVerified bool `json:"from_verified"`
	// RelayPK is the visor that delivered a sealed envelope for PeerPK.
	RelayPK string `json:"relay_pk,omitempty"`
	// Queue is where an Outbox message stands.
	Queue *Queued `json:"queue,omitempty"`
}