Black Lives Matter. Support the Equal Justice Initiative.

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

Documentation: internal/syscall/windows/registry

     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