ipn,rpn: Kids, Main fns return RpnServer

ignoramous · ignoramous · commit fcab3ef469fb · 2026-07-01T01:19:02.000+05:30
diff --git a/intra/backend/ipn_proxies.go b/intra/backend/ipn_proxies.go
@@ -257,8 +257,10 @@ type RpnProxy interface {
 	Purge(cc string) bool
 	// Get returns proxy for country code, cc.
 	Get(cc string) (Proxy, error)
-	// Kids returns csv of forked proxy PIDs, excluding this one.
-	Kids() (csvpids string)
+	// Kids returns RpnServers describing all forked kids, excluding the main proxy.
+	Kids() RpnServers
+	// Main returns RpnServer describing the main proxy, if present.
+	Main() *RpnServer
 }
 
 // RpnAcc represents an account with RPN provider.
diff --git a/intra/ipn/proxies.go b/intra/ipn/proxies.go
@@ -194,7 +194,7 @@ type Rpn interface {
 	x.Rpn
 	rpnProxyProvider
 	// addRpnProxy adds an RPN proxy to this multi-transport.
-	addRpnProxy(acc RpnAcc, cc string) (Proxy, error)
+	addRpnProxy(acc RpnAcc, cc string) (Proxy, *x.RpnServer, error)
 	// removeRpnProxy removes an RPN proxy from this multi-transport.
 	removeRpnProxy(acc RpnAcc, cc string) bool
 }
@@ -1322,7 +1322,7 @@ func (px *proxifier) RegisterWin(entitlementOrState []byte, did string, ops *x.R
 
 	// TODO: create a new proxy type for win, so Refresh() could be sent to /connect
 	// TODO: best location: github.com/Windscribe/browser-extension/blob/ed83749ad1/modules/ext/src/utils/getBestLocation.js
-	rp, err := px.addRpnProxy(win, anycc(win))
+	rp, _, err := px.addRpnProxy(win, anycc(win))
 	if err != nil || rp == nil {
 		log.E("proxy: ws: add wg for %s failed: %v", win.Who(), err)
 		return nil, core.JoinErr(err, errNotRpnProxy)
diff --git a/intra/ipn/proxy.go b/intra/ipn/proxy.go
@@ -87,14 +87,14 @@ func (pxr *proxifier) removeRpnProxy(acc RpnAcc, cc string) bool {
 }
 
 // cc may be a fully qualified ID in case when re-adding the main proxy.
-func (pxr *proxifier) addRpnProxy(acc RpnAcc, cc string) (Proxy, error) {
+func (pxr *proxifier) addRpnProxy(acc RpnAcc, cc string) (Proxy, *x.RpnServer, error) {
 	if acc == nil || core.IsNil(acc) {
-		return nil, errNotRpnAcc
+		return nil, nil, errNotRpnAcc
 	}
 
 	typ := acc.ProviderID()
 	if !isRPN(typ) {
-		return nil, errNotRpnID
+		return nil, nil, errNotRpnID
 	}
 
 	if !acc.MultiCountry() && cc != noCountryForOldMen {
@@ -108,9 +108,9 @@ func (pxr *proxifier) addRpnProxy(acc RpnAcc, cc string) (Proxy, error) {
 	// but we need cc to be "city;cc"  (ref struct RpnServer.Key)
 	cc, _ = strings.CutPrefix(cc, typ)
 
-	txt, err := acc.Conf(cc)
+	txt, srv, err := acc.Conf(cc)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	rpnid := typ + cc
@@ -119,10 +119,11 @@ func (pxr *proxifier) addRpnProxy(acc RpnAcc, cc string) (Proxy, error) {
 	p, err := pxr.forceAddProxy(rpnid, txt)
 	if p == nil {
 		pxr.postAddRpnProxyError(acc) // remove from pxr.rp if exists
-		return nil, core.JoinErr(err, errAddProxy)
+		return nil, srv, core.JoinErr(err, errAddProxy)
 	}
 
-	return pxr.postAddRpnProxy(p, acc)
+	proxy, err := pxr.postAddRpnProxy(p, srv, acc)
+	return proxy, srv, err
 }
 
 // TODO: on add / update a via proxy; refresh all dependent origins
@@ -143,10 +144,10 @@ func (pxr *proxifier) addRpnProxy2(p Proxy, acc RpnAcc) (Proxy, error) {
 	// TODO: setup hop from mainCountryCode to forked rpn proxies
 	core.Gx(who, func() { pxr.refreshHopOriginsIfAny(p, who) })
 
-	return pxr.postAddRpnProxy(p, acc)
+	return pxr.postAddRpnProxy(p, nil, acc)
 }
 
-func (pxr *proxifier) postAddRpnProxy(p Proxy, acc RpnAcc) (_ Proxy, err error) {
+func (pxr *proxifier) postAddRpnProxy(p Proxy, srv *x.RpnServer, acc RpnAcc) (_ Proxy, err error) {
 	proxyid := idstr(p)
 	provider := acc.ProviderID()
 
@@ -160,7 +161,7 @@ func (pxr *proxifier) postAddRpnProxy(p Proxy, acc RpnAcc) (_ Proxy, err error)
 	// as forked children countries only need be added as plain-old proxies
 	// which is done before calling this function (ie, a no-op)
 	if rp == nil {
-		rp, err = asRpnProxy(p, acc, pxr)
+		rp, err = asRpnProxy(p, srv, acc, pxr)
 		if rp == nil { // should not happen; unexpected!
 			defer pxr.removeProxy(proxyid, true /*force*/)
 			return nil, core.JoinErr(err, errAddProxyAsRpn)
diff --git a/intra/ipn/rpn.go b/intra/ipn/rpn.go
@@ -7,6 +7,7 @@
 package ipn
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
@@ -32,7 +33,7 @@ type RpnAcc = rpn.RpnAcc
 
 // and kick-off an update if the acc is expired?
 type rpnp struct {
-	mu sync.RWMutex // protects Proxy & kids
+	mu sync.RWMutex // protects p, s, kids, & skids
 
 	// parent proxy
 	p Proxy
@@ -45,6 +46,10 @@ type rpnp struct {
 
 	// forked child proxy IDs, may be empty (returned proxy IDs may have stopped)
 	kids map[string]struct{}
+	// server metadata for each forked kid (keyed by CC)
+	skids map[string]*x.RpnServer
+	// server metadata for the main proxy
+	s *x.RpnServer
 }
 
 var _ RpnProxy = (*rpnp)(nil)
@@ -63,7 +68,7 @@ var (
 )
 
 // nb: client code isn't really expecting error from asRpnProxy.
-func asRpnProxy(e Proxy, acc RpnAcc, pxr Rpn) (RpnProxy, error) {
+func asRpnProxy(e Proxy, srv *x.RpnServer, acc RpnAcc, pxr Rpn) (RpnProxy, error) {
 	if e == nil || acc == nil || pxr == nil {
 		return nil, errRpnBadArgs
 	}
@@ -75,7 +80,7 @@ func asRpnProxy(e Proxy, acc RpnAcc, pxr Rpn) (RpnProxy, error) {
 		return nil, errRpnIDsMismatch
 	}
 	log.D("proxy: rpn: make: %s[%s]", providerid, proxyid)
-	return &rpnp{sync.RWMutex{}, e, acc, pxr, make(map[string]struct{}, 0)}, nil
+	return &rpnp{sync.RWMutex{}, e, acc, pxr, make(map[string]struct{}, 0), make(map[string]*x.RpnServer, 0), srv}, nil
 }
 
 func (r *rpnp) ensureProxy() Proxy {
@@ -324,7 +329,13 @@ func (r *rpnp) fork(cc string) (x.Proxy, error) {
 		// re-forking main proxy (which may not be multi-country acc) via Update() => forkAll()
 		log.I("proxy: rpn: fork: %s main cc %s; re-adding...", provider, cc)
 		// expect Emplace to be called
-		return r.pxr.addRpnProxy(acc, cc) // re-generates conf and re-adds
+		kid, srv, err := r.pxr.addRpnProxy(acc, cc) // re-generates conf and re-adds
+		if kid != nil && core.IsNotNil(kid) {
+			r.mu.Lock()
+			r.s = srv
+			r.mu.Unlock()
+		}
+		return kid, err
 	}
 
 	// check main's status if not forking main
@@ -344,11 +355,14 @@ func (r *rpnp) fork(cc string) (x.Proxy, error) {
 	log.I("proxy: rpn: fork: %s[%s]", provider, cc)
 
 	// re-adds + updates if the proxy already exists
-	kid, err := r.pxr.addRpnProxy(acc, cc)
+	kid, srv, err := r.pxr.addRpnProxy(acc, cc)
 
 	if kid != nil && core.IsNotNil(kid) {
 		r.mu.Lock()
 		r.kids[cc] = struct{}{}
+		if srv != nil {
+			r.skids[cc] = srv
+		}
 		r.mu.Unlock()
 	}
 
@@ -476,6 +490,9 @@ func (r *rpnp) purgeMain() bool {
 	if err != nil {
 		return false
 	}
+	r.mu.Lock()
+	r.s = nil
+	r.mu.Unlock()
 	return r.pxr.removeRpnProxy(r.RpnAcc, mainpid)
 }
 
@@ -511,6 +528,7 @@ func (r *rpnp) purge(cc string) bool {
 
 	r.mu.Lock()
 	delete(r.kids, cc)
+	delete(r.skids, cc)
 	r.mu.Unlock()
 
 	log.D("proxy: rpn: purge: %s[%s]? %t", provider, cc, rmv)
@@ -569,12 +587,16 @@ func (r *rpnp) get(cc string) (Proxy, error) {
 }
 
 // Kids implements x.RpnProxy.
-func (r *rpnp) Kids() (csvpids string) {
-	return r.kidsCsv()
-}
-
-func (r *rpnp) kidsCsv() string {
-	return strings.Join(r.flattenKids(), ",")
+func (r *rpnp) Kids() x.RpnServers {
+	r.mu.RLock()
+	all := make([]x.RpnServer, 0, len(r.skids))
+	for _, s := range r.skids {
+		if s != nil {
+			all = append(all, *s)
+		}
+	}
+	r.mu.RUnlock()
+	return &liveServers{all: all}
 }
 
 func (r *rpnp) flattenKids() (ccs []string) {
@@ -588,6 +610,46 @@ func (r *rpnp) flattenKids() (ccs []string) {
 	return
 }
 
+// liveServers implements x.RpnServers.
+type liveServers struct {
+	all []x.RpnServer
+}
+
+var _ x.RpnServers = (*liveServers)(nil)
+
+func (s *liveServers) Get(i int) (*x.RpnServer, error) {
+	if i < 0 || i >= len(s.all) {
+		return nil, fmt.Errorf("rpn: live: %d out of range [0, %d)", i, len(s.all))
+	}
+	return &s.all[i], nil
+}
+
+func (s *liveServers) Len() int {
+	return len(s.all)
+}
+
+func (s *liveServers) Json() ([]byte, error) {
+	if s == nil || len(s.all) <= 0 {
+		return nil, fmt.Errorf("rpn: live: no servers")
+	}
+	b, err := json.Marshal(s.all)
+	if err != nil {
+		return nil, fmt.Errorf("rpn: live: json: %w", err)
+	}
+	return b, nil
+}
+
+// Main implements x.RpnProxy.
+func (r *rpnp) Main() (m *x.RpnServer) {
+	r.mu.RLock()
+	if s := r.s; s != nil {
+		m = new(x.RpnServer)
+		*m = *s
+	}
+	r.mu.RUnlock()
+	return
+}
+
 // Update implements RpnAcc.
 func (r *rpnp) Update(ops *x.RpnOps) (newState []byte, err error) {
 	newState, err = r.RpnAcc.Update(ops)
diff --git a/intra/ipn/rpn/cfg.go b/intra/ipn/rpn/cfg.go
@@ -55,7 +55,7 @@ type RpnAcc interface {
 	x.RpnAcc
 	ProviderID() string // x.RpnWg, x.RpnPro, x.RpnAmz, x.RpnWin
 	MultiCountry() bool
-	Conf(key string) (string, error)
+	Conf(key string) (string, *x.RpnServer, error)
 }
 
 var _ RpnAcc = (*WsClient)(nil)
@@ -88,7 +88,7 @@ type RpnStateless struct {
 
 func (RpnStateless) Updated() int64                 { return neverEver.UnixMilli() }
 func (RpnStateless) State() ([]byte, error)         { return nil, errRpnStateless }
-func (RpnStateless) Conf(cc string) (string, error) { return "", errRpnStateless }
+func (RpnStateless) Conf(cc string) (string, *x.RpnServer, error) { return "", nil, errRpnStateless }
 
 type RpnUpdateless struct{}
 
diff --git a/intra/ipn/rpn/yegor.go b/intra/ipn/rpn/yegor.go
@@ -1150,10 +1150,10 @@ func (a *WsClient) shallowCopyConfig(b *WsClient) (copied bool, err error) {
 }
 
 // Conf implements RpnAcc.
-func (a *WsClient) Conf(cc string) (string, error) {
+func (a *WsClient) Conf(cc string) (string, *x.RpnServer, error) {
 	cfg := a.config()
 	if cfg == nil {
-		return "", errWsNoConfig
+		return "", nil, errWsNoConfig
 	}
 	usePerma := !disablePermaCreds && a.Ops().Perma()
 	if usePerma && cfg.PermaCreds == nil {
@@ -1179,7 +1179,7 @@ func (a *WsClient) Conf(cc string) (string, error) {
 	if !chooseAny && len(excl) > 0 {
 		if _, excluded := excl[cc]; excluded {
 			log.W("ws: conf: cc %s is excluded...", cc)
-			return "", errWsCCExcluded
+			return "", nil, errWsCCExcluded
 		}
 	}
 
@@ -1188,11 +1188,11 @@ reconf:
 	tot := 0  // total seen
 	c := 0    // good cc conf
 	badc := 0 // bad cc conf
-	x := 0    // total excluded
+	xl := 0   // total excluded
 	v := 0    // total visited
 	visited := make(map[string]struct{}, len(cfg.Configs))
 	out := make([]string, 0, maxPerRegionWgConfs)
-	ids := make([]string, 0, maxPerRegionWgConfs)
+	srvs := make([]x.RpnServer, 0, maxPerRegionWgConfs)
 	for _, rc := range cfg.Configs {
 		// TODO: strings.HasSuffix(rc.Cc, cc) replaced with ==?
 		if (chooseAny || strings.HasSuffix(rc.CC, cc)) && (!hasCity || rc.City == city) {
@@ -1204,7 +1204,7 @@ reconf:
 				v++
 				// skip CCs the user has excluded
 				if _, excluded := excl[rc.CC]; excluded {
-					x++
+					xl++
 					continue
 				}
 				if c > 2 {
@@ -1240,8 +1240,22 @@ reconf:
 				confstr, confok = rc.MakeUapiConfig(cfg.Creds, portstr)
 			}
 			if confok {
+				// _, isExcluded := excl[rc.CC] assert false!
 				out = append(out, confstr)
-				ids = append(ids, strings.Join([]string{rc.CC, rc.City, rc.Name}, "/"))
+				srvs = append(srvs, x.RpnServer{
+					CC:       rc.CC,
+					City:     rc.City,
+					Name:     rc.Name,
+					Load:     rc.Load,
+					Link:     rc.Link,
+					Count:    rc.Count,
+					Premium:  rc.Premium,
+					Excluded: false,
+					PubPub:   trunc8(rc.ServerPubKey) + "&" + trunc8(rc.ClientPubKey),
+					Allowed:  strings.Join(rc.AllowedIPs, ","),
+					Key:      strings.Join([]string{rc.City, rc.CC}, confKeySep),
+					Addrs:    strings.Join([]string{rc.ServerDomainPort, rc.addrCsv()}, ","),
+				})
 				c++
 			} else {
 				badc++
@@ -1251,12 +1265,13 @@ reconf:
 	}
 	if len(out) > 0 {
 		r := rand.IntN(len(out))
-		log.I("ws: conf: cc %s(%s): %d/%d => chosen (any? %t): %d[%s] (port: %s)", cc, city, c, len(out), chooseAny, r, ids[r], portstr)
-		return out[r], nil
+		log.I("ws: conf: cc %s(%s): %d/%d => chosen (any? %t): %d[%s/%s] (port: %s)",
+			cc, city, c, len(out), chooseAny, r, srvs[r].City, srvs[r].CC, portstr)
+		return out[r], &srvs[r], nil
 	}
-	if x > 0 && (tot == 0 || v <= x) { // fail open if all CCs excluded
+	if xl > 0 && (tot == 0 || v <= xl) { // fail open if all CCs excluded
 		logew(retried)("ws: conf: cc %s(%s): all visited(%d) / excluded(%d) / bad(%d); tot: %d / excl: %d; retry?",
-			cc, city, v, x, badc, tot, len(excl), !retried)
+			cc, city, v, xl, badc, tot, len(excl), !retried)
 		if !retried {
 			clear(excl) // fail open; excluded none
 			clear(visited)
@@ -1265,7 +1280,7 @@ reconf:
 		}
 	}
 	log.E("ws: conf: cc %s(%s) not found (tot: %d)", cc, city, tot)
-	return "", errWsNoCcConfig
+	return "", nil, errWsNoCcConfig
 }
 
 // unused on the control plane, so use a fixed but valid hostname
