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// 23package registry 24 25import ( 26 "io" 27 "syscall" 28 "time" 29) 30 31const ( 32 // Registry key security and access rights. 33 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms724878.aspx 34 // for details. 35 ALL_ACCESS = 0xf003f 36 CREATE_LINK = 0x00020 37 CREATE_SUB_KEY = 0x00004 38 ENUMERATE_SUB_KEYS = 0x00008 39 EXECUTE = 0x20019 40 NOTIFY = 0x00010 41 QUERY_VALUE = 0x00001 42 READ = 0x20019 43 SET_VALUE = 0x00002 44 WOW64_32KEY = 0x00200 45 WOW64_64KEY = 0x00100 46 WRITE = 0x20006 47) 48 49// Key is a handle to an open Windows registry key. 50// Keys can be obtained by calling OpenKey; there are 51// also some predefined root keys such as CURRENT_USER. 52// Keys can be used directly in the Windows API. 53type Key syscall.Handle 54 55const ( 56 // Windows defines some predefined root keys that are always open. 57 // An application can use these keys as entry points to the registry. 58 // Normally these keys are used in OpenKey to open new keys, 59 // but they can also be used anywhere a Key is required. 60 CLASSES_ROOT = Key(syscall.HKEY_CLASSES_ROOT) 61 CURRENT_USER = Key(syscall.HKEY_CURRENT_USER) 62 LOCAL_MACHINE = Key(syscall.HKEY_LOCAL_MACHINE) 63 USERS = Key(syscall.HKEY_USERS) 64 CURRENT_CONFIG = Key(syscall.HKEY_CURRENT_CONFIG) 65 PERFORMANCE_DATA = Key(syscall.HKEY_PERFORMANCE_DATA) 66) 67 68// Close closes open key k. 69func (k Key) Close() error { 70 return syscall.RegCloseKey(syscall.Handle(k)) 71} 72 73// OpenKey opens a new key with path name relative to key k. 74// It accepts any open key, including CURRENT_USER and others, 75// and returns the new key and an error. 76// The access parameter specifies desired access rights to the 77// key to be opened. 78func OpenKey(k Key, path string, access uint32) (Key, error) { 79 p, err := syscall.UTF16PtrFromString(path) 80 if err != nil { 81 return 0, err 82 } 83 var subkey syscall.Handle 84 err = syscall.RegOpenKeyEx(syscall.Handle(k), p, 0, access, &subkey) 85 if err != nil { 86 return 0, err 87 } 88 return Key(subkey), nil 89} 90 91// OpenRemoteKey opens a predefined registry key on another 92// computer pcname. The key to be opened is specified by k, but 93// can only be one of LOCAL_MACHINE, PERFORMANCE_DATA or USERS. 94// If pcname is "", OpenRemoteKey returns local computer key. 95func OpenRemoteKey(pcname string, k Key) (Key, error) { 96 var err error 97 var p *uint16 98 if pcname != "" { 99 p, err = syscall.UTF16PtrFromString(`\\` + pcname) 100 if err != nil { 101 return 0, err 102 } 103 } 104 var remoteKey syscall.Handle 105 err = regConnectRegistry(p, syscall.Handle(k), &remoteKey) 106 if err != nil { 107 return 0, err 108 } 109 return Key(remoteKey), nil 110} 111 112// ReadSubKeyNames returns the names of subkeys of key k. 113// The parameter n controls the number of returned names, 114// analogous to the way os.File.Readdirnames works. 115func (k Key) ReadSubKeyNames(n int) ([]string, error) { 116 names := make([]string, 0) 117 // Registry key size limit is 255 bytes and described there: 118 // https://msdn.microsoft.com/library/windows/desktop/ms724872.aspx 119 buf := make([]uint16, 256) //plus extra room for terminating zero byte 120loopItems: 121 for i := uint32(0); ; i++ { 122 if n > 0 { 123 if len(names) == n { 124 return names, nil 125 } 126 } 127 l := uint32(len(buf)) 128 for { 129 err := syscall.RegEnumKeyEx(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil) 130 if err == nil { 131 break 132 } 133 if err == syscall.ERROR_MORE_DATA { 134 // Double buffer size and try again. 135 l = uint32(2 * len(buf)) 136 buf = make([]uint16, l) 137 continue 138 } 139 if err == _ERROR_NO_MORE_ITEMS { 140 break loopItems 141 } 142 return names, err 143 } 144 names = append(names, syscall.UTF16ToString(buf[:l])) 145 } 146 if n > len(names) { 147 return names, io.EOF 148 } 149 return names, nil 150} 151 152// CreateKey creates a key named path under open key k. 153// CreateKey returns the new key and a boolean flag that reports 154// whether the key already existed. 155// The access parameter specifies the access rights for the key 156// to be created. 157func CreateKey(k Key, path string, access uint32) (newk Key, openedExisting bool, err error) { 158 var h syscall.Handle 159 var d uint32 160 err = regCreateKeyEx(syscall.Handle(k), syscall.StringToUTF16Ptr(path), 161 0, nil, _REG_OPTION_NON_VOLATILE, access, nil, &h, &d) 162 if err != nil { 163 return 0, false, err 164 } 165 return Key(h), d == _REG_OPENED_EXISTING_KEY, nil 166} 167 168// DeleteKey deletes the subkey path of key k and its values. 169func DeleteKey(k Key, path string) error { 170 return regDeleteKey(syscall.Handle(k), syscall.StringToUTF16Ptr(path)) 171} 172 173// A KeyInfo describes the statistics of a key. It is returned by Stat. 174type KeyInfo struct { 175 SubKeyCount uint32 176 MaxSubKeyLen uint32 // size of the key's subkey with the longest name, in Unicode characters, not including the terminating zero byte 177 ValueCount uint32 178 MaxValueNameLen uint32 // size of the key's longest value name, in Unicode characters, not including the terminating zero byte 179 MaxValueLen uint32 // longest data component among the key's values, in bytes 180 lastWriteTime syscall.Filetime 181} 182 183// ModTime returns the key's last write time. 184func (ki *KeyInfo) ModTime() time.Time { 185 return time.Unix(0, ki.lastWriteTime.Nanoseconds()) 186} 187 188// Stat retrieves information about the open key k. 189func (k Key) Stat() (*KeyInfo, error) { 190 var ki KeyInfo 191 err := syscall.RegQueryInfoKey(syscall.Handle(k), nil, nil, nil, 192 &ki.SubKeyCount, &ki.MaxSubKeyLen, nil, &ki.ValueCount, 193 &ki.MaxValueNameLen, &ki.MaxValueLen, nil, &ki.lastWriteTime) 194 if err != nil { 195 return nil, err 196 } 197 return &ki, nil 198} 199