使用WireGuardNT与Go创建WireGuard Windows适配器时遭遇“Cannot create a file when that file already exists.”错误

我来帮你拆解这个问题的根源，然后给你一套可行的解决方案。

首先，这个错误的核心原因是：当你在适配器创建过程中强行终止程序时，WireGuardNT驱动在系统中注册的部分资源（比如网络接口对应的注册表项、内核设备对象）没有被正确清理。这些残留的“僵尸”资源会让系统误以为同名的WireGuard适配器已经存在，所以下次创建时就抛出了“文件已存在”的错误——这里的“文件”其实是Windows对内核对象/系统资源的抽象表述，不是真正的磁盘文件。

接下来是具体的解决步骤，你可以按顺序实现：

1. 创建前主动清理残留适配器 #

在调用CreateAdapter之前，先检查系统中是否存在同名的残留WireGuard适配器，如果有就先删除它。这样能从源头避免冲突。

你可以通过Windows的网络接口API枚举所有接口，过滤出WireGuard类型且名字匹配的接口，然后调用WireGuardNT的删除API清理。这里给你一段示例代码：

import (
    "fmt"
    "syscall"
    "unsafe"
    "golang.org/x/sys/windows"
)

// 清理同名的残留WireGuard适配器
func CleanupResidualAdapter(name string) error {
    // 枚举所有网络适配器
    var ifaces *windows.IpAdapterInfo
    bufLen := uint32(1024)
    for {
        buf := make([]byte, bufLen)
        ifaces = (*windows.IpAdapterInfo)(unsafe.Pointer(&buf[0]))
        err := windows.GetAdaptersInfo(ifaces, &bufLen)
        if err == windows.ERROR_BUFFER_OVERFLOW {
            continue // 缓冲区不够，扩容后重试
        }
        if err != nil {
            return fmt.Errorf("failed to enumerate adapters: %w", err)
        }
        break
    }

    // 遍历适配器，查找目标WireGuard适配器
    for iface := ifaces; iface != nil; iface = iface.Next {
        friendlyName := windows.UTF16ToString(iface.FriendlyName)
        if friendlyName != name {
            continue
        }

        // 验证是否为WireGuard类型（通过注册表读取隧道类型）
        adapterID := windows.UTF16ToString(iface.AdapterName)
        tunnelType, err := getTunnelTypeFromRegistry(adapterID)
        if err != nil {
            continue
        }
        if tunnelType != "WireGuard" {
            continue
        }

        // 调用WireGuardNT的删除API清理适配器
        r0, _, e1 := syscall.SyscallN(procWireGuardDeleteAdapter.Addr(),
            uintptr(unsafe.Pointer(windows.StringToUTF16Ptr(adapterID))))
        if r0 == 0 {
            return fmt.Errorf("failed to delete residual adapter: %w", e1)
        }
        fmt.Printf("Cleaned up residual WireGuard adapter: %s\n", name)
        break
    }
    return nil
}

// 从注册表读取适配器的隧道类型
func getTunnelTypeFromRegistry(adapterID string) (string, error) {
    regPath := `SYSTEM\CurrentControlSet\Control\Class\{4d36e972-e325-11ce-bfc1-08002be10318}\` + adapterID
    key, err := windows.OpenRegistryKey(windows.HKEY_LOCAL_MACHINE,
        windows.StringToUTF16Ptr(regPath), windows.KEY_READ)
    if err != nil {
        return "", err
    }
    defer windows.CloseRegistryKey(key)

    var buf [256]uint16
    bufLen := uint32(len(buf))
    err = windows.RegQueryValueEx(key, windows.StringToUTF16Ptr("TunnelType"),
        nil, nil, (*byte)(unsafe.Pointer(&buf[0])), &bufLen)
    if err != nil {
        return "", err
    }
    return windows.UTF16ToString(buf[:]), nil
}

然后修改你的CreateAdapter函数，在开头加入清理逻辑：

func CreateAdapter(name, tunnelType string, requestedGUID *windows.GUID) (wireguard *Adapter, err error) {
    // 先清理残留适配器
    if err = CleanupResidualAdapter(name); err != nil {
        return nil, fmt.Errorf("cleanup failed: %w", err)
    }

    // 原有的创建逻辑...
    name16, err := windows.UTF16PtrFromString(name)
    if err != nil {
        return
    }

    tunnelType16, err := windows.UTF16PtrFromString(tunnelType)
    if err != nil {
        return
    }

    r0, _, e1 := syscall.SyscallN(procWireGuardCreateAdapter.Addr(),
        uintptr(unsafe.Pointer(name16)),
        uintptr(unsafe.Pointer(tunnelType16)),
        uintptr(unsafe.Pointer(requestedGUID)))
    
    // 如果创建失败且是文件已存在错误，再尝试清理后重试
    if r0 == 0 {
        err = e1
        if err == windows.ERROR_FILE_EXISTS {
            fmt.Println("Adapter exists, retrying cleanup...")
            if retryErr := CleanupResidualAdapter(name); retryErr == nil {
                // 重试创建
                r0, _, e1 := syscall.SyscallN(procWireGuardCreateAdapter.Addr(),
                    uintptr(unsafe.Pointer(name16)),
                    uintptr(unsafe.Pointer(tunnelType16)),
                    uintptr(unsafe.Pointer(requestedGUID)))
                if r0 != 0 {
                    wireguard = &Adapter{handle: r0}
                    runtime.SetFinalizer(wireguard, closeAdapter)
                    err = nil
                } else {
                    err = e1
                }
            }
        }
        return
    }

    wireguard = &Adapter{handle: r0}
    runtime.SetFinalizer(wireguard, closeAdapter)
    return
}

2. 处理程序终止信号，确保资源清理 #

runtime.SetFinalizer并不总是可靠的（比如程序被强行终止时，Go runtime可能没机会执行finalizer），所以最好手动捕获终止信号，在退出前主动清理适配器。

在你的main函数里加入信号处理逻辑：

import (
    "log"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    // 捕获Ctrl+C、系统终止信号
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    var activeAdapter *Adapter
    // 启动信号监听 goroutine
    go func() {
        <-sigChan
        log.Println("Received termination signal, cleaning up adapter...")
        if activeAdapter != nil {
            closeAdapter(activeAdapter)
        }
        os.Exit(0)
    }()

    // 创建适配器
    var err error
    activeAdapter, err = CreateAdapter("MyWireGuardAdapter", "WireGuard", nil)
    if err != nil {
        log.Fatalf("Failed to create adapter: %v", err)
    }

    // 后续业务逻辑...
    // 比如保持程序运行，等待用户输入或其他事件
    select {}
}

// 完善closeAdapter函数，确保调用WireGuardNT的删除API
func closeAdapter(wireguard *Adapter) {
    if wireguard.handle != 0 {
        syscall.SyscallN(procWireGuardDeleteAdapter.Addr(), wireguard.handle)
        wireguard.handle = 0
        log.Println("Adapter cleaned up successfully")
    }
}

3. 可选：使用固定GUID标识适配器 #

如果你希望适配器的标识更稳定，可以指定固定的requestedGUID，而不是让系统自动生成。这样即使有残留，也能通过GUID精准清理，避免名字冲突的问题。

比如定义一个固定GUID：

var myAdapterGUID = windows.GUID{Data1: 0x12345678, Data2: 0x1234, Data3: 0x1234, Data4: [8]byte{0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef}}

然后创建时传入这个GUID：

activeAdapter, err = CreateAdapter("MyWireGuardAdapter", "WireGuard", &myAdapterGUID)

这样一来，无论程序是否被强行终止，下次启动时都能精准找到并清理对应GUID的适配器，彻底避免冲突。

备注：内容来源于stack exchange，提问作者kunal