@@ -9,6 +9,7 @@ import (

 	"path/filepath"

 	"strconv"

 	"strings"

+	"time"

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/daemon/execdriver"

@@ -223,10 +224,32 @@ func (d *Driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, hooks execd

 	configuration := string(configurationb)

-	err = hcsshim.CreateComputeSystem(c.ID, configuration)

-	if err != nil {

-		logrus.Debugln("Failed to create temporary container ", err)

-		return execdriver.ExitStatus{ExitCode: -1}, err

+	// TODO Windows TP5 timeframe. Remove when TP4 is no longer supported.

+	// The following a workaround for Windows TP4 which has a networking

+	// bug which fairly frequently returns an error. Back off and retry.

+	maxAttempts := 1

+	if TP4RetryHack {

+		maxAttempts = 5

+	}

+	i := 0

+	for i < maxAttempts {

+		i++

+		err = hcsshim.CreateComputeSystem(c.ID, configuration)

+		if err != nil {

+			if TP4RetryHack {

+				if !strings.Contains(err.Error(), `Win32 API call returned error r1=2147746291`) && // Invalid class string

+					!strings.Contains(err.Error(), `Win32 API call returned error r1=2147943568`) && // Element not found

+					!strings.Contains(err.Error(), `Win32 API call returned error r1=2147942402`) && // The system cannot find the file specified

+					!strings.Contains(err.Error(), `Win32 API call returned error r1=2147943622`) { // The network is not present or not started

+					logrus.Debugln("Failed to create temporary container ", err)

+					return execdriver.ExitStatus{ExitCode: -1}, err

+				}

+				logrus.Warnf("Invoking Windows TP4 retry hack (%d of %d)", i, maxAttempts-1)

+				time.Sleep(50 * time.Millisecond)

+			}

+		} else {

+			break

+		}

 	}

 	// Start the container

@@ -4,6 +4,7 @@ package windows

 import (

 	"fmt"

+	"strconv"

 	"strings"

 	"sync"

@@ -12,8 +13,13 @@ import (

 	"github.com/docker/docker/dockerversion"

 	"github.com/docker/docker/pkg/parsers"

 	"github.com/docker/engine-api/types/container"

+	"golang.org/x/sys/windows/registry"

 )

+// TP4RetryHack is a hack to retry CreateComputeSystem if it fails with

+// known return codes from Windows due to bugs in TP4.

+var TP4RetryHack bool

+

 // This is a daemon development variable only and should not be

 // used for running production containers on Windows.

 var dummyMode bool

@@ -89,6 +95,37 @@ func NewDriver(root string, options []string) (*Driver, error) {

 		}

 	}

+	// TODO Windows TP5 timeframe. Remove this next block of code once TP4

+	// is no longer supported. Also remove the workaround in run.go.

+	//

+	// Hack for TP4 - determine the version of Windows from the registry.

+	// This overcomes an issue on TP4 which causes CreateComputeSystem to

+	// intermittently fail. It's predominantly here to make Windows to Windows

+	// CI more reliable.

+	TP4RetryHack = false

+	k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion`, registry.QUERY_VALUE)

+	if err != nil {

+		return &Driver{}, err

+	}

+	defer k.Close()

+

+	s, _, err := k.GetStringValue("BuildLab")

+	if err != nil {

+		return &Driver{}, err

+	}

+	parts := strings.Split(s, ".")

+	if len(parts) < 1 {

+		return &Driver{}, err

+	}

+	var val int

+	if val, err = strconv.Atoi(parts[0]); err != nil {

+		return &Driver{}, err

+	}

+	if val < 14250 {

+		TP4RetryHack = true

+	}

+	// End of Windows TP4 hack

+

 	return &Driver{

 		root:             root,

 		activeContainers: make(map[string]*activeContainer),

@@ -20,6 +20,7 @@ clone git github.com/mistifyio/go-zfs v2.1.1

 clone git github.com/tchap/go-patricia v2.1.0

 clone git github.com/vdemeester/shakers 3c10293ce22b900c27acad7b28656196fcc2f73b

 clone git golang.org/x/net 47990a1ba55743e6ef1affd3a14e5bac8553615d https://github.com/golang/net.git

+clone git golang.org/x/sys eb2c74142fd19a79b3f237334c7384d5167b1b46 https://github.com/golang/sys.git

 clone git github.com/docker/go-units 651fc226e7441360384da338d0fd37f2440ffbe3

 clone git github.com/docker/go-connections v0.1.2

 clone git github.com/docker/engine-api bdbab71ec21209ef56dffdbe42c9d21843c30862

@@ -17,21 +17,17 @@ import (

 )

 func (s *DockerSuite) TestPsListContainersBase(c *check.C) {

-	// TODO Windows CI (TP5 timeframe). This test has a very high likelyhood

-	// of hitting a known bug in TP4. Hence disabling for now until TP5

-	// is available.

-	testRequires(c, DaemonIsLinux)

-	out, _ := dockerCmd(c, "run", "-d", "busybox", "top")

+	out, _ := runSleepingContainer(c, "-d")

 	firstID := strings.TrimSpace(out)

-	out, _ = dockerCmd(c, "run", "-d", "busybox", "top")

+	out, _ = runSleepingContainer(c, "-d")

 	secondID := strings.TrimSpace(out)

 	// not long running

 	out, _ = dockerCmd(c, "run", "-d", "busybox", "true")

 	thirdID := strings.TrimSpace(out)

-	out, _ = dockerCmd(c, "run", "-d", "busybox", "top")

+	out, _ = runSleepingContainer(c, "-d")

 	fourthID := strings.TrimSpace(out)

 	// make sure the second is running

@@ -172,10 +168,6 @@ func (s *DockerSuite) TestPsListContainersSize(c *check.C) {

 }

 func (s *DockerSuite) TestPsListContainersFilterStatus(c *check.C) {

-	// TODO Windows CI (TP5 timeframe). This test has a very high likelyhood

-	// of hitting a known bug in TP4. Hence disabling for now until TP5

-	// is available.

-	testRequires(c, DaemonIsLinux)

 	// start exited container

 	out, _ := dockerCmd(c, "run", "-d", "busybox")

 	firstID := strings.TrimSpace(out)

@@ -215,10 +207,6 @@ func (s *DockerSuite) TestPsListContainersFilterStatus(c *check.C) {

 }

 func (s *DockerSuite) TestPsListContainersFilterID(c *check.C) {

-	// TODO Windows CI (TP5 timeframe). This test has a very high likelyhood

-	// of hitting a known bug in TP4. Hence disabling for now until TP5

-	// is available.

-	testRequires(c, DaemonIsLinux)

 	// start container

 	out, _ := dockerCmd(c, "run", "-d", "busybox")

 	firstID := strings.TrimSpace(out)

@@ -257,10 +245,6 @@ func (s *DockerSuite) TestPsListContainersFilterName(c *check.C) {

 // - Run containers for each of those image (busybox, images_ps_filter_test1, images_ps_filter_test2)

 // - Filter them out :P

 func (s *DockerSuite) TestPsListContainersFilterAncestorImage(c *check.C) {

-	// TODO Windows CI (TP5 timeframe). This test has a very high likelyhood

-	// of hitting a known bug in TP4. Hence disabling for now until TP5

-	// is available.

-	testRequires(c, DaemonIsLinux)

 	// Build images

 	imageName1 := "images_ps_filter_test1"

 	imageID1, err := buildImage(imageName1,

@@ -356,10 +340,6 @@ func checkPsAncestorFilterOutput(c *check.C, out string, filterName string, expe

 }

 func (s *DockerSuite) TestPsListContainersFilterLabel(c *check.C) {

-	// TODO Windows CI (TP5 timeframe). This test has a very high likelyhood

-	// of hitting a known bug in TP4. Hence disabling for now until TP5

-	// is available.

-	testRequires(c, DaemonIsLinux)

 	// start container

 	out, _ := dockerCmd(c, "run", "-d", "-l", "match=me", "-l", "second=tag", "busybox")

 	firstID := strings.TrimSpace(out)

@@ -396,11 +376,6 @@ func (s *DockerSuite) TestPsListContainersFilterLabel(c *check.C) {

 }

 func (s *DockerSuite) TestPsListContainersFilterExited(c *check.C) {

-	// TODO Windows CI (TP5 timeframe). This test has a very high likelyhood

-	// of hitting a known bug in TP4. Hence disabling for now until TP5

-	// is available.

-	testRequires(c, DaemonIsLinux)

-	testRequires(c, DaemonIsLinux)

 	runSleepingContainer(c, "--name=sleep")

 	dockerCmd(c, "run", "--name", "zero1", "busybox", "true")

new file mode 100644

@@ -0,0 +1,27 @@

+Copyright (c) 2009 The Go Authors. All rights reserved.

+

+Redistribution and use in source and binary forms, with or without

+modification, are permitted provided that the following conditions are

+met:

+

+   * Redistributions of source code must retain the above copyright

+notice, this list of conditions and the following disclaimer.

+   * Redistributions in binary form must reproduce the above

+copyright notice, this list of conditions and the following disclaimer

+in the documentation and/or other materials provided with the

+distribution.

+   * Neither the name of Google Inc. nor the names of its

+contributors may be used to endorse or promote products derived from

+this software without specific prior written permission.

+

+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

new file mode 100644

@@ -0,0 +1,178 @@

+// Copyright 2015 The Go Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style

+// license that can be found in the LICENSE file.

+

+// +build windows

+

+// Package registry provides access to the Windows registry.

+//

+// Here is a simple example, opening a registry key and reading a string value from it.

+//

+//	k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion`, registry.QUERY_VALUE)

+//	if err != nil {

+//		log.Fatal(err)

+//	}

+//	defer k.Close()

+//

+//	s, _, err := k.GetStringValue("SystemRoot")

+//	if err != nil {

+//		log.Fatal(err)

+//	}

+//	fmt.Printf("Windows system root is %q\n", s)

+//

+package registry

+

+import (

+	"io"

+	"syscall"

+	"time"

+)

+

+const (

+	// Registry key security and access rights.

+	// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms724878.aspx

+	// for details.

+	ALL_ACCESS         = 0xf003f

+	CREATE_LINK        = 0x00020

+	CREATE_SUB_KEY     = 0x00004

+	ENUMERATE_SUB_KEYS = 0x00008

+	EXECUTE            = 0x20019

+	NOTIFY             = 0x00010

+	QUERY_VALUE        = 0x00001

+	READ               = 0x20019

+	SET_VALUE          = 0x00002

+	WOW64_32KEY        = 0x00200

+	WOW64_64KEY        = 0x00100

+	WRITE              = 0x20006

+)

+

+// Key is a handle to an open Windows registry key.

+// Keys can be obtained by calling OpenKey; there are

+// also some predefined root keys such as CURRENT_USER.

+// Keys can be used directly in the Windows API.

+type Key syscall.Handle

+

+const (

+	// Windows defines some predefined root keys that are always open.

+	// An application can use these keys as entry points to the registry.

+	// Normally these keys are used in OpenKey to open new keys,

+	// but they can also be used anywhere a Key is required.

+	CLASSES_ROOT   = Key(syscall.HKEY_CLASSES_ROOT)

+	CURRENT_USER   = Key(syscall.HKEY_CURRENT_USER)

+	LOCAL_MACHINE  = Key(syscall.HKEY_LOCAL_MACHINE)

+	USERS          = Key(syscall.HKEY_USERS)

+	CURRENT_CONFIG = Key(syscall.HKEY_CURRENT_CONFIG)

+)

+

+// Close closes open key k.

+func (k Key) Close() error {

+	return syscall.RegCloseKey(syscall.Handle(k))

+}

+

+// OpenKey opens a new key with path name relative to key k.

+// It accepts any open key, including CURRENT_USER and others,

+// and returns the new key and an error.

+// The access parameter specifies desired access rights to the

+// key to be opened.

+func OpenKey(k Key, path string, access uint32) (Key, error) {

+	p, err := syscall.UTF16PtrFromString(path)

+	if err != nil {

+		return 0, err

+	}

+	var subkey syscall.Handle

+	err = syscall.RegOpenKeyEx(syscall.Handle(k), p, 0, access, &subkey)

+	if err != nil {

+		return 0, err

+	}

+	return Key(subkey), nil

+}

+

+// ReadSubKeyNames returns the names of subkeys of key k.

+// The parameter n controls the number of returned names,

+// analogous to the way os.File.Readdirnames works.

+func (k Key) ReadSubKeyNames(n int) ([]string, error) {

+	ki, err := k.Stat()

+	if err != nil {

+		return nil, err

+	}

+	names := make([]string, 0, ki.SubKeyCount)

+	buf := make([]uint16, ki.MaxSubKeyLen+1) // extra room for terminating zero byte

+loopItems:

+	for i := uint32(0); ; i++ {

+		if n > 0 {

+			if len(names) == n {

+				return names, nil

+			}

+		}

+		l := uint32(len(buf))

+		for {

+			err := syscall.RegEnumKeyEx(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)

+			if err == nil {

+				break

+			}

+			if err == syscall.ERROR_MORE_DATA {

+				// Double buffer size and try again.

+				l = uint32(2 * len(buf))

+				buf = make([]uint16, l)

+				continue

+			}

+			if err == _ERROR_NO_MORE_ITEMS {

+				break loopItems

+			}

+			return names, err

+		}

+		names = append(names, syscall.UTF16ToString(buf[:l]))

+	}

+	if n > len(names) {

+		return names, io.EOF

+	}

+	return names, nil

+}

+

+// CreateKey creates a key named path under open key k.

+// CreateKey returns the new key and a boolean flag that reports

+// whether the key already existed.

+// The access parameter specifies the access rights for the key

+// to be created.

+func CreateKey(k Key, path string, access uint32) (newk Key, openedExisting bool, err error) {

+	var h syscall.Handle

+	var d uint32

+	err = regCreateKeyEx(syscall.Handle(k), syscall.StringToUTF16Ptr(path),

+		0, nil, _REG_OPTION_NON_VOLATILE, access, nil, &h, &d)

+	if err != nil {

+		return 0, false, err

+	}

+	return Key(h), d == _REG_OPENED_EXISTING_KEY, nil

+}

+

+// DeleteKey deletes the subkey path of key k and its values.

+func DeleteKey(k Key, path string) error {

+	return regDeleteKey(syscall.Handle(k), syscall.StringToUTF16Ptr(path))

+}

+

+// A KeyInfo describes the statistics of a key. It is returned by Stat.

+type KeyInfo struct {

+	SubKeyCount     uint32

+	MaxSubKeyLen    uint32 // size of the key's subkey with the longest name, in Unicode characters, not including the terminating zero byte

+	ValueCount      uint32

+	MaxValueNameLen uint32 // size of the key's longest value name, in Unicode characters, not including the terminating zero byte

+	MaxValueLen     uint32 // longest data component among the key's values, in bytes

+	lastWriteTime   syscall.Filetime

+}

+

+// ModTime returns the key's last write time.

+func (ki *KeyInfo) ModTime() time.Time {

+	return time.Unix(0, ki.lastWriteTime.Nanoseconds())

+}

+

+// Stat retrieves information about the open key k.

+func (k Key) Stat() (*KeyInfo, error) {

+	var ki KeyInfo

+	err := syscall.RegQueryInfoKey(syscall.Handle(k), nil, nil, nil,

+		&ki.SubKeyCount, &ki.MaxSubKeyLen, nil, &ki.ValueCount,

+		&ki.MaxValueNameLen, &ki.MaxValueLen, nil, &ki.lastWriteTime)

+	if err != nil {

+		return nil, err

+	}

+	return &ki, nil

+}

new file mode 100644

@@ -0,0 +1,33 @@

+// Copyright 2015 The Go Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style

+// license that can be found in the LICENSE file.

+

+// +build windows

+

+package registry

+

+import "syscall"

+

+//go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output zsyscall_windows.go syscall.go

+

+const (

+	_REG_OPTION_NON_VOLATILE = 0

+

+	_REG_CREATED_NEW_KEY     = 1

+	_REG_OPENED_EXISTING_KEY = 2

+

+	_ERROR_NO_MORE_ITEMS syscall.Errno = 259

+)

+

+func LoadRegLoadMUIString() error {

+	return procRegLoadMUIStringW.Find()

+}

+

+//sys	regCreateKeyEx(key syscall.Handle, subkey *uint16, reserved uint32, class *uint16, options uint32, desired uint32, sa *syscall.SecurityAttributes, result *syscall.Handle, disposition *uint32) (regerrno error) = advapi32.RegCreateKeyExW

+//sys	regDeleteKey(key syscall.Handle, subkey *uint16) (regerrno error) = advapi32.RegDeleteKeyW

+//sys	regSetValueEx(key syscall.Handle, valueName *uint16, reserved uint32, vtype uint32, buf *byte, bufsize uint32) (regerrno error) = advapi32.RegSetValueExW

+//sys	regEnumValue(key syscall.Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) = advapi32.RegEnumValueW

+//sys	regDeleteValue(key syscall.Handle, name *uint16) (regerrno error) = advapi32.RegDeleteValueW

+//sys   regLoadMUIString(key syscall.Handle, name *uint16, buf *uint16, buflen uint32, buflenCopied *uint32, flags uint32, dir *uint16) (regerrno error) = advapi32.RegLoadMUIStringW

+

+//sys	expandEnvironmentStrings(src *uint16, dst *uint16, size uint32) (n uint32, err error) = kernel32.ExpandEnvironmentStringsW

new file mode 100644

@@ -0,0 +1,384 @@

+// Copyright 2015 The Go Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style

+// license that can be found in the LICENSE file.

+

+// +build windows

+

+package registry

+

+import (

+	"errors"

+	"io"

+	"syscall"

+	"unicode/utf16"

+	"unsafe"

+)

+

+const (

+	// Registry value types.

+	NONE                       = 0

+	SZ                         = 1

+	EXPAND_SZ                  = 2

+	BINARY                     = 3

+	DWORD                      = 4

+	DWORD_BIG_ENDIAN           = 5

+	LINK                       = 6

+	MULTI_SZ                   = 7

+	RESOURCE_LIST              = 8

+	FULL_RESOURCE_DESCRIPTOR   = 9

+	RESOURCE_REQUIREMENTS_LIST = 10

+	QWORD                      = 11

+)

+

+var (

+	// ErrShortBuffer is returned when the buffer was too short for the operation.

+	ErrShortBuffer = syscall.ERROR_MORE_DATA

+

+	// ErrNotExist is returned when a registry key or value does not exist.

+	ErrNotExist = syscall.ERROR_FILE_NOT_FOUND

+

+	// ErrUnexpectedType is returned by Get*Value when the value's type was unexpected.

+	ErrUnexpectedType = errors.New("unexpected key value type")

+)

+

+// GetValue retrieves the type and data for the specified value associated

+// with an open key k. It fills up buffer buf and returns the retrieved

+// byte count n. If buf is too small to fit the stored value it returns

+// ErrShortBuffer error along with the required buffer size n.

+// If no buffer is provided, it returns true and actual buffer size n.

+// If no buffer is provided, GetValue returns the value's type only.

+// If the value does not exist, the error returned is ErrNotExist.

+//

+// GetValue is a low level function. If value's type is known, use the appropriate

+// Get*Value function instead.

+func (k Key) GetValue(name string, buf []byte) (n int, valtype uint32, err error) {

+	pname, err := syscall.UTF16PtrFromString(name)

+	if err != nil {

+		return 0, 0, err

+	}

+	var pbuf *byte

+	if len(buf) > 0 {

+		pbuf = (*byte)(unsafe.Pointer(&buf[0]))

+	}

+	l := uint32(len(buf))

+	err = syscall.RegQueryValueEx(syscall.Handle(k), pname, nil, &valtype, pbuf, &l)

+	if err != nil {

+		return int(l), valtype, err

+	}

+	return int(l), valtype, nil

+}

+

+func (k Key) getValue(name string, buf []byte) (date []byte, valtype uint32, err error) {

+	p, err := syscall.UTF16PtrFromString(name)

+	if err != nil {

+		return nil, 0, err

+	}

+	var t uint32

+	n := uint32(len(buf))

+	for {

+		err = syscall.RegQueryValueEx(syscall.Handle(k), p, nil, &t, (*byte)(unsafe.Pointer(&buf[0])), &n)

+		if err == nil {

+			return buf[:n], t, nil

+		}

+		if err != syscall.ERROR_MORE_DATA {

+			return nil, 0, err

+		}

+		if n <= uint32(len(buf)) {

+			return nil, 0, err

+		}

+		buf = make([]byte, n)

+	}

+}

+

+// GetStringValue retrieves the string value for the specified

+// value name associated with an open key k. It also returns the value's type.

+// If value does not exist, GetStringValue returns ErrNotExist.

+// If value is not SZ or EXPAND_SZ, it will return the correct value

+// type and ErrUnexpectedType.

+func (k Key) GetStringValue(name string) (val string, valtype uint32, err error) {

+	data, typ, err2 := k.getValue(name, make([]byte, 64))

+	if err2 != nil {

+		return "", typ, err2

+	}

+	switch typ {

+	case SZ, EXPAND_SZ:

+	default:

+		return "", typ, ErrUnexpectedType

+	}

+	if len(data) == 0 {

+		return "", typ, nil

+	}

+	u := (*[1 << 29]uint16)(unsafe.Pointer(&data[0]))[:]

+	return syscall.UTF16ToString(u), typ, nil

+}

+

+// GetMUIStringValue retrieves the localized string value for

+// the specified value name associated with an open key k.

+// If the value name doesn't exist or the localized string value

+// can't be resolved, GetMUIStringValue returns ErrNotExist.

+// GetMUIStringValue panics if the system doesn't support

+// regLoadMUIString; use LoadRegLoadMUIString to check if

+// regLoadMUIString is supported before calling this function.

+func (k Key) GetMUIStringValue(name string) (string, error) {

+	pname, err := syscall.UTF16PtrFromString(name)

+	if err != nil {

+		return "", err

+	}

+

+	buf := make([]uint16, 1024)

+	var buflen uint32

+	var pdir *uint16

+

+	err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)

+	if err == syscall.ERROR_FILE_NOT_FOUND { // Try fallback path

+

+		// Try to resolve the string value using the system directory as

+		// a DLL search path; this assumes the string value is of the form

+		// @[path]\dllname,-strID but with no path given, e.g. @tzres.dll,-320.

+

+		// This approach works with tzres.dll but may have to be revised

+		// in the future to allow callers to provide custom search paths.

+

+		var s string

+		s, err = ExpandString("%SystemRoot%\\system32\\")

+		if err != nil {

+			return "", err

+		}

+		pdir, err = syscall.UTF16PtrFromString(s)

+		if err != nil {

+			return "", err

+		}

+

+		err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)

+	}

+

+	for err == syscall.ERROR_MORE_DATA { // Grow buffer if needed

+		if buflen <= uint32(len(buf)) {

+			break // Buffer not growing, assume race; break

+		}

+		buf = make([]uint16, buflen)

+		err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)

+	}

+

+	if err != nil {

+		return "", err

+	}

+

+	return syscall.UTF16ToString(buf), nil

+}

+

+// ExpandString expands environment-variable strings and replaces

+// them with the values defined for the current user.

+// Use ExpandString to expand EXPAND_SZ strings.

+func ExpandString(value string) (string, error) {

+	if value == "" {

+		return "", nil

+	}

+	p, err := syscall.UTF16PtrFromString(value)

+	if err != nil {

+		return "", err

+	}

+	r := make([]uint16, 100)

+	for {

+		n, err := expandEnvironmentStrings(p, &r[0], uint32(len(r)))

+		if err != nil {

+			return "", err

+		}

+		if n <= uint32(len(r)) {

+			u := (*[1 << 29]uint16)(unsafe.Pointer(&r[0]))[:]

+			return syscall.UTF16ToString(u), nil

+		}

+		r = make([]uint16, n)

+	}

+}

+

+// GetStringsValue retrieves the []string value for the specified

+// value name associated with an open key k. It also returns the value's type.

+// If value does not exist, GetStringsValue returns ErrNotExist.

+// If value is not MULTI_SZ, it will return the correct value

+// type and ErrUnexpectedType.

+func (k Key) GetStringsValue(name string) (val []string, valtype uint32, err error) {

+	data, typ, err2 := k.getValue(name, make([]byte, 64))

+	if err2 != nil {

+		return nil, typ, err2

+	}

+	if typ != MULTI_SZ {

+		return nil, typ, ErrUnexpectedType

+	}

+	if len(data) == 0 {

+		return nil, typ, nil

+	}

+	p := (*[1 << 29]uint16)(unsafe.Pointer(&data[0]))[:len(data)/2]

+	if len(p) == 0 {

+		return nil, typ, nil

+	}

+	if p[len(p)-1] == 0 {

+		p = p[:len(p)-1] // remove terminating null

+	}

+	val = make([]string, 0, 5)

+	from := 0

+	for i, c := range p {

+		if c == 0 {

+			val = append(val, string(utf16.Decode(p[from:i])))

+			from = i + 1

+		}

+	}

+	return val, typ, nil

+}

+

+// GetIntegerValue retrieves the integer value for the specified

+// value name associated with an open key k. It also returns the value's type.

+// If value does not exist, GetIntegerValue returns ErrNotExist.

+// If value is not DWORD or QWORD, it will return the correct value

+// type and ErrUnexpectedType.

+func (k Key) GetIntegerValue(name string) (val uint64, valtype uint32, err error) {

+	data, typ, err2 := k.getValue(name, make([]byte, 8))

+	if err2 != nil {

+		return 0, typ, err2

+	}

+	switch typ {

+	case DWORD:

+		if len(data) != 4 {

+			return 0, typ, errors.New("DWORD value is not 4 bytes long")

+		}

+		return uint64(*(*uint32)(unsafe.Pointer(&data[0]))), DWORD, nil

+	case QWORD:

+		if len(data) != 8 {

+			return 0, typ, errors.New("QWORD value is not 8 bytes long")

+		}

+		return uint64(*(*uint64)(unsafe.Pointer(&data[0]))), QWORD, nil

+	default:

+		return 0, typ, ErrUnexpectedType

+	}

+}

+

+// GetBinaryValue retrieves the binary value for the specified

+// value name associated with an open key k. It also returns the value's type.

+// If value does not exist, GetBinaryValue returns ErrNotExist.

+// If value is not BINARY, it will return the correct value

+// type and ErrUnexpectedType.

+func (k Key) GetBinaryValue(name string) (val []byte, valtype uint32, err error) {

+	data, typ, err2 := k.getValue(name, make([]byte, 64))

+	if err2 != nil {

+		return nil, typ, err2

+	}

+	if typ != BINARY {

+		return nil, typ, ErrUnexpectedType

+	}

+	return data, typ, nil

+}

+

+func (k Key) setValue(name string, valtype uint32, data []byte) error {

+	p, err := syscall.UTF16PtrFromString(name)

+	if err != nil {

+		return err

+	}

+	if len(data) == 0 {

+		return regSetValueEx(syscall.Handle(k), p, 0, valtype, nil, 0)

+	}

+	return regSetValueEx(syscall.Handle(k), p, 0, valtype, &data[0], uint32(len(data)))

+}

+

+// SetDWordValue sets the data and type of a name value

+// under key k to value and DWORD.

+func (k Key) SetDWordValue(name string, value uint32) error {

+	return k.setValue(name, DWORD, (*[4]byte)(unsafe.Pointer(&value))[:])

+}

+

+// SetQWordValue sets the data and type of a name value

+// under key k to value and QWORD.

+func (k Key) SetQWordValue(name string, value uint64) error {

+	return k.setValue(name, QWORD, (*[8]byte)(unsafe.Pointer(&value))[:])

+}

+

+func (k Key) setStringValue(name string, valtype uint32, value string) error {

+	v, err := syscall.UTF16FromString(value)

+	if err != nil {

+		return err

+	}

+	buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[:len(v)*2]

+	return k.setValue(name, valtype, buf)

+}

+

+// SetStringValue sets the data and type of a name value

+// under key k to value and SZ. The value must not contain a zero byte.

+func (k Key) SetStringValue(name, value string) error {

+	return k.setStringValue(name, SZ, value)

+}

+

+// SetExpandStringValue sets the data and type of a name value

+// under key k to value and EXPAND_SZ. The value must not contain a zero byte.

+func (k Key) SetExpandStringValue(name, value string) error {

+	return k.setStringValue(name, EXPAND_SZ, value)

+}

+

+// SetStringsValue sets the data and type of a name value

+// under key k to value and MULTI_SZ. The value strings

+// must not contain a zero byte.

+func (k Key) SetStringsValue(name string, value []string) error {

+	ss := ""

+	for _, s := range value {

+		for i := 0; i < len(s); i++ {

+			if s[i] == 0 {

+				return errors.New("string cannot have 0 inside")

+			}

+		}

+		ss += s + "\x00"

+	}

+	v := utf16.Encode([]rune(ss + "\x00"))

+	buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[:len(v)*2]

+	return k.setValue(name, MULTI_SZ, buf)

+}

+

+// SetBinaryValue sets the data and type of a name value

+// under key k to value and BINARY.

+func (k Key) SetBinaryValue(name string, value []byte) error {

+	return k.setValue(name, BINARY, value)

+}

+

+// DeleteValue removes a named value from the key k.

+func (k Key) DeleteValue(name string) error {

+	return regDeleteValue(syscall.Handle(k), syscall.StringToUTF16Ptr(name))

+}

+

+// ReadValueNames returns the value names of key k.

+// The parameter n controls the number of returned names,

+// analogous to the way os.File.Readdirnames works.

+func (k Key) ReadValueNames(n int) ([]string, error) {

+	ki, err := k.Stat()

+	if err != nil {

+		return nil, err

+	}

+	names := make([]string, 0, ki.ValueCount)

+	buf := make([]uint16, ki.MaxValueNameLen+1) // extra room for terminating null character

+loopItems:

+	for i := uint32(0); ; i++ {

+		if n > 0 {

+			if len(names) == n {

+				return names, nil

+			}

+		}

+		l := uint32(len(buf))

+		for {

+			err := regEnumValue(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)

+			if err == nil {

+				break

+			}

+			if err == syscall.ERROR_MORE_DATA {

+				// Double buffer size and try again.

+				l = uint32(2 * len(buf))

+				buf = make([]uint16, l)

+				continue

+			}

+			if err == _ERROR_NO_MORE_ITEMS {

+				break loopItems

+			}

+			return names, err

+		}

+		names = append(names, syscall.UTF16ToString(buf[:l]))

+	}

+	if n > len(names) {

+		return names, io.EOF

+	}

+	return names, nil

+}

new file mode 100644

@@ -0,0 +1,82 @@

+// MACHINE GENERATED BY 'go generate' COMMAND; DO NOT EDIT

+

+package registry

+

+import "unsafe"

+import "syscall"

+

+var _ unsafe.Pointer

+

+var (

+	modadvapi32 = syscall.NewLazyDLL("advapi32.dll")

+	modkernel32 = syscall.NewLazyDLL("kernel32.dll")

+

+	procRegCreateKeyExW           = modadvapi32.NewProc("RegCreateKeyExW")

+	procRegDeleteKeyW             = modadvapi32.NewProc("RegDeleteKeyW")

+	procRegSetValueExW            = modadvapi32.NewProc("RegSetValueExW")

+	procRegEnumValueW             = modadvapi32.NewProc("RegEnumValueW")

+	procRegDeleteValueW           = modadvapi32.NewProc("RegDeleteValueW")

+	procRegLoadMUIStringW         = modadvapi32.NewProc("RegLoadMUIStringW")

+	procExpandEnvironmentStringsW = modkernel32.NewProc("ExpandEnvironmentStringsW")

+)

+

+func regCreateKeyEx(key syscall.Handle, subkey *uint16, reserved uint32, class *uint16, options uint32, desired uint32, sa *syscall.SecurityAttributes, result *syscall.Handle, disposition *uint32) (regerrno error) {

+	r0, _, _ := syscall.Syscall9(procRegCreateKeyExW.Addr(), 9, uintptr(key), uintptr(unsafe.Pointer(subkey)), uintptr(reserved), uintptr(unsafe.Pointer(class)), uintptr(options), uintptr(desired), uintptr(unsafe.Pointer(sa)), uintptr(unsafe.Pointer(result)), uintptr(unsafe.Pointer(disposition)))

+	if r0 != 0 {

+		regerrno = syscall.Errno(r0)

+	}

+	return

+}

+

+func regDeleteKey(key syscall.Handle, subkey *uint16) (regerrno error) {

+	r0, _, _ := syscall.Syscall(procRegDeleteKeyW.Addr(), 2, uintptr(key), uintptr(unsafe.Pointer(subkey)), 0)

+	if r0 != 0 {

+		regerrno = syscall.Errno(r0)

+	}

+	return

+}

+

+func regSetValueEx(key syscall.Handle, valueName *uint16, reserved uint32, vtype uint32, buf *byte, bufsize uint32) (regerrno error) {

+	r0, _, _ := syscall.Syscall6(procRegSetValueExW.Addr(), 6, uintptr(key), uintptr(unsafe.Pointer(valueName)), uintptr(reserved), uintptr(vtype), uintptr(unsafe.Pointer(buf)), uintptr(bufsize))

+	if r0 != 0 {

+		regerrno = syscall.Errno(r0)

+	}

+	return

+}

+

+func regEnumValue(key syscall.Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) {

+	r0, _, _ := syscall.Syscall9(procRegEnumValueW.Addr(), 8, uintptr(key), uintptr(index), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(nameLen)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(valtype)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(buflen)), 0)