msgpipeline: Allow to chain pipelines

This allows for some complex but useful configurations, such as making
decision on delivery target based on the result of per-destination
address rewriting. One example where that can be useful is aliasing
local address to a remote address in a way that can't make the server
an open relay.

dist/vim/syntax/maddy-conf.vim

@@ -61,6 +61,7 @@ syn keyword maddyModule
 	\ test_check
 	\ test_modifier
 	\ verify_dkim
+	\ aliases_file
 
 syn keyword maddyDispatchDir
 	\ check
@@ -71,6 +72,7 @@ syn keyword maddyDispatchDir
 	\ destination
 	\ reject
 	\ deliver_to
+	\ reroute
 
 " grep --no-file -E 'cfg..+\(".+", ' **.go | sed -E 's/.+cfg..+\("([^"]+)", .+/\1/' | sort -u
 syn keyword maddyModDir

man/maddy-smtp.5.scd

@@ -340,6 +340,36 @@ default_source {
 }
 ```
 
+*Syntax*: reroute { ... } ++
+*Context*: pipeline configuration, source block, destination block
+
+This directive allows to make message routing decisions based on the 
+result of modifiers. The block can contain all pipeline directives and they
+will be handled the same with the exception that source and destination rules
+will use the final recipient and sender values (e.g. after all modifiers are
+applied).
+
+Here is the concrete example how it can be useful:
+```
+destination example.org {
+    modify {
+        alias_file /etc/maddy/aliases
+    }
+    reroute {
+        destination example.org {
+            deliver_to local_mailboxes
+        }
+        default_destination {
+            deliver_to remote_queue
+        }
+    }
+}
+```
+
+This configuration allows to specify alias local addresses to remote ones
+without being an open relay, since remote_queue can be used only if remote
+address was introduced as a result of rewrite of local address.
+
 *Syntax*: destination _rule..._ { ... } ++
 *Context*: pipeline configuration, source block
 

msgpipeline/check_runner.go

@@ -72,7 +72,7 @@ func (cr *checkRunner) checkStates(checks []module.Check) ([]module.CheckState,
 			continue
 		}
 
-		cr.log.Debugf("initializing state for %v (%p)", check.(module.Module).InstanceName(), check)
+		cr.log.Debugf("initializing state for %v (%p)", objectName(check), check)
 		state, err := check.CheckStateForMsg(cr.msgMeta)
 		if err != nil {
 			closeStates()

msgpipeline/config.go

@@ -230,6 +230,17 @@ func parseMsgPipelineRcptCfg(globals map[string]interface{}, nodes []config.Node
 			}
 
 			rcpt.targets = append(rcpt.targets, mod)
+		case "reroute":
+			if len(node.Children) == 0 {
+				return nil, config.NodeErr(&node, "missing or empty reroute pipeline configuration")
+			}
+
+			pipeline, err := New(globals, node.Children)
+			if err != nil {
+				return nil, err
+			}
+
+			rcpt.targets = append(rcpt.targets, pipeline)
 		case "reject":
 			if len(rcpt.targets) != 0 {
 				return nil, config.NodeErr(&node, "can't use 'reject' and 'deliver_to' together")

msgpipeline/msgpipeline.go

@@ -476,14 +476,12 @@ func (dd *msgpipelineDelivery) getDelivery(tgt module.DeliveryTarget) (*delivery
 
 	deliveryObj, err := tgt.Start(dd.msgMeta, dd.sourceAddr)
 	if err != nil {
-		dd.log.Debugf("tgt.Start(%s) failure, target = %s (%s): %v",
+		dd.log.Debugf("tgt.Start(%s) failure, target = %s: %v", dd.sourceAddr, objectName(tgt), err)
-			dd.sourceAddr, tgt.(module.Module).InstanceName(), tgt.(module.Module).Name(), err)
 		return nil, err
 	}
 	delivery_ = &delivery{Delivery: deliveryObj}
 
-	dd.log.Debugf("tgt.Start(%s) ok, target = %s (%s)",
+	dd.log.Debugf("tgt.Start(%s) ok, target = %s (%s)", dd.sourceAddr, objectName(tgt))
-		dd.sourceAddr, tgt.(module.Module).InstanceName(), tgt.(module.Module).Name())
 
 	dd.deliveries[tgt] = delivery_
 	return delivery_, nil

msgpipeline/objname.go

@@ -0,0 +1,26 @@
+package msgpipeline
+
+import (
+	"fmt"
+
+	"github.com/foxcpp/maddy/module"
+)
+
+// objectName returns a new that is usable to identify the used external
+// component (module or some stub) in debug logs.
+func objectName(x interface{}) string {
+	mod, ok := x.(module.Module)
+	if ok {
+		if mod.InstanceName() == "" {
+			return mod.Name()
+		}
+		return mod.InstanceName()
+	}
+
+	_, pipeline := x.(*MsgPipeline)
+	if pipeline {
+		return "reroute"
+	}
+
+	return fmt.Sprintf("%T", x)
+}