gitee.com/aurawing/surguard-go@v0.3.1-0.20240409071558-96509a61ecf3/device/postconfig_windows.go

package device

import (
	"fmt"
	"net"
	"os"
	"os/exec"
	"sort"
	"strconv"
	"strings"
	"time"
)

const DEFAULT_YID_PATH = "C:\\yid.conf"

var deviceName string
var deviceIndex int

func GetDeviceIndex() int {
	return deviceIndex
}

//var lock filelock.FileLock

// func init() {
// 	lockfile := "C:\\surguard.lock"
// 	if _, err := os.Stat(lockfile); err != nil {
// 		if os.IsNotExist(err) {
// 			var file, err = os.Create(lockfile)
// 			if err != nil {
// 				panic(err)
// 			}
// 			file.Close()
// 		} else {
// 			panic(err)
// 		}
// 	}
// 	lock = filelock.FileLock{Path: lockfile, Timeout: time.Second * 5}
// }

func (device *Device) configTunDevice() error {
	ifBindInterface = true
	var err error
	//find tun device name
	deviceName, err = device.tun.device.Name()
	if err != nil {
		device.log.Errorf("configTunDevice: failed to find tun device name: %s", err)
		return err
	}
	deviceIf, err := net.InterfaceByName(deviceName)
	if err != nil {
		device.log.Errorf("configTunDevice: failed to find tun device interface: %s", err)
		return err
	}
	deviceIndex = deviceIf.Index
	interfaceIndex = byte(deviceIndex % 254)

	//bring up tun device
	device.runCmd(false, "netsh", "interface", "set", "interface", deviceName, "admin=enable")
	for {
		if deviceState(device.state.state.Load()) == deviceStateUp {
			break
		} else {
			time.Sleep(500 * time.Millisecond)
		}
	}
	device.log.Verbosef("configTunDevice: device %s is up\n", deviceName)

	device.runCmd(false, "netsh", "interface", "ipv4", "set", "subinterface", deviceName, fmt.Sprintf("mtu=%d", DefaultMTU), "store=persistent")
	device.log.Verbosef("configTunDevice: set device MTU to %d\n", DefaultMTU)

	ipaddrs, err := device.getIP()
	if err != nil {
		device.log.Errorf("configTunDevice: failed to get IP address: %s", err)
		return err
	}
	sort.Strings(ipaddrs)
	interfaceIP = strings.Join(ipaddrs, ",")
	interfaceIPArr = make([][4]byte, 0)
	sgIPArr = make([][4]byte, 0)
	for i, ipaddr := range ipaddrs {
		tmp := net.ParseIP(ipaddr)
		tmp2 := [4]byte{tmp[12], tmp[13], tmp[14], tmp[15]}
		interfaceIPArr = append(interfaceIPArr, tmp2)
		sgIPArr = append(sgIPArr, [4]byte{169, 254, interfaceIndex, byte(i + 1)})
		staticip := fmt.Sprintf("169.254.%d.%d", interfaceIndex, i+1)
		device.runCmd(false, "netsh", "interface", "ipv4", "add", "address", "name="+deviceName, staticip, "255.255.255.0")
		device.log.Verbosef("configTunDevice: set address %s/24 for device %s\n", staticip, deviceName)
	}

	// device.runCmd(false, "netsh", "interface", "ipv4", "set", "address", "name="+deviceName, "static", "169.254.254.1", "255.255.255.0")
	// device.log.Verbosef("configTunDevice: device %s has address 169.254.254.1/24\n", deviceName)

	device.runCmd(false, "netsh", "interface", "ipv4", "set", "interface", deviceName, "weakhostsend=enabled")
	device.runCmd(false, "netsh", "interface", "ipv4", "set", "interface", deviceName, "weakhostreceive=enabled")
	device.log.Verbosef("configTunDevice: device %s is setup to weakhost mode\n", deviceName)

	//close rp_filter of tun device
	// err = sysctl.Set("net.ipv4.conf.all.rp_filter", "0")
	// if err != nil {
	// 	device.log.Errorf("configTunDevice: failed to disable net.ipv4.conf.all.rp_filter: %s", err)
	// 	return err
	// }
	// device.log.Verbosef("configTunDevice: set net.ipv4.conf.all.rp_filter to 0\n")
	// err = sysctl.Set(fmt.Sprintf("net.ipv4.conf.%s.rp_filter", deviceName), "0")
	// if err != nil {
	// 	device.log.Errorf("configTunDevice: failed to disable net.ipv4.conf.%s.rp_filter: %s", deviceName, err)
	// 	return err
	// }
	// device.log.Verbosef("configTunDevice: set net.ipv4.conf.%s.rp_filter to 0\n", deviceName)

	// //get fwmark and route table id
	// rtid := 256
	// fwmarkStr := os.Getenv(ENV_SG_FWMARK)
	// tunnelFwmarkStr := os.Getenv(ENV_SG_TUNNEL_FWMARK)

	// if fwmarkStr != "" {
	// 	fwmark, err = strconv.Atoi(fwmarkStr)
	// 	if err != nil {
	// 		device.log.Errorf("configTunDevice: failed to parse fwmark %s: %s", fwmarkStr, err)
	// 	}
	// }
	// if tunnelFwmarkStr != "" {
	// 	tunnelFwmark, err = strconv.Atoi(tunnelFwmarkStr)
	// 	if err != nil {
	// 		device.log.Errorf("configTunDevice: failed to parse tunnel fwmark %s: %s", fwmarkStr, err)
	// 	}
	// }
	// rtidStr := os.Getenv(ENV_SG_RT_ID)
	// if rtidStr != "" {
	// 	rtid, err = strconv.Atoi(rtidStr)
	// 	if err != nil {
	// 		device.log.Errorf("configTunDevice: failed to parse route table ID %s: %s", rtidStr, err)
	// 	}
	// }

	// //modify route table
	// err = device.modifyRtTables("/etc/iproute2/rt_tables", rtid)
	// if err != nil {
	// 	device.log.Errorf("configTunDevice: failed to modify route table ID %d: %s", rtid, err)
	// 	return err
	// }

	// // set route policy
	// device.runCmd(false, "ip", "route", "flush", "table", groupName)
	// device.runCmd(false, "ip", "route", "add", "default", "dev", deviceName, "table", groupName)
	// device.runCmd(true, "ip", "rule", "delete", "from", "all", "fwmark", strconv.Itoa(fwmark), "lookup", groupName)
	// device.runCmd(false, "ip", "rule", "add", "from", "all", "fwmark", strconv.Itoa(fwmark), "lookup", groupName)
	// device.log.Verbosef("configTunDevice: set route policy table %d %s for %s\n", rtid, groupName, deviceName)
	return nil
}

func (device *Device) initRules() error {
	return nil
}

func (device *Device) zkChangedCallback(addedMap, deletedMap map[string]string) {
	for _, dels := range deletedMap {
		for _, del := range strings.Split(dels, ",") {
			strs := strings.Split(del, ":")
			device.runCmd(true, "route", "delete", strs[0])
		}
	}
	for _, adds := range addedMap {
		for _, add := range strings.Split(adds, ",") {
			strs := strings.Split(add, ":")
			device.runCmd(true, "route", "add", strs[0], "mask", "255.255.255.255", "0.0.0.0", "IF", strconv.Itoa(deviceIndex))
		}
	}
}

func (device *Device) clearConfigOSSpecific() error {
	return nil
}

func (device *Device) runCmd(ignoreErr bool, args ...string) {
	cmd := exec.Command(args[0], args[1:]...)
	cmd.Stderr = os.Stderr
	cmd.Stdout = os.Stdout
	cmd.Stdin = os.Stdin
	err := cmd.Run()
	if nil != err {
		if !ignoreErr {
			device.log.Errorf("Error running %s: %s\n", args[0], err)
		} else {
			device.log.Verbosef("Warning: %s\n", err.Error())
		}
	}
}