gtsocial-umbx

key.go (6502B)

---

 // 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
 // +build windows
 
 // Package registry provides access to the Windows registry.
 //
 // Here is a simple example, opening a registry key and reading a string value from it.
 //
 //	k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion`, registry.QUERY_VALUE)
 //	if err != nil {
 //		log.Fatal(err)
 //	}
 //	defer k.Close()
 //
 //	s, _, err := k.GetStringValue("SystemRoot")
 //	if err != nil {
 //		log.Fatal(err)
 //	}
 //	fmt.Printf("Windows system root is %q\n", s)
 package registry
 
 import (
 	"io"
 	"runtime"
 	"syscall"
 	"time"
 )
 
 const (
 	// Registry key security and access rights.
 	// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms724878.aspx
 	// for details.
 	ALL_ACCESS         = 0xf003f
 	CREATE_LINK        = 0x00020
 	CREATE_SUB_KEY     = 0x00004
 	ENUMERATE_SUB_KEYS = 0x00008
 	EXECUTE            = 0x20019
 	NOTIFY             = 0x00010
 	QUERY_VALUE        = 0x00001
 	READ               = 0x20019
 	SET_VALUE          = 0x00002
 	WOW64_32KEY        = 0x00200
 	WOW64_64KEY        = 0x00100
 	WRITE              = 0x20006
 )
 
 // Key is a handle to an open Windows registry key.
 // Keys can be obtained by calling OpenKey; there are
 // also some predefined root keys such as CURRENT_USER.
 // Keys can be used directly in the Windows API.
 type Key syscall.Handle
 
 const (
 	// Windows defines some predefined root keys that are always open.
 	// An application can use these keys as entry points to the registry.
 	// Normally these keys are used in OpenKey to open new keys,
 	// but they can also be used anywhere a Key is required.
 	CLASSES_ROOT     = Key(syscall.HKEY_CLASSES_ROOT)
 	CURRENT_USER     = Key(syscall.HKEY_CURRENT_USER)
 	LOCAL_MACHINE    = Key(syscall.HKEY_LOCAL_MACHINE)
 	USERS            = Key(syscall.HKEY_USERS)
 	CURRENT_CONFIG   = Key(syscall.HKEY_CURRENT_CONFIG)
 	PERFORMANCE_DATA = Key(syscall.HKEY_PERFORMANCE_DATA)
 )
 
 // Close closes open key k.
 func (k Key) Close() error {
 	return syscall.RegCloseKey(syscall.Handle(k))
 }
 
 // OpenKey opens a new key with path name relative to key k.
 // It accepts any open key, including CURRENT_USER and others,
 // and returns the new key and an error.
 // The access parameter specifies desired access rights to the
 // key to be opened.
 func OpenKey(k Key, path string, access uint32) (Key, error) {
 	p, err := syscall.UTF16PtrFromString(path)
 	if err != nil {
 		return 0, err
 	}
 	var subkey syscall.Handle
 	err = syscall.RegOpenKeyEx(syscall.Handle(k), p, 0, access, &subkey)
 	if err != nil {
 		return 0, err
 	}
 	return Key(subkey), nil
 }
 
 // OpenRemoteKey opens a predefined registry key on another
 // computer pcname. The key to be opened is specified by k, but
 // can only be one of LOCAL_MACHINE, PERFORMANCE_DATA or USERS.
 // If pcname is "", OpenRemoteKey returns local computer key.
 func OpenRemoteKey(pcname string, k Key) (Key, error) {
 	var err error
 	var p *uint16
 	if pcname != "" {
 		p, err = syscall.UTF16PtrFromString(`\\` + pcname)
 		if err != nil {
 			return 0, err
 		}
 	}
 	var remoteKey syscall.Handle
 	err = regConnectRegistry(p, syscall.Handle(k), &remoteKey)
 	if err != nil {
 		return 0, err
 	}
 	return Key(remoteKey), nil
 }
 
 // ReadSubKeyNames returns the names of subkeys of key k.
 // The parameter n controls the number of returned names,
 // analogous to the way os.File.Readdirnames works.
 func (k Key) ReadSubKeyNames(n int) ([]string, error) {
 	// RegEnumKeyEx must be called repeatedly and to completion.
 	// During this time, this goroutine cannot migrate away from
 	// its current thread. See https://golang.org/issue/49320 and
 	// https://golang.org/issue/49466.
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
 	names := make([]string, 0)
 	// Registry key size limit is 255 bytes and described there:
 	// https://msdn.microsoft.com/library/windows/desktop/ms724872.aspx
 	buf := make([]uint16, 256) //plus extra room for terminating zero byte
 loopItems:
 	for i := uint32(0); ; i++ {
 		if n > 0 {
 			if len(names) == n {
 				return names, nil
 			}
 		}
 		l := uint32(len(buf))
 		for {
 			err := syscall.RegEnumKeyEx(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
 }
 
 // CreateKey creates a key named path under open key k.
 // CreateKey returns the new key and a boolean flag that reports
 // whether the key already existed.
 // The access parameter specifies the access rights for the key
 // to be created.
 func CreateKey(k Key, path string, access uint32) (newk Key, openedExisting bool, err error) {
 	var h syscall.Handle
 	var d uint32
 	err = regCreateKeyEx(syscall.Handle(k), syscall.StringToUTF16Ptr(path),
 		0, nil, _REG_OPTION_NON_VOLATILE, access, nil, &h, &d)
 	if err != nil {
 		return 0, false, err
 	}
 	return Key(h), d == _REG_OPENED_EXISTING_KEY, nil
 }
 
 // DeleteKey deletes the subkey path of key k and its values.
 func DeleteKey(k Key, path string) error {
 	return regDeleteKey(syscall.Handle(k), syscall.StringToUTF16Ptr(path))
 }
 
 // A KeyInfo describes the statistics of a key. It is returned by Stat.
 type KeyInfo struct {
 	SubKeyCount     uint32
 	MaxSubKeyLen    uint32 // size of the key's subkey with the longest name, in Unicode characters, not including the terminating zero byte
 	ValueCount      uint32
 	MaxValueNameLen uint32 // size of the key's longest value name, in Unicode characters, not including the terminating zero byte
 	MaxValueLen     uint32 // longest data component among the key's values, in bytes
 	lastWriteTime   syscall.Filetime
 }
 
 // ModTime returns the key's last write time.
 func (ki *KeyInfo) ModTime() time.Time {
 	return time.Unix(0, ki.lastWriteTime.Nanoseconds())
 }
 
 // Stat retrieves information about the open key k.
 func (k Key) Stat() (*KeyInfo, error) {
 	var ki KeyInfo
 	err := syscall.RegQueryInfoKey(syscall.Handle(k), nil, nil, nil,
 		&ki.SubKeyCount, &ki.MaxSubKeyLen, nil, &ki.ValueCount,
 		&ki.MaxValueNameLen, &ki.MaxValueLen, nil, &ki.lastWriteTime)
 	if err != nil {
 		return nil, err
 	}
 	return &ki, nil
 }