Black Lives Matter. Support the Equal Justice Initiative.

Source file src/internal/syscall/windows/registry/value.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
     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]))[: len(data)/2 : len(data)/2]
   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  			return syscall.UTF16ToString(r[:n]), nil
   189  		}
   190  		r = make([]uint16, n)
   191  	}
   192  }
   193  
   194  // GetStringsValue retrieves the []string value for the specified
   195  // value name associated with an open key k. It also returns the value's type.
   196  // If value does not exist, GetStringsValue returns ErrNotExist.
   197  // If value is not MULTI_SZ, it will return the correct value
   198  // type and ErrUnexpectedType.
   199  func (k Key) GetStringsValue(name string) (val []string, valtype uint32, err error) {
   200  	data, typ, err2 := k.getValue(name, make([]byte, 64))
   201  	if err2 != nil {
   202  		return nil, typ, err2
   203  	}
   204  	if typ != MULTI_SZ {
   205  		return nil, typ, ErrUnexpectedType
   206  	}
   207  	if len(data) == 0 {
   208  		return nil, typ, nil
   209  	}
   210  	p := (*[1 << 29]uint16)(unsafe.Pointer(&data[0]))[: len(data)/2 : len(data)/2]
   211  	if len(p) == 0 {
   212  		return nil, typ, nil
   213  	}
   214  	if p[len(p)-1] == 0 {
   215  		p = p[:len(p)-1] // remove terminating null
   216  	}
   217  	val = make([]string, 0, 5)
   218  	from := 0
   219  	for i, c := range p {
   220  		if c == 0 {
   221  			val = append(val, string(utf16.Decode(p[from:i])))
   222  			from = i + 1
   223  		}
   224  	}
   225  	return val, typ, nil
   226  }
   227  
   228  // GetIntegerValue retrieves the integer value for the specified
   229  // value name associated with an open key k. It also returns the value's type.
   230  // If value does not exist, GetIntegerValue returns ErrNotExist.
   231  // If value is not DWORD or QWORD, it will return the correct value
   232  // type and ErrUnexpectedType.
   233  func (k Key) GetIntegerValue(name string) (val uint64, valtype uint32, err error) {
   234  	data, typ, err2 := k.getValue(name, make([]byte, 8))
   235  	if err2 != nil {
   236  		return 0, typ, err2
   237  	}
   238  	switch typ {
   239  	case DWORD:
   240  		if len(data) != 4 {
   241  			return 0, typ, errors.New("DWORD value is not 4 bytes long")
   242  		}
   243  		return uint64(*(*uint32)(unsafe.Pointer(&data[0]))), DWORD, nil
   244  	case QWORD:
   245  		if len(data) != 8 {
   246  			return 0, typ, errors.New("QWORD value is not 8 bytes long")
   247  		}
   248  		return uint64(*(*uint64)(unsafe.Pointer(&data[0]))), QWORD, nil
   249  	default:
   250  		return 0, typ, ErrUnexpectedType
   251  	}
   252  }
   253  
   254  // GetBinaryValue retrieves the binary value for the specified
   255  // value name associated with an open key k. It also returns the value's type.
   256  // If value does not exist, GetBinaryValue returns ErrNotExist.
   257  // If value is not BINARY, it will return the correct value
   258  // type and ErrUnexpectedType.
   259  func (k Key) GetBinaryValue(name string) (val []byte, valtype uint32, err error) {
   260  	data, typ, err2 := k.getValue(name, make([]byte, 64))
   261  	if err2 != nil {
   262  		return nil, typ, err2
   263  	}
   264  	if typ != BINARY {
   265  		return nil, typ, ErrUnexpectedType
   266  	}
   267  	return data, typ, nil
   268  }
   269  
   270  func (k Key) setValue(name string, valtype uint32, data []byte) error {
   271  	p, err := syscall.UTF16PtrFromString(name)
   272  	if err != nil {
   273  		return err
   274  	}
   275  	if len(data) == 0 {
   276  		return regSetValueEx(syscall.Handle(k), p, 0, valtype, nil, 0)
   277  	}
   278  	return regSetValueEx(syscall.Handle(k), p, 0, valtype, &data[0], uint32(len(data)))
   279  }
   280  
   281  // SetDWordValue sets the data and type of a name value
   282  // under key k to value and DWORD.
   283  func (k Key) SetDWordValue(name string, value uint32) error {
   284  	return k.setValue(name, DWORD, (*[4]byte)(unsafe.Pointer(&value))[:])
   285  }
   286  
   287  // SetQWordValue sets the data and type of a name value
   288  // under key k to value and QWORD.
   289  func (k Key) SetQWordValue(name string, value uint64) error {
   290  	return k.setValue(name, QWORD, (*[8]byte)(unsafe.Pointer(&value))[:])
   291  }
   292  
   293  func (k Key) setStringValue(name string, valtype uint32, value string) error {
   294  	v, err := syscall.UTF16FromString(value)
   295  	if err != nil {
   296  		return err
   297  	}
   298  	buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[: len(v)*2 : len(v)*2]
   299  	return k.setValue(name, valtype, buf)
   300  }
   301  
   302  // SetStringValue sets the data and type of a name value
   303  // under key k to value and SZ. The value must not contain a zero byte.
   304  func (k Key) SetStringValue(name, value string) error {
   305  	return k.setStringValue(name, SZ, value)
   306  }
   307  
   308  // SetExpandStringValue sets the data and type of a name value
   309  // under key k to value and EXPAND_SZ. The value must not contain a zero byte.
   310  func (k Key) SetExpandStringValue(name, value string) error {
   311  	return k.setStringValue(name, EXPAND_SZ, value)
   312  }
   313  
   314  // SetStringsValue sets the data and type of a name value
   315  // under key k to value and MULTI_SZ. The value strings
   316  // must not contain a zero byte.
   317  func (k Key) SetStringsValue(name string, value []string) error {
   318  	ss := ""
   319  	for _, s := range value {
   320  		for i := 0; i < len(s); i++ {
   321  			if s[i] == 0 {
   322  				return errors.New("string cannot have 0 inside")
   323  			}
   324  		}
   325  		ss += s + "\x00"
   326  	}
   327  	v := utf16.Encode([]rune(ss + "\x00"))
   328  	buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[: len(v)*2 : len(v)*2]
   329  	return k.setValue(name, MULTI_SZ, buf)
   330  }
   331  
   332  // SetBinaryValue sets the data and type of a name value
   333  // under key k to value and BINARY.
   334  func (k Key) SetBinaryValue(name string, value []byte) error {
   335  	return k.setValue(name, BINARY, value)
   336  }
   337  
   338  // DeleteValue removes a named value from the key k.
   339  func (k Key) DeleteValue(name string) error {
   340  	return regDeleteValue(syscall.Handle(k), syscall.StringToUTF16Ptr(name))
   341  }
   342  
   343  // ReadValueNames returns the value names of key k.
   344  // The parameter n controls the number of returned names,
   345  // analogous to the way os.File.Readdirnames works.
   346  func (k Key) ReadValueNames(n int) ([]string, error) {
   347  	ki, err := k.Stat()
   348  	if err != nil {
   349  		return nil, err
   350  	}
   351  	names := make([]string, 0, ki.ValueCount)
   352  	buf := make([]uint16, ki.MaxValueNameLen+1) // extra room for terminating null character
   353  loopItems:
   354  	for i := uint32(0); ; i++ {
   355  		if n > 0 {
   356  			if len(names) == n {
   357  				return names, nil
   358  			}
   359  		}
   360  		l := uint32(len(buf))
   361  		for {
   362  			err := regEnumValue(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)
   363  			if err == nil {
   364  				break
   365  			}
   366  			if err == syscall.ERROR_MORE_DATA {
   367  				// Double buffer size and try again.
   368  				l = uint32(2 * len(buf))
   369  				buf = make([]uint16, l)
   370  				continue
   371  			}
   372  			if err == _ERROR_NO_MORE_ITEMS {
   373  				break loopItems
   374  			}
   375  			return names, err
   376  		}
   377  		names = append(names, syscall.UTF16ToString(buf[:l]))
   378  	}
   379  	if n > len(names) {
   380  		return names, io.EOF
   381  	}
   382  	return names, nil
   383  }
   384  

View as plain text