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,53 @@ class App : UninitializedApp(), libtailscale.AppContext, ViewModelStoreOwner {
     return sb.toString()
   }
 
+  @Serializable
+  data class InterfaceJson(
+    val name: String,
+    val index: Int,
+    val mtu: Int,
+    val up: Boolean,
+    val loopback: Boolean,
+    val pointToPoint: Boolean,
+    val multicast: Boolean,
+    val addrs: List<String>,
+  )
+
+  override fun getInterfacesAsJson(): String {
+    val interfaces = Collections.list(NetworkInterface.getNetworkInterfaces())
+    val out = ArrayList<InterfaceJson>(interfaces.size)
+  
+    for (nif in interfaces) {
+      try {
+        val addrs = ArrayList<String>()
+        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(String.format(Locale.ROOT, "%s/%d", host, ia.networkPrefixLength.toInt()))
+        }
+  
+        out.add(
+          InterfaceJson(
+            name = nif.name,
+            index = nif.index,
+            mtu = nif.mtu,
+            up = nif.isUp,
+            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,191 @@
+// Copyright (c) Tailscale Inc & AUTHORS
+// SPDX-License-Identifier: BSD-3-Clause
+
+package ifaceparse
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net"
+	"net/netip"
+	"strings"
+
+	"tailscale.com/net/netmon"
+)
+
+type ParseStats struct {
+	LinesTotal   int
+	LinesParsed  int
+	LinesSkipped int
+	AddrsTotal   int
+	AddrsParsed  int
+	AddrsSkipped int
+}
+
+type ifaceJSON struct {
+	Name      string   `json:"name"`
+	Index     int      `json:"index"`
+	MTU       int      `json:"mtu"`
+	Up        bool     `json:"up"`
+	Loopback  bool     `json:"loopback"`
+	PointToPt bool     `json:"pointToPoint"`
+	Multicast bool     `json:"multicast"`
+	Addrs     []string `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.LinesTotal++
+
+		if it.Name == "" || it.Index == 0 || it.MTU == 0 {
+			st.LinesSkipped++
+			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.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 _, addr := range it.Addrs {
+			ipStr, _, _ := strings.Cut(addr, "/")
+			na, err := netip.ParseAddr(ipStr)
+			if err != nil {
+				st.AddrsSkipped++
+				continue
+			}
+			st.AddrsParsed++
+			nif.AltAddrs = append(nif.AltAddrs, &net.IPAddr{
+				IP:   net.IP(na.AsSlice()),
+				Zone: na.Zone(),
+			})
+		}
+
+		out = append(out, nif)
+		st.LinesParsed++
+	}
+
+	return out, st, nil
+}
+
+// ParseInterfacesAsNetmon parses the string returned by Android's GetInterfacesAsString()
+// into netmon.Interface values.
+func ParseInterfacesAsNetmon(ifaceString string) ([]netmon.Interface, ParseStats, error) {
+	var ifaces []netmon.Interface
+	var st ParseStats
+
+	for _, line := range strings.Split(ifaceString, "\n") {
+		// Example of the strings we're processing:
+		// wlan0 30 1500 true true false false true | fe80::2f60:2c82:4163:8389%wlan0/64 10.1.10.131/24
+		// r_rmnet_data0 21 1500 true false false false false | fe80::9318:6093:d1ad:ba7f%r_rmnet_data0/64
+		// mnet_data2 12 1500 true false false false false | fe80::3c8c:44dc:46a9:9907%rmnet_data2/64
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+		st.LinesTotal++
+
+		fields := strings.Split(line, "|")
+		if len(fields) != 2 {
+			st.LinesSkipped++
+			continue
+		}
+
+		var name string
+		var index, mtu int
+		var up, broadcast, loopback, pointToPoint, multicast bool
+		if _, err := fmt.Sscanf(fields[0], "%s %d %d %t %t %t %t %t",
+			&name, &index, &mtu, &up, &broadcast, &loopback, &pointToPoint, &multicast); err != nil {
+			st.LinesSkipped++
+			continue
+		}
+
+		newIf := netmon.Interface{
+			Interface: &net.Interface{
+				Name:  name,
+				Index: index,
+				MTU:   mtu,
+			},
+			AltAddrs: []net.Addr{}, // non-nil to avoid Go using netlink
+		}
+		if up {
+			newIf.Flags |= net.FlagUp
+		}
+		if broadcast {
+			newIf.Flags |= net.FlagBroadcast
+		}
+		if loopback {
+			newIf.Flags |= net.FlagLoopback
+		}
+		if pointToPoint {
+			newIf.Flags |= net.FlagPointToPoint
+		}
+		if multicast {
+			newIf.Flags |= net.FlagMulticast
+		}
+
+		addrField := strings.TrimSpace(fields[1])
+		addrTokens := strings.Fields(addrField)
+		st.AddrsTotal += len(addrTokens)
+
+		for _, addr := range addrTokens {
+			// addr is typically in CIDR form: "10.0.0.159/8" or "2601:.../64".
+			// For endpoints we want the host IP, not the CIDR prefix base, so strip "/NN".
+			ipStr, _, _ := strings.Cut(addr, "/")
+
+			na, err := netip.ParseAddr(ipStr) // supports IPv6 zones (e.g. "%wlan0")
+			if err != nil {
+				st.AddrsSkipped++
+				continue
+			}
+			st.AddrsParsed++
+
+			newIf.AltAddrs = append(newIf.AltAddrs, &net.IPAddr{
+				IP:   net.IP(na.AsSlice()),
+				Zone: na.Zone(),
+			})
+		}
+
+		ifaces = append(ifaces, newIf)
+		st.LinesParsed++
+	}
+
+	return ifaces, st, nil
+}