修复生产审查凭据泄露风险并增加持久投递队列
Security Checks / security (push) Waiting to run

This commit is contained in:
xuans committed 2026-09-17 10:17:09 +08:00
1 parent 24670a3c2d
commit bf1e69f480
70 files changed
+1581 -262

No files matched your search

+3
View File
@@ -26,4 +26,7 @@ const (
// EmailStatusDeliveryPending marks an outbound audit whose delivery result is not final.
EmailStatusDeliveryPending int8 = 6
// EmailStatusDeliveryUncertain 禁止自动重投,需人工核对接收结果。
EmailStatusDeliveryUncertain int8 = 7
)
+11 -56
View File
@@ -10,17 +10,14 @@ import (
"git.pcux.cn/xuans/Smail/dto/parsemail"
"git.pcux.cn/xuans/Smail/dto/response"
"git.pcux.cn/xuans/Smail/hooks"
"git.pcux.cn/xuans/Smail/hooks/framework"
"git.pcux.cn/xuans/Smail/i18n"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/access"
"git.pcux.cn/xuans/Smail/services/outbox"
"git.pcux.cn/xuans/Smail/utils/async"
"git.pcux.cn/xuans/Smail/utils/context"
"git.pcux.cn/xuans/Smail/utils/send"
"git.pcux.cn/xuans/Smail/utils/validation"
log "github.com/sirupsen/logrus"
"github.com/spf13/cast"
"mime"
"net/http"
"strings"
@@ -274,61 +271,12 @@ func Send(ctx *context.Context, w http.ResponseWriter, req *http.Request) {
}
RecordUserContacts(ctx.UserID, contactList)
e.MessageId = cast.ToInt64(modelEmail.Id)
e.MsgID = modelEmail.MsgID
async.New(ctx).Process(func(p any) {
errMsg := ""
err, sendErr := send.SendTriggered(ctx, e, "网页写信")
log.WithContext(ctx).Debugf("插件执行--SendAfter")
as2 := async.New(ctx)
for _, hook := range hooks.Snapshot() {
if hook == nil {
continue
}
as2.WaitProcess(func(hk any) {
hk.(framework.EmailHook).SendAfter(ctx, e, sendErr)
}, hook)
}
as2.Wait()
log.WithContext(ctx).Debugf("插件执行--SendAfter")
if err != nil {
errMsg = err.Error()
_ = db.Transaction(db.Instance, func(session *xorm.Session) error {
if _, updateErr := session.Exec(db.WithContext(ctx, "update email set status = ?, error = ? where id = ?"), consts.EmailStatusFail, errMsg, modelEmail.Id); updateErr != nil {
log.WithContext(ctx).Errorf("update email status failed: %+v", updateErr)
return updateErr
}
if _, updateErr := session.Exec(db.WithContext(ctx, "update user_email set status = ? where email_id = ? and user_id = ?"), consts.EmailStatusFail, modelEmail.Id, ctx.UserID); updateErr != nil {
log.WithContext(ctx).Errorf("update user_email status failed: %+v", updateErr)
return updateErr
}
return nil
})
} else {
_ = db.Transaction(db.Instance, func(session *xorm.Session) error {
if _, updateErr := session.Exec(db.WithContext(ctx, "update email set status = ?, error = '' where id = ?"), consts.EmailStatusSent, modelEmail.Id); updateErr != nil {
log.WithContext(ctx).Errorf("update email status failed: %+v", updateErr)
return updateErr
}
if _, updateErr := session.Exec(db.WithContext(ctx, "update user_email set status = ? where email_id = ? and user_id = ?"), consts.EmailStatusSent, modelEmail.Id, ctx.UserID); updateErr != nil {
log.WithContext(ctx).Errorf("update user_email status failed: %+v", updateErr)
return updateErr
}
return nil
})
}
}, nil)
response.NewSuccessResponse(i18n.GetText(ctx.Lang, "succ")).FPrint(w)
}
func persistOutgoingEmail(engine *xorm.Engine, userID int, email *models.Email) error {
return db.Transaction(engine, func(session *xorm.Session) error {
var saved models.Email
err := db.Transaction(engine, func(session *xorm.Session) error {
candidate := *email
candidate.Id = 0
candidate.Status = consts.EmailStatusDeliveryPending
@@ -347,9 +295,16 @@ func persistOutgoingEmail(engine *xorm.Engine, userID int, email *models.Email)
if _, err := session.Insert(&relation); err != nil {
return err
}
*email = candidate
if err := outbox.Enqueue(session, candidate); err != nil {
return err
}
saved = candidate
return nil
})
if err == nil {
*email = saved
}
return err
}
func decodeAttachment(data string) (string, []byte, error) {
+30 -4
View File
@@ -20,7 +20,7 @@ func TestSendTransactionalPersistenceConsistency(t *testing.T) {
t.Fatalf("create test engine: %v", err)
}
engine.SetMaxOpenConns(1)
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}); err != nil {
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}, &models.OutboundDelivery{}); err != nil {
t.Fatalf("sync test database: %v", err)
}
defer engine.Close()
@@ -43,6 +43,7 @@ func TestSendTransactionalPersistenceConsistency(t *testing.T) {
Status: consts.EmailStatusDeliveryPending,
CreateTime: now,
MsgID: "msg-123@example.com",
To: `[{"EmailAddress":"recipient@example.com"}]`,
}
err = persistOutgoingEmail(engine, ctx.UserID, &modelEmail)
@@ -120,18 +121,18 @@ func TestOutboxExposesDeliveryStatus(t *testing.T) {
}
defer engine.Close()
engine.SetMaxOpenConns(1)
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}, &models.UserTrustedSender{}); err != nil {
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}, &models.UserTrustedSender{}, &models.OutboundDelivery{}); err != nil {
t.Fatal(err)
}
previous := db.Instance
db.Instance = engine
defer func() { db.Instance = previous }()
ctx := &context.Context{UserID: 1}
email := models.Email{Subject: "pending", Type: consts.EmailTypeSend, Status: consts.EmailStatusSent}
email := models.Email{Subject: "pending", Type: consts.EmailTypeSend, Status: consts.EmailStatusSent, To: `[{"EmailAddress":"recipient@example.com"}]`}
if err := persistOutgoingEmail(engine, ctx.UserID, &email); err != nil {
t.Fatal(err)
}
for _, status := range []int8{consts.EmailStatusDeliveryPending, consts.EmailStatusSent, consts.EmailStatusFail} {
for _, status := range []int8{consts.EmailStatusDeliveryPending, consts.EmailStatusSent, consts.EmailStatusFail, consts.EmailStatusDeliveryUncertain} {
if _, err := engine.ID(email.Id).Cols("status").Update(&models.Email{Status: status}); err != nil {
t.Fatal(err)
}
@@ -150,3 +151,28 @@ func TestOutboxExposesDeliveryStatus(t *testing.T) {
}
}
}
func TestPersistOutgoingEmailRollsBackQueueFailure(t *testing.T) {
engine, err := xorm.NewEngine("sqlite", ":memory:")
if err != nil {
t.Fatal(err)
}
defer engine.Close()
engine.SetMaxOpenConns(1)
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}, &models.OutboundDelivery{}); err != nil {
t.Fatal(err)
}
if _, err := engine.Exec("CREATE TRIGGER reject_queue BEFORE INSERT ON outbound_delivery BEGIN SELECT RAISE(ABORT, 'injected queue failure'); END"); err != nil {
t.Fatal(err)
}
email := models.Email{To: `[{"EmailAddress":"recipient@example.com"}]`}
if err := persistOutgoingEmail(engine, 1, &email); err == nil {
t.Fatal("queue failure ignored")
}
for _, model := range []any{&models.Email{}, &models.UserEmail{}, &models.OutboundDelivery{}} {
count, err := engine.Count(model)
if err != nil || count != 0 || email.Id != 0 {
t.Fatalf("rollback failed for %T: count=%d id=%d error=%v", model, count, email.Id, err)
}
}
}
+19
View File
@@ -0,0 +1,19 @@
package migration
func outboundDeliveryStatements() map[Dialect][]string {
return map[Dialect][]string{
DialectSQLite: {
`CREATE TABLE IF NOT EXISTS "outbound_delivery" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "email_id" INTEGER NOT NULL, "recipient" TEXT NOT NULL, "state" TEXT NOT NULL, "attempts" INTEGER NOT NULL DEFAULT 0, "next_attempt" BIGINT NOT NULL DEFAULT 0, "last_error" TEXT NOT NULL DEFAULT '')`,
`CREATE INDEX IF NOT EXISTS "idx_outbound_delivery_email" ON "outbound_delivery"("email_id")`,
`CREATE INDEX IF NOT EXISTS "idx_outbound_delivery_due" ON "outbound_delivery"("state", "next_attempt")`,
},
DialectMySQL: {
"CREATE TABLE IF NOT EXISTS `outbound_delivery` (`id` BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, `email_id` BIGINT NOT NULL, `recipient` VARCHAR(320) NOT NULL, `state` VARCHAR(24) NOT NULL, `attempts` INT NOT NULL DEFAULT 0, `next_attempt` BIGINT NOT NULL DEFAULT 0, `last_error` TEXT NOT NULL, KEY `idx_outbound_delivery_email` (`email_id`), KEY `idx_outbound_delivery_due` (`state`, `next_attempt`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",
},
DialectPostgres: {
`CREATE TABLE IF NOT EXISTS "outbound_delivery" ("id" BIGSERIAL PRIMARY KEY, "email_id" BIGINT NOT NULL, "recipient" VARCHAR(320) NOT NULL, "state" VARCHAR(24) NOT NULL, "attempts" INTEGER NOT NULL DEFAULT 0, "next_attempt" BIGINT NOT NULL DEFAULT 0, "last_error" TEXT NOT NULL DEFAULT '')`,
`CREATE INDEX IF NOT EXISTS "idx_outbound_delivery_email" ON "outbound_delivery"("email_id")`,
`CREATE INDEX IF NOT EXISTS "idx_outbound_delivery_due" ON "outbound_delivery"("state", "next_attempt")`,
},
}
}
+2 -1
View File
@@ -1,4 +1,4 @@
package migration
package migration
import (
"regexp"
@@ -32,6 +32,7 @@ func DefaultMigrations() []Migration {
DefineCustom(20, "expand_protocol_credential_ciphertext", "expand_protocol_credential_ciphertext_v1", applyProtocolCredentialCiphertextSchema),
DefineCustom(21, "expand_trusted_sender_blacklist", "expand_trusted_sender_blacklist_v1", applyTrustedSenderBlacklistSchema),
DefineForDialects(22, "create_client_credentials", clientCredentialStatements()),
DefineForDialects(23, "create_outbound_delivery", outboundDeliveryStatements()),
}
}
+1
View File
@@ -296,6 +296,7 @@ func TestDefaultMigrationChecksumsAreImmutable(t *testing.T) {
20: "e0bc01f4c2df742bc23c519c2a399cc1c3f341565dbed014509a8c63d68bf725",
21: "ac1a0b3be90128c0e0512d2cec858f8cd7e70abc5ff4734d7113b9674f08dbb0",
22: "1047cb22f5a32c8a09ba4ccedff8713a5225c14fdb98357db86a6e0723c30d8b",
23: "5d80f2c2c583fc9a033fc320c0852c73bd6701ce6c8f12e8904deedfe0ba44b2",
}
migrations := DefaultMigrations()
if len(migrations) != len(expected) {
+13
View File
@@ -0,0 +1,13 @@
package models
type OutboundDelivery struct {
ID int64 `xorm:"id pk autoincr"`
EmailID int `xorm:"email_id notnull index"`
Recipient string `xorm:"varchar(320) notnull"`
State string `xorm:"varchar(24) notnull"`
Attempts int `xorm:"notnull"`
NextAttempt int64 `xorm:"notnull"`
LastError string `xorm:"text"`
}
func (OutboundDelivery) TableName() string { return "outbound_delivery" }
+15
View File
@@ -25,6 +25,7 @@ import (
"git.pcux.cn/xuans/Smail/services/dbmigration"
"git.pcux.cn/xuans/Smail/services/externalemail"
"git.pcux.cn/xuans/Smail/services/logstore"
"git.pcux.cn/xuans/Smail/services/outbox"
pluginservice "git.pcux.cn/xuans/Smail/services/plugin"
"git.pcux.cn/xuans/Smail/services/recovery"
"git.pcux.cn/xuans/Smail/services/restart"
@@ -47,6 +48,7 @@ var verificationRuntime *verification.Runtime
var credentialService *credentials.Service
var webAuthnRuntimeService *webauthnservice.Service
var logRuntime *logstore.Runtime
var outboxRuntime *outbox.Runtime
func startConfigManager() error {
root := filepath.Join(config.ROOT_PATH, "config")
@@ -215,6 +217,11 @@ func Init(serverVersion string) error {
}()
}
hooks.Init(serverVersion)
outboxRuntime, err = outbox.Start(db.Instance)
if err != nil {
stopServices()
return fmt.Errorf("start persistent outbox: %w", err)
}
httpRun, httpsRun, err := http_server.PrepareWebServers()
if err != nil {
stopServices()
@@ -294,6 +301,14 @@ func stopServices() error {
http_server.HttpStop()
pop3_server.Stop()
imap_server.Stop()
// 停止接收新请求后等待正在投递的任务写回,超时则保留数据库,避免提前关闭连接池。
drainCtx, drainCancel := context.WithTimeout(context.Background(), 25*time.Second)
err := outboxRuntime.Stop(drainCtx)
drainCancel()
if err != nil {
return fmt.Errorf("outbox did not drain; database retained: %w", err)
}
outboxRuntime = nil
hooks.Stop()
// 先关闭业务入口,再撤下安全服务及会话清理器,避免新请求读取停止中的依赖。
stopVerificationRuntime()
@@ -104,3 +104,40 @@ func TestMaintenanceGuardDrainsRequestsAndKeepsRestartRoute(t *testing.T) {
t.Fatal("cleanup wrote to frozen source")
}
}
func TestMaintenanceDrainsBackgroundDeliveryBeforeFreeze(t *testing.T) {
executor := &PortableExecutor{}
service := NewService(&DatabaseExecutor{portable: executor})
previous := Current()
SetCurrent(service)
t.Cleanup(func() { SetCurrent(previous) })
entered, finish, done := make(chan struct{}), make(chan struct{}), make(chan struct{})
go func() {
defer close(done)
_ = WhileWritable(func() error {
close(entered)
<-finish
return nil
})
}()
<-entered
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
defer cancel()
release, err := service.drainRequests(ctx)
release()
close(finish)
<-done
if !errors.Is(err, context.DeadlineExceeded) {
t.Fatalf("migration did not wait for delivery: %v", err)
}
release, err = service.drainRequests(context.Background())
if err != nil {
t.Fatal(err)
}
executor.paused.Store(true)
release()
called := false
if err := WhileWritable(func() error { called = true; return nil }); err != nil || called {
t.Fatal("delivery started after source freeze")
}
}
+172
View File
@@ -0,0 +1,172 @@
package outbox
import (
stdcontext "context"
"errors"
"fmt"
"sync"
"time"
"git.pcux.cn/xuans/Smail/dto/parsemail"
"git.pcux.cn/xuans/Smail/hooks"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/dbmigration"
"git.pcux.cn/xuans/Smail/utils/context"
"git.pcux.cn/xuans/Smail/utils/send"
"git.pcux.cn/xuans/Smail/utils/smtp"
log "github.com/sirupsen/logrus"
"xorm.io/xorm"
)
type Runtime struct {
engine *xorm.Engine
stop chan struct{}
done chan struct{}
once sync.Once
deliver func(*context.Context, *parsemail.Email, string) error
}
func Start(engine *xorm.Engine) (*Runtime, error) {
if err := recoverInterrupted(engine); err != nil {
return nil, err
}
r := &Runtime{engine: engine, stop: make(chan struct{}), done: make(chan struct{}), deliver: send.SendRecipientTriggered}
go r.loop()
return r, nil
}
func (r *Runtime) Stop(ctx stdcontext.Context) error {
if r == nil {
return nil
}
r.once.Do(func() { close(r.stop) })
select {
case <-r.done:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
func (r *Runtime) loop() {
defer close(r.done)
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for {
select {
case <-r.stop:
return
default:
}
var jobs []models.OutboundDelivery
err := r.engine.Where("state = ? AND next_attempt <= ?", queued, time.Now().Unix()).Asc("id").Limit(20).Find(&jobs)
if err != nil {
log.WithError(err).Error("读取持久投递队列失败")
}
for _, job := range jobs {
select {
case <-r.stop:
return
default:
}
if err := r.process(job); err != nil {
log.WithError(err).WithField("delivery_id", job.ID).Error("处理持久投递队列失败")
}
}
select {
case <-r.stop:
return
case <-ticker.C:
}
}
}
func (r *Runtime) process(job models.OutboundDelivery) error {
// 迁移必须等待 SMTP 及结果落库结束,冻结源库后不再领取任务。
return dbmigration.WhileWritable(func() error { return r.processWritable(job) })
}
func (r *Runtime) processWritable(job models.OutboundDelivery) error {
// 读取失败时尚未开始投递,保留排队状态供数据库恢复后继续处理。
var stored models.Email
emailFound, err := r.engine.ID(job.EmailID).Get(&stored)
if err != nil {
return err
}
var user models.User
userFound := false
if emailFound {
userFound, err = r.engine.ID(stored.SendUserID).Get(&user)
if err != nil {
return err
}
}
owned, err := claim(r.engine, &job)
if err != nil || !owned {
return err
}
ctx := &context.Context{Context: stdcontext.Background()}
var message *parsemail.Email
deliveryErr := func() (result error) {
defer func() {
if value := recover(); value != nil {
result = &smtp.DeliveryUncertainError{Cause: fmt.Errorf("投递任务异常: %v", value)}
}
}()
if !emailFound {
return errors.New("待投递邮件已不存在")
}
if !userFound || user.Disabled != 0 {
return errors.New("发件账号不可用,已停止投递")
}
ctx.UserID, ctx.UserAccount, ctx.UserName, ctx.Role = user.ID, user.Account, user.Name, user.EffectiveRole()
message, err = parsemail.NewEmailFromModel(stored)
if err != nil {
return err
}
return r.deliver(ctx, message, job.Recipient)
}()
// 只重试结果落库,绝不因数据库故障再次调用 SMTP。
var terminal bool
for attempt := 0; attempt < 3; attempt++ {
terminal, err = finish(r.engine, job, deliveryErr)
if err == nil {
break
}
time.Sleep(time.Second)
}
if err != nil {
return fmt.Errorf("投递结果写入失败,保留在途记录并禁止自动重投: %w", err)
}
if terminal && message != nil {
r.notify(ctx, message, job.EmailID)
}
return nil
}
func (r *Runtime) notify(ctx *context.Context, message *parsemail.Email, emailID int) {
var jobs []models.OutboundDelivery
if err := r.engine.Where("email_id = ?", emailID).Find(&jobs); err != nil {
log.WithError(err).Error("读取投递结果用于插件通知失败")
return
}
failures := make(map[string]error)
for _, job := range jobs {
if job.State != accepted {
failures[job.Recipient] = errors.New(job.LastError)
}
}
for _, hook := range hooks.Snapshot() {
if hook == nil {
continue
}
func() {
defer func() {
if recover() != nil {
log.Error("投递完成插件发生异常")
}
}()
hook.SendAfter(ctx, message, failures)
}()
}
}
+179
View File
@@ -0,0 +1,179 @@
package outbox
import (
"database/sql"
"errors"
"fmt"
"sort"
"strings"
"time"
"git.pcux.cn/xuans/Smail/consts"
"git.pcux.cn/xuans/Smail/db"
"git.pcux.cn/xuans/Smail/dto/parsemail"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/logstore"
"git.pcux.cn/xuans/Smail/utils/send"
"git.pcux.cn/xuans/Smail/utils/smtp"
"xorm.io/xorm"
)
const (
queued = "queued"
running = "running"
accepted = "accepted"
failed = "failed"
uncertain = "uncertain"
maxAttempts = 5
uncertainMessage = "投递结果不确定,已暂停自动重试,请先核对收件结果"
)
// Enqueue 必须与邮件及用户关联在同一事务内保存,不保存验证码或恢复令牌。
func Enqueue(session *xorm.Session, email models.Email) error {
message, err := parsemail.NewEmailFromModel(email)
if err != nil {
return err
}
seen := make(map[string]bool)
for _, user := range append(append(message.To, message.Cc...), message.Bcc...) {
if user == nil || user.EmailAddress == "" {
return errors.New("队列收件人不能为空")
}
// 本地部分保留大小写,仅合并完全相同的 SMTP 信封地址。
address := user.EmailAddress
if at := strings.LastIndexByte(address, '@'); at >= 0 {
address = address[:at+1] + strings.ToLower(address[at+1:])
}
if seen[address] {
continue
}
seen[address] = true
job := models.OutboundDelivery{EmailID: email.Id, Recipient: address, State: queued}
if _, err := session.Insert(&job); err != nil {
return err
}
}
if len(seen) == 0 {
return errors.New("队列必须包含收件人")
}
return nil
}
func summarize(jobs []models.OutboundDelivery) (int8, string, bool) {
counts := make(map[string]int)
reasons := make(map[string]bool)
for _, job := range jobs {
counts[job.State]++
if job.LastError != "" {
reasons[job.LastError] = true
}
}
if counts[queued]+counts[running] > 0 {
return consts.EmailStatusDeliveryPending, "", false
}
details := make([]string, 0, len(reasons))
for reason := range reasons {
details = append(details, reason)
}
sort.Strings(details)
suffix := ""
if len(details) > 0 {
suffix = ";原因:" + strings.Join(details, ";")
}
if counts[uncertain] > 0 {
return consts.EmailStatusDeliveryUncertain, fmt.Sprintf("%s;已接收 %d,结果不确定 %d,失败 %d", uncertainMessage, counts[accepted], counts[uncertain], counts[failed]) + suffix, true
}
if len(jobs) > 0 && counts[accepted] == len(jobs) {
return consts.EmailStatusSent, "", true
}
return consts.EmailStatusFail, fmt.Sprintf("投递未全部完成;已接收 %d,失败 %d。已接收的收件人不会自动重投", counts[accepted], counts[failed]) + suffix, true
}
func syncStatus(session *xorm.Session, emailID int) (bool, error) {
var jobs []models.OutboundDelivery
if err := session.Where("email_id = ?", emailID).Find(&jobs); err != nil {
return false, err
}
status, message, terminal := summarize(jobs)
if _, err := session.ID(emailID).Cols("status", "error").Update(&models.Email{Status: status, Error: sql.NullString{String: message, Valid: true}}); err != nil {
return false, err
}
// 不改动用户已放入回收站的关联状态。
_, err := session.Where("email_id = ? AND status <> ?", emailID, consts.EmailStatusDel).Cols("status").Update(&models.UserEmail{Status: status})
return terminal, err
}
// recoverInterrupted 只在独占运行实例启动时执行,在途记录绝不重新排队。
func recoverInterrupted(engine *xorm.Engine) error {
return db.Transaction(engine, func(session *xorm.Session) error {
// 旧版本未记录 SMTP 尝试边界,只标记待核对,不能当作未发送任务导入。
var legacy []models.Email
if err := session.Where("type = ? AND status = ? AND id NOT IN (SELECT email_id FROM outbound_delivery)", consts.EmailTypeSend, consts.EmailStatusDeliveryPending).Find(&legacy); err != nil {
return err
}
for _, email := range legacy {
if _, err := session.ID(email.Id).Cols("status", "error").Update(&models.Email{Status: consts.EmailStatusDeliveryUncertain, Error: sql.NullString{String: uncertainMessage, Valid: true}}); err != nil {
return err
}
if _, err := session.Where("email_id = ? AND status = ?", email.Id, consts.EmailStatusDeliveryPending).Cols("status").Update(&models.UserEmail{Status: consts.EmailStatusDeliveryUncertain}); err != nil {
return err
}
}
var interrupted []models.OutboundDelivery
if err := session.Where("state = ?", running).Find(&interrupted); err != nil {
return err
}
if _, err := session.Where("state = ?", running).Cols("state", "last_error").Update(&models.OutboundDelivery{State: uncertain, LastError: uncertainMessage}); err != nil {
return err
}
seen := make(map[int]bool)
for _, job := range interrupted {
if !seen[job.EmailID] {
if _, err := syncStatus(session, job.EmailID); err != nil {
return err
}
seen[job.EmailID] = true
}
}
return nil
})
}
func claim(engine *xorm.Engine, job *models.OutboundDelivery) (bool, error) {
update := *job
update.State = running
update.Attempts++
count, err := engine.ID(job.ID).Where("state = ? AND attempts = ? AND next_attempt <= ?", queued, job.Attempts, time.Now().Unix()).Cols("state", "attempts").Update(&update)
if err == nil && count == 1 {
*job = update
}
return count == 1, err
}
func finish(engine *xorm.Engine, job models.OutboundDelivery, deliveryErr error) (bool, error) {
job.State, job.LastError, job.NextAttempt = accepted, "", 0
if deliveryErr != nil {
// 不保存远端响应原文,避免凭据或恶意超长内容进入数据库和页面。
job.State, job.LastError = failed, logstore.MailFailureReason(deliveryErr)
if smtp.IsDeliveryUncertain(deliveryErr) {
job.State = uncertain
job.LastError = uncertainMessage
} else if send.Retryable(deliveryErr) && job.Attempts < maxAttempts {
job.State = queued
job.NextAttempt = time.Now().Add(time.Minute * time.Duration(1<<(job.Attempts-1))).Unix()
}
}
terminal := false
err := db.Transaction(engine, func(session *xorm.Session) error {
count, err := session.ID(job.ID).Where("state = ? AND attempts = ?", running, job.Attempts).Cols("state", "last_error", "next_attempt").Update(&job)
if err != nil {
return err
}
if count != 1 {
return errors.New("投递任务状态已发生变化")
}
terminal, err = syncStatus(session, job.EmailID)
return err
})
return terminal, err
}
+340
View File
@@ -0,0 +1,340 @@
package outbox
import (
stdcontext "context"
"errors"
"io"
"net/textproto"
"strings"
"sync/atomic"
"testing"
"time"
"git.pcux.cn/xuans/Smail/consts"
"git.pcux.cn/xuans/Smail/db"
"git.pcux.cn/xuans/Smail/dto/parsemail"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/utils/context"
"git.pcux.cn/xuans/Smail/utils/smtp"
"xorm.io/xorm"
)
func queueFixture(t *testing.T) (*xorm.Engine, models.Email, []models.OutboundDelivery) {
t.Helper()
engine, err := xorm.NewEngine("sqlite", ":memory:")
if err != nil {
t.Fatal(err)
}
engine.SetMaxOpenConns(1)
t.Cleanup(func() { engine.Close() })
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}, &models.User{}, &models.OutboundDelivery{}); err != nil {
t.Fatal(err)
}
user := models.User{Account: "sender", Name: "sender", Password: "test", Role: "user"}
if _, err := engine.Insert(&user); err != nil {
t.Fatal(err)
}
email := models.Email{Type: consts.EmailTypeSend, Status: consts.EmailStatusDeliveryPending, SendUserID: user.ID, FromAddress: "sender@example.com", To: `[{"EmailAddress":"one@example.com"},{"EmailAddress":"two@example.com"}]`, Cc: `[{"EmailAddress":"one@EXAMPLE.com"}]`, MsgID: "stable@example.com"}
err = db.Transaction(engine, func(session *xorm.Session) error {
if _, err := session.Insert(&email); err != nil {
return err
}
if _, err := session.Insert(&models.UserEmail{UserID: user.ID, EmailID: email.Id, Status: consts.EmailStatusDeliveryPending}); err != nil {
return err
}
return Enqueue(session, email)
})
if err != nil {
t.Fatal(err)
}
var jobs []models.OutboundDelivery
if err := engine.Asc("id").Find(&jobs); err != nil {
t.Fatal(err)
}
if len(jobs) != 2 {
t.Fatalf("duplicate recipient: %v", jobs)
}
return engine, email, jobs
}
func assertStatus(t *testing.T, engine *xorm.Engine, emailID int, status int8) {
t.Helper()
var email models.Email
var relation models.UserEmail
if ok, err := engine.ID(emailID).Get(&email); err != nil || !ok {
t.Fatal(err)
}
if ok, err := engine.Where("email_id = ?", emailID).Get(&relation); err != nil || !ok {
t.Fatal(err)
}
if email.Status != status || relation.Status != status {
t.Fatalf("email=%d relation=%d want=%d", email.Status, relation.Status, status)
}
}
func TestClaimAndPartialResults(t *testing.T) {
engine, email, jobs := queueFixture(t)
first := jobs[0]
if ok, err := claim(engine, &first); err != nil || !ok {
t.Fatal(err)
}
if ok, err := claim(engine, &jobs[0]); err != nil || ok {
t.Fatalf("duplicate claim: %v %v", ok, err)
}
if _, err := finish(engine, first, nil); err != nil {
t.Fatal(err)
}
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryPending)
second := jobs[1]
if ok, err := claim(engine, &second); err != nil || !ok {
t.Fatal(err)
}
if _, err := finish(engine, second, &textproto.Error{Code: 451, Msg: "later"}); err != nil {
t.Fatal(err)
}
var queuedJob models.OutboundDelivery
if _, err := engine.ID(second.ID).Get(&queuedJob); err != nil {
t.Fatal(err)
}
if queuedJob.State != queued || queuedJob.NextAttempt <= time.Now().Unix() {
t.Fatalf("retry state=%+v", queuedJob)
}
if ok, err := claim(engine, &queuedJob); err != nil || ok {
t.Fatal("retry was claimed before backoff elapsed")
}
if _, err := engine.ID(queuedJob.ID).Cols("next_attempt").Update(&models.OutboundDelivery{}); err != nil {
t.Fatal(err)
}
if ok, err := claim(engine, &queuedJob); err != nil || !ok {
t.Fatal(err)
}
if _, err := finish(engine, queuedJob, &textproto.Error{Code: 550, Msg: "rejected"}); err != nil {
t.Fatal(err)
}
assertStatus(t, engine, email.Id, consts.EmailStatusFail)
if ok, err := claim(engine, &first); err != nil || ok {
t.Fatal("accepted job was claimed again")
}
}
func TestRestartDoesNotResendInterruptedOrAccepted(t *testing.T) {
engine, email, jobs := queueFixture(t)
for i := range jobs {
if ok, err := claim(engine, &jobs[i]); err != nil || !ok {
t.Fatal(err)
}
}
if _, err := finish(engine, jobs[0], nil); err != nil {
t.Fatal(err)
}
if err := recoverInterrupted(engine); err != nil {
t.Fatal(err)
}
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryUncertain)
var stored []models.OutboundDelivery
if err := engine.Asc("id").Find(&stored); err != nil {
t.Fatal(err)
}
if stored[0].State != accepted || stored[1].State != uncertain {
t.Fatalf("states=%+v", stored)
}
if err := recoverInterrupted(engine); err != nil {
t.Fatal(err)
}
}
func TestUncertainDATAIsNeverRetried(t *testing.T) {
engine, _, jobs := queueFixture(t)
job := jobs[0]
if ok, err := claim(engine, &job); err != nil || !ok {
t.Fatal(err)
}
if _, err := finish(engine, job, &smtp.DeliveryUncertainError{Cause: io.EOF}); err != nil {
t.Fatal(err)
}
if ok, err := claim(engine, &job); err != nil || ok {
t.Fatal("uncertain job was claimed again")
}
}
func TestResultFailureRollsBackAndNeverRedelivers(t *testing.T) {
engine, email, jobs := queueFixture(t)
if _, err := engine.Exec("CREATE TRIGGER reject_result BEFORE UPDATE ON user_email BEGIN SELECT RAISE(ABORT, 'injected failure'); END"); err != nil {
t.Fatal(err)
}
var calls atomic.Int32
r := &Runtime{engine: engine, deliver: func(_ *context.Context, e *parsemail.Email, recipient string) error {
calls.Add(1)
if e.MsgID != "stable@example.com" || len(e.To) != 2 || recipient != "one@example.com" {
t.Fatal("envelope changed message headers")
}
return nil
}}
if err := r.process(jobs[0]); err == nil {
t.Fatal("result failure was ignored")
}
if err := r.process(jobs[0]); err != nil {
t.Fatal(err)
}
if calls.Load() != 1 {
t.Fatalf("SMTP called %d times", calls.Load())
}
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryPending)
var job models.OutboundDelivery
if _, err := engine.ID(jobs[0].ID).Get(&job); err != nil {
t.Fatal(err)
}
if job.State != running {
t.Fatalf("state=%s", job.State)
}
}
func TestQueuedJobsSurviveRestartAndDrain(t *testing.T) {
engine, email, _ := queueFixture(t)
if err := recoverInterrupted(engine); err != nil {
t.Fatal(err)
}
var calls atomic.Int32
r := &Runtime{engine: engine, stop: make(chan struct{}), done: make(chan struct{}), deliver: func(_ *context.Context, _ *parsemail.Email, _ string) error { calls.Add(1); return nil }}
go r.loop()
deadline := time.Now().Add(3 * time.Second)
for calls.Load() < 2 && time.Now().Before(deadline) {
time.Sleep(10 * time.Millisecond)
}
ctx, cancel := stdcontext.WithTimeout(stdcontext.Background(), time.Second)
defer cancel()
if err := r.Stop(ctx); err != nil {
t.Fatal(err)
}
if calls.Load() != 2 {
t.Fatalf("calls=%d", calls.Load())
}
assertStatus(t, engine, email.Id, consts.EmailStatusSent)
}
func TestRetryLimitAndSafeFailureDetails(t *testing.T) {
engine, _, jobs := queueFixture(t)
job := jobs[0]
for attempt := 1; attempt <= maxAttempts; attempt++ {
if _, err := engine.ID(job.ID).Cols("next_attempt").Update(&models.OutboundDelivery{}); err != nil {
t.Fatal(err)
}
if ok, err := claim(engine, &job); err != nil || !ok {
t.Fatalf("claim %d: %v", attempt, err)
}
before := time.Now().Unix()
if _, err := finish(engine, job, &textproto.Error{Code: 451, Msg: "sensitive-remote-response"}); err != nil {
t.Fatal(err)
}
var refreshed models.OutboundDelivery
if found, err := engine.ID(job.ID).Get(&refreshed); err != nil || !found {
t.Fatal(err)
}
job = refreshed
if strings.Contains(job.LastError, "sensitive") || !strings.Contains(job.LastError, "451") {
t.Fatalf("unsafe or missing failure details: %s", job.LastError)
}
if attempt < maxAttempts {
minimum := before + int64(60*(1<<(attempt-1)))
if job.State != queued || job.NextAttempt < minimum || job.NextAttempt > minimum+2 {
t.Fatalf("unexpected backoff: %+v", job)
}
} else if job.State != failed || job.NextAttempt != 0 {
t.Fatalf("retry limit ignored: %+v", job)
}
}
status, message, terminal := summarize([]models.OutboundDelivery{job})
if status != consts.EmailStatusFail || !terminal || !strings.Contains(message, "451") {
t.Fatalf("failure summary: %d %s %v", status, message, terminal)
}
}
func TestLegacyPendingIsUncertainWithoutEnqueue(t *testing.T) {
engine, _, _ := queueFixture(t)
email := models.Email{Type: consts.EmailTypeSend, Status: consts.EmailStatusDeliveryPending}
if _, err := engine.Insert(&email); err != nil {
t.Fatal(err)
}
if _, err := engine.Insert(&models.UserEmail{UserID: 1, EmailID: email.Id, Status: consts.EmailStatusDeliveryPending}); err != nil {
t.Fatal(err)
}
if err := recoverInterrupted(engine); err != nil {
t.Fatal(err)
}
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryUncertain)
count, err := engine.Where("email_id = ?", email.Id).Count(&models.OutboundDelivery{})
if err != nil || count != 0 {
t.Fatalf("legacy message enqueued: %d %v", count, err)
}
}
func TestReadFailureDoesNotClaimOrDeliver(t *testing.T) {
engine, _, jobs := queueFixture(t)
if _, err := engine.Exec("ALTER TABLE email RENAME TO unavailable_email"); err != nil {
t.Fatal(err)
}
r := &Runtime{engine: engine, deliver: func(_ *context.Context, _ *parsemail.Email, _ string) error {
t.Fatal("SMTP called despite read failure")
return nil
}}
if err := r.process(jobs[0]); err == nil {
t.Fatal("read failure ignored")
}
var job models.OutboundDelivery
if _, err := engine.ID(jobs[0].ID).Get(&job); err != nil {
t.Fatal(err)
}
if job.State != queued || job.Attempts != 0 {
t.Fatalf("read failure consumed attempt: %+v", job)
}
}
func TestStopTimeoutDoesNotStartAnotherDelivery(t *testing.T) {
engine, _, _ := queueFixture(t)
entered, release := make(chan struct{}), make(chan struct{})
var calls atomic.Int32
r := &Runtime{engine: engine, stop: make(chan struct{}), done: make(chan struct{}), deliver: func(_ *context.Context, _ *parsemail.Email, _ string) error {
if calls.Add(1) == 1 {
close(entered)
}
<-release
return nil
}}
go r.loop()
<-entered
ctx, cancel := stdcontext.WithTimeout(stdcontext.Background(), 20*time.Millisecond)
defer cancel()
err := r.Stop(ctx)
close(release)
if !errors.Is(err, stdcontext.DeadlineExceeded) {
t.Fatalf("stop did not time out: %v", err)
}
if err := r.Stop(stdcontext.Background()); err != nil {
t.Fatal(err)
}
if calls.Load() != 1 {
t.Fatalf("delivery started after stop: %d", calls.Load())
}
}
func TestDeliveryDoesNotRestoreTrashedRelation(t *testing.T) {
engine, email, jobs := queueFixture(t)
if _, err := engine.Where("email_id = ?", email.Id).Cols("status").Update(&models.UserEmail{Status: consts.EmailStatusDel}); err != nil {
t.Fatal(err)
}
for _, job := range jobs {
if ok, err := claim(engine, &job); err != nil || !ok {
t.Fatal(err)
}
if _, err := finish(engine, job, nil); err != nil {
t.Fatal(err)
}
}
var relation models.UserEmail
if _, err := engine.Where("email_id = ?", email.Id).Get(&relation); err != nil {
t.Fatal(err)
}
if relation.Status != consts.EmailStatusDel {
t.Fatal("delivery restored trashed message")
}
}
+93
View File
@@ -0,0 +1,93 @@
package send
import (
stdcontext "context"
"errors"
"fmt"
"net"
"net/textproto"
"sort"
"strings"
"time"
"git.pcux.cn/xuans/Smail/utils/smtp"
)
var errNullMX = errors.New("收件域名声明不接收邮件")
type mxLookup func(stdcontext.Context, string) ([]*net.MX, error)
func resolveMX(domain string, lookup mxLookup) ([]string, error) {
ctx, cancel := stdcontext.WithTimeout(stdcontext.Background(), 10*time.Second)
defer cancel()
records, err := lookup(ctx, domain)
if err != nil {
var dnsErr *net.DNSError
if !errors.As(err, &dnsErr) || !dnsErr.IsNotFound || dnsErr.IsTemporary || dnsErr.IsTimeout {
return nil, fmt.Errorf("查询收件域名 MX 失败: %w", err)
}
// 无 MX 时使用域名自身的地址记录,不猜测 smtp 子域名。
return []string{domain}, nil
}
if len(records) == 0 {
return []string{domain}, nil
}
records = append([]*net.MX(nil), records...)
for _, record := range records {
if record == nil || record.Host == "" {
return nil, errors.New("收件域名 MX 记录无效")
}
if record.Host == "." {
return nil, errNullMX
}
}
sort.SliceStable(records, func(i, j int) bool { return records[i].Pref < records[j].Pref })
hosts := make([]string, 0, len(records))
seen := make(map[string]bool)
for _, record := range records {
host := strings.ToLower(strings.TrimSuffix(record.Host, "."))
if !seen[host] {
hosts = append(hosts, host)
seen[host] = true
}
}
return hosts, nil
}
func stopFallback(err error) bool {
return smtp.IsDeliveryUncertain(err) || isCertificateVerificationError(err) || isPermanentSMTPResponse(err) || errors.Is(err, smtp.ErrUnsafeRemoteAddress)
}
// deliverMX 只在确认本次未接收时切换安全通道,DATA 不确定结果不进入下一条路由。
func deliverMX(hosts []string, attempt func(host, port string) error) error {
var lastErr error
for _, host := range hosts {
for _, port := range []string{"25", "587", "465"} {
lastErr = attempt(host, port)
if lastErr == nil || stopFallback(lastErr) {
return lastErr
}
}
}
if lastErr == nil {
lastErr = errors.New("收件域名没有可用邮件服务器")
}
return lastErr
}
// Retryable 仅允许有明确临时失败语义的结果进入持久队列重试。
func Retryable(err error) bool {
if err == nil || stopFallback(err) {
return false
}
var response *textproto.Error
if errors.As(err, &response) {
return response.Code >= 400 && response.Code <= 499
}
var dnsErr *net.DNSError
if errors.As(err, &dnsErr) {
return dnsErr.IsTimeout || dnsErr.IsTemporary
}
var networkErr net.Error
return errors.As(err, &networkErr)
}
+95
View File
@@ -0,0 +1,95 @@
package send
import (
"context"
"crypto/tls"
"errors"
"io"
"net"
"net/textproto"
"reflect"
"testing"
"git.pcux.cn/xuans/Smail/utils/smtp"
)
func TestResolveMX(t *testing.T) {
for _, tt := range []struct {
name string
records []*net.MX
err error
want []string
wantErr bool
}{
{name: "priority and duplicate", records: []*net.MX{{Host: "backup.example.", Pref: 20}, {Host: "primary.example.", Pref: 10}, {Host: "PRIMARY.example.", Pref: 30}}, want: []string{"primary.example", "backup.example"}},
{name: "implicit MX", want: []string{"example.com"}},
{name: "no MX record", err: &net.DNSError{IsNotFound: true}, want: []string{"example.com"}},
{name: "temporary DNS", err: &net.DNSError{IsTemporary: true}, wantErr: true},
{name: "timeout DNS", err: &net.DNSError{IsTimeout: true}, wantErr: true},
{name: "null MX", records: []*net.MX{{Host: "."}}, wantErr: true},
{name: "invalid MX", records: []*net.MX{nil}, wantErr: true},
} {
t.Run(tt.name, func(t *testing.T) {
hosts, err := resolveMX("example.com", func(ctx context.Context, domain string) ([]*net.MX, error) {
if _, ok := ctx.Deadline(); !ok || domain != "example.com" {
t.Fatal("unbounded or wrong lookup")
}
return tt.records, tt.err
})
if (err != nil) != tt.wantErr || !reflect.DeepEqual(hosts, tt.want) {
t.Fatalf("hosts=%v error=%v", hosts, err)
}
})
}
}
func TestDeliverMXFallbackAndStop(t *testing.T) {
for _, tt := range []struct {
name string
err error
calls int
}{
{"network fallback", &net.OpError{Op: "dial", Err: io.EOF}, 4},
{"temporary refusal fallback", &textproto.Error{Code: 451, Msg: "later"}, 4},
{"permanent refusal", &textproto.Error{Code: 550, Msg: "rejected"}, 1},
{"certificate failure", &tls.CertificateVerificationError{Err: io.EOF}, 1},
{"uncertain DATA", &smtp.DeliveryUncertainError{Cause: io.EOF}, 1},
{"private MX", smtp.ErrUnsafeRemoteAddress, 1},
} {
t.Run(tt.name, func(t *testing.T) {
var calls []string
err := deliverMX([]string{"primary.example", "backup.example"}, func(host, port string) error {
calls = append(calls, host+":"+port)
if host == "backup.example" {
return nil
}
return tt.err
})
if len(calls) != tt.calls {
t.Fatalf("calls=%v", calls)
}
if tt.calls == 4 && err != nil {
t.Fatal(err)
}
if tt.calls == 1 && !errors.Is(err, tt.err) {
t.Fatalf("error=%v", err)
}
})
}
}
func TestRetryable(t *testing.T) {
for _, tt := range []struct {
err error
want bool
}{
{&textproto.Error{Code: 451}, true}, {&net.DNSError{IsTemporary: true}, true},
{&net.DNSError{IsNotFound: true}, false}, {&textproto.Error{Code: 550}, false},
{&smtp.DeliveryUncertainError{Cause: &net.DNSError{IsTimeout: true}}, false},
{&tls.CertificateVerificationError{Err: io.EOF}, false}, {nil, false},
} {
if got := Retryable(tt.err); got != tt.want {
t.Fatalf("Retryable(%v)=%v", tt.err, got)
}
}
}
+51 -107
View File
@@ -9,7 +9,6 @@ import (
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/logstore"
"git.pcux.cn/xuans/Smail/utils/array"
"git.pcux.cn/xuans/Smail/utils/async"
"git.pcux.cn/xuans/Smail/utils/consts"
"git.pcux.cn/xuans/Smail/utils/context"
"git.pcux.cn/xuans/Smail/utils/smtp"
@@ -89,6 +88,23 @@ func Send(ctx *context.Context, e *parsemail.Email) (error, map[string]error) {
// SendTriggered 显式标记业务发起方,不从邮件主题或内容推断来源。
func SendTriggered(ctx *context.Context, e *parsemail.Email, trigger string) (error, map[string]error) {
return sendRecipients(ctx, e, nil, trigger)
}
// SendRecipientTriggered 保留原邮件头,只向当前队列收件人发送 SMTP 信封。
func SendRecipientTriggered(ctx *context.Context, e *parsemail.Email, recipient string) error {
err, failures := sendRecipients(ctx, e, []*parsemail.User{{EmailAddress: recipient}}, "网页写信")
if err != nil {
for _, cause := range failures {
if cause != nil {
return cause
}
}
}
return err
}
func sendRecipients(ctx *context.Context, e *parsemail.Email, recipients []*parsemail.User, trigger string) (error, map[string]error) {
_, fromDomain := e.From.GetDomainAccount()
b, err := e.BuildBytes(ctx, true)
@@ -104,6 +120,9 @@ func SendTriggered(ctx *context.Context, e *parsemail.Email, trigger string) (er
var to []*parsemail.User
to = append(append(append(to, e.To...), e.Cc...), e.Bcc...)
if recipients != nil {
to = recipients
}
return doSend(ctx, fromDomain, b, to, e.From.EmailAddress, trigger)
@@ -176,8 +195,7 @@ func doSend(ctx *context.Context, fromDomain string, data []byte, to []*parsemai
invalidErrors := make(map[string]error)
// 按域名整理
toByDomain := map[mxDomain][]*parsemail.User{}
mxLookupErrors := map[mxDomain]error{}
toByDomain := map[string][]*parsemail.User{}
for _, s := range to {
address, domain, addressErr := parseRecipientAddress(s)
if addressErr != nil {
@@ -189,41 +207,7 @@ func doSend(ctx *context.Context, fromDomain string, data []byte, to []*parsemai
log.WithContext(ctx).WithError(addressErr).Error("invalid recipient address")
continue
}
args := []string{address, domain}
if len(args) == 2 {
if args[1] == consts.TEST_DOMAIN {
// 测试使用
address := mxDomain{
domain: "localhost",
mxHost: "127.0.0.1",
localTest: true,
}
toByDomain[address] = append(toByDomain[address], s)
} else {
//查询dns mx记录
mxInfo, lookupErr := net.LookupMX(args[1])
address := mxDomain{
domain: "smtp." + args[1],
mxHost: "smtp." + args[1],
}
if lookupErr != nil {
log.WithContext(ctx).Errorf("%s 域名mx记录查询失败,检查邮箱是否存在!", s.EmailAddress)
}
if len(mxInfo) > 0 {
address = mxDomain{
domain: args[1],
mxHost: mxInfo[0].Host,
}
}
if lookupErr != nil {
mxLookupErrors[address] = lookupErr
}
toByDomain[address] = append(toByDomain[address], s)
}
} else {
log.WithContext(ctx).Errorf("邮箱地址解析错误! %s", s)
continue
}
toByDomain[domain] = append(toByDomain[domain], s)
}
errEmailAddress := append([]string(nil), invalidAddresses...)
@@ -234,14 +218,14 @@ func doSend(ctx *context.Context, fromDomain string, data []byte, to []*parsemai
errMap.Store(address, err)
}
as := async.New(ctx)
var workers sync.WaitGroup
for domain, tos := range toByDomain {
domain := domain
tos := tos
mxLookupErr := mxLookupErrors[domain]
as.WaitProcess(func(p any) {
workers.Add(1)
go func() {
defer workers.Done()
recordFailure := func(err error) {
err = deliveryFailureCause(mxLookupErr, err)
log.WithContext(ctx).Errorf("%v 邮件投递失败%+v", tos, err)
errEmailAddressMu.Lock()
@@ -250,11 +234,16 @@ func doSend(ctx *context.Context, fromDomain string, data []byte, to []*parsemai
}
errEmailAddressMu.Unlock()
errMap.Store(domain.domain, err)
errMap.Store(domain, err)
}
defer func() {
if value := recover(); value != nil {
recordFailure(&smtp.DeliveryUncertainError{Cause: fmt.Errorf("投递任务异常: %v", value)})
}
}()
if allowUnsafeSMTP(domain) {
err := smtp.SendMailUnsafe("localhost", domain.mxHost+":25", nil, from, fromDomain, buildAddress(tos), data)
if domain == consts.TEST_DOMAIN {
err := smtp.SendMailUnsafe("localhost", "127.0.0.1:25", nil, from, fromDomain, buildAddress(tos), data)
if err != nil {
recordFailure(err)
} else {
@@ -263,71 +252,26 @@ func doSend(ctx *context.Context, fromDomain string, data []byte, to []*parsemai
return
}
// 优先尝试25端口,starttls方式投递
err := smtp.SendMail("", domain.mxHost+":25", nil, from, fromDomain, buildAddress(tos), data)
if err == nil {
hosts, err := resolveMX(domain, net.DefaultResolver.LookupMX)
if err != nil {
recordFailure(err)
return
}
err = deliverMX(hosts, func(host, port string) error {
address := net.JoinHostPort(host, port)
if port == "465" {
return smtp.SendMailWithTls(host, address, nil, from, fromDomain, buildAddress(tos), data)
}
return smtp.SendMail(host, address, nil, from, fromDomain, buildAddress(tos), data)
})
if err != nil {
recordFailure(err)
} else {
accepted.Add(int64(len(tos)))
return
}
if isCertificateVerificationError(err) {
recordFailure(err)
return
}
if isPermanentSMTPResponse(err) {
recordFailure(err)
return
}
log.WithContext(ctx).WithFields(log.Fields{
"action": "SMTP 邮件投递",
"result": "failure",
"object": domain.mxHost + ":25",
}).Infof("SMTP 25 端口 STARTTLS 投递失败: %s", err.Error())
// 587 使用 STARTTLS,只有 465 使用隐式 TLS。
err = smtp.SendMail(strings.TrimSuffix(domain.mxHost, "."), domain.mxHost+":587", nil, from, fromDomain, buildAddress(tos), data)
if err == nil {
accepted.Add(int64(len(tos)))
return
}
if isCertificateVerificationError(err) {
recordFailure(err)
return
}
if isPermanentSMTPResponse(err) {
recordFailure(err)
return
}
log.WithContext(ctx).WithFields(log.Fields{
"action": "SMTP 邮件投递",
"result": "failure",
"object": domain.mxHost + ":587",
}).Infof("SMTP 587 端口投递失败: %s", err.Error())
// 再次尝试465投递
err = smtp.SendMailWithTls(strings.TrimSuffix(domain.mxHost, "."), domain.mxHost+":465", nil, from, fromDomain, buildAddress(tos), data)
if err == nil {
accepted.Add(int64(len(tos)))
return
}
if isCertificateVerificationError(err) {
recordFailure(err)
return
}
if isPermanentSMTPResponse(err) {
recordFailure(err)
return
}
log.WithContext(ctx).WithFields(log.Fields{
"action": "SMTP 邮件投递",
"result": "failure",
"object": domain.mxHost + ":465",
}).Infof("SMTP 465 端口投递失败: %s", err.Error())
// 所有安全投递方式均失败后记录错误,不允许回退到明文连接。
recordFailure(err)
}, nil)
}()
}
as.Wait()
workers.Wait()
orgMap := map[string]error{}
errMap.Range(func(key, value any) bool {
+22 -2
View File
@@ -45,6 +45,22 @@ var EOFError = errors.New("EOF")
var ErrUnsafeRemoteAddress = errors.New("smtp: remote address is not public")
var ErrUnsafePlaintextTarget = errors.New("smtp: plaintext delivery is restricted to localhost")
// DeliveryUncertainError 表示 DATA 已开始,但未取得明确接收或拒绝响应,禁止自动重投。
type DeliveryUncertainError struct {
Cause error
}
func (e *DeliveryUncertainError) Error() string {
return "投递结果不确定,请核对收件结果后再操作: " + e.Cause.Error()
}
func (e *DeliveryUncertainError) Unwrap() error { return e.Cause }
func IsDeliveryUncertain(err error) bool {
var uncertain *DeliveryUncertainError
return errors.As(err, &uncertain)
}
const (
outboundSMTPDialTimeout = 2 * time.Second
outboundSMTPTLSHandshakeTimeout = 2 * time.Second
@@ -554,10 +570,14 @@ func (c *Client) Data() (io.WriteCloser, error) {
func finishDelivery(c *Client, w io.WriteCloser, msg []byte) error {
if _, err := w.Write(msg); err != nil {
return err
return &DeliveryUncertainError{Cause: err}
}
if err := w.Close(); err != nil {
return err
var rejection *textproto.Error
if errors.As(err, &rejection) && rejection.Code >= 400 && rejection.Code <= 599 {
return err
}
return &DeliveryUncertainError{Cause: err}
}
// The final 250 response to DATA transfers responsibility for the message.
+15
View File
@@ -219,6 +219,10 @@ func startSMTPTransactionServer(t *testing.T, dataResponse string, holdWithoutQu
done <- fmt.Errorf("message body was not received: %q", body)
return
}
if dataResponse == "" {
done <- nil
return
}
if err := text.PrintfLine("%s", dataResponse); err != nil {
done <- err
return
@@ -244,6 +248,17 @@ func startSMTPTransactionServer(t *testing.T, dataResponse string, holdWithoutQu
return listener.Addr().String(), done
}
func TestLostFinalDATAResponseIsUncertain(t *testing.T) {
addr, done := startSMTPTransactionServer(t, "", false)
err := SendMailUnsafe("localhost", addr, nil, "sender@example.com", "example.com", []string{"recipient@example.net"}, []byte("Subject: test\r\n\r\nbody\r\n"))
if !IsDeliveryUncertain(err) {
t.Fatalf("error=%v, want uncertain delivery", err)
}
if err := <-done; err != nil {
t.Fatal(err)
}
}
func expectSMTPCommand(conn *textproto.Conn, prefix string) error {
line, err := conn.ReadLine()
if err != nil {