android: fix local endpoint parsing and add regression ifaceparse_test

Android reports interface addresses in CIDR form. Recent changes
(see 9c933a0#diff-1d627686c31972e04ef60d7d301e8a2a93714c60096a50055a6bbe9aa041ca8fL105,  9c933a0#diff-1d627686c31972e04ef60d7d301e8a2a93714c60096a50055a6bbe9aa041ca8fL105) parsed addresses as CIDR prefixes, resulting in prefix base being advertised as a local endpoint.
This change:
-instead of parsing CIDR prefixes, the parser strips the /NN portion and uses netip.ParseAddr to parse the host IP only
-extracts the interface parsing into a helper in a new package to make it testable on non-Android platforms
-adds a unit test to verify that host addresses are present and prefix-base ones are not

Fixes tailscale/tailscale#16836

Signed-off-by: kari-ts <kari@tailscale.com>

Author: kari-ts

android/src/main/java/com/tailscale/ipn/App.kt

@@ -41,9 +41,11 @@ import com.tailscale.ipn.util.NoSuchKeyException
 import com.tailscale.ipn.util.ShareFileHelper
 import com.tailscale.ipn.util.TSLog
 import java.io.IOException
+import java.lang.UnsupportedOperationException
 import java.net.NetworkInterface
 import java.security.GeneralSecurityException
 import java.util.Locale
+import java.util.Collections
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -54,8 +56,9 @@ import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.Serializable
 import libtailscale.Libtailscale
-import java.lang.UnsupportedOperationException
 class App : UninitializedApp(), libtailscale.AppContext, ViewModelStoreOwner {
   val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
 
@@ -333,6 +336,60 @@ class App : UninitializedApp(), libtailscale.AppContext, ViewModelStoreOwner {
     return sb.toString()
   }
 
+  @Serializable
+  data class AddrJson(
+    val ip: String,
+    val prefixLen: Int,
+  )
+  
+  @Serializable
+  data class InterfaceJson(
+    val name: String,
+    val index: Int,
+    val mtu: Int,
+    val up: Boolean,
+    val broadcast: Boolean,
+    val loopback: Boolean,
+    val pointToPoint: Boolean,
+    val multicast: Boolean,
+    val addrs: List<AddrJson>,
+  )
+  override fun getInterfacesAsJson(): String {
+    val interfaces = Collections.list(NetworkInterface.getNetworkInterfaces())
+    val out = ArrayList<InterfaceJson>(interfaces.size)
+  
+    for (nif in interfaces) {
+      try {
+        val addrs = ArrayList<AddrJson>()
+        for (ia in nif.interfaceAddresses) {
+          val addr = ia.address ?: continue
+          // hostAddress is stable and avoids InterfaceAddress.toString() formatting risks.
+          val host = addr.hostAddress ?: continue
+          addrs.add(AddrJson(ip = host, prefixLen = ia.networkPrefixLength.toInt()))
+        }
+  
+        out.add(
+          InterfaceJson(
+            name = nif.name,
+            index = nif.index,
+            mtu = nif.mtu,
+            up = nif.isUp,
+            broadcast = nif.supportsMulticast(),
+            loopback = nif.isLoopback,
+            pointToPoint = nif.isPointToPoint,
+            multicast = nif.supportsMulticast(),
+            addrs = addrs,
+          )
+        )
+      } catch (_: Exception) {
+        continue
+      }
+    }
+  
+    // Avoid pretty printing to keep payload small.
+    return Json { encodeDefaults = true }.encodeToString(out)
+  }
+
   @Throws(
       IOException::class, GeneralSecurityException::class, MDMSettings.NoSuchKeyException::class)
   override fun getSyspolicyBooleanValue(key: String): Boolean {

libtailscale/ifaceparse/ifaceparse.go

@@ -0,0 +1,138 @@
+// Copyright (c) Tailscale Inc & AUTHORS
+// SPDX-License-Identifier: BSD-3-Clause
+
+package ifaceparse
+
+import (
+	"encoding/json"
+	"errors"
+	"net"
+	"net/netip"
+	"strings"
+
+	"tailscale.com/net/netmon"
+)
+
+type ParseStats struct {
+	IfacesTotal   int
+	IfacesParsed  int
+	IfacesSkipped int
+	AddrsTotal    int
+	AddrsParsed   int
+	AddrsSkipped  int
+}
+
+type addrJSON struct {
+	IP        string `json:"ip"`
+	PrefixLen int    `json:"prefixLen"`
+}
+type ifaceJSON struct {
+	Name      string     `json:"name"`
+	Index     int        `json:"index"`
+	MTU       int        `json:"mtu"`
+	Up        bool       `json:"up"`
+	Broadcast bool       `json:"broadcast"`
+	Loopback  bool       `json:"loopback"`
+	PointToPt bool       `json:"pointToPoint"`
+	Multicast bool       `json:"multicast"`
+	Addrs     []addrJSON `json:"addrs"`
+}
+
+var ErrNotJSON = errors.New("not a JSON interfaces payload")
+
+// ParseInterfacesJSONAsNetmon parses a JSON payload produced by getInterfacesAsJson()
+// and returns netmon.Interfaces plus parsing stats.
+func ParseInterfacesJSONAsNetmon(b []byte) ([]netmon.Interface, ParseStats, error) {
+	var st ParseStats
+	trim := strings.TrimSpace(string(b))
+	if trim == "" {
+		return nil, st, nil
+	}
+	if !(strings.HasPrefix(trim, "[") || strings.HasPrefix(trim, "{")) {
+		return nil, st, ErrNotJSON
+	}
+
+	var in []ifaceJSON
+	if err := json.Unmarshal([]byte(trim), &in); err != nil {
+		return nil, st, err
+	}
+
+	out := make([]netmon.Interface, 0, len(in))
+	for _, it := range in {
+		st.IfacesTotal++
+
+		if it.Name == "" {
+			st.IfacesSkipped++
+			continue
+		}
+
+		nif := netmon.Interface{
+			Interface: &net.Interface{
+				Name:  it.Name,
+				Index: it.Index,
+				MTU:   it.MTU,
+			},
+			AltAddrs: []net.Addr{},
+		}
+
+		if it.Up {
+			nif.Flags |= net.FlagUp
+		}
+		if it.Broadcast {
+			nif.Flags |= net.FlagBroadcast
+		}
+		if it.Loopback {
+			nif.Flags |= net.FlagLoopback
+		}
+		if it.PointToPt {
+			nif.Flags |= net.FlagPointToPoint
+		}
+		if it.Multicast {
+			nif.Flags |= net.FlagMulticast
+		}
+
+		st.AddrsTotal += len(it.Addrs)
+		for _, a := range it.Addrs {
+			appendAltAddr(&nif, &st, a.IP, a.PrefixLen)
+		}
+
+		out = append(out, nif)
+		st.IfacesParsed++
+	}
+
+	return out, st, nil
+}
+
+func appendAltAddr(nif *netmon.Interface, st *ParseStats, ipStr string, prefixLen int) {
+	na, err := netip.ParseAddr(ipStr) // supports IPv6 zones (e.g. "%wlan0")
+	if err != nil {
+		st.AddrsSkipped++
+		return
+	}
+	st.AddrsParsed++
+
+	zone := na.Zone()
+	ip := net.IP(append([]byte(nil), na.AsSlice()...)) // copy to be safe
+
+	// If there's a zone (e.g. fe80::...%wlan0), we can't represent it in net.IPNet.
+	if zone != "" {
+		nif.AltAddrs = append(nif.AltAddrs, &net.IPAddr{IP: ip, Zone: zone})
+		return
+	}
+
+	// Prefer net.IPNet for compatibility with code that expects *net.IPNet.
+	bits := 128
+	if na.Is4() {
+		bits = 32
+	}
+	if prefixLen < 0 || prefixLen > bits {
+		// Weird prefix; fall back to IPAddr rather than dropping it.
+		nif.AltAddrs = append(nif.AltAddrs, &net.IPAddr{IP: ip})
+		return
+	}
+
+	nif.AltAddrs = append(nif.AltAddrs, &net.IPNet{
+		IP:   ip,
+		Mask: net.CIDRMask(prefixLen, bits),
+	})
+}