dialers,auto: parallel dial

Author: ignoramous

intra/dialers/retrier.go

@@ -50,8 +50,9 @@ const maxRetryCount = 3
 type retrier struct {
 	dialers    []protect.RDialer
 	dialerOpts settings.DialerOpts
-	raddr      *net.TCPAddr
-	laddr      *net.TCPAddr // laddr may be nil; TCPAddr.IP may be nil.
+	racing     bool
+	raddr      net.Addr
+	laddr      net.Addr // laddr may be nil; TCPAddr.IP may be nil.
 
 	// Flags indicating whether the caller has called CloseRead and CloseWrite.
 	readDone  atomic.Bool
@@ -119,7 +120,7 @@ func calcTimeout(rtt time.Duration) time.Duration {
 	// These values were chosen to have a <1% false positive rate based on test data.
 	// False positives trigger an unnecessary retry, which can make connections slower, so they are
 	// worth avoiding.  However, overly long timeouts make retry slower and less useful.
-	return 800*time.Millisecond + max(2*rtt, 100*time.Millisecond)
+	return 400*time.Millisecond + max(2*rtt, 100*time.Millisecond)
 }
 
 // DialWithSplitRetry returns a TCP connection that transparently retries by
@@ -146,6 +147,33 @@ func DialWithSplitRetry(d *protect.RDial, laddr, raddr *net.TCPAddr) (*retrier,
 	return r, nil
 }
 
+func dialerOptsForRace() settings.DialerOpts {
+	return settings.DialerOpts{
+		Strat: settings.SplitNever,
+		Retry: settings.RetryWithSplit,
+	}
+}
+
+func DialRace(ds []protect.RDialer, laddr, raddr net.Addr) (*retrier, error) {
+	r := &retrier{
+		dialers:     ds,
+		dialerOpts:  dialerOptsForRace(),
+		racing:      true,
+		laddr:       laddr, // may be nil
+		raddr:       raddr, // must not be nil
+		retryDoneCh: make(chan struct{}),
+	}
+
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if _, err := r.dialLocked(); err != nil {
+		return nil, err
+	}
+	return r, nil
+}
+
+// SycallConn implements core.DuplexConn.
 func (r *retrier) SyscallConn() (syscall.RawConn, error) {
 	r.mu.Lock()
 	c := r.conn
@@ -157,6 +185,7 @@ func (r *retrier) SyscallConn() (syscall.RawConn, error) {
 	return nil, syscall.EINVAL
 }
 
+// SetKeepAlive implements core.DuplexConn.
 func (r *retrier) SetKeepAlive(y bool) error {
 	r.mu.Lock()
 	c := r.conn
@@ -242,8 +271,8 @@ func (r *retrier) dialLocked() (c core.DuplexConn, err error) {
 	r.conn = c // c may be nil
 	r.timeout = calcTimeout(rtt)
 
-	logeif(err)("retrier: dial(%s) %s=>%s; strat: %d, rtt: %dms; err? %v",
-		r.dialerOpts, laddr(c), r.raddr, strat, rtt.Milliseconds(), err)
+	logeif(err)("retrier: dial(%s) %s=>%s; strat: %d (race? %t), rtt: %dms; err? %v",
+		r.dialerOpts, laddr(c), r.raddr, strat, r.racing, rtt.Milliseconds(), err)
 
 	return
 }
@@ -285,8 +314,8 @@ func (r *retrier) retryWriteReadLocked(buf []byte) (int, error) {
 
 	var nw int
 	nw, r.retryErr = newConn.Write(r.tee)
-	logeif(r.retryErr)("retrier: retryLocked: strat(%s) %s=>%s; write? %d/%d; err? %v",
-		r.dialerOpts, laddr(newConn), r.raddr, nw, len(r.tee), r.retryErr)
+	logeif(r.retryErr)("retrier: retryLocked: strat(%s, racing? %t) %s=>%s; write? %d/%d; err? %v",
+		r.dialerOpts, r.racing, laddr(newConn), r.raddr, nw, len(r.tee), r.retryErr)
 	if r.retryErr != nil {
 		return 0, r.retryErr
 	}
@@ -309,8 +338,8 @@ func (r *retrier) retryWriteReadLocked(buf []byte) (int, error) {
 		_ = newConn.SetWriteDeadline(r.writeDeadline)
 	}
 
-	logedcond(readdone || writedone)("retrier: retryLocked: done! strat(%s) %s=>%s; write? %d/%d; closed r/w? %t/%t; deadline r/w: %v/%v",
-		r.dialerOpts, laddr(newConn), r.raddr, nw, len(r.tee), readdone, writedone, time.Since(r.readDeadline).Seconds(), time.Since(r.writeDeadline).Seconds())
+	logedcond(readdone || writedone)("retrier: retryLocked: done! strat(%s; racing? %t) %s=>%s; write? %d/%d; closed r/w? %t/%t; deadline r/w: %v/%v",
+		r.dialerOpts, r.racing, laddr(newConn), r.raddr, nw, len(r.tee), readdone, writedone, time.Since(r.readDeadline).Seconds(), time.Since(r.writeDeadline).Seconds())
 
 	return newConn.Read(buf)
 }
@@ -349,16 +378,20 @@ func (r *retrier) Read(buf []byte) (n int, err error) {
 		if !r.retryCompleted() {
 			defer close(r.retryDoneCh) // signal that retry is complete or unnecessary
 			var retryerr error
+			canRetry := r.retryCount < maxRetryCount
+			if r.racing {
+				canRetry = r.dialerCount < len(r.dialers)
+			}
 			// retry on errs like timeouts or connection resets
-			for (c == nil || err != nil) && r.retryCount < maxRetryCount {
+			for (c == nil || err != nil) && canRetry {
 				r.retryCount++
 				n, retryerr = r.retryWriteReadLocked(buf)
 				c = r.conn // re-assign c to newConn, if any; may be nil
 				if c == nil {
 					err = core.UniqErr(err, retryerr)
 				}
-				logeor(retryerr, log.I)("retrier: read# %d: [%s<=%s] %d; err? %v",
-					r.retryCount, laddr(c), r.raddr, n, retryerr)
+				logeor(retryerr, log.I)("retrier: read# %d + (racing? %t / c: %d): [%s<=%s] %d; err? %v",
+					r.retryCount, r.racing, r.dialerCount, laddr(c), r.raddr, n, retryerr)
 			}
 			if c != nil && core.IsNotNil(c) {
 				_ = c.SetReadDeadline(r.readDeadline)

intra/dialers/split_and_desync.go

@@ -298,9 +298,9 @@ func desyncWithFixedTtl(d protect.RDialer, local, remote netip.AddrPort, initial
 // then returns a TCP connection that may launch TCB Desynchronization
 // and split the initial upstream segment.
 // ref: github.com/bol-van/zapret/blob/c369f11638/docs/readme.eng.md#dpi-desync-attack
-func dialWithSplitAndDesync(d protect.RDialer, laddr, raddr *net.TCPAddr) (*overwriteSplitter, error) {
-	remote := raddr.AddrPort() // must not be invalid
-	local := laddr.AddrPort()  // can be invalid
+func dialWithSplitAndDesync(d protect.RDialer, laddr, raddr net.Addr) (*overwriteSplitter, error) {
+	remote := netip.MustParseAddrPort(raddr.String()) // must not be invalid
+	local := netip.MustParseAddrPort(laddr.String())  // can be invalid
 
 	if !remote.IsValid() {
 		log.E("desync: invalid raddr: conv %s to %s", raddr, remote)

intra/ipn/auto.go

@@ -19,8 +19,11 @@ import (
 	"github.com/celzero/firestack/intra/settings"
 )
 
-const ttl30s = 30 * time.Second
-const shortdelay = 100 * time.Millisecond
+const (
+	ttl30s       = 30 * time.Second
+	shortdelay   = 100 * time.Millisecond
+	parallelDial = true
+)
 
 // exit is a proxy that always dials out to the internet.
 type auto struct {
@@ -131,6 +134,15 @@ func (h *auto) dial(network, local, remote string) (protect.Conn, error) {
 
 	remoteOnly := settings.AutoAlwaysRemote.Load()
 
+	if parallelDial {
+		all := []protect.RDialer{exit, exit64, pro, warp, amz, sep}
+		if remoteOnly {
+			all = []protect.RDialer{pro, warp, amz, sep}
+		}
+		// TODO: pinning IPs
+		return parallelDialStrat(all, network, local, remote)
+	}
+
 	previdx, recent := h.exp.Get(remote)
 
 	c, who, err := core.Race(

intra/ipn/proxies.go

@@ -11,7 +11,9 @@ import (
 	"errors"
 	"fmt"
 	"math/rand"
+	"net"
 	"net/netip"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -1487,6 +1489,35 @@ func localDialStrat(d *protect.RDial, network, local, remote string) (protect.Co
 	return dialers.SplitDialBind(d, network, local, remote)
 }
 
+func parallelDialStrat(all []protect.RDialer, network, local, remote string) (protect.Conn, error) {
+	return dialers.DialRace(all, str2addr(network, local), str2addr(network, remote))
+}
+
+func str2addr(network, addrport string) net.Addr {
+	ip, port, err := net.SplitHostPort(addrport)
+	if err != nil {
+		return nil
+	}
+	portno, err := strconv.Atoi(port)
+	if err != nil {
+		return nil
+	}
+	switch network {
+	case "tcp", "tcp4", "tcp6":
+		return &net.TCPAddr{
+			IP:   net.ParseIP(ip),
+			Port: portno,
+		}
+	case "udp", "udp4", "udp6":
+		fallthrough
+	default:
+		return &net.UDPAddr{
+			IP:   net.ParseIP(ip),
+			Port: portno,
+		}
+	}
+}
+
 func firstEmpty(arr []string) bool {
 	return len(arr) <= 0 || len(arr[0]) <= 0
 }

intra/protect/xdial.go

@@ -233,7 +233,7 @@ func (d *RDial) DialTCP(network string, laddr, raddr *net.TCPAddr) (*net.TCPConn
 	return DialTCP(d, network, laddr, raddr)
 }
 
-func DialTCP(d RDialer, network string, laddr, raddr *net.TCPAddr) (*net.TCPConn, error) {
+func DialTCP(d RDialer, network string, laddr, raddr net.Addr) (*net.TCPConn, error) {
 	if c, err := d.DialBind(network, laddr.String(), raddr.String()); err != nil {
 		return nil, err
 	} else if tc, ok := c.(*net.TCPConn); ok {
@@ -254,7 +254,7 @@ func (d *RDial) DialUDP(network string, laddr, raddr *net.UDPAddr) (*net.UDPConn
 	return DialUDP(d, network, laddr, raddr)
 }
 
-func DialUDP(d RDialer, network string, laddr, raddr *net.UDPAddr) (*net.UDPConn, error) {
+func DialUDP(d RDialer, network string, laddr, raddr net.Addr) (*net.UDPConn, error) {
 	if c, err := d.DialBind(network, laddr.String(), raddr.String()); err != nil {
 		return nil, err
 	} else if uc, ok := c.(*net.UDPConn); ok {

intra/settings/dialeropts.go

@@ -26,10 +26,6 @@ type DialerOpts struct {
 	WriteTimeoutSec int32
 }
 
-func newDialerOpts() *DialerOpts {
-	return &DialerOpts{}
-}
-
 func (d DialerOpts) String() string {
 	s := func() string {
 		switch d.Strat {
@@ -99,7 +95,7 @@ const (
 	RetryNever
 )
 
-var dialerOpts = newDialerOpts()
+var dialerOpts = &DialerOpts{}
 
 // SetDialerOpts sets the dialer options to use.
 func SetDialerOpts(strat, retry, timeoutsec int32, keepalive bool) bool {