Implement DELIVERBY (RFC 2852)

Author: qugu2427

client.go

@@ -534,6 +534,16 @@ func (c *Client) Rcpt(to string, opts *RcptOptions) error {
 	if _, ok := c.ext["RRVS"]; ok && opts != nil && !opts.RequireRecipientValidSince.IsZero() {
 		sb.WriteString(fmt.Sprintf(" RRVS=%s", opts.RequireRecipientValidSince.Format(time.RFC3339)))
 	}
+	if _, ok := c.ext["DELIVERBY"]; ok && opts != nil && opts.DeliverBy != nil {
+		if opts.DeliverBy.Mode == DeliverByReturn && opts.DeliverBy.Time < 1 {
+			return errors.New("smtp: DELIVERBY mode must be greater than zero with return mode")
+		}
+		arg := fmt.Sprintf(" BY=%d;%s", int(opts.DeliverBy.Time.Seconds()), opts.DeliverBy.Mode)
+		if opts.DeliverBy.Trace {
+			arg += "T"
+		}
+		sb.WriteString(arg)
+	}
 	if _, _, err := c.cmd(25, "%s", sb.String()); err != nil {
 		return err
 	}

client_test.go

@@ -1079,3 +1079,39 @@ func TestClientRRVS(t *testing.T) {
 		t.Errorf("wrote %q; want %q", actualcmds, client)
 	}
 }
+
+var deliverByServer = `220 hello world
+250 ok
+`
+
+var deliverByClient = `RCPT TO:<root@nsa.gov> BY=100;RT
+`
+
+func TestClientDELIVERBY(t *testing.T) {
+	server := strings.Join(strings.Split(deliverByServer, "\n"), "\r\n")
+	client := strings.Join(strings.Split(deliverByClient, "\n"), "\r\n")
+
+	var wrote bytes.Buffer
+	var fake faker
+	fake.ReadWriter = struct {
+		io.Reader
+		io.Writer
+	}{
+		strings.NewReader(server),
+		&wrote,
+	}
+	c := NewClient(fake)
+	c.didHello = true
+	c.ext = map[string]string{"DELIVERBY": ""}
+	c.Rcpt("root@nsa.gov", &RcptOptions{
+		DeliverBy: &DeliverByOptions{
+			Time:  100 * time.Second,
+			Mode:  DeliverByReturn,
+			Trace: true,
+		},
+	})
+	c.Close()
+	if actualcmds := wrote.String(); client != actualcmds {
+		t.Errorf("wrote %q; want %q", actualcmds, client)
+	}
+}

conn.go

@@ -294,6 +294,13 @@ func (c *Conn) handleGreet(enhanced bool, arg string) {
 	if c.server.EnableRRVS {
 		caps = append(caps, "RRVS")
 	}
+	if c.server.EnableDELIVERBY {
+		if c.server.MinimumDeliverByTime == 0 {
+			caps = append(caps, "DELIVERBY")
+		} else {
+			caps = append(caps, fmt.Sprintf("DELIVERBY %d", int(c.server.MinimumDeliverByTime.Seconds())))
+		}
+	}
 
 	args := []string{"Hello " + domain}
 	args = append(args, caps...)
@@ -731,6 +738,23 @@ func (c *Conn) handleRcpt(arg string) {
 				return
 			}
 			opts.RequireRecipientValidSince = rrvsTime
+		case "BY":
+			if !c.server.EnableDELIVERBY {
+				c.writeResponse(504, EnhancedCode{5, 5, 4}, "DELIVERBY is not implemented")
+				return
+			}
+			deliverBy := parseDeliverByArgument(value)
+			if deliverBy == nil {
+				c.writeResponse(501, EnhancedCode{5, 5, 4}, "Malformed BY parameter value")
+				return
+			}
+			if c.server.MinimumDeliverByTime != 0 &&
+				deliverBy.Mode == DeliverByReturn &&
+				deliverBy.Time < c.server.MinimumDeliverByTime {
+				c.writeResponse(501, EnhancedCode{5, 5, 4}, "BY parameter is below server minimum")
+				return
+			}
+			opts.DeliverBy = deliverBy
 		default:
 			c.writeResponse(500, EnhancedCode{5, 5, 4}, "Unknown RCPT TO argument")
 			return

parse.go

@@ -2,7 +2,9 @@ package smtp
 
 import (
 	"fmt"
+	"strconv"
 	"strings"
+	"time"
 )
 
 // cutPrefixFold is a version of strings.CutPrefix which is case-insensitive.
@@ -74,6 +76,29 @@ func parseHelloArgument(arg string) (string, error) {
 	return domain, nil
 }
 
+// Parses the BY argument defined in RFC2852 section 4.
+// Returns pointer to options or nil if invalid.
+func parseDeliverByArgument(arg string) *DeliverByOptions {
+	secondsStr, modeStr, ok := strings.Cut(arg, ";")
+	if !ok {
+		return nil
+	}
+	modeStr, traceValue := strings.CutSuffix(modeStr, "T")
+	if modeStr != string(DeliverByNotify) && modeStr != string(DeliverByReturn) {
+		return nil
+	}
+	modeValue := DeliverByMode(modeStr)
+	secondsValue, err := strconv.Atoi(secondsStr)
+	if err != nil || (modeValue == DeliverByReturn && secondsValue < 1) {
+		return nil
+	}
+	return &DeliverByOptions{
+		Time:  time.Duration(secondsValue) * time.Second,
+		Mode:  modeValue,
+		Trace: traceValue,
+	}
+}
+
 // parser parses command arguments defined in RFC 5321 section 4.1.2.
 type parser struct {
 	s string

server.go

@@ -61,6 +61,15 @@ type Server struct {
 	// Should be used only if backend supports it.
 	EnableRRVS bool
 
+	// Advertise DELIVERBY (RFC 2852) capability.
+	// Should be used only if backend supports it.
+	EnableDELIVERBY bool
+	// The minimum time, with seconds precision, that a client
+	// may specify in the BY argument with return mode.
+	// A zero value indicates no set minimum.
+	// Only use if DELIVERBY is enabled.
+	MinimumDeliverByTime time.Duration
+
 	// The server backend.
 	Backend Backend
 

server_test.go

@@ -1580,3 +1580,73 @@ func TestServerRRVS(t *testing.T) {
 		t.Fatal("Invalid RRVS parameter value:", fmt.Sprintf("%#v", opts[1].RequireRecipientValidSince))
 	}
 }
+
+func TestServerDELIVERBY(t *testing.T) {
+	be, s, c, scanner, caps := testServerEhlo(t,
+		func(s *smtp.Server) {
+			s.EnableDELIVERBY = true
+			s.MinimumDeliverByTime = 50 * time.Second
+		})
+	defer s.Close()
+	defer c.Close()
+
+	if _, ok := caps["DELIVERBY 50"]; !ok {
+		t.Fatal("Missing capability: DELIVERBY")
+	}
+
+	io.WriteString(c, "MAIL FROM:<root@nsa.gov>\r\n")
+	scanner.Scan()
+
+	malformedMsgs := []string{
+		"RCPT TO:<root@gchq.gov.uk> BY=",
+		"RCPT TO:<root@gchq.gov.uk> BY=1234",
+		"RCPT TO:<root@gchq.gov.uk> BY=123;RT;",
+		"RCPT TO:<root@gchq.gov.uk> BY=0;R",
+		"RCPT TO:<root@gchq.gov.uk> BY=49;RT",
+	}
+
+	for _, msg := range malformedMsgs {
+		io.WriteString(c, msg+"\r\n")
+		scanner.Scan()
+		if !strings.HasPrefix(scanner.Text(), "501 5.5.4") {
+			t.Fatal("Unexpected res on malformed BY parameter value:", scanner.Text())
+		}
+	}
+
+	io.WriteString(c, "RCPT TO:<root@gchq.gov.uk> BY=100;NT\r\n")
+	scanner.Scan()
+
+	if !strings.HasPrefix(scanner.Text(), "250 ") {
+		t.Fatal("Invalid BY parameter value:", scanner.Text())
+	}
+
+	// complete the transaction
+	io.WriteString(c, "DATA\r\n")
+	scanner.Scan()
+	io.WriteString(c, "Hey <3\r\n")
+	io.WriteString(c, ".\r\n")
+	scanner.Scan()
+
+	opts := be.anonmsgs[0].RcptOpts
+	if opts == nil || len(opts) != 1 {
+		t.Fatal("Invalid number of recipients:", opts)
+	}
+
+	deliverByOpts := opts[0].DeliverBy
+
+	if deliverByOpts == nil {
+		t.Fatal("Deliver by options is nil:", opts)
+	}
+
+	expectedDeliverByOpts := smtp.DeliverByOptions{
+		Time:  100 * time.Second,
+		Mode:  smtp.DeliverByNotify,
+		Trace: true,
+	}
+
+	if deliverByOpts.Time != expectedDeliverByOpts.Time ||
+		deliverByOpts.Mode != expectedDeliverByOpts.Mode ||
+		deliverByOpts.Trace != expectedDeliverByOpts.Trace {
+		t.Fatal("Incorrect BY parameter value:", fmt.Sprintf("expected %#v, got %#v", expectedDeliverByOpts, deliverByOpts))
+	}
+}

smtp.go

@@ -3,21 +3,25 @@
 // It also implements the following extensions:
 //
 //   - 8BITMIME (RFC 1652)
-//   - AUTH (RFC 2554)
-//   - STARTTLS (RFC 3207)
 //   - ENHANCEDSTATUSCODES (RFC 2034)
-//   - SMTPUTF8 (RFC 6531)
-//   - REQUIRETLS (RFC 8689)
+//   - AUTH (RFC 2554)
+//   - DELIVERBY (RFC 2852)
 //   - CHUNKING (RFC 3030)
 //   - BINARYMIME (RFC 3030)
+//   - STARTTLS (RFC 3207)
 //   - DSN (RFC 3461, RFC 6533)
+//   - SMTPUTF8 (RFC 6531)
+//   - RRVS (RFC 7293)
+//   - REQUIRETLS (RFC 8689)
 //
 // LMTP (RFC 2033) is also supported.
 //
 // Additional extensions may be handled by other packages.
 package smtp
 
-import "time"
+import (
+	"time"
+)
 
 type BodyType string
 
@@ -84,6 +88,19 @@ const (
 	DSNAddressTypeUTF8   DSNAddressType = "UTF-8"
 )
 
+type DeliverByMode string
+
+const (
+	DeliverByNotify DeliverByMode = "N"
+	DeliverByReturn DeliverByMode = "R"
+)
+
+type DeliverByOptions struct {
+	Time  time.Duration
+	Mode  DeliverByMode
+	Trace bool
+}
+
 // RcptOptions contains parameters for the RCPT command.
 type RcptOptions struct {
 	// Value of NOTIFY= argument, NEVER or a combination of either of
@@ -95,6 +112,9 @@ type RcptOptions struct {
 	OriginalRecipient     string
 
 	// Time value of the RRVS= argument
-	// Left as the zero time if unset.
+	// or the zero time if unset.
 	RequireRecipientValidSince time.Time
+
+	// Value of BY= argument or nil if unset.
+	DeliverBy *DeliverByOptions
 }