Skip to content

Agent Mesh

mobile: resolve DNS bootstrap addresses through Android

Antonio Ojeabf7b3501d005
diff --git a/mobile/sam-node-app/README.md b/mobile/sam-node-app/README.md
index e2610c59..8aa390e3 100644
--- a/mobile/sam-node-app/README.md
+++ b/mobile/sam-node-app/README.md
@@ -18,6 +18,11 @@ Before building the application, ensure you have configured:
3. **Android NDK**: Required to cross-compile the Go library for Android platforms. Ensure the `ANDROID_NDK_HOME` environment variable points to your NDK installation.
4. **Xcode**: (iOS only) Installed and configured for iOS compile targets.
+Android DNS bootstrap addresses (`/dnsaddr/...`) require Android 10 or newer.
+The mobile client resolves their TXT records through Android's native resolver,
+which uses the device's network and private DNS configuration. Older Android
+versions can still use explicit router IP addresses.
+
---
## Compilation Instructions
diff --git a/mobile/sam-node-ffi/ffi/dns_android.go b/mobile/sam-node-ffi/ffi/dns_android.go
new file mode 100644
index 00000000..1ecdd38f
--- /dev/null
+++ b/mobile/sam-node-ffi/ffi/dns_android.go
@@ -0,0 +1,122 @@
+//go:build android && cgo
+
+package ffi
+
+/*
+#cgo LDFLAGS: -landroid
+#include <android/multinetwork.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#pragma weak android_res_nquery
+#pragma weak android_res_nresult
+#pragma weak android_res_cancel
+
+static int query_txt(const char *name) {
+ if (!android_res_nquery || !android_res_nresult || !android_res_cancel) {
+ return -ENOSYS;
+ }
+ return android_res_nquery(NETWORK_UNSPECIFIED, name, 1, 16, 0);
+}
+*/
+import "C"
+
+import (
+ "context"
+ "fmt"
+ "net"
+ "strings"
+ "time"
+ "unsafe"
+
+ madns "github.com/multiformats/go-multiaddr-dns"
+ "golang.org/x/net/dns/dnsmessage"
+ "golang.org/x/sys/unix"
+)
+
+type androidDNSResolver struct {
+ *net.Resolver
+}
+
+func (resolver androidDNSResolver) LookupTXT(ctx context.Context, name string) ([]string, error) {
+ ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+ defer cancel()
+ if err := ctx.Err(); err != nil {
+ return nil, err
+ }
+ if strings.ContainsRune(name, '\x00') {
+ return nil, fmt.Errorf("invalid DNS name")
+ }
+ queryName := C.CString(name)
+ defer C.free(unsafe.Pointer(queryName))
+ queryFD := C.query_txt(queryName)
+ if queryFD < 0 {
+ if unix.Errno(-queryFD) == unix.ENOSYS {
+ return nil, fmt.Errorf("TXT DNS resolution requires Android 10 or later")
+ }
+ return nil, fmt.Errorf("Android DNS query for %q: %w", name, unix.Errno(-queryFD))
+ }
+ if err := waitAndroidDNS(ctx, int(queryFD)); err != nil {
+ C.android_res_cancel(queryFD)
+ return nil, err
+ }
+ answer := make([]byte, 65535)
+ var rcode C.int
+ length := C.android_res_nresult(queryFD, &rcode, (*C.uint8_t)(unsafe.Pointer(&answer[0])), C.size_t(len(answer)))
+ if length < 0 {
+ return nil, fmt.Errorf("Android DNS response for %q: %w", name, unix.Errno(-length))
+ }
+ if rcode != 0 {
+ return nil, &net.DNSError{
+ Err: fmt.Sprintf("DNS response code %d", rcode),
+ Name: name,
+ IsNotFound: dnsmessage.RCode(rcode) == dnsmessage.RCodeNameError,
+ }
+ }
+ return androidTXTRecords(answer[:int(length)])
+}
+
+func waitAndroidDNS(ctx context.Context, descriptor int) error {
+ descriptors := []unix.PollFd{{Fd: int32(descriptor), Events: unix.POLLIN}}
+ for {
+ if err := ctx.Err(); err != nil {
+ return err
+ }
+ ready, err := unix.Poll(descriptors, 50)
+ if err == unix.EINTR {
+ continue
+ }
+ if err != nil {
+ return fmt.Errorf("waiting for Android DNS response: %w", err)
+ }
+ if ready > 0 {
+ if descriptors[0].Revents&unix.POLLNVAL != 0 {
+ return unix.EBADF
+ }
+ return ctx.Err()
+ }
+ }
+}
+
+func androidTXTRecords(answer []byte) ([]string, error) {
+ var message dnsmessage.Message
+ if err := message.Unpack(answer); err != nil {
+ return nil, fmt.Errorf("invalid Android DNS response: %w", err)
+ }
+ var records []string
+ for _, answer := range message.Answers {
+ if txt, ok := answer.Body.(*dnsmessage.TXTResource); ok {
+ records = append(records, strings.Join(txt.TXT, ""))
+ }
+ }
+ return records, nil
+}
+
+func init() {
+ resolver, err := madns.NewResolver(madns.WithDefaultResolver(androidDNSResolver{Resolver: net.DefaultResolver}))
+ if err != nil {
+ logger.Errorf("failed to configure Android DNS resolver: %v", err)
+ return
+ }
+ madns.DefaultResolver = resolver
+}
diff --git a/mobile/sam-node-ffi/ffi/dns_android_test.go b/mobile/sam-node-ffi/ffi/dns_android_test.go
new file mode 100644
index 00000000..5be0ad19
--- /dev/null
+++ b/mobile/sam-node-ffi/ffi/dns_android_test.go
@@ -0,0 +1,83 @@
+//go:build android && cgo
+
+package ffi
+
+import (
+ "context"
+ "errors"
+ "net"
+ "reflect"
+ "testing"
+ "time"
+
+ "golang.org/x/net/dns/dnsmessage"
+ "golang.org/x/sys/unix"
+)
+
+func TestAndroidTXTRecords(t *testing.T) {
+ name := dnsmessage.MustNewName("_dnsaddr.example.com.")
+ message := dnsmessage.Message{
+ Header: dnsmessage.Header{Response: true},
+ Answers: []dnsmessage.Resource{
+ {
+ Header: dnsmessage.ResourceHeader{Name: name, Class: dnsmessage.ClassINET, Type: dnsmessage.TypeTXT},
+ Body: &dnsmessage.TXTResource{TXT: []string{"dnsaddr=", "/ip4/192.0.2.1/tcp/4501"}},
+ },
+ {
+ Header: dnsmessage.ResourceHeader{Name: name, Class: dnsmessage.ClassINET, Type: dnsmessage.TypeTXT},
+ Body: &dnsmessage.TXTResource{TXT: []string{"dnsaddr=/ip4/192.0.2.2/tcp/4501"}},
+ },
+ },
+ }
+ response, err := message.Pack()
+ if err != nil {
+ t.Fatal(err)
+ }
+ records, err := androidTXTRecords(response)
+ if err != nil {
+ t.Fatal(err)
+ }
+ want := []string{"dnsaddr=/ip4/192.0.2.1/tcp/4501", "dnsaddr=/ip4/192.0.2.2/tcp/4501"}
+ if !reflect.DeepEqual(records, want) {
+ t.Fatalf("records = %v, want %v", records, want)
+ }
+ if _, err := androidTXTRecords([]byte{0}); err == nil {
+ t.Fatal("accepted malformed DNS response")
+ }
+}
+
+func TestAndroidDNSCanceled(t *testing.T) {
+ ctx, cancel := context.WithCancel(context.Background())
+ cancel()
+ resolver := androidDNSResolver{Resolver: net.DefaultResolver}
+ if _, err := resolver.LookupTXT(ctx, "_dnsaddr.example.com"); !errors.Is(err, context.Canceled) {
+ t.Fatalf("LookupTXT error = %v, want context.Canceled", err)
+ }
+ if _, err := resolver.LookupTXT(context.Background(), "example.com\x00.invalid"); err == nil {
+ t.Fatal("accepted DNS name containing NUL")
+ }
+}
+
+func TestAndroidDNSWait(t *testing.T) {
+ descriptors, err := unix.Socketpair(unix.AF_UNIX, unix.SOCK_STREAM, 0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() {
+ _ = unix.Close(descriptors[0])
+ _ = unix.Close(descriptors[1])
+ })
+ ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
+ defer cancel()
+ if err := waitAndroidDNS(ctx, descriptors[0]); !errors.Is(err, context.DeadlineExceeded) {
+ t.Fatalf("idle socket error = %v, want context.DeadlineExceeded", err)
+ }
+ if _, err := unix.Write(descriptors[1], []byte{1}); err != nil {
+ t.Fatal(err)
+ }
+ ctx, cancel = context.WithTimeout(context.Background(), time.Second)
+ defer cancel()
+ if err := waitAndroidDNS(ctx, descriptors[0]); err != nil {
+ t.Fatalf("ready socket error = %v", err)
+ }
+}