查看固定设备的清单

本文探讨了在 Go 语言中获取仅物理驱动器的所有挂载点的方法。与仅列出所有安装点的其他解决方案不同，此方法通过使用 Windows API 来区分固定驱动器和网络共享，从而提供了更精确的结果。通过枚举系统中的所有卷并查询每个卷的装载路径名，该方法可以识别和排除非驱动器安装，例如作为目录安装的卷。尽管这种方法比简单地列出所有安装点更复杂，但它提供了对系统存储结构的更准确和细粒度的了解。

如何获取仅物理驱动器的所有挂载点的列表？我看到这里有一个类似的答案，但这列出了所有安装点，包括网络共享。

如何使用 golang 获取 Windows 上所有驱动器的列表？

解决方案

好的，我决定重新审视我的 win32 api 编程技能并准备一个解决方案。

基于 the thread you referred to 的蹩脚方法的解决方案如下：

package main

import (
    "errors"
    "fmt"
    "log"
    "syscall"
    "unsafe"
)

var (
    kernel32 = syscall.newlazydll("kernel32.dll")

    getdrivetypewproc = kernel32.newproc("getdrivetypew")
)

func getdrivetype(rootpathname []uint16) (int, error) {
    rc, _, _ := getdrivetypewproc.call(
        uintptr(unsafe.pointer(&rootpathname[0])),
    )

    dt := int(rc)

    if dt == driveunknown || dt == drivenorootdir {
        return -1, drivetypeerrors[dt]
    }

    return dt, nil
}

var (
    errunknowndrivetype = errors.new("unknown drive type")
    errnorootdir        = errors.new("invalid root drive path")

    drivetypeerrors = [...]error{
        0: errunknowndrivetype,
        1: errnorootdir,
    }
)

const (
    driveunknown = iota
    drivenorootdir

    driveremovable
    drivefixed
    driveremote
    drivecdrom
    driveramdisk
)

func getfixeddosdrives() ([]string, error) {
    var drive = [4]uint16{
        1: ':',
        2: '\\',
    }

    var drives []string

    for c := 'a'; c <= 'z'; c++ {
        drive[0] = uint16(c)
        dt, err := getdrivetype(drive[:])

        if err != nil {
            if err == errnorootdir {
                continue
            }
            return nil, fmt.errorf("error getting type of: %s: %s",
                syscall.utf16tostring(drive[:]), err)
        }

        if dt != drivefixed {
            continue
        }

        drives = append(drives, syscall.utf16tostring(drive[:]))
    }

    return drives, nil
}

func main() {
    drives, err := getfixeddosdrives()
    if err != nil {
        log.fatal(err)
    }
    for _, drive := range drives {
        log.println(drive)
    }
}

通过盒子运行（在 wine 4.0 下）我得到：

tmp$ goos=windows go build drvs.go 
tmp$ wine64 ./drvs.exe
0009:fixme:process:setprocesspriorityboost (0xffffffffffffffff,1): stub
2020/07/06 21:06:02 c:\
2020/07/06 21:06:02 d:\
2020/07/06 21:06:02 x:\
2020/07/06 21:06:02 z:\

（所有驱动器均使用 winecfg 进行映射。）

这种方法的问题是：

• 即使系统中存在的 dos 驱动器数量远小于 ascii 大写字母的数量，它也会执行 26 个系统调用。

• 在当今的 windows 系统上，驱动器可能会映射到常规目录下 - 与 posix 系统非常相似，因此它根本没有 dos 驱动器号。

  eryk sun 准确地暗示了对此应该采取的措施。
  我将尝试提供一个考虑到这些因素的适当（尽管更复杂）的解决方案。

这是带有代码的 gist。

GetDriveTypeW docs。

希望这能让您对 win32 api 的工作原理以及如何从 go 中使用它感兴趣。尝试查看 go 安装中的 syscall 包的源代码 - 结合 msdn 文档，这应该会有所启发。

基于 eryk sun 在评论中建议的改进方法。

代码

package main

import (
    "errors"
    "log"
    "strings"
    "syscall"
    "unsafe"
)

func main() {
    mounts, err := getfixeddrivemounts()
    if err != nil {
        log.fatal(err)
    }
    for _, m := range mounts {
        log.println("volume:", m.volume,
            "mounts:", strings.join(m.mounts, ", "))
    }
}

var (
    kernel32 = syscall.newlazydll("kernel32.dll")

    findfirstvolumewproc = kernel32.newproc("findfirstvolumew")
    findnextvolumewproc  = kernel32.newproc("findnextvolumew")
    findvolumecloseproc  = kernel32.newproc("findvolumeclose")

    getvolumepathnamesforvolumenamewproc = kernel32.newproc("getvolumepathnamesforvolumenamew")

    getdrivetypewproc = kernel32.newproc("getdrivetypew")
)

const guidbuflen = syscall.max_path + 1

func findfirstvolume() (uintptr, []uint16, error) {
    const invalidhandlevalue = ^uintptr(0)

    guid := make([]uint16, guidbuflen)

    handle, _, err := findfirstvolumewproc.call(
        uintptr(unsafe.pointer(&guid[0])),
        uintptr(guidbuflen*2),
    )

    if handle == invalidhandlevalue {
        return invalidhandlevalue, nil, err
    }

    return handle, guid, nil
}

func findnextvolume(handle uintptr) ([]uint16, bool, error) {
    const nomorefiles = 18

    guid := make([]uint16, guidbuflen)

    rc, _, err := findnextvolumewproc.call(
        handle,
        uintptr(unsafe.pointer(&guid[0])),
        uintptr(guidbuflen*2),
    )

    if rc == 1 {
        return guid, true, nil
    }

    if err.(syscall.errno) == nomorefiles {
        return nil, false, nil
    }
    return nil, false, err
}

func findvolumeclose(handle uintptr) error {
    ok, _, err := findvolumecloseproc.call(handle)
    if ok == 0 {
        return err
    }

    return nil
}

func getvolumepathnamesforvolumename(volname []uint16) ([][]uint16, error) {
    const (
        errormoredata = 234
        nul           = 0x0000
    )

    var (
        pathnameslen uint32
        pathnames    []uint16
    )

    pathnameslen = 2
    for {
        pathnames = make([]uint16, pathnameslen)
        pathnameslen *= 2

        rc, _, err := getvolumepathnamesforvolumenamewproc.call(
            uintptr(unsafe.pointer(&volname[0])),
            uintptr(unsafe.pointer(&pathnames[0])),
            uintptr(pathnameslen),
            uintptr(unsafe.pointer(&pathnameslen)),
        )

        if rc == 0 {
            if err.(syscall.errno) == errormoredata {
                continue
            }

            return nil, err
        }

        pathnames = pathnames[:pathnameslen]
        break
    }

    var out [][]uint16
    i := 0
    for j, c := range pathnames {
        if c == nul && i < j {
            out = append(out, pathnames[i:j+1])
            i = j + 1
        }
    }
    return out, nil
}

func getdrivetype(rootpathname []uint16) (int, error) {
    rc, _, _ := getdrivetypewproc.call(
        uintptr(unsafe.pointer(&rootpathname[0])),
    )

    dt := int(rc)

    if dt == driveunknown || dt == drivenorootdir {
        return -1, drivetypeerrors[dt]
    }

    return dt, nil
}

var (
    errunknowndrivetype = errors.new("unknown drive type")
    errnorootdir        = errors.new("invalid root drive path")

    drivetypeerrors = [...]error{
        0: errunknowndrivetype,
        1: errnorootdir,
    }
)

const (
    driveunknown = iota
    drivenorootdir

    driveremovable
    drivefixed
    driveremote
    drivecdrom
    driveramdisk

    drivelastknowntype = driveramdisk
)

type fixeddrivevolume struct {
    volname          string
    mountedpathnames []string
}

type fixedvolumemounts struct {
    volume string
    mounts []string
}

func getfixeddrivemounts() ([]fixedvolumemounts, error) {
    var out []fixedvolumemounts

    err := enumvolumes(func(guid []uint16) error {
        mounts, err := maybegetfixedvolumemounts(guid)
        if err != nil {
            return err
        }
        if len(mounts) > 0 {
            out = append(out, fixedvolumemounts{
                volume: syscall.utf16tostring(guid),
                mounts: lpstrstostrings(mounts),
            })
        }
        return nil
    })

    if err != nil {
        return nil, err
    }

    return out, nil
}

func enumvolumes(handlevolume func(guid []uint16) error) error {
    handle, guid, err := findfirstvolume()
    if err != nil {
        return err
    }
    defer func() {
        err = findvolumeclose(handle)
    }()

    if err := handlevolume(guid); err != nil {
        return err
    }

    for {
        guid, more, err := findnextvolume(handle)
        if err != nil {
            return err
        }

        if !more {
            break
        }

        if err := handlevolume(guid); err != nil {
            return err
        }
    }

    return nil
}

func maybegetfixedvolumemounts(guid []uint16) ([][]uint16, error) {
    paths, err := getvolumepathnamesforvolumename(guid)
    if err != nil {
        return nil, err
    }

    if len(paths) == 0 {
        return nil, nil
    }

    var lasterr error
    for _, path := range paths {
        dt, err := getdrivetype(path)
        if err == nil {
            if dt == drivefixed {
                return paths, nil
            }
            return nil, nil
        }
        lasterr = err
    }

    return nil, lasterr
}

func lpstrstostrings(in [][]uint16) []string {
    if len(in) == 0 {
        return nil
    }

    out := make([]string, len(in))
    for i, s := range in {
        out[i] = syscall.utf16tostring(s)
    }

    return out
}

（这是包含此代码的 gist。）

在具有 4 个驱动器的 wine 4.0 下（使用 `winecfg 配置），我有：

tmp$ GOOS=windows go build fvs.go
tmp$ wine64 ./fvs.exe 
0009:fixme:process:SetProcessPriorityBoost (0xffffffffffffffff,1): stub
2020/07/09 22:48:25 volume: \\?\Volume{00000000-0000-0000-0000-000000000043}\ mounts: C:\
2020/07/09 22:48:25 volume: \\?\Volume{00000000-0000-0000-0000-000000000044}\ mounts: D:\
2020/07/09 22:48:25 volume: \\?\Volume{00000000-0000-0000-0000-00000000005a}\ mounts: Z:\
2020/07/09 22:48:25 volume: \\?\Volume{169203c7-20c7-4ca6-aaec-19a806b9b81e}\ mounts: X:\

代码是这样滚动的：

1. 枚举系统中的所有卷（不是 dos“驱动器”）。
2. 对于每个卷，它会查询装载该卷的路径名列表（如果有）。
3. 对于每个这样的路径名，它依次尝试获取其类型 - 查看它是否是固定的。

好处

这种方法的优点是，正如我的其他答案中所述，此代码应该能够检测非驱动器安装 - 即，作为目录安装的卷，而不是 dos 设备。 p>

缺点

• 代码比较复杂。
• 它实际上产生了一个两层结构（深度为 2 的树）：一个固定卷列表，每个卷包含一个其安装列表。
  唯一明显的问题是它可能更难处理，但你可以随意伪造它，以便它返回一个简单的坐骑列表。

可能出现的问题

刚才我看到了两个，不幸的是我没有方便访问的运行 windows 的机器来检查。

第一个问题是我希望对 kernel32!getdrivetypew 的调用能够处理卷名称 - 这些 \\?\volume{169203c7-20c7-4ca6-aaec-19a806b9b81e}\ 风格的卷枚举返回的内容api 调用，但它没有 — 始终返回 drive_unknown 错误代码。
因此，在我的代码中，我什至不尝试在卷名称上调用它，而是直接通过 kernel32!getvolumepathnamesforvolumenamew 查询卷的安装，然后尝试获取它们的驱动器类型。

我不知道为什么会这样。可能——只是可能——这是我用来测试的 wine 4.0 中的一个错误，但这不太可能。

另一个问题是我不知道如何在 wine 下创建一个新型的非驱动卷挂载，老实说我没有时间去了解。因此可能结果是 kernel32!getdrivetypew 对于目录挂载也会失败（并且仅适用于“dos 驱动器”挂载）。
msdn 对这些问题保持沉默，所以我只是不知道它应该如何表现。如果我是你，我可能会在 windows 机器上进行一些测试;-)

今天关于《查看固定设备的清单》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！