tun_windows: Introduce preliminary TUN interface creation

Signed-off-by: Simon Rozman <simon@rozman.si>

setupapi/types_windows.go

@@ -300,6 +300,21 @@ const (
 	DICS_FLAG_CONFIGGENERAL  DICS_FLAG = 0x00000004 // 1 or more hardware profile-specific changes to follow
 )
 
+// DI_REMOVEDEVICE specifies the scope of the device removal
+type DI_REMOVEDEVICE uint32
+
+const (
+	DI_REMOVEDEVICE_GLOBAL         DI_REMOVEDEVICE = 0x00000001 // Make this change in all hardware profiles. Remove information about the device from the registry.
+	DI_REMOVEDEVICE_CONFIGSPECIFIC DI_REMOVEDEVICE = 0x00000002 // Make this change to only the hardware profile specified by HwProfile. this flag only applies to root-enumerated devices. When Windows removes the device from the last hardware profile in which it was configured, Windows performs a global removal.
+)
+
+// SP_REMOVEDEVICE_PARAMS is a structure corresponding to a DIF_REMOVE install function.
+type SP_REMOVEDEVICE_PARAMS struct {
+	ClassInstallHeader SP_CLASSINSTALL_HEADER
+	Scope              DI_REMOVEDEVICE
+	HwProfile          uint32
+}
+
 type SP_DRVINFO_DATA struct {
 	Size          uint32
 	DriverType    uint32

tun/tun_windows.go

@@ -5,13 +5,20 @@
 
 package tun
 
+//go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output ztun_windows.go tun_windows.go
+
 import (
 	"errors"
 	"fmt"
 	"os"
+	"strings"
+	"syscall"
+	"time"
 	"unsafe"
 
+	"git.zx2c4.com/wireguard-go/setupapi"
 	"golang.org/x/sys/windows"
+	"golang.org/x/sys/windows/registry"
 )
 
 const (
@@ -27,6 +34,10 @@ const (
 	TUN_SIGNAL_MAX = 2
 )
 
+var deviceClassNetGUID = windows.GUID{0x4d36e972, 0xe325, 0x11ce, [8]byte{0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18}}
+
+const TUN_HWID = "Wintun"
+
 type TunPacket struct {
 	size uint32
 	data [TUN_MAX_PACKET_SIZE]byte
@@ -39,7 +50,7 @@ type TunRWQueue struct {
 }
 
 type nativeTun struct {
-	ifname       string
+	ifid         *windows.GUID
 	tunName      string
 	signalName   *uint16
 	tunFile      *os.File
@@ -52,15 +63,31 @@ type nativeTun struct {
 }
 
 func CreateTUN(ifname string) (TUNDevice, error) {
-	signalNameUTF16, err := windows.UTF16PtrFromString(fmt.Sprintf("Global\\WINTUN_EVENT_%s", ifname))
+	// Does an interface with this name already exist?
+	ifid, err := getInterface(ifname, 0)
+	if ifid == nil || err != nil {
+		// Interface does not exist or an error occured. Create one.
+		ifid, _, err = createInterface("", 0)
 		if err != nil {
 			return nil, err
 		}
 
+		// Set interface name. (Ignore errors.)
+		setInterfaceName(ifid, ifname)
+	}
+
+	ifidStr := guidToString(ifid)
+
+	signalNameUTF16, err := windows.UTF16PtrFromString(fmt.Sprintf("Global\\WINTUN_EVENT_%s", ifidStr))
+	if err != nil {
+		deleteInterface(ifid, 0)
+		return nil, err
+	}
+
 	// Create instance.
 	tun := &nativeTun{
-		ifname:     ifname,
+		ifid:       ifid,
-		tunName:    fmt.Sprintf("\\\\.\\Global\\WINTUN_DEVICE_%s", ifname),
+		tunName:    fmt.Sprintf("\\\\.\\Global\\WINTUN_DEVICE_%s", ifidStr),
 		signalName: signalNameUTF16,
 		events:     make(chan TUNEvent, 10),
 		errors:     make(chan error, 1),
@@ -69,6 +96,7 @@ func CreateTUN(ifname string) (TUNDevice, error) {
 	// Create close event.
 	tun.signals[TUN_SIGNAL_CLOSE], err = windows.CreateEvent(nil, 1 /*TRUE*/, 0 /*FALSE*/, nil)
 	if err != nil {
+		deleteInterface(ifid, 0)
 		return nil, err
 	}
 
@@ -132,7 +160,7 @@ func (tun *nativeTun) closeTUN() (err error) {
 }
 
 func (tun *nativeTun) Name() (string, error) {
-	return tun.ifname, nil
+	return getInterfaceName(tun.ifid)
 }
 
 func (tun *nativeTun) File() *os.File {
@@ -156,6 +184,11 @@ func (tun *nativeTun) Close() error {
 		close(tun.events)
 	}
 
+	_, _, e = deleteInterface(tun.ifid, 0)
+	if err == nil {
+		err = e
+	}
+
 	return err
 }
 
@@ -283,3 +316,457 @@ func (tun *nativeTun) Write(buff []byte, offset int) (int, error) {
 	// Flush write buffer.
 	return len(buff) - offset, tun.flush()
 }
+
+//
+// getInterface finds interface ID by name.
+//
+// hwndParent is a handle to the top-level window to use for any user
+// interface that is related to non-device-specific actions (such as a select-
+// device dialog box that uses the global class driver list). This handle is
+// optional and can be 0. If a specific top-level window is not required, set
+// hwndParent to 0.
+//
+// Function returns interface ID when the interface was found, or nil
+// otherwise.
+//
+func getInterface(ifname string, hwndParent uintptr) (*windows.GUID, error) {
+	// Create a list of network devices.
+	devInfoList, err := setupapi.SetupDiGetClassDevsEx(&deviceClassNetGUID, "", hwndParent, setupapi.DIGCF_PRESENT, setupapi.DevInfo(0), "")
+	if err != nil {
+		return nil, err
+	}
+	defer devInfoList.Close()
+
+	// Retrieve information associated with a device information set.
+	// TODO: Is this really necessary?
+	_, err = devInfoList.GetDeviceInfoListDetail()
+	if err != nil {
+		return nil, err
+	}
+
+	ifname = strings.ToLower(ifname)
+
+	// Iterate.
+	for index := 0; ; index++ {
+		// Get the device from the list.
+		deviceData, err := devInfoList.EnumDeviceInfo(index)
+		if err != nil {
+			if errWin, ok := err.(syscall.Errno); ok && errWin == 259 /*ERROR_NO_MORE_ITEMS*/ {
+				break
+			}
+			// Something is wrong with this device. Skip it.
+			continue
+		}
+
+		// Get interface ID.
+		ifid, err := getInterfaceId(devInfoList, deviceData, 1)
+		if err != nil {
+			// Something is wrong with this device. Skip it.
+			continue
+		}
+
+		// Get interface name.
+		ifname2, err := getInterfaceName(ifid)
+		if err != nil {
+			// Something is wrong with this device. Skip it.
+			continue
+		}
+
+		if ifname == strings.ToLower(ifname2) {
+			// Interface name found.
+			return ifid, nil
+		}
+	}
+
+	return nil, nil
+}
+
+//
+// createInterface creates a TUN interface.
+//
+// description is a string that supplies the text description of the device.
+// Description is optional and can be "".
+//
+// hwndParent is a handle to the top-level window to use for any user
+// interface that is related to non-device-specific actions (such as a select-
+// device dialog box that uses the global class driver list). This handle is
+// optional and can be 0. If a specific top-level window is not required, set
+// hwndParent to 0.
+//
+// Function returns the network interface ID and a flag if reboot is required.
+//
+func createInterface(description string, hwndParent uintptr) (*windows.GUID, bool, error) {
+	// Create an empty device info set for network adapter device class.
+	devInfoList, err := setupapi.SetupDiCreateDeviceInfoListEx(&deviceClassNetGUID, hwndParent, "")
+	if err != nil {
+		return nil, false, err
+	}
+
+	// Get the device class name from GUID.
+	className, err := setupapi.SetupDiClassNameFromGuidEx(&deviceClassNetGUID, "")
+	if err != nil {
+		return nil, false, err
+	}
+
+	// Create a new device info element and add it to the device info set.
+	deviceData, err := devInfoList.CreateDeviceInfo(className, &deviceClassNetGUID, description, hwndParent, setupapi.DICD_GENERATE_ID)
+	if err != nil {
+		return nil, false, err
+	}
+
+	// Set a device information element as the selected member of a device information set.
+	err = devInfoList.SetSelectedDevice(deviceData)
+	if err != nil {
+		return nil, false, err
+	}
+
+	// Set Plug&Play device hardware ID property.
+	hwid, err := syscall.UTF16FromString(TUN_HWID)
+	if err != nil {
+		return nil, false, err
+	}
+	err = devInfoList.SetDeviceRegistryProperty(deviceData, setupapi.SPDRP_HARDWAREID, setupapi.UTF16ToBuf(append(hwid, 0)))
+	if err != nil {
+		return nil, false, err
+	}
+
+	// Search for the driver.
+	const driverType = setupapi.SPDIT_CLASSDRIVER
+	err = devInfoList.BuildDriverInfoList(deviceData, driverType)
+	if err != nil {
+		return nil, false, err
+	}
+	defer devInfoList.DestroyDriverInfoList(deviceData, driverType)
+
+	driverDate := windows.Filetime{}
+	driverVersion := uint64(0)
+	for index := 0; ; index++ {
+		// Get a driver from the list.
+		driverData, err := devInfoList.EnumDriverInfo(deviceData, driverType, index)
+		if err != nil {
+			if errWin, ok := err.(syscall.Errno); ok && errWin == 259 /*ERROR_NO_MORE_ITEMS*/ {
+				break
+			}
+			// Something is wrong with this driver. Skip it.
+			continue
+		}
+
+		// Check the driver version first, since the check is trivial and will save us iterating over hardware IDs for any driver versioned prior our best match.
+		if driverData.IsNewer(driverDate, driverVersion) {
+			// Get driver info details.
+			driverDetailData, err := devInfoList.GetDriverInfoDetail(deviceData, driverData)
+			if err != nil {
+				// Something is wrong with this driver. Skip it.
+				continue
+			}
+
+			if driverDetailData.IsCompatible(TUN_HWID) {
+				// Matching hardware ID found. Select the driver.
+				err := devInfoList.SetSelectedDriver(deviceData, driverData)
+				if err != nil {
+					// Something is wrong with this driver. Skip it.
+					continue
+				}
+
+				driverDate = driverData.DriverDate
+				driverVersion = driverData.DriverVersion
+			}
+		}
+	}
+
+	if driverVersion == 0 {
+		return nil, false, fmt.Errorf("No driver for device \"%v\" installed", TUN_HWID)
+	}
+
+	// Call appropriate class installer.
+	err = devInfoList.CallClassInstaller(setupapi.DIF_REGISTERDEVICE, deviceData)
+	if err != nil {
+		return nil, false, err
+	}
+
+	// Register device co-installers if any.
+	devInfoList.CallClassInstaller(setupapi.DIF_REGISTER_COINSTALLERS, deviceData)
+
+	// Install interfaces if any.
+	devInfoList.CallClassInstaller(setupapi.DIF_INSTALLINTERFACES, deviceData)
+
+	var ifid *windows.GUID
+	var rebootRequired bool
+
+	// Install the device.
+	err = devInfoList.CallClassInstaller(setupapi.DIF_INSTALLDEVICE, deviceData)
+	if err == nil {
+		// Check if a system reboot is required. (Ignore errors)
+		if ret, _ := checkReboot(devInfoList, deviceData); ret {
+			rebootRequired = true
+		}
+
+		// Get network interface ID from registry. Retry for max 30sec.
+		ifid, err = getInterfaceId(devInfoList, deviceData, 30)
+	}
+
+	if err == nil {
+		return ifid, rebootRequired, nil
+	}
+
+	// The interface failed to install, or the interface ID was unobtainable. Clean-up.
+	removeDeviceParams := setupapi.SP_REMOVEDEVICE_PARAMS{
+		ClassInstallHeader: setupapi.SP_CLASSINSTALL_HEADER{
+			InstallFunction: setupapi.DIF_REMOVE,
+		},
+		Scope: setupapi.DI_REMOVEDEVICE_GLOBAL,
+	}
+	removeDeviceParams.ClassInstallHeader.Size = uint32(unsafe.Sizeof(removeDeviceParams.ClassInstallHeader))
+
+	// Set class installer parameters for DIF_REMOVE.
+	if devInfoList.SetClassInstallParams(deviceData, &removeDeviceParams.ClassInstallHeader, uint32(unsafe.Sizeof(removeDeviceParams))) == nil {
+		// Call appropriate class installer.
+		if devInfoList.CallClassInstaller(setupapi.DIF_REMOVE, deviceData) == nil {
+			// Check if a system reboot is required. (Ignore errors)
+			if ret, _ := checkReboot(devInfoList, deviceData); ret {
+				rebootRequired = true
+			}
+		}
+	}
+
+	return nil, false, err
+}
+
+//
+// deleteInterface deletes a TUN interface.
+//
+// hwndParent is a handle to the top-level window to use for any user
+// interface that is related to non-device-specific actions (such as a select-
+// device dialog box that uses the global class driver list). This handle is
+// optional and can be 0. If a specific top-level window is not required, set
+// hwndParent to 0.
+//
+// Function returns true if the interface was found and deleted and a flag if
+// reboot is required.
+//
+func deleteInterface(ifid *windows.GUID, hwndParent uintptr) (bool, bool, error) {
+	// Create a list of network devices.
+	devInfoList, err := setupapi.SetupDiGetClassDevsEx(&deviceClassNetGUID, "", hwndParent, setupapi.DIGCF_PRESENT, setupapi.DevInfo(0), "")
+	if err != nil {
+		return false, false, err
+	}
+	defer devInfoList.Close()
+
+	// Retrieve information associated with a device information set.
+	// TODO: Is this really necessary?
+	_, err = devInfoList.GetDeviceInfoListDetail()
+	if err != nil {
+		return false, false, err
+	}
+
+	// Iterate.
+	for index := 0; ; index++ {
+		// Get the device from the list.
+		deviceData, err := devInfoList.EnumDeviceInfo(index)
+		if err != nil {
+			if errWin, ok := err.(syscall.Errno); ok && errWin == 259 /*ERROR_NO_MORE_ITEMS*/ {
+				break
+			}
+			// Something is wrong with this device. Skip it.
+			continue
+		}
+
+		// Get interface ID.
+		ifid2, err := getInterfaceId(devInfoList, deviceData, 1)
+		if err != nil {
+			// Something is wrong with this device. Skip it.
+			continue
+		}
+
+		if ifid == ifid2 {
+			// Remove the device.
+			removeDeviceParams := setupapi.SP_REMOVEDEVICE_PARAMS{
+				ClassInstallHeader: setupapi.SP_CLASSINSTALL_HEADER{
+					InstallFunction: setupapi.DIF_REMOVE,
+				},
+				Scope: setupapi.DI_REMOVEDEVICE_GLOBAL,
+			}
+			removeDeviceParams.ClassInstallHeader.Size = uint32(unsafe.Sizeof(removeDeviceParams.ClassInstallHeader))
+
+			// Set class installer parameters for DIF_REMOVE.
+			err = devInfoList.SetClassInstallParams(deviceData, &removeDeviceParams.ClassInstallHeader, uint32(unsafe.Sizeof(removeDeviceParams)))
+			if err != nil {
+				return false, false, err
+			}
+
+			// Call appropriate class installer.
+			err = devInfoList.CallClassInstaller(setupapi.DIF_REMOVE, deviceData)
+			if err != nil {
+				return false, false, err
+			}
+
+			// Check if a system reboot is required. (Ignore errors)
+			if ret, _ := checkReboot(devInfoList, deviceData); ret {
+				return true, true, nil
+			}
+
+			return true, false, nil
+		}
+	}
+
+	return false, false, nil
+}
+
+///
+/// checkReboot checks device install parameters if a system reboot is required.
+///
+func checkReboot(DeviceInfoSet setupapi.DevInfo, DeviceInfoData *setupapi.SP_DEVINFO_DATA) (bool, error) {
+	devInstallParams, err := DeviceInfoSet.GetDeviceInstallParams(DeviceInfoData)
+	if err != nil {
+		return false, err
+	}
+
+	if (devInstallParams.Flags & (setupapi.DI_NEEDREBOOT | setupapi.DI_NEEDRESTART)) != 0 {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// getInterfaceId returns network interface ID.
+//
+// After the device is created, it might take some time before the registry
+// key is populated. numAttempts parameter specifies the number of attempts
+// to read NetCfgInstanceId value from registry. A 1sec sleep is inserted
+// between retry attempts.
+//
+// Function returns the network interface ID.
+//
+func getInterfaceId(DeviceInfoSet setupapi.DevInfo, DeviceInfoData *setupapi.SP_DEVINFO_DATA, numAttempts int) (*windows.GUID, error) {
+	if numAttempts < 1 {
+		return nil, fmt.Errorf("Invalid numAttempts (expected: >=1, provided: %v)", numAttempts)
+	}
+
+	// Open HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class\<class>\<id> registry key.
+	key, err := DeviceInfoSet.OpenDevRegKey(DeviceInfoData, setupapi.DICS_FLAG_GLOBAL, 0, setupapi.DIREG_DRV, registry.READ)
+	if err != nil {
+		return nil, errors.New("Device-specific registry key open failed: " + err.Error())
+	}
+	defer key.Close()
+
+	for {
+		// Query the NetCfgInstanceId value. Using get_reg_string() right on might clutter the output with error messages while the registry is still being populated.
+		_, _, err = key.GetValue("NetCfgInstanceId", nil)
+		if err != nil {
+			if errWin, ok := err.(syscall.Errno); ok && errWin == windows.ERROR_FILE_NOT_FOUND {
+				numAttempts--
+				if numAttempts > 0 {
+					// Wait and retry.
+					// TODO: Wait for a cancellable event instead.
+					time.Sleep(1000 * time.Millisecond)
+					continue
+				}
+			}
+
+			return nil, errors.New("RegQueryValueEx(\"NetCfgInstanceId\") failed: " + err.Error())
+		}
+
+		// Read the NetCfgInstanceId value now.
+		value, err := getRegStringValue(key, "NetCfgInstanceId")
+		if err != nil {
+			return nil, errors.New("RegQueryStringValue(\"NetCfgInstanceId\") failed: " + err.Error())
+		}
+
+		// Convert to windows.GUID.
+		ifid, err := stringToGUID(value)
+		if err != nil {
+			return nil, fmt.Errorf("NetCfgInstanceId registry value is not a GUID (expected: \"{...}\", provided: \"%v\")", value)
+		}
+
+		return ifid, err
+	}
+}
+
+//
+// getInterfaceName returns network interface name.
+//
+func getInterfaceName(ifid *windows.GUID) (string, error) {
+	// Open network interface registry key.
+	key, err := registry.OpenKey(registry.LOCAL_MACHINE, fmt.Sprintf("SYSTEM\\CurrentControlSet\\Control\\Network\\%v\\%v\\Connection", guidToString(&deviceClassNetGUID), guidToString(ifid)), registry.QUERY_VALUE)
+	if err != nil {
+		return "", errors.New("Network-specific registry key open failed: " + err.Error())
+	}
+	defer key.Close()
+
+	// Get the interface name.
+	return getRegStringValue(key, "Name")
+}
+
+//
+// setInterfaceName sets network interface name.
+//
+func setInterfaceName(ifid *windows.GUID, ifname string) error {
+	// Open network interface registry key.
+	key, err := registry.OpenKey(registry.LOCAL_MACHINE, fmt.Sprintf("SYSTEM\\CurrentControlSet\\Control\\Network\\%v\\%v\\Connection", guidToString(&deviceClassNetGUID), guidToString(ifid)), registry.SET_VALUE)
+	if err != nil {
+		return errors.New("Network-specific registry key open failed: " + err.Error())
+	}
+	defer key.Close()
+
+	// Set the interface name.
+	return key.SetStringValue("Name", ifname)
+}
+
+//sys	clsidFromString(lpsz *uint16, pclsid *windows.GUID) (hr int32) = ole32.CLSIDFromString
+
+//
+// stringToGUID parses "{XXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" string to GUID.
+//
+func stringToGUID(str string) (*windows.GUID, error) {
+	strUTF16, err := syscall.UTF16PtrFromString(str)
+	if err != nil {
+		return nil, err
+	}
+
+	guid := &windows.GUID{}
+
+	hr := clsidFromString(strUTF16, guid)
+	if hr < 0 {
+		return nil, syscall.Errno(hr)
+	}
+
+	return guid, nil
+}
+
+//
+// guidToString function converts GUID to string
+// "{XXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}".
+//
+// The resulting string is uppercase.
+//
+func guidToString(guid *windows.GUID) string {
+	return fmt.Sprintf("{%06X-%04X-%04X-%04X-%012X}", guid.Data1, guid.Data2, guid.Data3, guid.Data4[:2], guid.Data4[2:])
+}
+
+//
+// getRegStringValue function reads a string value from registry.
+//
+// If the value type is REG_EXPAND_SZ the environment variables are expanded.
+// Should expanding fail, original string value and nil error are returned.
+//
+func getRegStringValue(key registry.Key, name string) (string, error) {
+	// Read string value.
+	value, valueType, err := key.GetStringValue(name)
+	if err != nil {
+		return "", err
+	}
+
+	if valueType != registry.EXPAND_SZ {
+		// Value does not require expansion.
+		return value, nil
+	}
+
+	valueExp, err := registry.ExpandString(value)
+	if err != nil {
+		// Expanding failed: return original sting value.
+		return value, nil
+	}
+
+	// Return expanded value.
+	return valueExp, nil
+}

tun/ztun_windows.go

@@ -0,0 +1,49 @@
+// Code generated by 'go generate'; DO NOT EDIT.
+
+package tun
+
+import (
+	"syscall"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+)
+
+var _ unsafe.Pointer
+
+// Do the interface allocations only once for common
+// Errno values.
+const (
+	errnoERROR_IO_PENDING = 997
+)
+
+var (
+	errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e syscall.Errno) error {
+	switch e {
+	case 0:
+		return nil
+	case errnoERROR_IO_PENDING:
+		return errERROR_IO_PENDING
+	}
+	// TODO: add more here, after collecting data on the common
+	// error values see on Windows. (perhaps when running
+	// all.bat?)
+	return e
+}
+
+var (
+	modole32 = windows.NewLazySystemDLL("ole32.dll")
+
+	procCLSIDFromString = modole32.NewProc("CLSIDFromString")
+)
+
+func clsidFromString(lpsz *uint16, pclsid *windows.GUID) (hr int32) {
+	r0, _, _ := syscall.Syscall(procCLSIDFromString.Addr(), 2, uintptr(unsafe.Pointer(lpsz)), uintptr(unsafe.Pointer(pclsid)), 0)
+	hr = int32(r0)
+	return
+}