jochen
be92762969
The live tests reached one shared bus and assert, read and remove the mesh's own objects by their fixed names, so packages run in parallel deleted what each other read and the suite passed only one package at a time; a red suite read as noise. internal/testbus starts a server per test, linked in at the nats-server release go.mod pins, and a test holds that pin to the catalogue's bus image and to the facts snapshot's bus when there is one, so the tests never run a bus the mesh does not. The waiter test read a timing (the most connections held at one look) and now reads the state it means (the fewest held across the wait). make check runs the packages in parallel under the race detector, with a timeout.
391 lines
12 KiB
Go
391 lines
12 KiB
Go
// Copyright 2015 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
//go:build windows
|
|
|
|
package registry
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"syscall"
|
|
"unicode/utf16"
|
|
"unsafe"
|
|
)
|
|
|
|
const (
|
|
// Registry value types.
|
|
NONE = 0
|
|
SZ = 1
|
|
EXPAND_SZ = 2
|
|
BINARY = 3
|
|
DWORD = 4
|
|
DWORD_BIG_ENDIAN = 5
|
|
LINK = 6
|
|
MULTI_SZ = 7
|
|
RESOURCE_LIST = 8
|
|
FULL_RESOURCE_DESCRIPTOR = 9
|
|
RESOURCE_REQUIREMENTS_LIST = 10
|
|
QWORD = 11
|
|
)
|
|
|
|
var (
|
|
// ErrShortBuffer is returned when the buffer was too short for the operation.
|
|
ErrShortBuffer = syscall.ERROR_MORE_DATA
|
|
|
|
// ErrNotExist is returned when a registry key or value does not exist.
|
|
ErrNotExist = syscall.ERROR_FILE_NOT_FOUND
|
|
|
|
// ErrUnexpectedType is returned by Get*Value when the value's type was unexpected.
|
|
ErrUnexpectedType = errors.New("unexpected key value type")
|
|
)
|
|
|
|
// GetValue retrieves the type and data for the specified value associated
|
|
// with an open key k. It fills up buffer buf and returns the retrieved
|
|
// byte count n. If buf is too small to fit the stored value it returns
|
|
// ErrShortBuffer error along with the required buffer size n.
|
|
// If no buffer is provided, it returns true and actual buffer size n.
|
|
// If no buffer is provided, GetValue returns the value's type only.
|
|
// If the value does not exist, the error returned is ErrNotExist.
|
|
//
|
|
// GetValue is a low level function. If value's type is known, use the appropriate
|
|
// Get*Value function instead.
|
|
func (k Key) GetValue(name string, buf []byte) (n int, valtype uint32, err error) {
|
|
pname, err := syscall.UTF16PtrFromString(name)
|
|
if err != nil {
|
|
return 0, 0, err
|
|
}
|
|
var pbuf *byte
|
|
if len(buf) > 0 {
|
|
pbuf = (*byte)(unsafe.Pointer(&buf[0]))
|
|
}
|
|
l := uint32(len(buf))
|
|
err = syscall.RegQueryValueEx(syscall.Handle(k), pname, nil, &valtype, pbuf, &l)
|
|
if err != nil {
|
|
return int(l), valtype, err
|
|
}
|
|
return int(l), valtype, nil
|
|
}
|
|
|
|
func (k Key) getValue(name string, buf []byte) (data []byte, valtype uint32, err error) {
|
|
p, err := syscall.UTF16PtrFromString(name)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
var t uint32
|
|
n := uint32(len(buf))
|
|
for {
|
|
err = syscall.RegQueryValueEx(syscall.Handle(k), p, nil, &t, (*byte)(unsafe.Pointer(&buf[0])), &n)
|
|
if err == nil {
|
|
return buf[:n], t, nil
|
|
}
|
|
if err != syscall.ERROR_MORE_DATA {
|
|
return nil, 0, err
|
|
}
|
|
if n <= uint32(len(buf)) {
|
|
return nil, 0, err
|
|
}
|
|
buf = make([]byte, n)
|
|
}
|
|
}
|
|
|
|
// GetStringValue retrieves the string value for the specified
|
|
// value name associated with an open key k. It also returns the value's type.
|
|
// If value does not exist, GetStringValue returns ErrNotExist.
|
|
// If value is not SZ or EXPAND_SZ, it will return the correct value
|
|
// type and ErrUnexpectedType.
|
|
func (k Key) GetStringValue(name string) (val string, valtype uint32, err error) {
|
|
data, typ, err2 := k.getValue(name, make([]byte, 64))
|
|
if err2 != nil {
|
|
return "", typ, err2
|
|
}
|
|
switch typ {
|
|
case SZ, EXPAND_SZ:
|
|
default:
|
|
return "", typ, ErrUnexpectedType
|
|
}
|
|
if len(data) == 0 {
|
|
return "", typ, nil
|
|
}
|
|
u := (*[1 << 29]uint16)(unsafe.Pointer(&data[0]))[: len(data)/2 : len(data)/2]
|
|
return syscall.UTF16ToString(u), typ, nil
|
|
}
|
|
|
|
// GetMUIStringValue retrieves the localized string value for
|
|
// the specified value name associated with an open key k.
|
|
// If the value name doesn't exist or the localized string value
|
|
// can't be resolved, GetMUIStringValue returns ErrNotExist.
|
|
// GetMUIStringValue panics if the system doesn't support
|
|
// regLoadMUIString; use LoadRegLoadMUIString to check if
|
|
// regLoadMUIString is supported before calling this function.
|
|
func (k Key) GetMUIStringValue(name string) (string, error) {
|
|
pname, err := syscall.UTF16PtrFromString(name)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
buf := make([]uint16, 1024)
|
|
var buflen uint32
|
|
var pdir *uint16
|
|
|
|
err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
|
|
if err == syscall.ERROR_FILE_NOT_FOUND { // Try fallback path
|
|
|
|
// Try to resolve the string value using the system directory as
|
|
// a DLL search path; this assumes the string value is of the form
|
|
// @[path]\dllname,-strID but with no path given, e.g. @tzres.dll,-320.
|
|
|
|
// This approach works with tzres.dll but may have to be revised
|
|
// in the future to allow callers to provide custom search paths.
|
|
|
|
var s string
|
|
s, err = ExpandString("%SystemRoot%\\system32\\")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
pdir, err = syscall.UTF16PtrFromString(s)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
|
|
}
|
|
|
|
for err == syscall.ERROR_MORE_DATA { // Grow buffer if needed
|
|
if buflen <= uint32(len(buf)) {
|
|
break // Buffer not growing, assume race; break
|
|
}
|
|
buf = make([]uint16, buflen)
|
|
err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
|
|
}
|
|
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return syscall.UTF16ToString(buf), nil
|
|
}
|
|
|
|
// ExpandString expands environment-variable strings and replaces
|
|
// them with the values defined for the current user.
|
|
// Use ExpandString to expand EXPAND_SZ strings.
|
|
func ExpandString(value string) (string, error) {
|
|
if value == "" {
|
|
return "", nil
|
|
}
|
|
p, err := syscall.UTF16PtrFromString(value)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
r := make([]uint16, 100)
|
|
for {
|
|
n, err := expandEnvironmentStrings(p, &r[0], uint32(len(r)))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if n <= uint32(len(r)) {
|
|
return syscall.UTF16ToString(r[:n]), nil
|
|
}
|
|
r = make([]uint16, n)
|
|
}
|
|
}
|
|
|
|
// GetStringsValue retrieves the []string value for the specified
|
|
// value name associated with an open key k. It also returns the value's type.
|
|
// If value does not exist, GetStringsValue returns ErrNotExist.
|
|
// If value is not MULTI_SZ, it will return the correct value
|
|
// type and ErrUnexpectedType.
|
|
func (k Key) GetStringsValue(name string) (val []string, valtype uint32, err error) {
|
|
data, typ, err2 := k.getValue(name, make([]byte, 64))
|
|
if err2 != nil {
|
|
return nil, typ, err2
|
|
}
|
|
if typ != MULTI_SZ {
|
|
return nil, typ, ErrUnexpectedType
|
|
}
|
|
if len(data) == 0 {
|
|
return nil, typ, nil
|
|
}
|
|
p := (*[1 << 29]uint16)(unsafe.Pointer(&data[0]))[: len(data)/2 : len(data)/2]
|
|
if len(p) == 0 {
|
|
return nil, typ, nil
|
|
}
|
|
if p[len(p)-1] == 0 {
|
|
p = p[:len(p)-1] // remove terminating null
|
|
}
|
|
val = make([]string, 0, 5)
|
|
from := 0
|
|
for i, c := range p {
|
|
if c == 0 {
|
|
val = append(val, string(utf16.Decode(p[from:i])))
|
|
from = i + 1
|
|
}
|
|
}
|
|
return val, typ, nil
|
|
}
|
|
|
|
// GetIntegerValue retrieves the integer value for the specified
|
|
// value name associated with an open key k. It also returns the value's type.
|
|
// If value does not exist, GetIntegerValue returns ErrNotExist.
|
|
// If value is not DWORD or QWORD, it will return the correct value
|
|
// type and ErrUnexpectedType.
|
|
func (k Key) GetIntegerValue(name string) (val uint64, valtype uint32, err error) {
|
|
data, typ, err2 := k.getValue(name, make([]byte, 8))
|
|
if err2 != nil {
|
|
return 0, typ, err2
|
|
}
|
|
switch typ {
|
|
case DWORD:
|
|
if len(data) != 4 {
|
|
return 0, typ, errors.New("DWORD value is not 4 bytes long")
|
|
}
|
|
var val32 uint32
|
|
copy((*[4]byte)(unsafe.Pointer(&val32))[:], data)
|
|
return uint64(val32), DWORD, nil
|
|
case QWORD:
|
|
if len(data) != 8 {
|
|
return 0, typ, errors.New("QWORD value is not 8 bytes long")
|
|
}
|
|
copy((*[8]byte)(unsafe.Pointer(&val))[:], data)
|
|
return val, QWORD, nil
|
|
default:
|
|
return 0, typ, ErrUnexpectedType
|
|
}
|
|
}
|
|
|
|
// GetBinaryValue retrieves the binary value for the specified
|
|
// value name associated with an open key k. It also returns the value's type.
|
|
// If value does not exist, GetBinaryValue returns ErrNotExist.
|
|
// If value is not BINARY, it will return the correct value
|
|
// type and ErrUnexpectedType.
|
|
func (k Key) GetBinaryValue(name string) (val []byte, valtype uint32, err error) {
|
|
data, typ, err2 := k.getValue(name, make([]byte, 64))
|
|
if err2 != nil {
|
|
return nil, typ, err2
|
|
}
|
|
if typ != BINARY {
|
|
return nil, typ, ErrUnexpectedType
|
|
}
|
|
return data, typ, nil
|
|
}
|
|
|
|
func (k Key) setValue(name string, valtype uint32, data []byte) error {
|
|
p, err := syscall.UTF16PtrFromString(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(data) == 0 {
|
|
return regSetValueEx(syscall.Handle(k), p, 0, valtype, nil, 0)
|
|
}
|
|
return regSetValueEx(syscall.Handle(k), p, 0, valtype, &data[0], uint32(len(data)))
|
|
}
|
|
|
|
// SetDWordValue sets the data and type of a name value
|
|
// under key k to value and DWORD.
|
|
func (k Key) SetDWordValue(name string, value uint32) error {
|
|
return k.setValue(name, DWORD, (*[4]byte)(unsafe.Pointer(&value))[:])
|
|
}
|
|
|
|
// SetQWordValue sets the data and type of a name value
|
|
// under key k to value and QWORD.
|
|
func (k Key) SetQWordValue(name string, value uint64) error {
|
|
return k.setValue(name, QWORD, (*[8]byte)(unsafe.Pointer(&value))[:])
|
|
}
|
|
|
|
func (k Key) setStringValue(name string, valtype uint32, value string) error {
|
|
v, err := syscall.UTF16FromString(value)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[: len(v)*2 : len(v)*2]
|
|
return k.setValue(name, valtype, buf)
|
|
}
|
|
|
|
// SetStringValue sets the data and type of a name value
|
|
// under key k to value and SZ. The value must not contain a zero byte.
|
|
func (k Key) SetStringValue(name, value string) error {
|
|
return k.setStringValue(name, SZ, value)
|
|
}
|
|
|
|
// SetExpandStringValue sets the data and type of a name value
|
|
// under key k to value and EXPAND_SZ. The value must not contain a zero byte.
|
|
func (k Key) SetExpandStringValue(name, value string) error {
|
|
return k.setStringValue(name, EXPAND_SZ, value)
|
|
}
|
|
|
|
// SetStringsValue sets the data and type of a name value
|
|
// under key k to value and MULTI_SZ. The value strings
|
|
// must not contain a zero byte.
|
|
func (k Key) SetStringsValue(name string, value []string) error {
|
|
ss := ""
|
|
for _, s := range value {
|
|
for i := 0; i < len(s); i++ {
|
|
if s[i] == 0 {
|
|
return errors.New("string cannot have 0 inside")
|
|
}
|
|
}
|
|
ss += s + "\x00"
|
|
}
|
|
v := utf16.Encode([]rune(ss + "\x00"))
|
|
buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[: len(v)*2 : len(v)*2]
|
|
return k.setValue(name, MULTI_SZ, buf)
|
|
}
|
|
|
|
// SetBinaryValue sets the data and type of a name value
|
|
// under key k to value and BINARY.
|
|
func (k Key) SetBinaryValue(name string, value []byte) error {
|
|
return k.setValue(name, BINARY, value)
|
|
}
|
|
|
|
// DeleteValue removes a named value from the key k.
|
|
func (k Key) DeleteValue(name string) error {
|
|
namePointer, err := syscall.UTF16PtrFromString(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return regDeleteValue(syscall.Handle(k), namePointer)
|
|
}
|
|
|
|
// ReadValueNames returns the value names of key k.
|
|
// The parameter n controls the number of returned names,
|
|
// analogous to the way os.File.Readdirnames works.
|
|
func (k Key) ReadValueNames(n int) ([]string, error) {
|
|
ki, err := k.Stat()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
names := make([]string, 0, ki.ValueCount)
|
|
buf := make([]uint16, ki.MaxValueNameLen+1) // extra room for terminating null character
|
|
loopItems:
|
|
for i := uint32(0); ; i++ {
|
|
if n > 0 {
|
|
if len(names) == n {
|
|
return names, nil
|
|
}
|
|
}
|
|
l := uint32(len(buf))
|
|
for {
|
|
err := regEnumValue(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)
|
|
if err == nil {
|
|
break
|
|
}
|
|
if err == syscall.ERROR_MORE_DATA {
|
|
// Double buffer size and try again.
|
|
l = uint32(2 * len(buf))
|
|
buf = make([]uint16, l)
|
|
continue
|
|
}
|
|
if err == _ERROR_NO_MORE_ITEMS {
|
|
break loopItems
|
|
}
|
|
return names, err
|
|
}
|
|
names = append(names, syscall.UTF16ToString(buf[:l]))
|
|
}
|
|
if n > len(names) {
|
|
return names, io.EOF
|
|
}
|
|
return names, nil
|
|
}
|