Source file src/internal/syscall/windows/registry/key.go

     1	// Copyright 2015 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// +build windows
     6	
     7	// Package registry provides access to the Windows registry.
     8	//
     9	// Here is a simple example, opening a registry key and reading a string value from it.
    10	//
    11	//	k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion`, registry.QUERY_VALUE)
    12	//	if err != nil {
    13	//		log.Fatal(err)
    14	//	}
    15	//	defer k.Close()
    16	//
    17	//	s, _, err := k.GetStringValue("SystemRoot")
    18	//	if err != nil {
    19	//		log.Fatal(err)
    20	//	}
    21	//	fmt.Printf("Windows system root is %q\n", s)
    22	//
    23	// NOTE: This package is a copy of golang.org/x/sys/windows/registry
    24	// with KeyInfo.ModTime removed to prevent dependency cycles.
    25	//
    26	package registry
    27	
    28	import (
    29		"io"
    30		"syscall"
    31	)
    32	
    33	const (
    34		// Registry key security and access rights.
    35		// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms724878.aspx
    36		// for details.
    37		ALL_ACCESS         = 0xf003f
    38		CREATE_LINK        = 0x00020
    39		CREATE_SUB_KEY     = 0x00004
    40		ENUMERATE_SUB_KEYS = 0x00008
    41		EXECUTE            = 0x20019
    42		NOTIFY             = 0x00010
    43		QUERY_VALUE        = 0x00001
    44		READ               = 0x20019
    45		SET_VALUE          = 0x00002
    46		WOW64_32KEY        = 0x00200
    47		WOW64_64KEY        = 0x00100
    48		WRITE              = 0x20006
    49	)
    50	
    51	// Key is a handle to an open Windows registry key.
    52	// Keys can be obtained by calling OpenKey; there are
    53	// also some predefined root keys such as CURRENT_USER.
    54	// Keys can be used directly in the Windows API.
    55	type Key syscall.Handle
    56	
    57	const (
    58		// Windows defines some predefined root keys that are always open.
    59		// An application can use these keys as entry points to the registry.
    60		// Normally these keys are used in OpenKey to open new keys,
    61		// but they can also be used anywhere a Key is required.
    62		CLASSES_ROOT   = Key(syscall.HKEY_CLASSES_ROOT)
    63		CURRENT_USER   = Key(syscall.HKEY_CURRENT_USER)
    64		LOCAL_MACHINE  = Key(syscall.HKEY_LOCAL_MACHINE)
    65		USERS          = Key(syscall.HKEY_USERS)
    66		CURRENT_CONFIG = Key(syscall.HKEY_CURRENT_CONFIG)
    67	)
    68	
    69	// Close closes open key k.
    70	func (k Key) Close() error {
    71		return syscall.RegCloseKey(syscall.Handle(k))
    72	}
    73	
    74	// OpenKey opens a new key with path name relative to key k.
    75	// It accepts any open key, including CURRENT_USER and others,
    76	// and returns the new key and an error.
    77	// The access parameter specifies desired access rights to the
    78	// key to be opened.
    79	func OpenKey(k Key, path string, access uint32) (Key, error) {
    80		p, err := syscall.UTF16PtrFromString(path)
    81		if err != nil {
    82			return 0, err
    83		}
    84		var subkey syscall.Handle
    85		err = syscall.RegOpenKeyEx(syscall.Handle(k), p, 0, access, &subkey)
    86		if err != nil {
    87			return 0, err
    88		}
    89		return Key(subkey), nil
    90	}
    91	
    92	// ReadSubKeyNames returns the names of subkeys of key k.
    93	// The parameter n controls the number of returned names,
    94	// analogous to the way os.File.Readdirnames works.
    95	func (k Key) ReadSubKeyNames(n int) ([]string, error) {
    96		names := make([]string, 0)
    97		// Registry key size limit is 255 bytes and described there:
    98		// https://msdn.microsoft.com/library/windows/desktop/ms724872.aspx
    99		buf := make([]uint16, 256) //plus extra room for terminating zero byte
   100	loopItems:
   101		for i := uint32(0); ; i++ {
   102			if n > 0 {
   103				if len(names) == n {
   104					return names, nil
   105				}
   106			}
   107			l := uint32(len(buf))
   108			for {
   109				err := syscall.RegEnumKeyEx(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)
   110				if err == nil {
   111					break
   112				}
   113				if err == syscall.ERROR_MORE_DATA {
   114					// Double buffer size and try again.
   115					l = uint32(2 * len(buf))
   116					buf = make([]uint16, l)
   117					continue
   118				}
   119				if err == _ERROR_NO_MORE_ITEMS {
   120					break loopItems
   121				}
   122				return names, err
   123			}
   124			names = append(names, syscall.UTF16ToString(buf[:l]))
   125		}
   126		if n > len(names) {
   127			return names, io.EOF
   128		}
   129		return names, nil
   130	}
   131	
   132	// CreateKey creates a key named path under open key k.
   133	// CreateKey returns the new key and a boolean flag that reports
   134	// whether the key already existed.
   135	// The access parameter specifies the access rights for the key
   136	// to be created.
   137	func CreateKey(k Key, path string, access uint32) (newk Key, openedExisting bool, err error) {
   138		var h syscall.Handle
   139		var d uint32
   140		err = regCreateKeyEx(syscall.Handle(k), syscall.StringToUTF16Ptr(path),
   141			0, nil, _REG_OPTION_NON_VOLATILE, access, nil, &h, &d)
   142		if err != nil {
   143			return 0, false, err
   144		}
   145		return Key(h), d == _REG_OPENED_EXISTING_KEY, nil
   146	}
   147	
   148	// DeleteKey deletes the subkey path of key k and its values.
   149	func DeleteKey(k Key, path string) error {
   150		return regDeleteKey(syscall.Handle(k), syscall.StringToUTF16Ptr(path))
   151	}
   152	
   153	// A KeyInfo describes the statistics of a key. It is returned by Stat.
   154	type KeyInfo struct {
   155		SubKeyCount     uint32
   156		MaxSubKeyLen    uint32 // size of the key's subkey with the longest name, in Unicode characters, not including the terminating zero byte
   157		ValueCount      uint32
   158		MaxValueNameLen uint32 // size of the key's longest value name, in Unicode characters, not including the terminating zero byte
   159		MaxValueLen     uint32 // longest data component among the key's values, in bytes
   160		lastWriteTime   syscall.Filetime
   161	}
   162	
   163	// Stat retrieves information about the open key k.
   164	func (k Key) Stat() (*KeyInfo, error) {
   165		var ki KeyInfo
   166		err := syscall.RegQueryInfoKey(syscall.Handle(k), nil, nil, nil,
   167			&ki.SubKeyCount, &ki.MaxSubKeyLen, nil, &ki.ValueCount,
   168			&ki.MaxValueNameLen, &ki.MaxValueLen, nil, &ki.lastWriteTime)
   169		if err != nil {
   170			return nil, err
   171		}
   172		return &ki, nil
   173	}
   174	

View as plain text