rpn: rmv amnezia

Author: ignoramous

intra/backend/ipn_proxies.go

@@ -23,8 +23,6 @@ const ( // see ipn/proxies.go
 	Auto = "Auto"
 	// RPN Warp (must be registered by Rpn.RegisterWarp)
 	RpnWg = WG + "w" + RPN
-	// RPN Amnezia (must be registered by Rpn.RegisterAmnezia)
-	RpnAmz = WG + "a" + RPN
 	// RPN Win proxy (must be registered by Rpn.RegisterWin)
 	RpnWin = WG + "y" + RPN
 	// Alias for RPN Win
@@ -90,16 +88,12 @@ type Rpn interface {
 	RegisterWarp(existingStateJson *Gobyte) (json *Gobyte, err error)
 	// RegisterSE registers a new SurfEasy user.
 	RegisterSE() error
-	// RegisterAmnezia registers a new Amnezia installation.
-	RegisterAmnezia(existingStateJson *Gobyte) (json *Gobyte, err error)
 	// RegisterProton is alias for RegisterWin.
 	RegisterProton(entitlementOrStateJson *Gobyte) (json *Gobyte, err error)
 	// RegisterWin is alias for RegisterWin.
 	RegisterWin(entitlementOrStateJson *Gobyte) (json *Gobyte, err error)
 	// UnregisterWarp unregisters a Warp public key.
 	UnregisterWarp() bool
-	// UnregisterAmnezia unregisters an Amnezia installation.
-	UnregisterAmnezia() bool
 	// UnregisterProton is an alias for UnregisterWin.
 	UnregisterProton() bool
 	// UnregisterWin unregisters a Windscribe installation.
@@ -108,8 +102,6 @@ type Rpn interface {
 	UnregisterSE() bool
 	// TestWarp connects to some Warp IPs and returns reachable ones.
 	TestWarp() (ips *Gostr, errs error)
-	// TestAmnezia connects to the Amnezia gateway and returns its IP if reachable.
-	TestAmnezia() (ips *Gostr, errs error)
 	// TestWin connects to the Windscribe gateway and returns its IP if reachable.
 	TestWin() (ips *Gostr, errs error)
 	// TestProton is an alias for TestWin.
@@ -124,8 +116,6 @@ type Rpn interface {
 	Win() (wg RpnProxy, err error)
 	// Proton is an alias for Win.
 	Proton() (wg RpnProxy, err error)
-	// Amnezia returns a Amnezia WireGuard proxy.
-	Amnezia() (awg RpnProxy, err error)
 	// Pip returns a RpnWs proxy.
 	Pip() (ws RpnProxy, err error)
 	// Exit64 returns a Exit proxy hopping over preset publicly-available

intra/ipn/auto.go

@@ -90,9 +90,6 @@ func (h *auto) DialerHandle() (mix uintptr) {
 	if pro, _ := h.pxr.mainRpnProxyOf(RpnPro); pro != nil {
 		mix ^= pro.DialerHandle()
 	}
-	if amz, _ := h.pxr.mainRpnProxyOf(RpnAmz); amz != nil {
-		mix ^= amz.DialerHandle()
-	}
 	if sep, _ := h.pxr.mainRpnProxyOf(RpnSE); sep != nil {
 		mix ^= sep.DialerHandle()
 	}
@@ -119,10 +116,9 @@ func (h *auto) dial(network, laddr, raddr string) (protect.Conn, error) {
 	exit64, ex64err := h.pxr.ProxyFor(Rpn64)
 	warp, waerr := h.pxr.mainRpnProxyOf(RpnWg)
 	pro, proerr := h.pxr.mainRpnProxyOf(RpnPro)
-	amz, amzerr := h.pxr.mainRpnProxyOf(RpnAmz)
 	sep, seerr := h.pxr.mainRpnProxyOf(RpnSE)
 
-	pxrerrs := core.JoinErr(exerr, waerr, proerr, amzerr, seerr, ex64err)
+	pxrerrs := core.JoinErr(exerr, waerr, proerr, seerr, ex64err)
 
 	if usevia(h.viaID) {
 		if v, vok := h.via.Get(); !vok {
@@ -137,7 +133,7 @@ func (h *auto) dial(network, laddr, raddr string) (protect.Conn, error) {
 	parallelDial := settings.AutoDialsParallel.Load()
 
 	if !parallelDial {
-		rpns := []Proxy{exit, warp, amz, exit64, sep, pro}
+		rpns := []Proxy{exit, warp, exit64, sep, pro}
 		healthy := core.Map(
 			core.FilterLeft(
 				rpns,
@@ -248,25 +244,6 @@ func (h *auto) dial(network, laddr, raddr string) (protect.Conn, error) {
 			return h.dialIfHealthy(exit64, network, laddr, raddr)
 		}, func(ctx context.Context) (protect.Conn, error) {
 			const myidx = 3
-			if amz == nil {
-				return nil, amzerr
-			}
-			if recent {
-				if previdx != myidx {
-					return nil, errNotPinned
-				}
-				// ip pinned to this proxy
-				return h.dialAlways(amz, network, laddr, raddr)
-			}
-
-			select {
-			case <-ctx.Done():
-				return nil, ctx.Err()
-			case <-time.After(shortdelay * myidx): // 400ms
-			}
-			return h.dialIfHealthy(amz, network, laddr, raddr)
-		}, func(ctx context.Context) (protect.Conn, error) {
-			const myidx = 4
 			if sep == nil {
 				return nil, seerr
 			}
@@ -281,11 +258,11 @@ func (h *auto) dial(network, laddr, raddr string) (protect.Conn, error) {
 			select {
 			case <-ctx.Done():
 				return nil, ctx.Err()
-			case <-time.After(shortdelay * myidx): // 500ms
+			case <-time.After(shortdelay * myidx): // 400ms
 			}
 			return h.dialIfHealthy(sep, network, laddr, raddr)
 		}, func(ctx context.Context) (protect.Conn, error) {
-			const myidx = 5
+			const myidx = 4
 			if pro == nil {
 				return nil, proerr
 			}
@@ -302,7 +279,7 @@ func (h *auto) dial(network, laddr, raddr string) (protect.Conn, error) {
 				select {
 				case <-ctx.Done():
 					return nil, ctx.Err()
-				case <-time.After(shortdelay * myidx): // 100ms
+				case <-time.After(shortdelay * myidx): // 500ms
 				}
 			}
 			return h.dialIfHealthy(pro, network, laddr, raddr)
@@ -331,7 +308,6 @@ func (h *auto) Announce(network, local string) (protect.PacketConn, error) {
 	exit, exerr := h.pxr.ProxyFor(Exit)
 	warp, waerr := h.pxr.mainRpnProxyOf(RpnWg)
 	pro, proerr := h.pxr.mainRpnProxyOf(RpnPro)
-	amz, amzerr := h.pxr.mainRpnProxyOf(RpnAmz)
 
 	previdx, recent := h.exp.Get(local)
 
@@ -388,24 +364,6 @@ func (h *auto) Announce(network, local string) (protect.PacketConn, error) {
 			case <-time.After(shortdelay * myidx): // 200ms
 			}
 			return h.announceIfHealthy(warp, network, local)
-		}, func(ctx context.Context) (protect.PacketConn, error) {
-			const myidx = 3
-			if amz == nil {
-				return nil, amzerr
-			}
-			if recent {
-				if previdx != myidx {
-					return nil, errNotPinned
-				}
-				// ip pinned to this proxy
-				return h.announceIfHealthy(amz, network, local)
-			}
-			select {
-			case <-ctx.Done():
-				return nil, ctx.Err()
-			case <-time.After(shortdelay * myidx): // 300ms
-			}
-			return h.announceIfHealthy(amz, network, local)
 		}, // seasy-proxy does not support udp?
 	)
 	defer localDialStatus(h.status, err)
@@ -491,23 +449,20 @@ func (h *auto) Hop(p Proxy, dryrun bool) error {
 		return errProxyStopped
 	}
 
-	var warp, sep, amz, pro Proxy
-	var waerr, seerr, amzerr, proerr error
+	var warp, sep, pro Proxy
+	var waerr, seerr, proerr error
 	old := h.swapVia(p)
 	if warp, waerr = h.pxr.mainRpnProxyOf(RpnWg); warp != nil {
 		waerr = warp.Hop(p, dryrun)
 	}
 	if pro, proerr = h.pxr.mainRpnProxyOf(RpnPro); pro != nil {
 		proerr = pro.Hop(p, dryrun)
 	}
-	if amz, amzerr = h.pxr.mainRpnProxyOf(RpnAmz); amz != nil {
-		amzerr = amz.Hop(p, dryrun)
-	}
 	if sep, seerr = h.pxr.mainRpnProxyOf(RpnSE); sep != nil {
 		seerr = sep.Hop(p, dryrun)
 	}
 
-	errs := core.JoinErr(waerr, seerr, amzerr, proerr) // may be nil
+	errs := core.JoinErr(waerr, seerr, proerr) // may be nil
 
 	logei(errs)("proxy: auto: hop(%s) => %s; errs? %v",
 		idhandle(old), idhandle(p), errs)

intra/ipn/proxies.go

@@ -41,7 +41,6 @@ const (
 	RpnWg    = x.RpnWg
 	RpnPro   = x.RpnWin // pro is an alias for win
 	RpnWin   = x.RpnWin
-	RpnAmz   = x.RpnAmz
 	RpnWs    = x.RpnWs
 	Rpn64    = x.Rpn64
 	RpnH2    = x.RpnH2
@@ -258,7 +257,6 @@ type proxifier struct {
 
 	lastSeErr   *core.Volatile[error] // se proxy registration error
 	lastWarpErr *core.Volatile[error] // warp registration error
-	lastAmzErr  *core.Volatile[error] // amnezia registration error
 	lastWinErr  *core.Volatile[error] // win registration error
 }
 
@@ -298,7 +296,6 @@ func NewProxifier(pctx context.Context, l3 string, mtu int, c protect.Controller
 		rp:          make(map[string]RpnProxy),
 		lastSeErr:   core.NewZeroVolatile[error](),
 		lastWarpErr: core.NewZeroVolatile[error](),
-		lastAmzErr:  core.NewZeroVolatile[error](),
 		lastWinErr:  core.NewZeroVolatile[error](),
 	}
 
@@ -1177,44 +1174,6 @@ func (px *proxifier) registerWarp(existingStateJson []byte) (wc RpnAcc, err erro
 	}
 }
 
-// RegisterAmnezia implements x.Rpn.
-func (px *proxifier) RegisterAmnezia(existingState *x.Gobyte) (stateJson *x.Gobyte, err error) {
-	defer func() {
-		px.lastAmzErr.Store(err) // may be nil
-	}()
-	existingStateJson := existingState.V()
-	restore := len(existingStateJson) > 0
-
-	ac, err := px.registerAmnezia(existingStateJson)
-
-	if err != nil || core.IsNil(ac) {
-		log.E("proxy: amz: make (restore? %t) failed: %v", restore, err)
-		return nil, core.JoinErr(err, errNilAmzId)
-	}
-
-	state, err := ac.State()
-	if err != nil {
-		return nil, err
-	}
-
-	rp, err := px.addRpnProxy(ac, maincc(ac))
-	if err != nil || rp == nil {
-		log.E("proxy: amz: add wg for %s failed: %v", ac.Who(), err)
-		return nil, core.JoinErr(err, errNotRpnProxy)
-	}
-
-	log.I("proxy: amz: registered: %s / %d; new? %t", ac.Who(), state.Len(), !restore)
-	return state, nil
-}
-
-func (px *proxifier) registerAmnezia(existingStateJson []byte) (RpnAcc, error) {
-	if len(existingStateJson) > 0 { // restore
-		return px.extc.MakeAmzWgFrom(existingStateJson)
-	} else {
-		return px.extc.MakeAmzWg()
-	}
-}
-
 // RegisterProton implements x.Rpn.
 func (px *proxifier) RegisterProton(existingState *x.Gobyte) (stateJson *x.Gobyte, err error) {
 	return px.RegisterWin(existingState) // same as RegisterWin
@@ -1287,11 +1246,6 @@ func (px *proxifier) UnregisterWarp() bool {
 	return px.unregisterRpn(RpnWg)
 }
 
-// UnregisterAmnezia implements x.Rpn.
-func (px *proxifier) UnregisterAmnezia() bool {
-	return px.unregisterRpn(RpnAmz)
-}
-
 // UnregisterProton implements x.Rpn.
 func (px *proxifier) UnregisterProton() bool {
 	return px.UnregisterWin()
@@ -1346,15 +1300,6 @@ func (px *proxifier) Win() (x.RpnProxy, error) {
 	return win, nil
 }
 
-// Amnezia implements x.Rpn.
-func (px *proxifier) Amnezia() (x.RpnProxy, error) {
-	amz, err := px.mainRpnProxyOf(RpnAmz)
-	if amz == nil {
-		return nil, core.JoinErr(err, px.lastAmzErr.Load())
-	}
-	return amz, nil
-}
-
 // Pip implements x.Rpn.
 func (px *proxifier) Pip() (x.RpnProxy, error) {
 	// TODO: Register and Unregister for Pip
@@ -1498,38 +1443,6 @@ func (px *proxifier) testWin() (string, error) {
 	return strings.Join(oks, ","), nil
 }
 
-// TestAmnezia implements x.Rpn.
-func (px *proxifier) TestAmnezia() (*x.Gostr, error) {
-	return x.StrOfFunc(px.testAmnezia)
-}
-
-func (px *proxifier) testAmnezia() (ips string, errs error) {
-	v4, _, err := warp.AmzEndpoints()
-	if err != nil {
-		log.W("proxy: amz: err testing endpoints: %v", err)
-		return "", err
-	}
-
-	// todo: amnezia presently does not support ipv6
-	oks := make([]string, 0, len(v4))
-	for _, ip := range v4 {
-		ipstr := ip.String()
-		// base can route back into netstack (settings.LoopingBack)
-		// in which  case all endpoints will "seem" reachable.
-		// exit, however, never routes back into netstack and has
-		// the true, unhindered path to the underlying network.
-		if Reaches(px.exit, ipstr, "tcp") {
-			oks = append(oks, ipstr)
-		}
-	}
-
-	if len(oks) <= 0 {
-		log.E("proxy: amz: no reachable addrs among %v", v4)
-		return "", core.JoinErr(errNoSuitableAddress, px.lastAmzErr.Load())
-	}
-	return strings.Join(oks, ","), nil
-}
-
 // TestExit64 implements x.Rpn.
 func (px *proxifier) TestExit64() (*x.Gostr, error) {
 	return x.StrOfFunc(px.testExit64)