settings,ipn: local, remote, hybrid modes for auto

Author: ignoramous

intra/backend/netstat.go

@@ -164,7 +164,7 @@ type RDNSInfo struct {
 	ProxySince  string
 	Proxies     string
 
-	AutoAlwaysRemote  bool
+	AutoMode          string
 	AutoDialsParallel bool
 
 	OpenConnsTCP  string

intra/ipn/auto.go

@@ -76,7 +76,7 @@ func (h *auto) Handle() uintptr {
 
 // DialerHandle implements Proxy.
 func (h *auto) DialerHandle() (mix uintptr) {
-	remoteOnly := settings.AutoAlwaysRemote.Load()
+	remoteOnly := settings.AutoAlwaysRemote()
 	if !remoteOnly {
 		if exit, _ := h.pxr.ProxyFor(Exit); exit != nil {
 			mix ^= exit.DialerHandle()
@@ -132,7 +132,7 @@ func (h *auto) dial(network, laddr, raddr string) (protect.Conn, error) {
 		}
 	}
 
-	remoteOnly := settings.AutoAlwaysRemote.Load()
+	remoteOnly := settings.AutoAlwaysRemote()
 	parallelDial := settings.AutoDialsParallel.Load()
 
 	if !parallelDial {
@@ -407,7 +407,7 @@ func (h *auto) Accept(network, local string) (l protect.Listener, err error) {
 	if h.status.Load() == END {
 		return nil, errProxyStopped
 	}
-	if settings.AutoAlwaysRemote.Load() {
+	if settings.AutoAlwaysRemote() {
 		log.E("proxy: auto: accept(%s) on %s remote-dial unimplemented", network, local)
 		return nil, errNotRemote
 	}
@@ -426,7 +426,7 @@ func (h *auto) Probe(network, local string) (pc protect.PacketConn, err error) {
 	if h.status.Load() == END {
 		return nil, errProxyStopped
 	}
-	if settings.AutoAlwaysRemote.Load() {
+	if settings.AutoAlwaysRemote() {
 		log.E("proxy: auto: probe(%s) on %s remote-dial unimplemented", network, local)
 		return nil, errNotRemote
 	}

intra/ipn/proxies.go

@@ -26,6 +26,7 @@ import (
 	"github.com/celzero/firestack/intra/log"
 	"github.com/celzero/firestack/intra/netstack"
 	"github.com/celzero/firestack/intra/protect"
+	"github.com/celzero/firestack/intra/settings"
 )
 
 const (
@@ -175,6 +176,8 @@ type rpnProxyProvider interface {
 	mainRpnProxyOf(provider string) (RpnProxy, error)
 	// rpnProxyFor returns a country-specific RPN proxy from this multi-transport.
 	rpnProxyFor(provider, cc string) (Proxy, error)
+	// AutoActive returns true if any of the RPN proxies are in-use by ipn.Auto.
+	AutoActive() bool
 }
 
 type ProxyProvider interface {
@@ -653,6 +656,10 @@ func (px *proxifier) ProxyFor(id string) (Proxy, error) {
 	return p, nil
 }
 
+func (px *proxifier) AutoActive() bool {
+	return settings.AutoActive()
+}
+
 func (px *proxifier) mainRpnProxyOf(provider string) (RpnProxy, error) {
 	if !isRPN(provider) {
 		return nil, errNotRpnID

intra/settings/proxyopts.go

@@ -108,14 +108,54 @@ func (p *ProxyOptions) Url() string {
 	return p.Scheme + "://" + p.IPPort
 }
 
-// AutoAlwaysRemote is a global variable to instruct ipn.Auto proxy
-// to always use remote proxies and never use local (ex: ipn.Exit) ones.
-var AutoAlwaysRemote atomic.Bool
-
-// SetAutoAlwaysRemote puts backend.Auto in remote-only mode if y is true.
-// That is, backend.Auto will never use local proxies (ex: ipn.Exit).
-func SetAutoAlwaysRemote(y bool) (prev bool) {
-	return AutoAlwaysRemote.Swap(y)
+// AutoMode is a global variable to instruct if backend.Auto proxy
+// is in local, remote, or hybrid mode. In local mode, backend.Auto
+// uses local proxies (ex: ipn.Exit) only. In remote mode,
+// backend.Auto uses remote proxies (ex: RPN).
+var AutoMode atomic.Int32
+
+const (
+	// local mode: backend.Auto uses local proxies (ex: ipn.Exit) only.
+	AutoModeLocal = iota
+	// remote mode: backend.Auto uses remote proxies (ex: RPN) only.
+	AutoModeRemote
+	// hybrid mode: backend.Auto uses local and remote proxies.
+	AutoModeHybrid
+)
+
+// SetAutoMode sets the global AutoMode variable to y.
+// Indicates if backend.Auto proxy is in local, remote, or hybrid mode.
+func SetAutoMode(m int32) (ok bool) {
+	s := max(m, AutoModeLocal)
+	s = min(m, AutoModeHybrid)
+	if m != s {
+		return false
+	}
+	AutoMode.Store(m)
+	return true
+}
+
+func AutoModeStr() string {
+	switch AutoMode.Load() {
+	case AutoModeLocal:
+		return "local"
+	case AutoModeRemote:
+		return "remote"
+	case AutoModeHybrid:
+		return "hybrid"
+	default:
+		return "unknown"
+	}
+}
+
+// backend.Auto must use remote proxies and never use local (ex: ipn.Exit) ones.
+func AutoAlwaysRemote() bool {
+	return AutoMode.Load() == AutoModeRemote
+}
+
+// backend.Auto is effecively not active.
+func AutoActive() bool {
+	return AutoMode.Load() != AutoModeLocal
 }
 
 // AutoDialsParallel is a global variable to instruct ipn.Auto proxy

intra/tunnel.go

@@ -321,7 +321,7 @@ func (t *rtunnel) stat() (*x.NetStat, error) {
 	out.RDNSIn.Dialer4 = dialers.Use4()
 	out.RDNSIn.Dialer6 = dialers.Use6()
 	out.RDNSIn.DialerOpts = csv2ssv(settings.GetDialerOpts().String())
-	out.RDNSIn.AutoAlwaysRemote = settings.AutoAlwaysRemote.Load()
+	out.RDNSIn.AutoMode = settings.AutoModeStr()
 	out.RDNSIn.AutoDialsParallel = settings.AutoDialsParallel.Load()
 
 	firewall := settings.BlockMode.Load()