path: root/tunnel/tools/libwg-go/api-android.go

/* SPDX-License-Identifier: Apache-2.0
 *
 * Copyright © 2017-2022 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
 */

package main

// #cgo LDFLAGS: -llog
// #include <android/log.h>
// extern void wgOnEvent(void *eventHandler, const char *event);
import "C"

import (
	"context"
	"fmt"
	"log"
	"math"
	"net"
	"os"
	"os/signal"
	"runtime"
	"runtime/debug"
	"strings"
	"unsafe"

	"golang.org/x/sys/unix"
	"golang.zx2c4.com/wireguard/conn"
	"golang.zx2c4.com/wireguard/device"
	"golang.zx2c4.com/wireguard/ipc"
	"golang.zx2c4.com/wireguard/tun"
	"golang.zx2c4.com/wireguard/tun/netstack"
	"golang.zx2c4.com/wireguard/tun/netstack/ipvlan"

	"gvisor.dev/gvisor/pkg/tcpip"
	"gvisor.dev/gvisor/pkg/tcpip/link/fdbased"
	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
	"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
	"gvisor.dev/gvisor/pkg/tcpip/stack"
	"gvisor.dev/gvisor/pkg/tcpip/transport/tcp"
	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
)

type AndroidLogger struct {
	level C.int
	tag   *C.char
}

func cstring(s string) *C.char {
	b, err := unix.BytePtrFromString(s)
	if err != nil {
		b := [1]C.char{}
		return &b[0]
	}
	return (*C.char)(unsafe.Pointer(b))
}

func (l AndroidLogger) Printf(format string, args ...interface{}) {
	C.__android_log_write(l.level, l.tag, cstring(fmt.Sprintf(format, args...)))
}

type TunnelHandle struct {
	device *device.Device
	uapi   net.Listener
	eventHandler unsafe.Pointer
	cancel context.CancelFunc
	master *ipvlan.IPVLANMaster
	tunEP stack.LinkEndpoint
	tunFd int
}

var globalStack *stack.Stack
var tunnelHandles map[int32]TunnelHandle

func init() {
	tunnelHandles = make(map[int32]TunnelHandle)
	opts := stack.Options{
		NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol, ipv6.NewProtocol},
		TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol, udp.NewProtocol},
		HandleLocal:        true,
	}
	globalStack = stack.New(opts)
	signals := make(chan os.Signal)
	signal.Notify(signals, unix.SIGUSR2)
	go func() {
		buf := make([]byte, os.Getpagesize())
		for {
			select {
			case <-signals:
				n := runtime.Stack(buf, true)
				if n == len(buf) {
					n--
				}
				buf[n] = 0
				C.__android_log_write(C.ANDROID_LOG_ERROR, cstring("WireGuard/GoBackend/Stacktrace"), (*C.char)(unsafe.Pointer(&buf[0])))
			}
		}
	}()
}

//export wgTurnOn
func wgTurnOn(interfaceName string, tunFd int32, settings string, eventHandler unsafe.Pointer) int32 {
	tag := cstring("WireGuard/GoBackend/" + interfaceName)
	logger := &device.Logger{
		Verbosef: AndroidLogger{level: C.ANDROID_LOG_DEBUG, tag: tag}.Printf,
		Errorf:   AndroidLogger{level: C.ANDROID_LOG_ERROR, tag: tag}.Printf,
	}

	tun, name, err := tun.CreateUnmonitoredTUNFromFD(int(tunFd))
	if err != nil {
		unix.Close(int(tunFd))
		logger.Errorf("CreateUnmonitoredTUNFromFD: %v", err)
		return -1
	}

	logger.Verbosef("Attaching to interface %v", name)
	device := device.NewDevice(tun, conn.NewStdNetBind(), logger)

	err = device.IpcSet(settings)
	if err != nil {
		unix.Close(int(tunFd))
		logger.Errorf("IpcSet: %v", err)
		return -1
	}
	device.DisableSomeRoamingForBrokenMobileSemantics()

	var uapi net.Listener

	uapiFile, err := ipc.UAPIOpen(name)
	if err != nil {
		logger.Errorf("UAPIOpen: %v", err)
	} else {
		uapi, err = ipc.UAPIListen(name, uapiFile)
		if err != nil {
			uapiFile.Close()
			logger.Errorf("UAPIListen: %v", err)
		} else {
			go func() {
				for {
					conn, err := uapi.Accept()
					if err != nil {
						return
					}
					go device.IpcHandle(conn)
				}
			}()
		}
	}

	err = device.Up()
	if err != nil {
		logger.Errorf("Unable to bring up device: %v", err)
		uapiFile.Close()
		device.Close()
		return -1
	}
	logger.Verbosef("Device started")

	var i int32
	for i = 0; i < math.MaxInt32; i++ {
		if _, exists := tunnelHandles[i]; !exists {
			break
		}
	}
	if i == math.MaxInt32 {
		logger.Errorf("Unable to find empty handle")
		uapiFile.Close()
		device.Close()
		return -1
	}
	tunnelHandles[i] = TunnelHandle{device: device, uapi: uapi, eventHandler: eventHandler}
	logger.Verbosef("Before wgOnEvent %v", eventHandler)
	C.wgOnEvent(tunnelHandles[i].eventHandler, C.CString("FOOBAR"))
	C.wgOnEvent(tunnelHandles[i].eventHandler, C.CString("Called wgTurnOn"))
	logger.Verbosef("After wgOnEvent")
	return i
}

func createNetTUNWithStack(stack *stack.Stack, nicID tcpip.NICID, localAddresses []net.IP, dnsServers []net.IP, mtu int) (tun.Device, *netstack.Net, *ipvlan.IPVLANMaster, error) {
	dev, ep, err := netstack.NewNetTUN(stack, mtu)
	if err != nil {
		return nil, nil, nil, err
	}

	master := ipvlan.NewIPVLANMaster(ep)

	addrs := make([]tcpip.Address, 0, len(localAddresses))
	for _, addr := range localAddresses {
		addrs = append(addrs, tcpip.Address(addr))
	}
	ipvlanEP := master.NewIPVLAN(addrs)

	tcpipErr := stack.CreateNIC(nicID, ipvlanEP)
	if tcpipErr != nil {
		return nil, nil, nil, fmt.Errorf("CreateNIC: %v", tcpipErr)
	}

	tnet, err := netstack.NewNetAdapter(stack, nicID, localAddresses, dnsServers)
	if err != nil {
		return nil, nil, nil, err
	}

	return dev, tnet, master, nil
}

//export wgTurnOnDhcp
func wgTurnOnDhcp(interfaceName string, lladdr string, settings string, eventHandler unsafe.Pointer) int32 {
	tag := cstring("WireGuard/GoBackend/" + interfaceName)
	logger := &device.Logger{
		Verbosef: AndroidLogger{level: C.ANDROID_LOG_DEBUG, tag: tag}.Printf,
		Errorf:   AndroidLogger{level: C.ANDROID_LOG_ERROR, tag: tag}.Printf,
	}

	stack := globalStack

	// FIXME name
	name := "wg0"
	var tundev tun.Device
	var tnet *netstack.Net
	llipaddr := net.ParseIP(lladdr)
	tundev, tnet, master, err := createNetTUNWithStack(
		stack,
		1,
		[]net.IP{llipaddr},
		[]net.IP{net.ParseIP("ff02::1:2")},
		1420)
	if err != nil {
		log.Panic(err)
	}

	logger.Verbosef("Attaching to netstack interface")
	device := device.NewDevice(tundev, conn.NewStdNetBind(), logger)

	err = device.IpcSet(settings)
	if err != nil {
		logger.Errorf("IpcSet: %v", err)
		return -1
	}
	device.DisableSomeRoamingForBrokenMobileSemantics()

	var uapi net.Listener

	uapiFile, err := ipc.UAPIOpen(name)
	if err != nil {
		logger.Errorf("UAPIOpen: %v", err)
	} else {
		uapi, err = ipc.UAPIListen(name, uapiFile)
		if err != nil {
			uapiFile.Close()
			logger.Errorf("UAPIListen: %v", err)
		} else {
			go func() {
				for {
					conn, err := uapi.Accept()
					if err != nil {
						return
					}
					go device.IpcHandle(conn)
				}
			}()
		}
	}

	err = device.Up()
	if err != nil {
		logger.Errorf("Unable to bring up device: %v", err)
		uapiFile.Close()
		device.Close()
		return -1
	}
	logger.Verbosef("Device started")

	var i int32
	for i = 0; i < math.MaxInt32; i++ {
		if _, exists := tunnelHandles[i]; !exists {
			break
		}
	}
	if i == math.MaxInt32 {
		logger.Errorf("Unable to find empty handle")
		uapiFile.Close()
		device.Close()
		return -1
	}
	ctx, cancel := context.WithCancel(context.Background())

	tunnelHandles[i] = TunnelHandle{device: device, uapi: uapi, eventHandler: eventHandler, cancel: cancel, master: master}

	go func(ctx context.Context) {
		logger.Verbosef("Start dhcp client")
		src, err := net.ResolveUDPAddr("udp6", fmt.Sprintf("[%s%%1]:546", lladdr))
		if err != nil {
			logger.Errorf("ResolveUDPAddr: %v", err)
			return
		}

		var dst *net.UDPAddr
		dst = nil

		conn, err := tnet.DialUDP(src, dst)
		if err != nil {
			logger.Errorf("DialUDP: %v", err)
			return
		}

		logger.Verbosef("Conn: %v %v %v", src, dst, conn)
		// TODO check byte 11, 12 of lladdr is ff fe
		hwAddr := []byte{0, 0, 0, 0, 0, 0}
		hwAddr[0] = llipaddr[8] ^ 0x02
		hwAddr[1] = llipaddr[9]
		hwAddr[2] = llipaddr[10]
		hwAddr[3] = llipaddr[13]
		hwAddr[4] = llipaddr[14]
		hwAddr[5] = llipaddr[15]
		addrs, err := netstack.RunDhcp(ctx, conn, hwAddr)

		if err != nil {
			conn.Close()
			logger.Errorf("DHCP: %v", err)
			return
		}

		msg := ""

		logger.Verbosef("DHCP finished")

		conn.Close()

		for _, addr := range addrs {
			logger.Verbosef("Address: %v", addr)
			if msg == "" {
				msg = "event=1\naddress=" + addr.String()
			} else {
				msg += "," + addr.String()
			}
		}

		C.wgOnEvent(tunnelHandles[i].eventHandler, C.CString(msg))
	}(ctx)

	logger.Verbosef("Before wgOnEvent %v", eventHandler)
	C.wgOnEvent(tunnelHandles[i].eventHandler, C.CString("FOOBAR"))
	C.wgOnEvent(tunnelHandles[i].eventHandler, C.CString("Called wgTurnOn"))
	logger.Verbosef("After wgOnEvent")
	return i
}

//export wgSetFd
func wgSetFd(tunnelHandle int32, tunFd int32) {
	tag := cstring(fmt.Sprintf("WireGuard/GoBackend/%x", tunnelHandle))
	logger := &device.Logger{
		Verbosef: AndroidLogger{level: C.ANDROID_LOG_DEBUG, tag: tag}.Printf,
		Errorf:   AndroidLogger{level: C.ANDROID_LOG_ERROR, tag: tag}.Printf,
	}

	handle, ok := tunnelHandles[tunnelHandle]
	if !ok {
		return
	}

	// FIXME MTU
	var mtu uint32 = 1280
	tunEP, err := fdbased.New(&fdbased.Options{FDs: []int{int(tunFd)}, MTU: mtu})
	if err != nil {
		log.Fatal(err)
	}
	handle.tunFd = int(tunFd)
	handle.tunEP = tunEP
	// FIXME panic
// 	03-23 22:19:25.182  9818     0 E Go      : panic: runtime error: invalid memory address or nil pointer dereference
// 03-23 22:19:25.182  9818     0 E Go      : [signal SIGSEGV: segmentation violation code=0x1 addr=0x34 pc=0x9f0f5d58]
// 03-23 22:19:25.182  9818     0 E Go      : goroutine 59 [running]:
// 03-23 22:19:25.182  9818     0 E Go      : golang.zx2c4.com/wireguard/tun/netstack/ipvlan.(*dispatcher).DeliverNetworkPacket(0x4f1a2008, 0x0, 0x0, 0x0, 0x0, 0x86dd, 0x4f1fe000)
// 03-23 22:19:25.182  9818     0 E Go      :      golang.zx2c4.com/wireguard/tun/netstack@v0.0.0-00010101000000-000000000000/ipvlan/endpoint.go:104 +0x48
// 03-23 22:19:25.182  9818     0 E Go      : golang.zx2c4.com/wireguard/tun/netstack.(*netTun).Write(0x4f1ac000, 0x4f1ec900, 0x77, 0x898, 0x10, 0x1, 0x0, 0x0)
// 03-23 22:19:25.182  9818     0 E Go      :      golang.zx2c4.com/wireguard/tun/netstack@v0.0.0-00010101000000-000000000000/tun.go:187 +0x1d4
// 03-23 22:19:25.182  9818     0 E Go      : golang.zx2c4.com/wireguard/device.(*Peer).RoutineSequentialReceiver(0x4f1f2000)
// 03-23 22:19:25.182  9818     0 E Go      :      golang.zx2c4.com/wireguard@v0.0.0-20210306154438-593658d9755b/device/receive.go:479 +0x3d8
// 03-23 22:19:25.183  9818     0 E Go      : created by golang.zx2c4.com/wireguard/device.(*Peer).Start
// 03-23 22:19:25.183  9818     0 E Go      :      golang.zx2c4.com/wireguard@v0.0.0-20210306154438-593658d9755b/device/peer.go:187 +0x254
// 03-23 22:19:25.183  9818  9907 F libc    : Fatal signal 6 (SIGABRT), code -6 in tid 9907 (DefaultDispatch)

	handle.master.SetIntEP(tunEP)
	logger.Verbosef("wgSetFd: %v %v", tunFd, tunEP)
	tunnelHandles[tunnelHandle] = handle
}

//export wgTurnOff
func wgTurnOff(tunnelHandle int32) unsafe.Pointer {
	tag := cstring(fmt.Sprintf("WireGuard/GoBackend/%x", tunnelHandle))
	logger := &device.Logger{
		Verbosef: AndroidLogger{level: C.ANDROID_LOG_DEBUG, tag: tag}.Printf,
		Errorf:   AndroidLogger{level: C.ANDROID_LOG_ERROR, tag: tag}.Printf,
	}

	handle, ok := tunnelHandles[tunnelHandle]
	if !ok {
		return nil
	}
	if handle.master != nil {
		logger.Verbosef("IPLAN master: %v %v", handle.tunFd, handle.tunEP)
		globalStack.RemoveNIC(1)
		handle.master.SetIntEP(nil)
//		handle.tunEP.Wait()
		unix.Close(handle.tunFd)
	} else {
		logger.Verbosef("No IPLAN master")
	}

	eventHandler := handle.eventHandler
	C.wgOnEvent(handle.eventHandler, C.CString("Called wgTurnOff"))
	delete(tunnelHandles, tunnelHandle)
	if handle.uapi != nil {
		handle.uapi.Close()
	}
	handle.device.Close()
	return eventHandler
}

//export wgGetSocketV4
func wgGetSocketV4(tunnelHandle int32) int32 {
	handle, ok := tunnelHandles[tunnelHandle]
	if !ok {
		return -1
	}
	C.wgOnEvent(handle.eventHandler, C.CString("Called wgGetSocketV4"))
	bind, _ := handle.device.Bind().(conn.PeekLookAtSocketFd)
	if bind == nil {
		return -1
	}
	fd, err := bind.PeekLookAtSocketFd4()
	if err != nil {
		return -1
	}
	return int32(fd)
}

//export wgGetSocketV6
func wgGetSocketV6(tunnelHandle int32) int32 {
	handle, ok := tunnelHandles[tunnelHandle]
	if !ok {
		return -1
	}
	C.wgOnEvent(handle.eventHandler, C.CString("Called wgGetSocketV6"))
	bind, _ := handle.device.Bind().(conn.PeekLookAtSocketFd)
	if bind == nil {
		return -1
	}
	fd, err := bind.PeekLookAtSocketFd6()
	if err != nil {
		return -1
	}
	return int32(fd)
}

//export wgGetConfig
func wgGetConfig(tunnelHandle int32) *C.char {
	handle, ok := tunnelHandles[tunnelHandle]
	if !ok {
		return nil
	}
	settings, err := handle.device.IpcGet()
	if err != nil {
		return nil
	}
	return C.CString(settings)
}

//export wgVersion
func wgVersion() *C.char {
	info, ok := debug.ReadBuildInfo()
	if !ok {
		return C.CString("unknown")
	}
	for _, dep := range info.Deps {
		if dep.Path == "golang.zx2c4.com/wireguard" {
			parts := strings.Split(dep.Version, "-")
			if len(parts) == 3 && len(parts[2]) == 12 {
				return C.CString(parts[2][:7])
			}
			return C.CString(dep.Version)
		}
	}
	return C.CString("unknown")
}

func main() {}