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

/* SPDX-License-Identifier: Apache-2.0
 *
 * Copyright (C) 2017-2019 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
 */

package main

// #cgo LDFLAGS: -llog
// #include <android/log.h>
import "C"

import (
	"bufio"
	"golang.org/x/sys/unix"
	"golang.zx2c4.com/wireguard/device"
	"golang.zx2c4.com/wireguard/ipc"
	"golang.zx2c4.com/wireguard/tun"
	"bytes"
	"log"
	"math"
	"net"
	"os"
	"os/signal"
	"runtime"
	"strconv"
	"strings"
	"unsafe"
	"gvisor.dev/gvisor/pkg/tcpip/config"
	"gvisor.dev/gvisor/pkg/tcpip/network/arp"
	"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
	interfaceName string
}

func (l AndroidLogger) Write(p []byte) (int, error) {
	C.__android_log_write(l.level, C.CString("WireGuard/GoBackend/"+l.interfaceName), C.CString(string(p)))
	return len(p), nil
}

type TunnelHandle struct {
	device *device.Device
	uapi   net.Listener
}

var tunnelHandles map[int32]TunnelHandle

func init() {
	device.RoamingDisabled = true
	tunnelHandles = make(map[int32]TunnelHandle)
	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)
				buf[n] = 0
				C.__android_log_write(C.ANDROID_LOG_ERROR, C.CString("WireGuard/GoBackend/Stacktrace"), (*C.char)(unsafe.Pointer(&buf[0])))
			}
		}
	}()
}

func getConfig() string {
	str := `network:
  version: 2
  renderer: gvisor
  ethernets:
    lo:
      addresses:
      - 127.0.0.1/8
      - ::1/128
      - 10.1.0.1/24
      - 2001:470:de6f:5310::1/64
      routes:
      - to: 10.1.15.0/24
      - to: 2001:470:de6f:531f::/64
  wireguards:
    wg2:
      name: wg2
      addresses:
      - 10.49.124.111/32
      - 2001:470:dfae:6300::111/128
      - 2001:470:dfae:6300::1:111/128
      - fe80::111/64
      listen_port: 51820
      private_key: cCBLRrAKF0oqLua2IGYr6ngQRLdgCSTa8hzDLQvezUI=
      peers:
        - public_key: 5Q5KIFIeskMh/QanwH9/5lHQ9NhWBsY16kwaS0ELQyg=
          endpoint: 10.49.50.215:51820
          allowed_ips:
          - 2001:470:dfae:6300::1:3/128
          - ::/0
          - 0.0.0.0/0
          persistent_keepalive: 3600
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
      routes:
      - to: 10.49.124.0/24
      - to: 0.0.0.0/0
      - to: ::/0
      - to: 2001:470:dfae:6300::/64
      macaddress: aa:00:01:01:02:04
  tuntaps:
    tun:
      name: tun1
      mode: tun
      mtu: 1280
      fd: @FD@
#      name: tap1
#      mode: tap
      addresses:
      - 10.1.1.2/24
      - 2001:470:de6f:5311::2/64
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
#      routes:
#      - to: 0.0.0.0/0
#        via: 10.1.1.1
#        metric: 200
#      - to: ::/0
#        via: 2001:470:de6f:5311::1
#        metric: 200
      macaddress: aa:00:01:01:02:01
`

//   tunnels:
//     tun1:
//       mode: udp
//       local: 0.0.0.0:10002
//       remote: 127.0.0.1:10001
//       #FIXME detect MTU
//       mtu: 1280 #1500
//       addresses:
//       - 10.1.2.1/24
//       - 2001:470:de6f:5312::1/64
//       routes:
// #      - to: 0.0.0.0/0
// #        via: 10.1.2.2
// #        metric: 100
// #      - to: ::/0
// #        via: 2001:470:de6f:5312::2
// #        metric: 100
//       macaddress: aa:00:01:01:02:02

//   wireguards:
// #     wg1:
// #       name: wg1
// #       addresses:
// #       - 10.1.3.2/24
// #       - 2001:470:de6f:5313::2/64
// #       listen_port: 51820
// #       private_key: cCBLRrAKF0oqLua2IGYr6ngQRLdgCSTa8hzDLQvezUI=
// #       peers:
// #         - public_key: igb6I+JFOEXPN4JjZvSslxNDPQK1/Ofi6310RzH2HAk=
// #           endpoint: 10.49.50.1:51820
// #           allowed_ips:
// #           - 10.1.2.3/32
// #           - 0.0.0.0/0
// #           - ::/0
// # #          persistent_keepalive: 3600
// #       nameservers:
// #         addresses:
// #           - 8.8.8.8
// #           - 8.8.4.4
// #       routes:
// #       - to: 0.0.0.0/0
// #         via: 10.1.3.1
// #         metric: 100
// #         mark: 1
// #         mask: 255
// #       - to: ::/0
// #         via: 2001:470:de6f:5313::1
// #         metric: 100
// #         mark: 1
// #         mask: 255
// #       macaddress: aa:00:01:01:02:03

	return str
}

//export wgTurnOn
func wgTurnOn(ifnameRef string, tunFd int32, settings string) int32 {
	interfaceName := string([]byte(ifnameRef))

	logger := &device.Logger{
		Debug: log.New(&AndroidLogger{level: C.ANDROID_LOG_DEBUG, interfaceName: interfaceName}, "", 0),
		Info:  log.New(&AndroidLogger{level: C.ANDROID_LOG_INFO, interfaceName: interfaceName}, "", 0),
		Error: log.New(&AndroidLogger{level: C.ANDROID_LOG_ERROR, interfaceName: interfaceName}, "", 0),
	}

	// Use DEBUG as default logger 
	log.SetOutput(logger.Debug.Writer())
	// Don't add date and time already added by android
	log.SetFlags(0)

	logger.Debug.Println("Debug log enabled")
	log.Println("Test stdout")

	yaml := strings.Replace(getConfig(), "@FD@", strconv.Itoa(int(tunFd)), 1)
	logger.Debug.Println("Loading config ", yaml)
	cfg := config.New(logger)
	err := cfg.LoadFromBytes([]byte(yaml))
	if err != nil {
		logger.Debug.Println("LoadFromBytes failed")
		unix.Close(int(tunFd))
		logger.Error.Println(err)
		return -1
	}

	logger.Debug.Println("Start gvisor stack")
	s := stack.New(stack.Options{
		NetworkProtocols:   []stack.NetworkProtocol{ipv4.NewProtocol(), ipv6.NewProtocol(), arp.NewProtocol()},
		TransportProtocols: []stack.TransportProtocol{
			tcp.NewProtocol(),
			udp.NewProtocol(),
			//icmp.NewProtocol6(),
		},
		//NDPConfigs: stack.DefaultNDPConfigurations(),
		//NDPDisp: &routes,
	})

	logger.Debug.Println("Stack started")

	cfg.Setup(s)

	logger.Debug.Println("Test gvisor TCP/IP", cfg)

    if false {
	tun, name, err := tun.CreateUnmonitoredTUNFromFD(int(tunFd))
	if err != nil {
		unix.Close(int(tunFd))
		logger.Error.Println(err)
		return -1
	}

	logger.Info.Println("Attaching to interface", name)
	device := device.NewDevice(tun, logger)

	setError := device.IpcSetOperation(bufio.NewReader(strings.NewReader(settings)))
	if setError != nil {
		unix.Close(int(tunFd))
		logger.Error.Println(setError)
		return -1
	}

	var uapi net.Listener

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

	device.Up()

	logger.Info.Println("Device started")

	var i int32
	for i = 0; i < math.MaxInt32; i++ {
		if _, exists := tunnelHandles[i]; !exists {
			break
		}
	}
	if i == math.MaxInt32 {
		unix.Close(int(tunFd))
		return -1
	}
	tunnelHandles[i] = TunnelHandle{device: device, uapi: uapi}
	return i
    }
	return 0
}

//export wgTurnOff
func wgTurnOff(tunnelHandle int32) {
	handle, ok := tunnelHandles[tunnelHandle]
	if !ok {
		return
	}
	delete(tunnelHandles, tunnelHandle)
	if handle.uapi != nil {
		handle.uapi.Close()
	}
	handle.device.Close()
}

//export wgGetSocketV4
func wgGetSocketV4(tunnelHandle int32) int32 {
	handle, ok := tunnelHandles[tunnelHandle]
	if !ok {
		return -1
	}
	fd, err := handle.device.PeekLookAtSocketFd4()
	if err != nil {
		return -1
	}
	return int32(fd)
}

//export wgGetSocketV6
func wgGetSocketV6(tunnelHandle int32) int32 {
	handle, ok := tunnelHandles[tunnelHandle]
	if !ok {
		return -1
	}
	fd, err := handle.device.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 := new(bytes.Buffer)
	writer := bufio.NewWriter(settings)
	err := handle.device.IpcGetOperation(writer)
	if err != nil {
		return nil
	}
	writer.Flush()
	return C.CString(settings.String())
}

//export wgVersion
func wgVersion() *C.char {
	return C.CString(device.WireGuardGoVersion)
}

func main() {}