Improve Asuswrt-Merlin 3006 DNS/SDN integration and service lifecycle

cmd/cli/cli.go

@@ -442,6 +442,18 @@ func run(appCallback *AppCallback, stopCh chan struct{}) {
 		os.Exit(0)
 	}
 
+	// On Merlin, self-upgrade replaces the executable before the old process
+	// invokes Service.Start. The newly launched `ctrld run` process is therefore
+	// the first guaranteed execution point for new service-lifecycle code.
+	// Migrate an exact ctrld-owned legacy startup script here. Failure is
+	// deliberately non-fatal: the legacy script remains atomically intact and
+	// the next daemon start retries the migration.
+	if router.Name() == "merlin" {
+		if err := router.RefreshMerlinStartupScriptFromRunningBinary(); err != nil {
+			mainLog.Load().Warn().Err(err).Msg("could not refresh Merlin startup script")
+		}
+	}
+
 	p.onStarted = append(p.onStarted, func() {
 		for _, lc := range p.cfg.Listener {
 			if shouldAllocateLoopbackIP(lc.IP) {

cmd/cli/commands.go

@@ -926,6 +926,19 @@ func initStopCmd() *cobra.Command {
 	return stopCmd
 }
 
+
+type restartWithBetweenService interface {
+	RestartWith(func() error) error
+}
+
+func restartServiceTransaction(s service.Service, between func() error) (bool, error) {
+	tx, ok := s.(restartWithBetweenService)
+	if !ok {
+		return false, nil
+	}
+	return true, tx.RestartWith(between)
+}
+
 func initRestartCmd() *cobra.Command {
 	restartCmd := &cobra.Command{
 		PreRun: func(cmd *cobra.Command, args []string) {
@@ -971,49 +984,77 @@ func initRestartCmd() *cobra.Command {
 			}
 
 			doRestart := func() bool {
-				tasks := []task{
-					{s.Stop, true, "Stop"},
-					{func() error {
-						p.router.Cleanup()
-						// restore static DNS settings or DHCP
-						p.resetDNS(false, true)
-						return nil
-					}, false, "Cleanup"},
-					{func() error {
-						time.Sleep(time.Second * 1)
-						return nil
-					}, false, "Waiting for service to stop"},
-				}
-				if doTasks(tasks) {
+				between := func() error {
+					p.router.Cleanup()
+					// restore static DNS settings or DHCP
+					p.resetDNS(false, true)
+					time.Sleep(time.Second)
 
 					if router.WaitProcessExited() {
 						ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
 						defer cancel()
 
-					loop:
 						for {
 							select {
 							case <-ctx.Done():
 								mainLog.Load().Error().Msg("timeout while waiting for service to stop")
-								break loop
+								return nil
 							default:
 							}
-							time.Sleep(time.Second)
 							if status, _ := s.Status(); status == service.StatusStopped {
 								break
 							}
+							time.Sleep(time.Second)
 						}
 					}
-				} else {
-					return false
+					return nil
 				}
 
-				tasks = []task{
-					{s.Start, true, "Start"},
+				if _, ok := s.(restartWithBetweenService); ok {
+					return doTasks([]task{
+						{func() error {
+							_, err := restartServiceTransaction(s, between)
+							return err
+						}, true, "Restart"},
+					})
 				}
 
-				return doTasks(tasks)
+				// Preserve the existing restart behavior for non-Merlin service
+				// backends. Only Merlin opts into RestartWith.
+				tasks := []task{
+					{s.Stop, true, "Stop"},
+					{func() error {
+						p.router.Cleanup()
+						p.resetDNS(false, true)
+						return nil
+					}, false, "Cleanup"},
+					{func() error {
+						time.Sleep(time.Second)
+						return nil
+					}, false, "Waiting for service to stop"},
+				}
+				if !doTasks(tasks) {
+					return false
+				}
+				if router.WaitProcessExited() {
+					ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
+					defer cancel()
 
+				loop:
+					for {
+						select {
+						case <-ctx.Done():
+							mainLog.Load().Error().Msg("timeout while waiting for service to stop")
+							break loop
+						default:
+						}
+						time.Sleep(time.Second)
+						if status, _ := s.Status(); status == service.StatusStopped {
+							break
+						}
+					}
+				}
+				return doTasks([]task{{s.Start, true, "Start"}})
 			}
 
 			if doRestart() {
@@ -1547,25 +1588,58 @@ func initUpgradeCmd() *cobra.Command {
 				if !svcInstalled {
 					return true
 				}
-				tasks := []task{
-					{s.Stop, true, "Stop"},
-					{func() error {
-						p.router.Cleanup()
-						// restore static DNS settings or DHCP
-						p.resetDNS(false, true)
-						return nil
-					}, false, "Cleanup"},
-					{func() error {
-						time.Sleep(time.Second * 1)
-						return nil
-					}, false, "Waiting for service to stop"},
-				}
-				if doTasks(tasks) {
+
+				between := func() error {
+					p.router.Cleanup()
+					// restore static DNS settings or DHCP
+					p.resetDNS(false, true)
+					time.Sleep(time.Second)
 
 					if router.WaitProcessExited() {
 						ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
 						defer cancel()
 
+						for {
+							select {
+							case <-ctx.Done():
+								mainLog.Load().Error().Msg("timeout while waiting for service to stop")
+								return nil
+							default:
+							}
+							if status, _ := s.Status(); status == service.StatusStopped {
+								break
+							}
+							time.Sleep(time.Second)
+						}
+					}
+					return nil
+				}
+
+				if _, ok := s.(restartWithBetweenService); ok {
+					_, err := restartServiceTransaction(s, between)
+					if err != nil {
+						mainLog.Load().Error().Err(err).Msg("failed to restart ctrld service")
+						return false
+					}
+				} else {
+					// Keep the historical upgrade restart path for every non-Merlin
+					// backend; they do not participate in the new Merlin flock.
+					tasks := []task{
+						{s.Stop, true, "Stop"},
+						{func() error {
+							p.router.Cleanup()
+							p.resetDNS(false, true)
+							return nil
+						}, false, "Cleanup"},
+						{func() error {
+							time.Sleep(time.Second)
+							return nil
+						}, false, "Waiting for service to stop"},
+					}
+					if doTasks(tasks) && router.WaitProcessExited() {
+						ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
+						defer cancel()
+
 					loop:
 						for {
 							select {
@@ -1580,17 +1654,15 @@ func initUpgradeCmd() *cobra.Command {
 							}
 						}
 					}
+					if !doTasks([]task{{s.Start, true, "Start"}}) {
+						return false
+					}
 				}
 
-				tasks = []task{
-					{s.Start, true, "Start"},
-				}
-				if doTasks(tasks) {
-					if dir, err := socketDir(); err == nil {
-						if cc := newSocketControlClient(context.TODO(), s, dir); cc != nil {
-							_, _ = cc.post(ifacePath, nil)
-							return true
-						}
+				if dir, err := socketDir(); err == nil {
+					if cc := newSocketControlClient(context.TODO(), s, dir); cc != nil {
+						_, _ = cc.post(ifacePath, nil)
+						return true
 					}
 				}
 				return false

internal/router/dnsmasq/dnsmasq.go

@@ -2,11 +2,11 @@ package dnsmasq
 
 import (
 	"errors"
+	"text/template"
 	"net"
 	"os"
 	"path/filepath"
 	"strings"
-	"text/template"
 
 	"github.com/Control-D-Inc/ctrld"
 )
@@ -28,22 +28,44 @@ max-cache-ttl=0
 `
 
 const (
-	MerlinConfPath     = "/tmp/etc/dnsmasq.conf"
-	MerlinJffsConfDir  = "/jffs/configs"
-	MerlinJffsConfPath = "/jffs/configs/dnsmasq.conf"
-	MerlinPostConfPath = "/jffs/scripts/dnsmasq.postconf"
+	MerlinConfPath        = "/tmp/etc/dnsmasq.conf"
+	MerlinJffsConfDir     = "/jffs/configs"
+	MerlinJffsConfPath    = "/jffs/configs/dnsmasq.conf"
+	MerlinPostConfPath    = "/jffs/scripts/dnsmasq.postconf"
+	MerlinSdnPostConfPath = "/jffs/scripts/dnsmasq-sdn.postconf"
 )
 
-const MerlinPostConfMarker = `# GENERATED BY ctrld - EOF`
-const MerlinPostConfTmpl = `# GENERATED BY ctrld - DO NOT MODIFY
-
-#!/bin/sh
+const (
+	MerlinPostConfBeginMarker            = `# BEGIN ctrld`
+	MerlinPostConfEndMarker              = `# END ctrld`
+	MerlinSyntheticShebangMarker         = `# ctrld: synthetic shebang`
+	// MerlinPostConfMarker is the legacy end marker used by ctrld <= 1.5.7.
+	MerlinPostConfMarker = `# GENERATED BY ctrld - EOF`
+)
 
+const MerlinPostConfTmpl = `(
 config_file="$1"
 . /usr/sbin/helper.sh
 
 pid=$(cat /tmp/ctrld.pid 2>/dev/null)
-if [ -n "$pid" ] && [ -f "/proc/${pid}/cmdline" ]; then
+ctrld_cmd=""
+case "$pid" in
+  ''|*[!0-9]*) ;;
+  *)
+    if [ -r "/proc/${pid}/cmdline" ]; then
+      ctrld_cmd=$(tr '\000' '\n' < "/proc/${pid}/cmdline" 2>/dev/null | sed -n '1p')
+    fi
+    ;;
+esac
+case "$ctrld_cmd" in
+  ctrld|*/ctrld)
+    ctrld_running=1
+    ;;
+  *)
+    ctrld_running=0
+    ;;
+esac
+if [ "$ctrld_running" -eq 1 ]; then
   pc_delete "servers-file" "$config_file"           # no WAN DNS settings
   pc_append "no-resolv" "$config_file"              # do not read /etc/resolv.conf
   # use ctrld as upstream
@@ -66,9 +88,8 @@ if [ -n "$pid" ] && [ -f "/proc/${pid}/cmdline" ]; then
   # Change /etc/resolv.conf, which may be changed by WAN DNS setup
   pc_delete "nameserver" /etc/resolv.conf
   pc_append "nameserver 127.0.0.1" /etc/resolv.conf
-
-  exit 0
 fi
+)
 `
 
 type Upstream struct {