vendor/golang.org/x/sys/windows/registry/value.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
   8
   9 import (
  10         "errors"
  11         "io"
  12         "syscall"
  13         "unicode/utf16"
  14         "unsafe"
  15 )
  16
  17 const (
  18         // Registry value types.
  19         NONE                       = 0
  20         SZ                         = 1
  21         EXPAND_SZ                  = 2
  22         BINARY                     = 3
  23         DWORD                      = 4
  24         DWORD_BIG_ENDIAN           = 5
  25         LINK                       = 6
  26         MULTI_SZ                   = 7
  27         RESOURCE_LIST              = 8
  28         FULL_RESOURCE_DESCRIPTOR   = 9
  29         RESOURCE_REQUIREMENTS_LIST = 10
  30         QWORD                      = 11
  31 )
  32
  33 var (
  34         // ErrShortBuffer is returned when the buffer was too short for the operation.
  35         ErrShortBuffer = syscall.ERROR_MORE_DATA
  36
  37         // ErrNotExist is returned when a registry key or value does not exist.
  38         ErrNotExist = syscall.ERROR_FILE_NOT_FOUND
  39
  40         // ErrUnexpectedType is returned by Get*Value when the value's type was unexpected.
  41         ErrUnexpectedType = errors.New("unexpected key value type")
  42 )
  43
  44 // GetValue retrieves the type and data for the specified value associated
  45 // with an open key k. It fills up buffer buf and returns the retrieved
  46 // byte count n. If buf is too small to fit the stored value it returns
  47 // ErrShortBuffer error along with the required buffer size n.
  48 // If no buffer is provided, it returns true and actual buffer size n.
  49 // If no buffer is provided, GetValue returns the value's type only.
  50 // If the value does not exist, the error returned is ErrNotExist.
  51 //
  52 // GetValue is a low level function. If value's type is known, use the appropriate
  53 // Get*Value function instead.
  54 func (k Key) GetValue(name string, buf []byte) (n int, valtype uint32, err error) {
  55         pname, err := syscall.UTF16PtrFromString(name)
  56         if err != nil {
  57                 return 0, 0, err
  58         }
  59         var pbuf *byte
  60         if len(buf) > 0 {
  61                 pbuf = (*byte)(unsafe.Pointer(&buf[0]))
  62         }
  63         l := uint32(len(buf))
  64         err = syscall.RegQueryValueEx(syscall.Handle(k), pname, nil, &valtype, pbuf, &l)
  65         if err != nil {
  66                 return int(l), valtype, err
  67         }
  68         return int(l), valtype, nil
  69 }
  70
  71 func (k Key) getValue(name string, buf []byte) (date []byte, valtype uint32, err error) {
  72         p, err := syscall.UTF16PtrFromString(name)
  73         if err != nil {
  74                 return nil, 0, err
  75         }
  76         var t uint32
  77         n := uint32(len(buf))
  78         for {
  79                 err = syscall.RegQueryValueEx(syscall.Handle(k), p, nil, &t, (*byte)(unsafe.Pointer(&buf[0])), &n)
  80                 if err == nil {
  81                         return buf[:n], t, nil
  82                 }
  83                 if err != syscall.ERROR_MORE_DATA {
  84                         return nil, 0, err
  85                 }
  86                 if n <= uint32(len(buf)) {
  87                         return nil, 0, err
  88                 }
  89                 buf = make([]byte, n)
  90         }
  91 }
  92
  93 // GetStringValue retrieves the string value for the specified
  94 // value name associated with an open key k. It also returns the value's type.
  95 // If value does not exist, GetStringValue returns ErrNotExist.
  96 // If value is not SZ or EXPAND_SZ, it will return the correct value
  97 // type and ErrUnexpectedType.
  98 func (k Key) GetStringValue(name string) (val string, valtype uint32, err error) {
  99         data, typ, err2 := k.getValue(name, make([]byte, 64))
 100         if err2 != nil {
 101                 return "", typ, err2
 102         }
 103         switch typ {
 104         case SZ, EXPAND_SZ:
 105         default:
 106                 return "", typ, ErrUnexpectedType
 107         }
 108         if len(data) == 0 {
 109                 return "", typ, nil
 110         }
 111         u := (*[1 << 29]uint16)(unsafe.Pointer(&data[0]))[:]
 112         return syscall.UTF16ToString(u), typ, nil
 113 }
 114
 115 // GetMUIStringValue retrieves the localized string value for
 116 // the specified value name associated with an open key k.
 117 // If the value name doesn't exist or the localized string value
 118 // can't be resolved, GetMUIStringValue returns ErrNotExist.
 119 // GetMUIStringValue panics if the system doesn't support
 120 // regLoadMUIString; use LoadRegLoadMUIString to check if
 121 // regLoadMUIString is supported before calling this function.
 122 func (k Key) GetMUIStringValue(name string) (string, error) {
 123         pname, err := syscall.UTF16PtrFromString(name)
 124         if err != nil {
 125                 return "", err
 126         }
 127
 128         buf := make([]uint16, 1024)
 129         var buflen uint32
 130         var pdir *uint16
 131
 132         err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
 133         if err == syscall.ERROR_FILE_NOT_FOUND { // Try fallback path
 134
 135                 // Try to resolve the string value using the system directory as
 136                 // a DLL search path; this assumes the string value is of the form
 137                 // @[path]\dllname,-strID but with no path given, e.g. @tzres.dll,-320.
 138
 139                 // This approach works with tzres.dll but may have to be revised
 140                 // in the future to allow callers to provide custom search paths.
 141
 142                 var s string
 143                 s, err = ExpandString("%SystemRoot%\\system32\\")
 144                 if err != nil {
 145                         return "", err
 146                 }
 147                 pdir, err = syscall.UTF16PtrFromString(s)
 148                 if err != nil {
 149                         return "", err
 150                 }
 151
 152                 err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
 153         }
 154
 155         for err == syscall.ERROR_MORE_DATA { // Grow buffer if needed
 156                 if buflen <= uint32(len(buf)) {
 157                         break // Buffer not growing, assume race; break
 158                 }
 159                 buf = make([]uint16, buflen)
 160                 err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
 161         }
 162
 163         if err != nil {
 164                 return "", err
 165         }
 166
 167         return syscall.UTF16ToString(buf), nil
 168 }
 169
 170 // ExpandString expands environment-variable strings and replaces
 171 // them with the values defined for the current user.
 172 // Use ExpandString to expand EXPAND_SZ strings.
 173 func ExpandString(value string) (string, error) {
 174         if value == "" {
 175                 return "", nil
 176         }
 177         p, err := syscall.UTF16PtrFromString(value)
 178         if err != nil {
 179                 return "", err
 180         }
 181         r := make([]uint16, 100)
 182         for {
 183                 n, err := expandEnvironmentStrings(p, &r[0], uint32(len(r)))
 184                 if err != nil {
 185                         return "", err
 186                 }
 187                 if n <= uint32(len(r)) {
 188                         u := (*[1 << 29]uint16)(unsafe.Pointer(&r[0]))[:]
 189                         return syscall.UTF16ToString(u), nil
 190                 }
 191                 r = make([]uint16, n)
 192         }
 193 }
 194
 195 // GetStringsValue retrieves the []string value for the specified
 196 // value name associated with an open key k. It also returns the value's type.
 197 // If value does not exist, GetStringsValue returns ErrNotExist.
 198 // If value is not MULTI_SZ, it will return the correct value
 199 // type and ErrUnexpectedType.
 200 func (k Key) GetStringsValue(name string) (val []string, valtype uint32, err error) {
 201         data, typ, err2 := k.getValue(name, make([]byte, 64))
 202         if err2 != nil {
 203                 return nil, typ, err2
 204         }
 205         if typ != MULTI_SZ {
 206                 return nil, typ, ErrUnexpectedType
 207         }
 208         if len(data) == 0 {
 209                 return nil, typ, nil
 210         }
 211         p := (*[1 << 29]uint16)(unsafe.Pointer(&data[0]))[:len(data)/2]
 212         if len(p) == 0 {
 213                 return nil, typ, nil
 214         }
 215         if p[len(p)-1] == 0 {
 216                 p = p[:len(p)-1] // remove terminating null
 217         }
 218         val = make([]string, 0, 5)
 219         from := 0
 220         for i, c := range p {
 221                 if c == 0 {
 222                         val = append(val, string(utf16.Decode(p[from:i])))
 223                         from = i + 1
 224                 }
 225         }
 226         return val, typ, nil
 227 }
 228
 229 // GetIntegerValue retrieves the integer value for the specified
 230 // value name associated with an open key k. It also returns the value's type.
 231 // If value does not exist, GetIntegerValue returns ErrNotExist.
 232 // If value is not DWORD or QWORD, it will return the correct value
 233 // type and ErrUnexpectedType.
 234 func (k Key) GetIntegerValue(name string) (val uint64, valtype uint32, err error) {
 235         data, typ, err2 := k.getValue(name, make([]byte, 8))
 236         if err2 != nil {
 237                 return 0, typ, err2
 238         }
 239         switch typ {
 240         case DWORD:
 241                 if len(data) != 4 {
 242                         return 0, typ, errors.New("DWORD value is not 4 bytes long")
 243                 }
 244                 return uint64(*(*uint32)(unsafe.Pointer(&data[0]))), DWORD, nil
 245         case QWORD:
 246                 if len(data) != 8 {
 247                         return 0, typ, errors.New("QWORD value is not 8 bytes long")
 248                 }
 249                 return uint64(*(*uint64)(unsafe.Pointer(&data[0]))), QWORD, nil
 250         default:
 251                 return 0, typ, ErrUnexpectedType
 252         }
 253 }
 254
 255 // GetBinaryValue retrieves the binary value for the specified
 256 // value name associated with an open key k. It also returns the value's type.
 257 // If value does not exist, GetBinaryValue returns ErrNotExist.
 258 // If value is not BINARY, it will return the correct value
 259 // type and ErrUnexpectedType.
 260 func (k Key) GetBinaryValue(name string) (val []byte, valtype uint32, err error) {
 261         data, typ, err2 := k.getValue(name, make([]byte, 64))
 262         if err2 != nil {
 263                 return nil, typ, err2
 264         }
 265         if typ != BINARY {
 266                 return nil, typ, ErrUnexpectedType
 267         }
 268         return data, typ, nil
 269 }
 270
 271 func (k Key) setValue(name string, valtype uint32, data []byte) error {
 272         p, err := syscall.UTF16PtrFromString(name)
 273         if err != nil {
 274                 return err
 275         }
 276         if len(data) == 0 {
 277                 return regSetValueEx(syscall.Handle(k), p, 0, valtype, nil, 0)
 278         }
 279         return regSetValueEx(syscall.Handle(k), p, 0, valtype, &data[0], uint32(len(data)))
 280 }
 281
 282 // SetDWordValue sets the data and type of a name value
 283 // under key k to value and DWORD.
 284 func (k Key) SetDWordValue(name string, value uint32) error {
 285         return k.setValue(name, DWORD, (*[4]byte)(unsafe.Pointer(&value))[:])
 286 }
 287
 288 // SetQWordValue sets the data and type of a name value
 289 // under key k to value and QWORD.
 290 func (k Key) SetQWordValue(name string, value uint64) error {
 291         return k.setValue(name, QWORD, (*[8]byte)(unsafe.Pointer(&value))[:])
 292 }
 293
 294 func (k Key) setStringValue(name string, valtype uint32, value string) error {
 295         v, err := syscall.UTF16FromString(value)
 296         if err != nil {
 297                 return err
 298         }
 299         buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[:len(v)*2]
 300         return k.setValue(name, valtype, buf)
 301 }
 302
 303 // SetStringValue sets the data and type of a name value
 304 // under key k to value and SZ. The value must not contain a zero byte.
 305 func (k Key) SetStringValue(name, value string) error {
 306         return k.setStringValue(name, SZ, value)
 307 }
 308
 309 // SetExpandStringValue sets the data and type of a name value
 310 // under key k to value and EXPAND_SZ. The value must not contain a zero byte.
 311 func (k Key) SetExpandStringValue(name, value string) error {
 312         return k.setStringValue(name, EXPAND_SZ, value)
 313 }
 314
 315 // SetStringsValue sets the data and type of a name value
 316 // under key k to value and MULTI_SZ. The value strings
 317 // must not contain a zero byte.
 318 func (k Key) SetStringsValue(name string, value []string) error {
 319         ss := ""
 320         for _, s := range value {
 321                 for i := 0; i < len(s); i++ {
 322                         if s[i] == 0 {
 323                                 return errors.New("string cannot have 0 inside")
 324                         }
 325                 }
 326                 ss += s + "\x00"
 327         }
 328         v := utf16.Encode([]rune(ss + "\x00"))
 329         buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[:len(v)*2]
 330         return k.setValue(name, MULTI_SZ, buf)
 331 }
 332
 333 // SetBinaryValue sets the data and type of a name value
 334 // under key k to value and BINARY.
 335 func (k Key) SetBinaryValue(name string, value []byte) error {
 336         return k.setValue(name, BINARY, value)
 337 }
 338
 339 // DeleteValue removes a named value from the key k.
 340 func (k Key) DeleteValue(name string) error {
 341         return regDeleteValue(syscall.Handle(k), syscall.StringToUTF16Ptr(name))
 342 }
 343
 344 // ReadValueNames returns the value names of key k.
 345 // The parameter n controls the number of returned names,
 346 // analogous to the way os.File.Readdirnames works.
 347 func (k Key) ReadValueNames(n int) ([]string, error) {
 348         ki, err := k.Stat()
 349         if err != nil {
 350                 return nil, err
 351         }
 352         names := make([]string, 0, ki.ValueCount)
 353         buf := make([]uint16, ki.MaxValueNameLen+1) // extra room for terminating null character
 354 loopItems:
 355         for i := uint32(0); ; i++ {
 356                 if n > 0 {
 357                         if len(names) == n {
 358                                 return names, nil
 359                         }
 360                 }
 361                 l := uint32(len(buf))
 362                 for {
 363                         err := regEnumValue(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)
 364                         if err == nil {
 365                                 break
 366                         }
 367                         if err == syscall.ERROR_MORE_DATA {
 368                                 // Double buffer size and try again.
 369                                 l = uint32(2 * len(buf))
 370                                 buf = make([]uint16, l)
 371                                 continue
 372                         }
 373                         if err == _ERROR_NO_MORE_ITEMS {
 374                                 break loopItems
 375                         }
 376                         return names, err
 377                 }
 378                 names = append(names, syscall.UTF16ToString(buf[:l]))
 379         }
 380         if n > len(names) {
 381                 return names, io.EOF
 382         }
 383         return names, nil
 384 }