95.3.1. pepsi.state¶
per-message state object carried through the Pepsi pipeline
- Manual section:
7
95.3.1.1.1. Name¶
pepsi.state - the JSON state object attached to every Pepsi message.
95.3.1.1.2. Description¶
Every message in flight is one row of the pepsi.workqueue table. Besides the
envelope and the message body, each row carries a free-form JSON object — the
state column (PostgreSQL JSONB) — that travels with the message from
ingress to its terminal stage. The state is the only channel through
which the stages of the pipeline communicate: one stage records a verdict or a
piece of provenance, a later stage reads it.
This page documents the layout of that object: the keys that the stock stages write, when they are written, and which stages consume them. It is a data-format reference, independent of any configuration; the pipeline graph and the options that drive each stage are described in pepsi.conf(5).
95.3.1.1.3. Merge semantics¶
state is built up incrementally. Every terminal stage helper that mutates a
row merges its new keys into the existing object (the SQL terminal functions
evaluate state || $new), rather than replacing it. Consequently a key that
is written early survives for the whole lifetime of the message unless a stage
deliberately overwrites that specific key; examples are the origin
provenance seeded by ingress and the dsn parameters.
The merge is shallow: state || {"auth": {"arc": "pass"}} would replace
the whole auth object, not just its arc member. Stages that update one
member of a nested object therefore read the current object, amend it, and write
it back whole (that is what set_auth_verdict/set_auth_fields do for
auth.arc).
The one structural rewrite is dsn.rcpt, which is an array parallel to
rcpt_to: every helper that reduces a row to a subset of its recipients, or
fans a group out onto a sibling row, re-slices that array in lockstep, and the
alias stage rebuilds it when it writes an entirely new recipient list. A stage
must never touch rcpt_to without going through those helpers.
There is exactly one exception: pepsi-stage-bounce(1) replaces
state with a lone retry_since (below), keeping only a "required"
tls_required tag, when it rewrites a message into a
delivery-status notification, because the bounce is a brand-new null-sender
message that inherits none of the original’s provenance.
95.3.1.1.4. Top-level keys¶
The keys below are written by the stock pipeline. A stage that does not recognise a key simply leaves it untouched (the merge rule preserves it), so the set is open-ended; custom stages may add their own.
95.3.1.1.4.1. origin¶
(object) The SMTP-origin metadata of the connection that delivered the
message, seeded by pepsi-ingress(1). It is read by pepsi-stage-arc(1)
(which needs the authserv_id and the rendered ar_results fragment to
reproduce the ARC Authentication-Results identity without re-running
SPF/DKIM/DMARC) and by the relay stages, whose per-hop 8BITMIME/SMTPUTF8 downgrade
decision consults the original BODY=/smtputf8 declarations:
{
"origin": {
"remote_ip": "203.0.113.7", // connecting client IP (null for local injection)
"helo": "mail.example.com", // HELO/EHLO name announced by the client
"esmtp": true, // client used EHLO (ESMTP) rather than HELO
"smtputf8": false, // SMTPUTF8 requested on MAIL FROM
"body_8bit": false, // BODY=8BITMIME declared on MAIL FROM (RFC 6152);
// cleared by pepsi-stage-dkim-sign once it has
// converted the body to 7-bit
"declared_size": 12345, // SIZE= declared on MAIL FROM (null if absent)
"tls": { "version": "TLSv1.3",
"cipher": "TLS13_AES_128_GCM_SHA256",
"sni": "mx.example.net" }, // null on a cleartext session
"listener": { "local_addr": "0.0.0.0:25", "mode": "starttls" },
"reverse_dns": "host.example.com", // PTR name of remote_ip (null if none)
"iprev": "pass", // RFC 8601 iprev / FCrDNS verdict
"ip_blocklist": { "listed": true, // the downloaded IP blocklists' verdict
"lists": { "blocklist-de-mail": true } },
// (absent unless a list was consulted)
"auth_method": "sasl", // how the session authenticated (null if not)
"auth_mechanism": "PLAIN", // SASL mechanism (sasl sessions only)
"auth_identity": "alice", // authentication id / peer login
"auth_authzid": null, // authorization id, when distinct
"from_bound": true, // From: bound to the account (see below)
"authserv_id": "mail.example.org", // this receiver's id (for pepsi-stage-arc)
"ar_results": ";\r\n\tdkim=pass header.d=example.com;\r\n\tdmarc=pass ..."
// rendered Authentication-Results body, reused by
// pepsi-stage-arc for the AAR (no SPF/DKIM/DMARC re-run)
}
}
The four auth_* members describe how the session identified itself, as
opposed to the sibling auth key below, which is about what the message
claims. They are recorded because local_origin is a single boolean and
collapses two very different statements: “an account that we authenticated
submitted this” and “this arrived from an address that we chose to trust”. A
policy stage cannot recover that distinction from the boolean, and neither can a
milter, which is handed these members as the RFC 4954 {auth_type} /
{auth_authen} / {auth_author} / {auth_ssf} macros.
auth_methodHow the session authenticated:
sasl(an RFC 4954AUTHsucceeded),peercred(a UNIX-socket peer whose uid resolved to a permitted login),client-cert(a TLS client certificate matched a pin) ormynetworks(the peer address is inMYNETWORKS).nullwhen the session did not authenticate. A later SASLAUTHoverwrites an earlier connection-time method: it is the stronger claim, and the only one that carries a username.auth_mechanismThe SASL mechanism that succeeded (
PLAIN,LOGIN), upper-cased. Set only forauth_method = sasl. The non-SASL methods leave itnullrather than putting a non-mechanism token in a field that a filter may be comparing against a list of real mechanisms.auth_identityThe authentication identity: the SASL authcid, or the login to which a UNIX peer’s uid resolved.
nullformynetworksandclient-cert, which authenticate an address or a key and name nobody.peercredtherefore yields an identity with no mechanism — the honest description of a session that the kernel authenticated rather than SASL.auth_authzidThe authorization identity, recorded only when the client asked to act as somebody other than whom it authenticated as (SASL
PLAIN’s authzid field).nullwhen they are the same, which is the normal case: RFC 4954 permits an empty authzid and clients routinely repeat the authcid there.from_boundtruewhen theFrom:field names exactly one mailbox and that mailbox matched a concrete (wildcard-free)USERNAME_MAPentry of the authenticated account, or its defaultlogin@HOSTNAME;falseotherwise, including for a session with no account grant. Being permitted to send as an address is enough to send; being bound to it is what lets a submission speak for it. pepsi-stage-encrypt(1) registers a key from the message, or runs an e-mail key command, only whenauth_methodismynetworksorclient-cert, or it issasl/peercredwithfrom_bound = true: an account granted*@example.orgmay send as its colleagues but must not be able to plant a key for them.ip_blocklistWhat the IP blocklists that pepsi-reputation(1) downloaded say about
remote_ip:listedistruewhen at least one list names it, andlistshas atruemember for each list that does. Recorded only for an unauthenticated session from the network, and only when at least one enabled list was current enough to consult (MAX_AGE); otherwise the member is absent, so that “unknown” is never mistaken for “clean”. Route on it with pepsi-stage-if(1):STATE_PATH = origin.ip_blocklist.listed,VALUE = true, ororigin.ip_blocklist.lists.NAMEfor one list.
95.3.1.1.4.2. auth¶
(object) The inbound authentication verdicts that ingress computed, also
reflected in the prepended Authentication-Results header. The arc
verdict is seeded as none and overwritten by pepsi-stage-arc(1) once
it re-evaluates the inbound ARC chain (its spf/dkim/dmarc siblings
are left untouched). Read by pepsi-stage-check-whitelist(1), whose
dkim_required gate accepts a row on auth.dkim = pass, or on auth.arc =
pass only together with auth.dmarc = pass, and whose sealer_domain
gate consults auth.arc_sealers only when auth.arc is pass:
{
"auth": {
"spf": "pass", // SPF verdict (pass/fail/softfail/neutral/temperror/permerror/none)
"dkim": "pass", // DKIM verdict ("pass" only for a signature aligned with From:)
"dkim_temperror": ["example.org"], // d= of signatures with a temporary error; absent if none
"dmarc": "pass", // DMARC verdict (pass/fail/temperror/permerror; none = no record)
"arc": "none", // inbound ARC chain verdict (filled in by pepsi-stage-arc)
"arc_sealers": [] // d= of each inbound ARC-Seal (filled in by pepsi-stage-arc)
}
}
auth.dmarc_policy (string, optional) is the DMARC policy that the
From: domain publishes, none, quarantine or reject (the
strictest when the field names several domains), recorded whatever the verdict;
it is absent when no author domain publishes a record.
pepsi-stage-list-post(1) keys its DMARC mitigation on it.
auth.display_name_mismatch (string, optional) is present only on mail from
an unauthenticated session whose From: display name (or a comment in the
field) names an address other than its own mailbox’s: it holds that claimed
address, lower-cased. Ingress then also prepends
X-Pepsi-Warning: display-name-claims-other-address. See
pepsi-ingress(1), Authentication.
auth.warnings (array of strings, optional) lists every
X-Pepsi-Warning value ingress wrote on the message, in header order:
display-name-claims-other-address, from-has-bidi-or-invisible-characters
(a From: carrying a bidirectional control or an invisible character),
from-domain-resembles-served-domain (a From: domain with the skeleton
of a served domain but another name),
attachment-name-has-bidi-or-invisible-characters (an attachment file name
carrying such a character), duplicate-header-date,
duplicate-header-subject, duplicate-header-to,
duplicate-header-cc, duplicate-header-reply-to and
duplicate-header-sender (differing copies of that message-header field
accepted: always for Cc, for the others under MIME_ANOMALIES = log),
from-ambiguous (a From: that cannot be read one way only, or names
mailboxes in several domains), served-domain-not-authenticated (a
From: at a served domain from outside with no DMARC, aligned DKIM or
aligned SPF pass), served-sender-not-authenticated (a Sender: at a
served domain with no aligned DKIM or SPF pass) and
dmarc-fail-not-enforced (a DMARC fail that the configuration did not
act on). Absent when none was written, and never on mail from an authenticated
session. The last four also put the [external] tag on the Subject
unless EXTERNAL_SUBJECT_TAG = no. See
pepsi-ingress(1), Marking mail from outside.
95.3.1.1.4.3. local_origin¶
(boolean) Seeded by ingress: true when the delivering session was
authenticated (the client was in MYNETWORKS, completed a SASL AUTH,
presented a matching TLS client certificate, or — on a UNIX socket with
AUTH_PEERCRED, which is the default there — was a peer whose uid resolved to
a permitted login, the path every locally submitted message takes; see the
[pepsi-ingress-listener-*] sections in pepsi.conf(5)), false
otherwise. It marks mail originating from a trusted sender and is preserved
through the pipeline for downstream stages to test (the per-address settings
layer keys on the sender for local_origin messages, and
pepsi-stage-edit-settings(1) and the wallet self-service role of
pepsi-stage-auto-pay(1) only treat a message as a control message when it
is local_origin).
95.3.1.1.4.4. notice¶
(object) {"kind": KIND}, written only by the component that composed the
message, on a message that Pepsi wrote itself: enrol (the console
sign-in link, pepsi-httpd(1)), secure-link (the portal’s link, PIN and
receipt notifications), secretary (the challenge and the confirmation
notice), payment-request (pepsi-stage-anti-spam(1)), wallet
(pepsi-stage-auto-pay(1)’s self-service reply), settings
(pepsi-stage-edit-settings(1)’s reply), keys
(pepsi-stage-encrypt(1)’s key-command replies and key notices),
key-change (pepsi-stage-autocrypt-learn(1)’s notice) and vacation
(pepsi-stage-vacation(1)). secretary, payment-request and
vacation go to a third party and are left unmarked while a per-address
override applies to the message that caused them. Read by
pepsi-stage-encrypt(1) under NOTICE_SIGNER, which signs exactly the
marked messages with the deployment’s notice identity. Never present on mail
from the wire, on portal replies, list mail, bounces or TLS reports.
95.3.1.1.4.5. dsn¶
(object) The RFC 3461 delivery-status-notification parameters that the sender
requested, seeded by ingress: the message-level ret/envid and a
per-recipient array parallel to rcpt_to of notify/orcpt.
Every stage must preserve and honour it — the relay stages propagate the
parameters to the next hop only when it advertises DSN, and
pepsi-stage-bounce(1) consults the per-recipient notify to decide
whether to emit a report at all. A recipient’s entry also carries its RFC 7293
RRVS= value, verbatim, as rrvs: not a DSN parameter, but per recipient
and kept aligned with rcpt_to the same way. Local delivery tests it, the
relay stages pass it on (see pepsi-ingress(1)), and an alias or
~/.forward target does not inherit it. Such a target’s entry instead
carries expanded_from, the address that the sender used (the first address
of a chain of expansions), and pepsi-stage-bounce(1) reports on that
address instead of the target. pepsi-stage-aliases(1) and
pepsi-stage-dot-forward(1) write it, and create the array for it when the
sender gave no parameters. It is never sent to a next hop:
{
"dsn": {
"ret": "hdrs", // RET= (full|hdrs), if given
"envid": "QQ314159", // ENVID= xtext, if given
"rcpt": [ { "notify": ["success", "failure"], // NOTIFY= keywords
"orcpt": "rfc822;user@example.com", // ORCPT= xtext
"rrvs": "2014-04-03T23:01:00Z;C" } ] // RRVS= value
}
}
95.3.1.1.4.6. tls_required¶
(string) The RFC 8689 tag, seeded by pepsi-ingress(1): "required"
when the message arrived with the REQUIRETLS MAIL FROM parameter (on a
TLS-protected session, the only kind on which it is accepted), "no" when it
arrived without the parameter but carrying one TLS-Required: No header
field; absent otherwise. Every row split or cloned from the message inherits
it. The relay stages read it (pepsi-stage-relay-to-internet(1),
pepsi-stage-relay-to-smarthost(1)): "required" means validated TLS
to a validated next hop that advertises REQUIRETLS, or a bounce; "no"
makes the recipient domain’s DANE and MTA-STS policy advisory for this message.
pepsi-stage-bounce(1) returns a "required" message headers-only and
copies the tag onto the DSN, the one key of the original’s state that a DSN
keeps:
{ "tls_required": "required" }
95.3.1.1.4.7. bounce¶
(object) Written by any stage that routes a message to its
BOUNCE_STAGE — the delivery stages
(pepsi-stage-relay-to-internet(1), pepsi-stage-relay-to-smarthost(1),
pepsi-stage-relay-to-maildir(1), pepsi-stage-relay-to-lmtp(1)) and
pepsi-stage-discard(1), but equally pepsi-stage-milter(1),
pepsi-stage-block-language(1), pepsi-stage-anti-spam(1),
pepsi-stage-encrypt(1), pepsi-stage-decrypt(1),
pepsi-stage-secretary(1) and pepsi-stage-dot-forward(1). They all build it with the same shared helpers,
so the shape below is the same whichever stage wrote it. It is consumed by
pepsi-stage-bounce(1) to build the report. Its kind is
permanent (a failure bounce, Action: failed), success (a positive
report, Action: delivered), delay (Action: delayed) or unknown
(delivery was given up on and the message may have arrived, Action: failed
with Status: 4.4.2);
diagnostic and failed_recipient are the human-readable reason and the
affected recipient, and the optional notify/orcpt/envid are copied
from the recipient’s state.dsn entry so the bounce stage can honour
NOTIFY and echo the original ENVID/ORCPT; so is expanded_from,
which makes the report name that address with a generic diagnostic instead of
the target and its reply. The relay stages also
record structured next-hop detail (remote_mta, smtp_code,
enhanced_status, phase, reply_text) so a bounce template can state
precisely why the next MTA refused the message, and enhanced_status feeds the
DSN Status: field. pepsi-stage-relay-to-lmtp(1) has no bounce of its
own to route to: it writes this object on the row it routes to NEXT_STAGE,
QUOTA_LIMIT_STAGE, SIEVE_REJECT_STAGE, UNKNOWN_MAILBOX_STAGE or (for
success/delay) NOTIFY_STAGE, with remote_mta naming the LMTP
socket or host:port. A full mailbox refused by
pepsi-stage-relay-to-maildir(1) carries smtp_code 552,
enhanced_status 5.2.2 and phase local delivery. The
message-level ret is carried here too, for the same reason as envid: the
bounce stage clears state as it rewrites the message, so anything it needs
after that point has to be inside this object:
{ "bounce": { "kind": "permanent",
"diagnostic": "550 5.1.1 user unknown",
"failed_recipient": "bob@example.net",
"remote_mta": "mx.example.net",
"smtp_code": 550,
"enhanced_status": "5.1.1",
"phase": "RCPT TO",
"reply_text": "5.1.1 user unknown",
"notify": ["failure"],
"orcpt": "rfc822;bob@example.net",
"envid": "QQ314159",
"ret": "hdrs" } }
95.3.1.1.4.8. attempts / last_error / delay_sent¶
Scratch values that the delivery stages (and pepsi-stage-milter(1), for a
deferral) record when they pause a message for retry: attempts
(number) is the number of attempts so far, which is what drives the retry
backoff, and delay_sent (boolean, present only when true) marks that the
one-shot NOTIFY=DELAY DSN has already been emitted, so it is never sent
twice. pepsi-stage-anti-spam(1) writes delay_sent the same way at its
DELAY_DSN_AFTER checkpoint, and last_error while its merchant backend is
unavailable.
last_error (string) is the most recent error text. It is not confined
to the retry path: the delivery, milter, crypto, DKIM-signing and
~/.forward stages also write it when they fail a message terminally, so on a
failed row it is the first thing to read (pepsi-queue(1) shows it as
part of the row’s state, and pepsi-status(1) lists it under each stuck
message).
95.3.1.1.4.9. temporary_failures / temporary_stage¶
(number / string) Written, together with last_error, by the stage
scaffolding when a stage’s error was not marked permanent – the host’s fault
rather than the message’s (see pepsi-dispatch(1)): the number of times the
message has been paused for it so far at temporary_stage, which drives the
back-off from one minute doubling up to an hour. A count recorded at another
stage is not continued. Removed when the worker gives up.
95.3.1.1.4.10. failed_stage / failure_class / failed_at¶
The record of a failure that happened on this host rather than at the next hop.
failed_stage (string) is the stage at which it happened. failure_class
(string) says how it ended: permanent (the stage marked the error as a
defect of the message), retries-exhausted (retried until MAX_LIFETIME),
crashed or timed-out (the message crashed or hung its worker three
times), or quarantine-expired (held at a quarantine stage past
[pepsi-queue] QUARANTINE_MAX_AGE_DAYS, see pepsi-queue(1), or past a
pepsi-stage-quarantine(1) stage’s MAX_HOLD on its way to
EXPIRE_STAGE).
failed_at (string, RFC 3339) is stamped by the database whenever
the row becomes failed or timeout; pepsi-failure-bouncer(1)’s
MIN_AGE counts from it. pepsi-stage-bounce(1) builds a DSN from
failed_stage and failure_class when no relay reported the failure
(bounce above), with a generic text; last_error is never copied into a
DSN.
95.3.1.1.4.11. arc_temperrors¶
(number) Written by pepsi-stage-arc(1) each time it met a temporary DNS
error while validating an inbound ARC chain: the message is paused five minutes
and retried, at most three times; if the lookups still fail after the third
pause the chain is sealed cv=fail as a failed one would be.
95.3.1.1.4.12. mime_anomalies, mime_normalise, mime_normalised¶
Written by pepsi-ingress(1) for a message whose MIME structure is
ambiguous (see its Ambiguous MIME structure). mime_anomalies (array of
strings) lists the classes found — empty-boundary, nul-in-header,
conflicting-content-type, conflicting-transfer-encoding,
encoded-word-boundary, conflicting-date, conflicting-subject,
conflicting-to, conflicting-reply-to, conflicting-sender (the hard
classes, refused under MIME_ANOMALIES = enforce), conflicting-cc (the
marked class, stored as received with X-Pepsi-Warning),
unknown-transfer-encoding, qp-soft-break-whitespace,
base64-non-alphabet, missing-close-delimiter,
duplicate-content-type, duplicate-transfer-encoding,
duplicate-header-field, delimiter-in-epilogue (the soft classes,
rewritten). mime_normalise
(boolean) is true while the soft-class rewrite is owed to
pepsi-stage-arc(1), which sets it false once done: a message that
arrived carrying an ARC chain is stored as received so the chain can be verified
over the bytes that its sealers signed. mime_normalised (string) names the
program that rewrote the message, pepsi-ingress or pepsi-stage-arc;
absent when nothing was rewritten (log mode, or only inside signed or
encrypted parts).
95.3.1.1.4.13. ingress_milter¶
(array of objects) Written by pepsi-ingress(1) for a message that
milters were consulted about during the SMTP session (see its Milters). One
object per milter that decided something about the message, in the order they
were asked: name (string), the milter’s section suffix; verdict
(string), continue, accept or failed; modifications (array of
strings, when any), what it changed (addheader:X-Spam-Score, replbody,
addrcpt:…); failed (boolean, when true), the milter could not be
consulted and its ON_FAILURE let the message in. A refused or discarded
message is not stored, so no row carries a refusal.
95.3.1.1.4.14. arc_original¶
(string) Written by pepsi-ingress(1), with the value
pepsi-ingress, when a milter changed a message that carries an ARC chain:
the message as received is kept in workqueue.arc_original_body_id, and
pepsi-stage-arc(1) verifies the inbound chain over those bytes while
sealing the stored message.
95.3.1.1.4.15. strikes¶
(number) Written by pepsi-dispatch(1) each time the message crashed its
worker or held it past MAX_RUNTIME; the third strike fails the message,
except that MAX_LIFETIME decides for a worker killed in a delivery stage.
95.3.1.1.4.16. lost_acks¶
(number) Written by pepsi-stage-relay-to-lmtp(1): how many attempts sent
the whole message and got no reply. Together with strikes at that stage it
decides when the stage stops and reports that the outcome is unknown.
95.3.1.1.4.17. retry_since¶
(string, RFC 3339) Written by pepsi-stage-bounce(1) on the DSN it
builds, which replaces the message in its row: the moment from which the
stages’ MAX_LIFETIME is counted instead of the row’s arrival time, so a DSN
is not born already expired.
95.3.1.1.4.18. srs¶
(object) Written by pepsi-stage-srs(1) when it rewrites the envelope sender, recording the address that it replaced:
{ "srs": { "original": "alice@example.org" } }
It exists for a DSN this deployment originates itself. SRS necessarily runs
before the delivery stage, since rewriting the envelope for the hand-off is
its whole purpose. So by the time a delivery stage calls complete_success,
or a relay routes a failure to its BOUNCE_STAGE, the row’s mail_from is
one of our own SRS aliases. pepsi-stage-bounce(1) would then address the
DSN to that alias. The DSN would go out to the next hop and come back in through
our own MX to be decoded, and it would have to survive the entire inbound
pipeline as a null-sender message, only to reach an address that was in the row
all along. Where that round trip does not work, the DSN is lost with nothing
reporting it.
The bounce stage therefore prefers this value over mail_from. It is recorded
rather than recovered by reversing the alias because Srs::reverse needs the
SRS HMAC secret, and a stage whose job is composing a bounce has no reason to
hold key material: the sender is ordinary message metadata, which is what
state is for.
Written only when absent, so a message rewritten twice keeps the address that names a real correspondent rather than the intermediate alias. A bounce (null sender) is never rewritten and so never records one; an empty value reads as absent, and the bounce stage falls back to the envelope sender. A copy that leaves with a forward return address records it too.
95.3.1.1.4.19. forward_return¶
(boolean) Written by pepsi-ingress(1) on the row that it makes from a
remote report about a forwarded copy (one sent to the copy’s forward return
address, see pepsi-stage-srs(1)). The row enters at the bounce stage with
the original sender as envelope sender, the address that the sender used as its
recipient and a bounce record carrying the report’s outcome and status
class only; pepsi-stage-bounce(1) turns it into this host’s own DSN. The
report itself is not stored.
95.3.1.1.4.20. pay_deadline¶
(number) Written by pepsi-stage-anti-spam(1): Unix epoch seconds, the
deadline by which the pay-to-send order must be settled. It is kept in state
(rather than the row’s timeout column) because the dispatcher nulls
timeout whenever it re-queues a paused message. A value written as a JSON
string is read as “no deadline”, so anything setting this by hand must write a
number. The stage short-circuits its payment gate when
state.paid is true.
95.3.1.1.4.21. spam / paid¶
(boolean) Anti-abuse short-circuit flags.
spam is written by pepsi-stage-check-whitelist(1), which sets it
false on a whitelist match (and otherwise leaves it unset), and by
pepsi-ingress(1), which sets it false for a message whose only
recipient is <Postmaster> (RFC 5321 §4.5.1 reachability), and by
pepsi-stage-secretary(1), which sets it false on a message it releases
because its sender confirmed. A false value makes
pepsi-stage-block-language(1), pepsi-stage-secretary(1) and
pepsi-stage-anti-spam(1) forward the message without applying their gate.
A true value makes pepsi-stage-anti-spam(1) drop the message rather
than gate it, sends it down pepsi-stage-secretary(1)’s timeout path,
suppresses key learning in pepsi-stage-autocrypt-learn(1) unless that
stage’s LEARN_FROM_SPAM is on, and blocks the RFC 3834 auto-responders that
use the shared suppression rules (pepsi-stage-vacation(1), the secretary’s
challenge and the mailing-list auto-responses). Only an explicit boolean
counts: an absent key triggers neither behaviour.
Note that no stock stage ever writes spam = true: the writers above
only ever write false. The true value is the hook that a milter-driven
pipeline, an operator or a site-specific stage uses — the same arrangement as
paid below.
paid is written by pepsi-stage-anti-spam(1) itself, and only ever as
false: it stores paid = false alongside pay_deadline on every pause
once the order exists (a pause because the order could not be created yet
carries pay_deadline and last_error only), which is what marks the message as awaiting payment. When the merchant reports
the order settled the stage simply advances the message, so no stage in the tree
ever writes paid = true — that value is an override hook for an operator or a
site-specific stage, and the payment gate is skipped when it is set (as it is
when spam is false).
95.3.1.1.4.22. dot-forwarders¶
(array of strings) The lower-cased login names whose ~/.forward files
forwarded this row, i.e. the forwarding chain that led to it, maintained by
pepsi-stage-dot-forward(1) as a forwarding-loop guard. A forwarded row
gets the chain of the row it came from plus the one login that forwarded it, so
the list describes one forwarding path, not every ~/.forward the message
has passed through. Because a forwarded message restarts the pipeline, a
recipient whose user is already listed here is bounced instead of being run
through its ~/.forward again, so a cycle (~bob → alice, ~alice →
bob) terminates.
95.3.1.1.4.23. language¶
(string) Written by pepsi-stage-detect-language(1) as an
Accept-Language-style string describing the detected body language(s), with
q-values in preference order.
pepsi-stage-block-language(1) reads it to score the message against its
allow/deny lists, but it is equally the localisation key: every stage that
composes prose for a human picks its template or message language from it,
falling back, when it is absent or names nothing supported, to the stage’s
DEFAULT_LANGUAGE where it has one (pepsi-stage-vacation(1),
pepsi-stage-secretary(1)) and to English otherwise — pepsi-stage-vacation(1) (the out-of-office notice),
pepsi-stage-anti-spam(1) (the payment request),
pepsi-stage-secretary(1) (the challenge),
pepsi-stage-encrypt(1), pepsi-stage-auto-pay(1) and
pepsi-stage-secure-link(1) (their reply messages) and pepsi-stage-edit-settings(1) (its confirmation or error
reply). That is why a deployment that does no language blocking may still want
the detection stage in the pipeline.
95.3.1.1.4.24. vacation¶
(object) Written by pepsi-stage-vacation(1) when it has answered a message on the recipient’s behalf, recording what it did:
{ "vacation": { "notified": true,
"recipient": "alice@example.org", // who is away
"range": "2026-08-01:2026-08-14",
"language": "de" } } // the notice's language
No stage acts on it unless you configure one to: it exists so the decision is visible in pepsi-queue(1), so pepsi-stage-if(1) can branch on it, and so a support question about a surprising out-of-office reply is answerable from the row rather than from the log. Absent on every message that was not answered.
95.3.1.1.4.25. secretary¶
(object) Written by pepsi-stage-secretary(1). On a message it holds:
{ "secretary": { "challenge": "00112233445566778899aabbccddeeff", // the cookie
"deadline": 1769812345, // Unix seconds, when it expires
"whitelist": "correspondents" } } // where a confirmation writes
A confirmation adds "confirmed": true as it releases the row (the stage then
forwards it with spam = false); a bounced challenge adds "abandoned": true,
sending it down the timeout path early. A message the stage would not challenge
and routed to its UNCHALLENGEABLE_STAGE carries { "secretary": {
"unchallengeable": "<reason>" } } instead. The timeout path removes the key
entirely: nothing of a challenge outlives it. Like pay_deadline, the deadline
is kept in state because the dispatcher clears the row’s timeout when it
requeues a paused message.
95.3.1.1.4.26. keydisc¶
(object) What a parked message is waiting for: the correspondent address whose key could not be found in the cache, and when the wait began:
{ "keydisc": { "address": "bob@example.com", // the address a key is wanted for
"since": 1769812345 } } // Unix seconds, when the park happened
It is written by the key-discovery park terminal, which in one round-trip
commits whatever the stage had already rewritten, merges this key, sets the row
paused with a retry timeout, and enqueues a request in
pepsi.key_request. A pepsi-keydisc(1) service that settles that request
matches waiters on keydisc.address — through a partial index on exactly that
expression — and flips them back to pending, so a stage must not rename or
hand-write the key. The retry timeout is the safety net for a deployment
running no discovery service at all: it is always set later than the discovery
deadline, so the release normally happens first.
The release only moves the row’s status and clears its timeout, so the
key survives it: a resumed message still carries the record of the wait that has
just ended, and a stage that parks again simply overwrites it.
95.3.1.1.4.27. secure_link¶
(object) Marks a message that pepsi-httpd(1)’s secure-link portal injected: a reply that a recipient typed into the portal after opening a message that pepsi-stage-secure-link(1) had sealed there:
{ "secure_link": { "reply": true,
"token": "b3d1…" } } // the portal token replied to
local_origin is deliberately absent from such a message, and that absence
is the whole security property: it is the single bit separating a portal reply
from an open relay. Without it the reply cannot take the submission path, so
there is no relaying as us, no auto-whitelisting of its recipient and no
SRS-as-local-origin. It is treated as what it is: inbound mail that happens to
have originated at our own web server.
95.3.1.1.4.28. tlsrpt¶
(boolean) A loop-guard flag set on a message that is itself an SMTP TLS
Reporting report (pepsi-tlsrpt(1)). The relay stages skip recording a
pepsi.tls_session row for such a message, so a report about a failed report
delivery cannot recurse.
95.3.1.1.4.29. auth.arc¶
Overwritten by pepsi-stage-arc(1) with the verdict of the inbound ARC
chain that it re-evaluated, replacing the none that ingress seeded under
auth (see the auth key above): none (no chain), pass or fail
(any chain that did not validate, including a DNS temperror and a set signed
with rsa-sha1).
95.3.1.1.4.30. auth.arc_sealers¶
(array of strings) Written by pepsi-stage-arc(1) alongside auth.arc:
the d= of the ARC-Seal fields that the message arrived carrying,
lower-cased, trailing root dot removed, de-duplicated and ordered by instance so
the ADMD closest to the originator comes first. Our own ARC_DOMAIN is never
present — the list is read before this stage’s own set is rendered:
{ "auth": { "arc": "pass", "arc_sealers": ["lists.example.org", "mx.forwarder.example"] } }
It exists because auth.arc alone cannot support a policy decision: RFC 8617
§8.4 states that a valid chain conveys no trustworthiness, only that the
named ADMDs handled the message, and leaves the rest to the receiver. Naming an
acceptable intermediary is that local policy, and this is what such a rule is
matched against — the sealer_domain rows of
pepsi-stage-check-whitelist(1).
For a chain that validated, only the sealers whose own ARC-Message-Signature
still verifies over the message are listed: chain validation checks only the
newest one, and the seals do not cover the message, so a genuine set copied onto
other content would otherwise name a sealer that never saw it. For a chain that
did not validate, the array is the record of what the message claimed; a seal
parses without verifying. Every reader must therefore require auth.arc = pass
before trusting an entry, which check-whitelist does by discarding the whole list
otherwise.
95.3.1.1.4.31. crypto¶
(object) What the end-to-end cryptography stages did. The outbound half,
crypto.out, is written by pepsi-stage-encrypt(1):
{ "crypto": { "out": {
"signed": true,
"protocol": "openpgp",
"signer": "alice@example.org",
"signer_fingerprint": "ABCD…",
"recipients": {
"bob@example.net": { "outcome": "encrypted",
"protocol": "openpgp",
"fingerprint": "1234…",
"key_source": "wkd",
"trust": "wkd-advanced",
"content_algorithm": "seipdv2-aead",
"downgraded": false } },
"key_attached": true } } }
signer is the From: author, never the envelope sender: the signature is
about the author that the recipient sees. Each recipient’s outcome is one of
encrypted, signed-only, cleartext, secure-link, bounced or
oversize, and route names the ON_NO_KEY/ON_OVERSIZE path taken
when it was not the ordinary one. reason carries a short phrase for the
operator’s log and for the bounce.
content_algorithm and downgraded are recorded so an operator can answer
“who are we still talking to in SEIPDv1?” without reading logs. downgraded
appears only beside a content_algorithm: false on a recipient that was
not encrypted at all would read as “we encrypted, without downgrading”, which is
a different claim.
key_source and trust are both own when the recipient is an address
for which this deployment holds its own identity. That is not a rank on the
discovery ladder: our own key pre-empts the pepsi.peer_key cache entirely
for such an address, so no MIN_TRUST floor applies and no discovered key was
consulted. See pepsi-stage-encrypt(1).
Because the stage splits divergent recipients one per row, a row’s
recipients object normally holds exactly the recipients in that row’s
rcpt_to.
key_attached (boolean, present only when true) records that the sender’s
public key went out as an application/pgp-keys file
(ATTACH_KEYS_AS_FILES). client_protected (boolean, present only when
true) records that the user’s own mail client had already encrypted the
submission, so the stage left it alone: no encryption, signature, Autocrypt:
header or key file of Pepsi’s.
The inbound half, crypto.in, is written by pepsi-stage-decrypt(1):
{ "crypto": { "in": {
"encrypted": true,
"outer_gossip": true,
"decrypted": true,
"decryption": "decrypted",
"protocol": "openpgp",
"decrypted_with": { "identity": 7,
"address": "bob@example.org",
"fingerprint": "ABCD…" },
"signature": { "status": "valid",
"signer": "alice@example.net",
"fingerprint": "1234…",
"key_source": "wkd",
"trust": "wkd",
"algorithm": "ed25519",
"signed_at": 1785000000,
"covers_plaintext": true },
"layers": [ { "kind": "encrypted", "protocol": "openpgp",
"encoding": "pgp-mime", "verdict": "good",
"container": "seipdv1-mdc", "downgraded": true },
{ "kind": "signed", "protocol": "openpgp",
"encoding": "pgp-mime", "verdict": "good" } ] } } }
decryption is not-encrypted, decrypted, failed, for-client
or withheld; on failed a sibling failure key carries the machine-readable reason
(no-decryption-key, decryption-failed, too-large, …), and
failed_unauthenticated (boolean, present only when true) records that the
ciphertext that failed carried no integrity protection (or could not be
identified), which is what ON_DECRYPT_FAILURE = bounce-if-unproblematic
drops rather than bounces. withheld is a message passed on unopened for the
recipient’s client, by UNAUTHENTICATED_PLAINTEXT = require-signature or
OPEN_ENVELOPED_DATA = no. route names the
ON_DECRYPT_FAILURE/ON_BAD_SIGNATURE path taken when it was not the
ordinary one (quarantine, bounce, bounce-generic or drop; a bad
signature from an enveloped-data container under ON_BAD_SIGNATURE =
bounce is drop).
for-client means the message is encrypted to the recipient’s own MUA
key (an identity with custody = client, whose private half lives only in
their mail client) and was passed on unopened, even when one of our own keys
was a recipient too. It is not a failure: ON_DECRYPT_FAILURE is not
consulted. The sibling for_client is then true and client_fingerprint
names the key. Nothing was verified, so signature_verified is not set.
unauthenticated (boolean, present only when true) records that the
plaintext came out of a ciphertext without integrity protection (an S/MIME
EnvelopedData container, container on the layer) and no valid signature
inside it covers the plaintext, so nothing rules out a block-wise rewrite
(EFAIL’s CBC gadgets). sanitised (text) then says the plaintext was
reduced to content that no client renders as markup ([stage-decrypt]
UNAUTHENTICATED_PLAINTEXT = text); it is also set, without unauthenticated,
when DECRYPTED_MARKUP = text reduced an authenticated plaintext. withheld as the decryption means
the same message was passed on unopened instead (require-signature): not a
failure, nothing opened it for the user, and decrypted is false.
isolated (array, present only when not empty) lists the rules that changed
the message before decryption or a recovered plaintext: encrypted (the first
encrypted unit of a message that carried ciphertext beside other content became
the message and the other parts were moved into inert attachments,
ISOLATE_ENCRYPTED) and signed (unsigned content beside signed content was
dropped, ISOLATE_SIGNED). encrypted is also listed when only attached
messages were reduced; nested (integer, present only when not zero)
counts them.
protected_mismatch (array, present only when not empty) names the
protected header fields (from, to, reply-to, mail-reply-to,
mail-followup-to, subject) whose
signed copy inside the message differs from the outer field that the recipient
is shown. A from or reply-steering (reply-to, mail-reply-to,
mail-followup-to) mismatch costs the signature its trust, because the
signature then vouches for a message from somebody else, or replies would go
somewhere the signer did not say: valid is reported as valid-untrusted,
so signature_verified is not set. A reply-steering field that a mailing list
added (List-Id present, none of the three signed) is reported but
keeps valid, with signature.reply_to_unsigned (boolean, present only
when true). A subject that differs only by bracketed segments inserted
in front is no mismatch; a larger difference is reported and, on a valid
signature, the signed subject is shown instead, recorded as
subject_promoted (boolean, present only when true). to differences
are only reported, since forwarding and list software change it legitimately.
An outer Subject: that is header protection’s own placeholder does not
count. The same list appears as protected-mismatch= in the
X-Pepsi-Crypto header.
signer_domain (string, present only then) is the signer’s domain as an
A-label when it is an internationalised domain name or looks like a served or
known domain (signature.withheld = lookalike-domain).
usually_signed (object, present only then) is set on a message without a
valid signature whose From: address had one within
MISSING_SIGNATURE_WINDOW_DAYS: last_valid_signature (integer) is
when that signature last verified, in Unix seconds (pepsi.signed_sender).
X-Pepsi-Crypto carries it as usually-signed=<date>; what follows is
ON_MISSING_SIGNATURE’s (pepsi-stage-decrypt(1)).
demoted and dropped (integers, present only when not zero) count the
parts that ISOLATE_ENCRYPTED moved out of the message: demoted those
delivered as attachments (each file into which a moved ciphertext was opened
counts once), dropped those not delivered – beside a PGP/MIME or S/MIME
container passed on unopened, and, beside a signed plaintext, cleartext and
ciphertext not signed by the same key.
The presence of encrypted or decrypted set to true also tells
pepsi-stage-bounce(1) and the auto-replying stages to withhold the content
of the message: a DSN then quotes only its addressing fields, and no reply quotes
its subject.
signature.binding (string, present when a key was found) is how the
signer’s key related to the From: address as the verifier saw it:
matched, mismatched or no-identity (the key names no address).
signature.anchor (string, present on an anchored S/MIME signature) is the
fingerprint of the ca_trust anchor at which the chain ended.
signature.bound_to (string, present only on ``valid``) is the address to
which the signature is bound, the one that the [verified: …] tag names.
signature.withheld (string, present only then) is why a signature that
verified is valid-untrusted rather than valid: ciphertext-cover,
protected-from, protected-subject, reply-to, no-identity,
display-name,
multiple-from, lookalike-domain, old-signature or
future-signature (pepsi-stage-decrypt(1), What
valid is granted for). signature.signed_at (integer, present only then)
is the creation time that the signature claims, in Unix seconds; it is compared
with the arrival time under MAX_SIGNATURE_AGE_DAYS. signature.unsigned_surface (string, present only
then) is why a verified clearsigned block is partial: armor-headers
or html.
signature.covers_plaintext is present whenever there is a signature verdict:
true when the verdict was granted by a signature over the plaintext,
false when it came from a layer wrapped around ciphertext.
pepsi-stage-autocrypt-learn(1) records that a correspondent holds one of
our keys (pepsi.peer_has_own_key) only on a valid or valid-untrusted
signature with covers_plaintext = true whose signer is the From:
address, on a message we decrypted.
outer_gossip (boolean, present only when true) records that the message
as it arrived already carried an Autocrypt-Gossip: field on its outer
header block — something that any hop on the path could have written, and which
inline-PGP reassembly can carry through decryption. It is written here because
the plaintext is committed over the arriving bytes, so nothing downstream could
answer the question later. Together with encrypted it is what
pepsi-stage-autocrypt-learn(1) consults before learning any gossiped key:
an unauthenticated outer field vetoes the lot. If LEARN_GOSSIP is on and
nothing is being learnt from an encrypted message, this is the key to look at.
signature.status is one of:
noneNo signature.
validCryptographically sound and the key was anchored — an X.509 chain to a
ca_trustanchor, or an OpenPGP key from WKD, from DNSSEC-validated DANE, added by the operator, or our own identity for the sender — and the signer is bound to theFrom:line as the reader sees it. A key from a key server (VKS, LDAP) isvalid-untrusted.partialWould be
valid, but the reader is shown text beside the signed text that the signature does not cover: an inline clearsigned block, delivered as it arrived, with armor header lines other thanHash:or in atext/htmlpart (signature.unsigned_surface). No tag, nosignature_verified.valid-untrustedSound, but the key could not be tied to anything: a first-seen key, one learnt from the message itself, or a certificate from a CA for which this deployment holds no anchor — or an anchored signature from which one of the stage’s rules withheld
valid(signature.withheld): a protectedFrom:orReply-To:that differs, a certificate naming no mailbox, a display name showing another address, severalFrom:mailboxes, a look-alike signer domain. Never reported as ``valid``; that distinction is what the stage exists to make.invalidThe signature does not verify, or the signer’s certificate is expired, revoked or bound to a different address.
signature.failuresays which.unverifiableNo key was available for the claimed signer.
signature.key_source and signature.trust here carry the crypto layer’s
own provenance vocabulary (anchor, dane, wkd, autocrypt,
pinned, attached, unknown), which is coarser than the outbound half’s
ladder names. A signature checked against our own identity for the claimed
sender reports pinned — the strongest value that vocabulary has, and the
right one, since the key is on record for that address. It is the same
pre-emption that the outbound half spells own: for an address for which this
deployment holds a key, no peer_key row is offered to the verifier at all.
See pepsi-stage-decrypt(1).
A message carrying several signature layers takes the worst of their
verdicts — among the layers that cover the plaintext. A signature layer marked
covers_ciphertext (see below) is consulted only when there is no other, and
even then can never yield valid.
layers is ordered outermost first, and the order matters: it is what the
subject tags are rendered from, so encrypted(signed(body)) and
signed(encrypted(body)) are distinguishable. It therefore survives a pause,
which is why the stage records it rather than recomputing it. container and
downgraded appear on ciphertext layers only, so an operator can see how much
inbound mail is still pre-AEAD.
"covers_ciphertext": true appears on a signature layer that has a ciphertext
layer nested inside it — the outer signature of signed(encrypted(body)). It
is present only when true. Such a signature was computed over the ciphertext, so
it says that the signer transmitted the blob and nothing about what came out of
it; anybody who obtains an encrypted message can wrap it in their own signature
and forward it. The layer keeps its own honest verdict, but it cannot raise
signature.status to valid and so cannot set signature_verified. In
signed(encrypted(signed(body))) only the outer layer is marked, and the inner
one — the one that speaks for the content — decides the verdict.
The storage half, crypto.store, is written by
pepsi-stage-reencrypt(1) on a row whose crypto.in says the message was
decrypted:
"crypto": {
"in": { … },
"store": { "outcome": "reencrypted", "protocol": "openpgp",
"fingerprint": "…", "container": "seipdv2-aead",
"downgraded": false }
}
outcome is reencrypted (sealed to the recipient’s own MUA key, named by
fingerprint), plaintext (filed as it is: no usable MUA key under
ON_NO_CLIENT_KEY = plaintext, or not a local recipient — reason says
which) or bounced (refused under ON_NO_CLIENT_KEY = bounce; reason).
The stage merges the whole crypto object, so crypto.in survives, and the
presence of store is what keeps it from sealing a row twice.
95.3.1.1.4.32. encrypted¶
(boolean) Set to true by pepsi-stage-encrypt(1) when the message on
this row really was encrypted to a recipient key, and by
pepsi-stage-decrypt(1) when the message arrived encrypted.
pepsi-stage-auto-whitelist(1) copies it into the new whitelist row’s
signature_required column, so that a correspondent who was reached under
encryption is later held to the same standard. Absent (rather than false)
when nothing was encrypted.
95.3.1.1.4.33. signature_verified¶
(boolean) Set to true by pepsi-stage-decrypt(1) for the valid
signature verdict, and only that one.
pepsi-stage-check-whitelist(1)’s signature_required gate tests it, so
letting valid-untrusted set it would open a gate that the operator meant to
hold for a trusted key — and, for the same reason, a signature that only covers
ciphertext (covers_ciphertext, above) never sets it either. Absent (rather
than false) otherwise.
95.3.1.1.4.34. milter¶
(object) What pepsi-stage-milter(1) did — the filter’s verdict, the protocol version negotiated, how long the conversation took, and every modification applied, labelled:
{ "milter": { "stage": "spam-filter",
"verdict": "reject",
"version": 6,
"elapsed_ms": 42,
"actions": ["addheader:X-Spam-Status", "replbody"],
"reply_code": "550 5.7.1 blocked",
"quarantine_reason": "virus found",
"rejected_recipients": 1 } }
stage is the label of the milter stage that acted (not its
MILTER_NAME, which is only the {daemon_name} macro handed to the filter).
verdict is continue, accept, reject, tempfail, discard or
— when the filter could not be spoken to at all, or sent a modification that
cannot be applied — failed, in which case the record holds only stage,
verdict and an error carrying the
diagnostic, and the routing followed the stage’s ON_FAILURE. reply_code, quarantine_reason and rejected_recipients
are present only when they apply.
No stage acts on it unless you configure one to. It exists so pepsi-queue(1)
can show why a message was tagged, so pepsi-stage-if(1) can branch on it,
and so a support question
about a surprising header is answerable from the row rather than from the log —
the same rationale as vacation above. A rejected message additionally carries
the usual bounce object, with the filter’s own SMTP code, RFC 3463 enhanced
status and text split into their own fields.
95.3.1.1.4.35. quarantine¶
(object) The quarantine record. A party that sends a message to a
pepsi-stage-quarantine(1) stage writes a fresh one, replacing any earlier
record as a whole: pepsi-stage-milter(1) when a filter quarantines and
QUARANTINE_STAGE is set, and pepsi-ingress(1) for a pre-queue
milter. The quarantine stage adds the times:
{ "quarantine": { "reason": "virus found",
"by": "milter:clamav",
"since": "2026-11-15T10:00:00Z",
"until": "2026-11-29T10:00:00Z",
"released_at": "2026-11-16T08:30:00Z" } }
reason (string, optional) is why the message is held, as the sender of
the request put it (a milter’s SMFIR_QUARANTINE text). by (string,
optional) names that sender: milter:<MILTER_NAME> or stage:<name>.
since (RFC 3339) is when the quarantine stage began to hold the message,
until when the hold ends on its own (with MAX_HOLD), released_at
when an operator released it, and expired (true) says that the hold ran
out. The stage holds a message whose record has no since, or whose earlier
hold ended (released_at or expired is set), so a message released once
and quarantined again later is held again. pepsi-queue(1) quarantine
and pepsi-status(1) read the record; the POST /resume webhook of
pepsi-httpd(1) leaves a message alone while it is held.
95.3.1.1.4.36. crypto_policy_refused¶
(boolean, present only when true) Written alongside last_error by
pepsi-stage-encrypt(1), pepsi-stage-decrypt(1) and
pepsi-stage-reencrypt(1) when they fail a message because the configured
policy refused it and there was no BOUNCE_STAGE to bounce it to —
ON_NO_KEY/ON_OVERSIZE = bounce for a recipient that could not be
encrypted to, an
ON_DECRYPT_FAILURE/ON_BAD_SIGNATURE bounce, ON_NO_CLIENT_KEY =
bounce. It distinguishes a deliberate refusal from a transport or
programming error, which otherwise look identical on a failed row: retrying
the first one will never help.
95.3.1.1.4.37. encrypt_dns_deferred¶
(boolean, present only when true) Written with last_error (and
delay_sent once a delay DSN went out) by pepsi-stage-encrypt(1) when it
pauses a message because a recipient’s key lookup failed in the DNS rather than
send it unencrypted; see “Recipient DNS failures” there.
95.3.1.1.4.38. milter_error¶
(string) Written by pepsi-stage-milter(1) when a filter rejected a
message but neither REJECT_STAGE nor BOUNCE_STAGE was configured, so the
stage had nowhere to route it. Distinct from milter.error inside the
milter object above, which is the diagnostic for a filter that could not be
spoken to at all.
95.3.1.1.4.39. list¶
(object) The mailing-list descriptor. pepsi-stage-list(1) writes it on
every row it routes to a list role (the list id, the role, the
address the message arrived at, plus the token of a -confirm+ address,
or the verp detail of a -bounces+ address, verbatim: the bounce stage
verifies and decodes it); pepsi-stage-list-post(1) writes a per-member
descriptor (id, member, lang, serial, duplicate) on each
delivery row it fans out, plus pending_rcpt on a partially fanned-out
posting and rejected on a refused one; pepsi-list(1) sets
moderator_approved; a digest issue’s rows carry digest (true), on
the pending row and on every per-member descriptor fanned out from it. Read by
pepsi-stage-list-post(1), pepsi-stage-list-command(1),
pepsi-stage-list-deliver(1) and pepsi-stage-list-bounce(1); see
those pages for the fields each one uses.
95.3.1.1.4.40. dispatch_error¶
(string) Written by pepsi-dispatch(1) when it forces a row to a terminal
state that it did not reach on its own — the diagnostic for a stage program that
crashed (failed), one that exceeded MAX_RUNTIME (timeout), or a row
sitting at a stage that the configuration does not define. pepsi-status(1)
lists it under each stuck message.
95.3.1.1.5. See Also¶
pepsi.conf(5), pepsi-ingress(1), pepsi-dispatch(1), pepsi-stage-arc(1), pepsi-stage-bounce(1), pepsi-stage-check-whitelist(1), pepsi-stage-anti-spam(1), pepsi-stage-detect-language(1), pepsi-stage-block-language(1), pepsi-stage-vacation(1), pepsi-stage-secretary(1), pepsi-stage-milter(1), pepsi-stage-encrypt(1), pepsi-stage-decrypt(1), pepsi-stage-auto-whitelist(1), pepsi-stage-list(1), pepsi-tlsrpt(1), pepsi-keydisc(1), pepsi-keys(1)