refactor: deprecate old methods and point to upstream lib

deprecate methods implemented in the upstream x/sys/windows library
remove pkg/errors dependency and use native error wrapping

Author: kruskall

constants.go

@@ -21,13 +21,9 @@
 package windows
 
 const (
-	// This process access rights are missing from Go's syscall package as of 1.10.3
-
-	// PROCESS_VM_READ right allows to read memory from the target process.
+	// Deprecated: use x/sys/windows
 	PROCESS_VM_READ = 0x10
 
-	// PROCESS_QUERY_LIMITED_INFORMATION right allows to access a subset of the
-	// information granted by PROCESS_QUERY_INFORMATION. Not available in XP
-	// and Server 2003.
+	// Deprecated: use x/sys/windows
 	PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
 )

doc.go

@@ -20,6 +20,6 @@ package windows
 
 // Use "GOOS=windows go generate -v -x" to generate the sources.
 // Add -trace to enable debug prints around syscalls.
-//go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -systemdll=true -output=zsyscall_windows.go kernel32.go version.go psapi.go ntdll.go
+//go:generate go run golang.org/x/sys/windows/mkwinsyscall -systemdll=true -output=zsyscall_windows.go kernel32.go version.go psapi.go ntdll.go
 //go:generate go run .ci/scripts/fix_generated.go -input zsyscall_windows.go
 //go:generate go-licenser

go.mod

@@ -3,9 +3,8 @@ module github.com/elastic/go-windows
 go 1.17
 
 require (
-	github.com/pkg/errors v0.8.1
 	github.com/stretchr/testify v1.3.0
-	golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a
+	golang.org/x/sys v0.24.0
 )
 
 require (

go.sum

@@ -1,11 +1,9 @@
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a h1:aYOabOQFp6Vj6W1F80affTUvO9UxmJRx8K0gsfABByQ=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg=
+golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

kernel32.go

@@ -21,20 +21,20 @@
 package windows
 
 import (
+	"errors"
 	"fmt"
 	"syscall"
 	"time"
 	"unsafe"
 
-	"github.com/pkg/errors"
+	"golang.org/x/sys/windows"
 )
 
 // Syscalls
 //sys   _GetNativeSystemInfo(systemInfo *SystemInfo) = kernel32.GetNativeSystemInfo
 //sys   _GetTickCount64() (millis uint64, err error) = kernel32.GetTickCount64
 //sys   _GetSystemTimes(idleTime *syscall.Filetime, kernelTime *syscall.Filetime, userTime *syscall.Filetime) (err error) = kernel32.GetSystemTimes
 //sys   _GlobalMemoryStatusEx(buffer *MemoryStatusEx) (err error) = kernel32.GlobalMemoryStatusEx
-//sys   _ReadProcessMemory(handle syscall.Handle, baseAddress uintptr, buffer uintptr, size uintptr, numRead *uintptr) (err error) = kernel32.ReadProcessMemory
 //sys   _GetProcessHandleCount(handle syscall.Handle, pdwHandleCount *uint32) (err error) = kernel32.GetProcessHandleCount
 
 var (
@@ -194,7 +194,7 @@ func GetSystemTimes() (idle, kernel, user time.Duration, err error) {
 	var idleTime, kernelTime, userTime syscall.Filetime
 	err = _GetSystemTimes(&idleTime, &kernelTime, &userTime)
 	if err != nil {
-		return 0, 0, 0, errors.Wrap(err, "GetSystemTimes failed")
+		return 0, 0, 0, fmt.Errorf("GetSystemTimes failed: %w", err)
 	}
 
 	idle = FiletimeToDuration(&idleTime)
@@ -219,32 +219,30 @@ func GlobalMemoryStatusEx() (MemoryStatusEx, error) {
 	memoryStatusEx := MemoryStatusEx{length: sizeofMemoryStatusEx}
 	err := _GlobalMemoryStatusEx(&memoryStatusEx)
 	if err != nil {
-		return MemoryStatusEx{}, errors.Wrap(err, "GlobalMemoryStatusEx failed")
+		return MemoryStatusEx{}, fmt.Errorf("GlobalMemoryStatusEx failed: %w", err)
 	}
 
 	return memoryStatusEx, nil
 }
 
-// ReadProcessMemory reads from another process memory. The Handle needs to have
-// the PROCESS_VM_READ right.
-// A zero-byte read is a no-op, no error is returned.
-func ReadProcessMemory(handle syscall.Handle, baseAddress uintptr, dest []byte) (numRead uintptr, err error) {
+// Deprecated: use x/sys/windows
+func ReadProcessMemory(handle syscall.Handle, baseAddress uintptr, dest []byte) (uintptr, error) {
 	n := len(dest)
 	if n == 0 {
 		return 0, nil
 	}
-	if err = _ReadProcessMemory(handle, baseAddress, uintptr(unsafe.Pointer(&dest[0])), uintptr(n), &numRead); err != nil {
-		return 0, err
-	}
-	return numRead, nil
+
+	var numRead uintptr
+	err := windows.ReadProcessMemory(windows.Handle(handle), baseAddress, &dest[0], uintptr(n), &numRead)
+	return numRead, err
 }
 
 // GetProcessHandleCount retrieves the number of open handles of a process.
 // https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-getprocesshandlecount
 func GetProcessHandleCount(process syscall.Handle) (uint32, error) {
 	var count uint32
 	if err := _GetProcessHandleCount(process, &count); err != nil {
-		return 0, errors.Wrap(err, "GetProcessHandleCount failed")
+		return 0, fmt.Errorf("GetProcessHandleCount failed: %w", err)
 	}
 	return count, nil
 }

ntdll.go

@@ -24,6 +24,8 @@ import (
 	"fmt"
 	"syscall"
 	"unsafe"
+
+	"golang.org/x/sys/windows"
 )
 
 const (
@@ -108,20 +110,11 @@ type RtlUserProcessParameters struct {
 	CommandLine   UnicodeString
 }
 
-// Syscalls
-// Warning: NtQueryInformationProcess is an unsupported API that can change
-//          in future versions of Windows. Available from XP to Windows 10.
-//sys   _NtQueryInformationProcess(handle syscall.Handle, infoClass uint32, info uintptr, infoLen uint32, returnLen *uint32) (ntStatus uint32) = ntdll.NtQueryInformationProcess
-
-// NtQueryInformationProcess is a wrapper for ntdll.NtQueryInformationProcess.
-// The handle must have the PROCESS_QUERY_INFORMATION access right.
-// Returns an error of type NTStatus.
-func NtQueryInformationProcess(handle syscall.Handle, infoClass ProcessInfoClass, info unsafe.Pointer, infoLen uint32) (returnedLen uint32, err error) {
-	status := _NtQueryInformationProcess(handle, uint32(infoClass), uintptr(info), infoLen, &returnedLen)
-	if status != 0 {
-		return returnedLen, NTStatus(status)
-	}
-	return returnedLen, nil
+// Deprecated: use x/sys/windows
+func NtQueryInformationProcess(handle syscall.Handle, infoClass ProcessInfoClass, info unsafe.Pointer, infoLen uint32) (uint32, error) {
+	var returnedLen uint32
+	err := windows.NtQueryInformationProcess(windows.Handle(handle), int32(infoClass), info, infoLen, &returnedLen)
+	return returnedLen, err
 }
 
 // Error prints the wrapped NTSTATUS in hex form.

psapi.go

@@ -21,16 +21,16 @@
 package windows
 
 import (
+	"fmt"
 	"syscall"
 	"unsafe"
 
-	"github.com/pkg/errors"
+	"golang.org/x/sys/windows"
 )
 
 // Syscalls
 //sys   _GetProcessMemoryInfo(handle syscall.Handle, psmemCounters *ProcessMemoryCountersEx, cb uint32) (err error) = psapi.GetProcessMemoryInfo
 //sys   _GetProcessImageFileNameA(handle syscall.Handle, imageFileName *byte, nSize uint32) (len uint32, err error) = psapi.GetProcessImageFileNameA
-//sys   _EnumProcesses(lpidProcess *uint32, cb uint32, lpcbNeeded *uint32) (err error) = psapi.EnumProcesses
 
 var (
 	sizeofProcessMemoryCountersEx = uint32(unsafe.Sizeof(ProcessMemoryCountersEx{}))
@@ -59,7 +59,7 @@ type ProcessMemoryCountersEx struct {
 func GetProcessMemoryInfo(process syscall.Handle) (ProcessMemoryCountersEx, error) {
 	var info ProcessMemoryCountersEx
 	if err := _GetProcessMemoryInfo(process, &info, sizeofProcessMemoryCountersEx); err != nil {
-		return ProcessMemoryCountersEx{}, errors.Wrap(err, "GetProcessMemoryInfo failed")
+		return ProcessMemoryCountersEx{}, fmt.Errorf("GetProcessMemoryInfo failed: %w", err)
 	}
 	return info, nil
 }
@@ -91,7 +91,7 @@ func GetProcessImageFileName(handle syscall.Handle) (string, error) {
 func EnumProcesses() (pids []uint32, err error) {
 	for nAlloc, nGot := uint32(128), uint32(0); ; nAlloc *= 2 {
 		pids = make([]uint32, nAlloc)
-		if err = _EnumProcesses(&pids[0], nAlloc*4, &nGot); err != nil {
+		if err = windows.EnumProcesses(pids, &nGot); err != nil {
 			return nil, err
 		}
 		if nGot/4 < nAlloc {

version.go

@@ -21,21 +21,14 @@
 package windows
 
 import (
+	"errors"
 	"fmt"
 	"unsafe"
 
-	"github.com/pkg/errors"
+	"golang.org/x/sys/windows"
 )
 
-// Syscalls
-//sys   _GetFileVersionInfo(filename string, reserved uint32, dataLen uint32, data *byte) (success bool, err error) [!success] = version.GetFileVersionInfoW
-//sys   _GetFileVersionInfoSize(filename string, handle uintptr) (size uint32, err error) = version.GetFileVersionInfoSizeW
-//sys   _VerQueryValueW(data *byte, subBlock string, pBuffer *uintptr, len *uint32) (success bool, err error) [!success] = version.VerQueryValueW
-
-// FixedFileInfo contains version information for a file. This information is
-// language and code page independent. This is an equivalent representation of
-// VS_FIXEDFILEINFO.
-// https://msdn.microsoft.com/en-us/library/windows/desktop/ms646997(v=vs.85).aspx
+// Deprecated: use x/sys/windows
 type FixedFileInfo struct {
 	Signature        uint32
 	StrucVersion     uint32
@@ -84,32 +77,27 @@ func (d VersionData) QueryValue(key string) (string, error) {
 		CodePage uint16
 	}
 
+	var langCodePage *LangAndCodePage
+	langCodeLen := uint32(unsafe.Sizeof(*langCodePage))
+	if err := windows.VerQueryValue(unsafe.Pointer(&d[0]), `\VarFileInfo\Translation`, (unsafe.Pointer)(&langCodePage), &langCodeLen); err != nil || langCodeLen == 0 {
+		return "", fmt.Errorf("failed to get list of languages: %w", err)
+	}
+
 	var dataPtr uintptr
 	var size uint32
-	if _, err := _VerQueryValueW(&d[0], `\VarFileInfo\Translation`, &dataPtr, &size); err != nil || size == 0 {
-		return "", errors.Wrap(err, "failed to get list of languages")
+	subBlock := fmt.Sprintf(`\StringFileInfo\%04x%04x\%v`, langCodePage.Language, langCodePage.CodePage, key)
+	if err := windows.VerQueryValue(unsafe.Pointer(&d[0]), subBlock, (unsafe.Pointer)(&dataPtr), &size); err != nil || langCodeLen == 0 {
+		return "", fmt.Errorf("failed to query %v: %w", subBlock, err)
 	}
 
 	offset := int(dataPtr - (uintptr)(unsafe.Pointer(&d[0])))
 	if offset <= 0 || offset > len(d)-1 {
 		return "", errors.New("invalid address")
 	}
 
-	l := *(*LangAndCodePage)(unsafe.Pointer(&d[offset]))
-
-	subBlock := fmt.Sprintf(`\StringFileInfo\%04x%04x\%v`, l.Language, l.CodePage, key)
-	if _, err := _VerQueryValueW(&d[0], subBlock, &dataPtr, &size); err != nil || size == 0 {
-		return "", errors.Wrapf(err, "failed to query %v", subBlock)
-	}
-
-	offset = int(dataPtr - (uintptr)(unsafe.Pointer(&d[0])))
-	if offset <= 0 || offset > len(d)-1 {
-		return "", errors.New("invalid address")
-	}
-
 	str, _, err := UTF16BytesToString(d[offset : offset+int(size)*2])
 	if err != nil {
-		return "", errors.Wrap(err, "failed to decode UTF16 data")
+		return "", fmt.Errorf("failed to decode UTF16 data: %w", err)
 	}
 
 	return str, nil
@@ -119,40 +107,32 @@ func (d VersionData) QueryValue(key string) (string, error) {
 // version-information resource. It queries the root block to get the
 // VS_FIXEDFILEINFO value.
 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms647464(v=vs.85).aspx
-func (d VersionData) FixedFileInfo() (*FixedFileInfo, error) {
+func (d VersionData) FixedFileInfo() (*windows.VS_FIXEDFILEINFO, error) {
 	if len(d) == 0 {
 		return nil, errors.New("use GetFileVersionInfo to initialize VersionData")
 	}
 
-	var dataPtr uintptr
-	var size uint32
-	if _, err := _VerQueryValueW(&d[0], `\`, &dataPtr, &size); err != nil {
-		return nil, errors.Wrap(err, "VerQueryValue failed for \\")
-	}
-
-	offset := int(dataPtr - (uintptr)(unsafe.Pointer(&d[0])))
-	if offset <= 0 || offset > len(d)-1 {
-		return nil, errors.New("invalid address")
+	var fixedInfo *windows.VS_FIXEDFILEINFO
+	fixedInfoLen := uint32(unsafe.Sizeof(*fixedInfo))
+	if err := windows.VerQueryValue(unsafe.Pointer(&d[0]), `\`, (unsafe.Pointer)(&fixedInfo), &fixedInfoLen); err != nil {
+		return nil, fmt.Errorf("VerQueryValue failed for \\ : %w", err)
 	}
 
-	// Make a copy of the struct.
-	ffi := *(*FixedFileInfo)(unsafe.Pointer(&d[offset]))
-
-	return &ffi, nil
+	return fixedInfo, nil
 }
 
 // GetFileVersionInfo retrieves version information for the specified file.
 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms647003(v=vs.85).aspx
 func GetFileVersionInfo(filename string) (VersionData, error) {
-	size, err := _GetFileVersionInfoSize(filename, 0)
+	size, err := windows.GetFileVersionInfoSize(filename, nil)
 	if err != nil {
-		return nil, errors.Wrap(err, "GetFileVersionInfoSize failed")
+		return nil, fmt.Errorf("GetFileVersionInfoSize failed: %w", err)
 	}
 
 	data := make(VersionData, size)
-	_, err = _GetFileVersionInfo(filename, 0, uint32(len(data)), &data[0])
+	err = windows.GetFileVersionInfo(filename, 0, uint32(len(data)), unsafe.Pointer(&data[0]))
 	if err != nil {
-		return nil, errors.Wrap(err, "GetFileVersionInfo failed")
+		return nil, fmt.Errorf("GetFileVersionInfo failed: %w", err)
 	}
 
 	return data, nil