@@ -8,22 +8,16 @@ import (

 	"github.com/Sirupsen/logrus"

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

-	"github.com/docker/docker/pkg/stringid"

 	"github.com/microsoft/hcsshim"

-	"github.com/natefinch/npipe"

 )

 // Exec implements the exec driver Driver interface.

 func (d *Driver) Exec(c *execdriver.Command, processConfig *execdriver.ProcessConfig, pipes *execdriver.Pipes, startCallback execdriver.StartCallback) (int, error) {

 	var (

-		inListen, outListen, errListen     *npipe.PipeListener

-		term                               execdriver.Terminal

-		err                                error

-		randomID                           = stringid.GenerateNonCryptoID()

-		serverPipeFormat, clientPipeFormat string

-		pid                                uint32

-		exitCode                           int32

+		term     execdriver.Terminal

+		err      error

+		exitCode int32

 	)

 	active := d.activeContainers[c.ID]

@@ -39,64 +33,6 @@ func (d *Driver) Exec(c *execdriver.Command, processConfig *execdriver.ProcessCo

 	// Configure the environment for the process // Note NOT c.ProcessConfig.Tty

 	createProcessParms.Environment = setupEnvironmentVariables(processConfig.Env)

-	// We use another unique ID here for each exec instance otherwise it

-	// may conflict with the pipe name being used by RUN.

-

-	// We use a different pipe name between real and dummy mode in the HCS

-	if dummyMode {

-		clientPipeFormat = `\\.\pipe\docker-exec-%[1]s-%[2]s-%[3]s`

-		serverPipeFormat = clientPipeFormat

-	} else {

-		clientPipeFormat = `\\.\pipe\docker-exec-%[2]s-%[3]s`

-		serverPipeFormat = `\\.\Containers\%[1]s\Device\NamedPipe\docker-exec-%[2]s-%[3]s`

-	}

-

-	// Connect stdin

-	if pipes.Stdin != nil {

-		stdInPipe := fmt.Sprintf(serverPipeFormat, c.ID, randomID, "stdin")

-		createProcessParms.StdInPipe = fmt.Sprintf(clientPipeFormat, c.ID, randomID, "stdin")

-

-		// Listen on the named pipe

-		inListen, err = npipe.Listen(stdInPipe)

-		if err != nil {

-			logrus.Errorf("stdin failed to listen on %s %s ", stdInPipe, err)

-			return -1, err

-		}

-		defer inListen.Close()

-

-		// Launch a goroutine to do the accept. We do this so that we can

-		// cause an otherwise blocking goroutine to gracefully close when

-		// the caller (us) closes the listener

-		go stdinAccept(inListen, stdInPipe, pipes.Stdin)

-	}

-

-	// Connect stdout

-	stdOutPipe := fmt.Sprintf(serverPipeFormat, c.ID, randomID, "stdout")

-	createProcessParms.StdOutPipe = fmt.Sprintf(clientPipeFormat, c.ID, randomID, "stdout")

-

-	outListen, err = npipe.Listen(stdOutPipe)

-	if err != nil {

-		logrus.Errorf("stdout failed to listen on %s %s", stdOutPipe, err)

-		return -1, err

-	}

-	defer outListen.Close()

-	go stdouterrAccept(outListen, stdOutPipe, pipes.Stdout)

-

-	// No stderr on TTY. Note NOT c.ProcessConfig.Tty

-	if !processConfig.Tty {

-		// Connect stderr

-		stdErrPipe := fmt.Sprintf(serverPipeFormat, c.ID, randomID, "stderr")

-		createProcessParms.StdErrPipe = fmt.Sprintf(clientPipeFormat, c.ID, randomID, "stderr")

-

-		errListen, err = npipe.Listen(stdErrPipe)

-		if err != nil {

-			logrus.Errorf("Stderr failed to listen on %s %s", stdErrPipe, err)

-			return -1, err

-		}

-		defer errListen.Close()

-		go stdouterrAccept(errListen, stdErrPipe, pipes.Stderr)

-	}

-

 	// While this should get caught earlier, just in case, validate that we

 	// have something to run.

 	if processConfig.Entrypoint == "" {

@@ -114,13 +50,16 @@ func (d *Driver) Exec(c *execdriver.Command, processConfig *execdriver.ProcessCo

 	logrus.Debugln("commandLine: ", createProcessParms.CommandLine)

 	// Start the command running in the container.

-	pid, err = hcsshim.CreateProcessInComputeSystem(c.ID, createProcessParms)

-

+	pid, stdin, stdout, stderr, err := hcsshim.CreateProcessInComputeSystem(c.ID, pipes.Stdin != nil, true, !processConfig.Tty, createProcessParms)

 	if err != nil {

 		logrus.Errorf("CreateProcessInComputeSystem() failed %s", err)

 		return -1, err

 	}

+	// Now that the process has been launched, begin copying data to and from

+	// the named pipes for the std handles.

+	setupPipes(stdin, stdout, stderr, pipes)

+

 	// Note NOT c.ProcessConfig.Tty

 	if processConfig.Tty {

 		term = NewTtyConsole(c.ID, pid)

@@ -6,77 +6,49 @@ import (

 	"io"

 	"github.com/Sirupsen/logrus"

-	"github.com/natefinch/npipe"

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

 )

-// stdinAccept runs as a go function. It waits for the container system

-// to accept our offer of a named pipe for stdin. Once accepted, if we are

-// running "attached" to the container (eg docker run -i), then we spin up

-// a further thread to copy anything from the client into the container.

-//

-// Important design note. This function is run as a go function for a very

-// good reason. The named pipe Accept call is blocking until one of two things

-// happen. Either someone connects to it, or it is forcibly closed. Let's

-// assume that no-one connects to it, the only way otherwise the Run()

-// method would continue is by closing it. However, as that would be the same

-// thread, it can't close it. Hence we run as another thread allowing Run()

-// to close the named pipe.

-func stdinAccept(inListen *npipe.PipeListener, pipeName string, copyfrom io.ReadCloser) {

+// General comment. Handling I/O for a container is very different to Linux.

+// We use a named pipe to HCS to copy I/O both in and out of the container,

+// very similar to how docker daemon communicates with a CLI.

-	// Wait for the pipe to be connected to by the shim

-	logrus.Debugln("stdinAccept: Waiting on ", pipeName)

-	stdinConn, err := inListen.Accept()

-	if err != nil {

-		logrus.Errorf("Failed to accept on pipe %s %s", pipeName, err)

-		return

-	}

-	logrus.Debugln("Connected to ", stdinConn.RemoteAddr())

+// startStdinCopy asynchronously copies an io.Reader to the container's

+// process's stdin pipe and closes the pipe when there is no more data to copy.

+func startStdinCopy(dst io.WriteCloser, src io.Reader) {

 	// Anything that comes from the client stdin should be copied

 	// across to the stdin named pipe of the container.

-	if copyfrom != nil {

-		go func() {

-			defer stdinConn.Close()

-			logrus.Debugln("Calling io.Copy on stdin")

-			bytes, err := io.Copy(stdinConn, copyfrom)

-			logrus.Debugf("Finished io.Copy on stdin bytes=%d err=%s pipe=%s", bytes, err, stdinConn.RemoteAddr())

-		}()

-	} else {

-		defer stdinConn.Close()

-	}

+	go func() {

+		defer dst.Close()

+		bytes, err := io.Copy(dst, src)

+		logrus.Debugf("Copied %d bytes from stdin err=%s", bytes, err)

+	}()

 }

-// stdouterrAccept runs as a go function. It waits for the container system to

-// accept our offer of a named pipe - in fact two of them - one for stdout

-// and one for stderr (we are called twice). Once the named pipe is accepted,

-// if we are running "attached" to the container (eg docker run -i), then we

-// spin up a further thread to copy anything from the containers output channels

-// to the client.

-func stdouterrAccept(outerrListen *npipe.PipeListener, pipeName string, copyto io.Writer) {

-

-	// Wait for the pipe to be connected to by the shim

-	logrus.Debugln("out/err: Waiting on ", pipeName)

-	outerrConn, err := outerrListen.Accept()

-	if err != nil {

-		logrus.Errorf("Failed to accept on pipe %s %s", pipeName, err)

-		return

-	}

-	logrus.Debugln("Connected to ", outerrConn.RemoteAddr())

-

+// startStdouterrCopy asynchronously copies data from the container's process's

+// stdout or stderr pipe to an io.Writer and closes the pipe when there is no

+// more data to copy.

+func startStdouterrCopy(dst io.Writer, src io.ReadCloser, name string) {

 	// Anything that comes from the container named pipe stdout/err should be copied

 	// across to the stdout/err of the client

-	if copyto != nil {

-		go func() {

-			defer outerrConn.Close()

-			logrus.Debugln("Calling io.Copy on ", pipeName)

-			bytes, err := io.Copy(copyto, outerrConn)

-			logrus.Debugf("Copied %d bytes from pipe=%s", bytes, outerrConn.RemoteAddr())

-			if err != nil {

-				// Not fatal, just debug log it

-				logrus.Debugf("Error hit during copy %s", err)

-			}

-		}()

-	} else {

-		defer outerrConn.Close()

+	go func() {

+		defer src.Close()

+		bytes, err := io.Copy(dst, src)

+		logrus.Debugf("Copied %d bytes from %s err=%s", bytes, name, err)

+	}()

+}

+

+// setupPipes starts the asynchronous copying of data to and from the named

+// pipes used byt he HCS for the std handles.

+func setupPipes(stdin io.WriteCloser, stdout, stderr io.ReadCloser, pipes *execdriver.Pipes) {

+	if stdin != nil {

+		startStdinCopy(stdin, pipes.Stdin)

+	}

+	if stdout != nil {

+		startStdouterrCopy(pipes.Stdout, stdout, "stdout")

+	}

+	if stderr != nil {

+		startStdouterrCopy(pipes.Stderr, stderr, "stderr")

 	}

 }

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

 	"github.com/Sirupsen/logrus"

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

 	"github.com/microsoft/hcsshim"

-	"github.com/natefinch/npipe"

 )

 // defaultContainerNAT is the default name of the container NAT device that is

@@ -60,23 +59,28 @@ type device struct {

 }

 type containerInit struct {

-	SystemType              string

-	Name                    string

-	IsDummy                 bool

-	VolumePath              string

-	Devices                 []device

-	IgnoreFlushesDuringBoot bool

-	LayerFolderPath         string

-	Layers                  []layer

+	SystemType              string   // HCS requires this to be hard-coded to "Container"

+	Name                    string   // Name of the container. We use the docker ID.

+	Owner                   string   // The management platform that created this container

+	IsDummy                 bool     // Used for development purposes.

+	VolumePath              string   // Windows volume path for scratch space

+	Devices                 []device // Devices used by the container

+	IgnoreFlushesDuringBoot bool     // Optimisation hint for container startup in Windows

+	LayerFolderPath         string   // Where the layer folders are located

+	Layers                  []layer  // List of storage layers

 }

+// defaultOwner is a tag passed to HCS to allow it to differentiate between

+// container creator management stacks. We hard code "docker" in the case

+// of docker.

+const defaultOwner = "docker"

+

 // Run implements the exec driver Driver interface

 func (d *Driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallback execdriver.StartCallback) (execdriver.ExitStatus, error) {

 	var (

-		term                           execdriver.Terminal

-		err                            error

-		inListen, outListen, errListen *npipe.PipeListener

+		term execdriver.Terminal

+		err  error

 	)

 	// Make sure the client isn't asking for options which aren't supported

@@ -88,6 +92,7 @@ func (d *Driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba

 	cu := &containerInit{

 		SystemType:              "Container",

 		Name:                    c.ID,

+		Owner:                   defaultOwner,

 		IsDummy:                 dummyMode,

 		VolumePath:              c.Rootfs,

 		IgnoreFlushesDuringBoot: c.FirstStart,

@@ -224,16 +229,6 @@ func (d *Driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba

 		}

 	}()

-	// We use a different pipe name between real and dummy mode in the HCS

-	var serverPipeFormat, clientPipeFormat string

-	if dummyMode {

-		clientPipeFormat = `\\.\pipe\docker-run-%[1]s-%[2]s`

-		serverPipeFormat = clientPipeFormat

-	} else {

-		clientPipeFormat = `\\.\pipe\docker-run-%[2]s`

-		serverPipeFormat = `\\.\Containers\%[1]s\Device\NamedPipe\docker-run-%[2]s`

-	}

-

 	createProcessParms := hcsshim.CreateProcessParams{

 		EmulateConsole:   c.ProcessConfig.Tty,

 		WorkingDirectory: c.WorkingDir,

@@ -243,51 +238,6 @@ func (d *Driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba

 	// Configure the environment for the process

 	createProcessParms.Environment = setupEnvironmentVariables(c.ProcessConfig.Env)

-	// Connect stdin

-	if pipes.Stdin != nil {

-		stdInPipe := fmt.Sprintf(serverPipeFormat, c.ID, "stdin")

-		createProcessParms.StdInPipe = fmt.Sprintf(clientPipeFormat, c.ID, "stdin")

-

-		// Listen on the named pipe

-		inListen, err = npipe.Listen(stdInPipe)

-		if err != nil {

-			logrus.Errorf("stdin failed to listen on %s err=%s", stdInPipe, err)

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

-		}

-		defer inListen.Close()

-

-		// Launch a goroutine to do the accept. We do this so that we can

-		// cause an otherwise blocking goroutine to gracefully close when

-		// the caller (us) closes the listener

-		go stdinAccept(inListen, stdInPipe, pipes.Stdin)

-	}

-

-	// Connect stdout

-	stdOutPipe := fmt.Sprintf(serverPipeFormat, c.ID, "stdout")

-	createProcessParms.StdOutPipe = fmt.Sprintf(clientPipeFormat, c.ID, "stdout")

-

-	outListen, err = npipe.Listen(stdOutPipe)

-	if err != nil {

-		logrus.Errorf("stdout failed to listen on %s err=%s", stdOutPipe, err)

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

-	}

-	defer outListen.Close()

-	go stdouterrAccept(outListen, stdOutPipe, pipes.Stdout)

-

-	// No stderr on TTY.

-	if !c.ProcessConfig.Tty {

-		// Connect stderr

-		stdErrPipe := fmt.Sprintf(serverPipeFormat, c.ID, "stderr")

-		createProcessParms.StdErrPipe = fmt.Sprintf(clientPipeFormat, c.ID, "stderr")

-		errListen, err = npipe.Listen(stdErrPipe)

-		if err != nil {

-			logrus.Errorf("stderr failed to listen on %s err=%s", stdErrPipe, err)

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

-		}

-		defer errListen.Close()

-		go stdouterrAccept(errListen, stdErrPipe, pipes.Stderr)

-	}

-

 	// This should get caught earlier, but just in case - validate that we

 	// have something to run

 	if c.ProcessConfig.Entrypoint == "" {

@@ -305,14 +255,16 @@ func (d *Driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba

 	logrus.Debugf("CommandLine: %s", createProcessParms.CommandLine)

 	// Start the command running in the container.

-	var pid uint32

-	pid, err = hcsshim.CreateProcessInComputeSystem(c.ID, createProcessParms)

-

+	pid, stdin, stdout, stderr, err := hcsshim.CreateProcessInComputeSystem(c.ID, pipes.Stdin != nil, true, !c.ProcessConfig.Tty, createProcessParms)

 	if err != nil {

 		logrus.Errorf("CreateProcessInComputeSystem() failed %s", err)

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

 	}

+	// Now that the process has been launched, begin copying data to and from

+	// the named pipes for the std handles.

+	setupPipes(stdin, stdout, stderr, pipes)

+

 	//Save the PID as we'll need this in Kill()

 	logrus.Debugf("PID %d", pid)

 	c.ContainerPid = int(pid)

@@ -13,10 +13,9 @@ clone git github.com/go-check/check 64131543e7896d5bcc6bd5a76287eb75ea96c673

 clone git github.com/gorilla/context 14f550f51a

 clone git github.com/gorilla/mux e444e69cbd

 clone git github.com/kr/pty 5cf931ef8f

-clone git github.com/microsoft/hcsshim f674a70f1306dbe20b3a516bedd3285d85db60d9

 clone git github.com/mattn/go-sqlite3 b4142c444a8941d0d92b0b7103a24df9cd815e42

+clone git github.com/microsoft/hcsshim da093dac579302d7b413696b96dec0b5e1bce8d4

 clone git github.com/mistifyio/go-zfs v2.1.1

-clone git github.com/natefinch/npipe 0938d701e50e580f5925c773055eb6d6b32a0cbc

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

 clone git golang.org/x/net 3cffabab72adf04f8e3b01c5baf775361837b5fe https://github.com/golang/net.git

 clone hg code.google.com/p/gosqlite 74691fb6f837

@@ -3,6 +3,8 @@ package hcsshim

 import (

 	"encoding/json"

 	"fmt"

+	"io"

+	"runtime"

 	"syscall"

 	"unsafe"

@@ -12,30 +14,71 @@ import (

 // processParameters is use to both the input of CreateProcessInComputeSystem

 // and to convert the parameters to JSON for passing onto the HCS

 type CreateProcessParams struct {

-	ApplicationName                   string

-	CommandLine                       string

-	WorkingDirectory                  string

-	StdInPipe, StdOutPipe, StdErrPipe string

-	Environment                       map[string]string

-	EmulateConsole                    bool

-	ConsoleSize                       [2]int

+	ApplicationName  string

+	CommandLine      string

+	WorkingDirectory string

+	Environment      map[string]string

+	EmulateConsole   bool

+	ConsoleSize      [2]int

+}

+

+// pipe struct used for the stdin/stdout/stderr pipes

+type pipe struct {

+	handle syscall.Handle

+}

+

+func makePipe(h syscall.Handle) *pipe {

+	p := &pipe{h}

+	runtime.SetFinalizer(p, (*pipe).closeHandle)

+	return p

+}

+

+func (p *pipe) closeHandle() {

+	if p.handle != 0 {

+		syscall.CloseHandle(p.handle)

+		p.handle = 0

+	}

+}

+

+func (p *pipe) Close() error {

+	p.closeHandle()

+	runtime.SetFinalizer(p, nil)

+	return nil

+}

+

+func (p *pipe) Read(b []byte) (int, error) {

+	// syscall.Read returns 0, nil on ERROR_BROKEN_PIPE, but for

+	// our purposes this should indicate EOF. This may be a go bug.

+	var read uint32

+	err := syscall.ReadFile(p.handle, b, &read, nil)

+	if err != nil {

+		if err == syscall.ERROR_BROKEN_PIPE {

+			return 0, io.EOF

+		}

+		return 0, err

+	}

+	return int(read), nil

+}

+

+func (p *pipe) Write(b []byte) (int, error) {

+	return syscall.Write(p.handle, b)

 }

 // CreateProcessInComputeSystem starts a process in a container. This is invoked, for example,

 // as a result of docker run, docker exec, or RUN in Dockerfile. If successful,

 // it returns the PID of the process.

-func CreateProcessInComputeSystem(id string, params CreateProcessParams) (processid uint32, err error) {

+func CreateProcessInComputeSystem(id string, useStdin bool, useStdout bool, useStderr bool, params CreateProcessParams) (processid uint32, stdin io.WriteCloser, stdout io.ReadCloser, stderr io.ReadCloser, err error) {

 	title := "HCSShim::CreateProcessInComputeSystem"

 	logrus.Debugf(title+"id=%s params=%s", id, params)

 	// Load the DLL and get a handle to the procedure we need

-	dll, proc, err := loadAndFind(procCreateProcessInComputeSystem)

+	dll, proc, err := loadAndFind(procCreateProcessWithStdHandlesInComputeSystem)

 	if dll != nil {

 		defer dll.Release()

 	}

 	if err != nil {

-		return 0, err

+		return

 	}

 	// Convert id to uint16 pointer for calling the procedure

@@ -43,7 +86,7 @@ func CreateProcessInComputeSystem(id string, params CreateProcessParams) (proces

 	if err != nil {

 		err = fmt.Errorf(title+" - Failed conversion of id %s to pointer %s", id, err)

 		logrus.Error(err)

-		return 0, err

+		return

 	}

 	// If we are not emulating a console, ignore any console size passed to us

@@ -55,13 +98,13 @@ func CreateProcessInComputeSystem(id string, params CreateProcessParams) (proces

 	paramsJson, err := json.Marshal(params)

 	if err != nil {

 		err = fmt.Errorf(title+" - Failed to marshall params %v %s", params, err)

-		return 0, err

+		return

 	}

 	// Convert paramsJson to uint16 pointer for calling the procedure

 	paramsJsonp, err := syscall.UTF16PtrFromString(string(paramsJson))

 	if err != nil {

-		return 0, err

+		return

 	}

 	// Get a POINTER to variable to take the pid outparm

@@ -69,11 +112,26 @@ func CreateProcessInComputeSystem(id string, params CreateProcessParams) (proces

 	logrus.Debugf(title+" - Calling the procedure itself %s %s", id, paramsJson)

+	var stdinHandle, stdoutHandle, stderrHandle syscall.Handle

+	var stdinParam, stdoutParam, stderrParam uintptr

+	if useStdin {

+		stdinParam = uintptr(unsafe.Pointer(&stdinHandle))

+	}

+	if useStdout {

+		stdoutParam = uintptr(unsafe.Pointer(&stdoutHandle))

+	}

+	if useStderr {

+		stderrParam = uintptr(unsafe.Pointer(&stderrHandle))

+	}

+

 	// Call the procedure itself.

 	r1, _, _ := proc.Call(

 		uintptr(unsafe.Pointer(idp)),

 		uintptr(unsafe.Pointer(paramsJsonp)),

-		uintptr(unsafe.Pointer(pid)))

+		uintptr(unsafe.Pointer(pid)),

+		stdinParam,

+		stdoutParam,

+		stderrParam)

 	use(unsafe.Pointer(idp))

 	use(unsafe.Pointer(paramsJsonp))

@@ -81,9 +139,19 @@ func CreateProcessInComputeSystem(id string, params CreateProcessParams) (proces

 	if r1 != 0 {

 		err = fmt.Errorf(title+" - Win32 API call returned error r1=%d err=%s id=%s params=%v", r1, syscall.Errno(r1), id, params)

 		logrus.Error(err)

-		return 0, err

+		return

+	}

+

+	if useStdin {

+		stdin = makePipe(stdinHandle)

+	}

+	if useStdout {

+		stdout = makePipe(stdoutHandle)

+	}

+	if useStderr {

+		stderr = makePipe(stderrHandle)

 	}

 	logrus.Debugf(title+" - succeeded id=%s params=%s pid=%d", id, paramsJson, *pid)

-	return *pid, nil

+	return *pid, stdin, stdout, stderr, nil

 }

@@ -15,5 +15,5 @@ func NewGUID(source string) *GUID {

 }

 func (g *GUID) ToString() string {

-	return fmt.Sprintf("%x-%x-%x-%x-%x", g[0:4], g[4:6], g[6:8], g[8:10], g[10:])

+	return fmt.Sprintf("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x-%02x", g[3], g[2], g[1], g[0], g[5], g[4], g[7], g[6], g[8:10], g[10:])

 }

@@ -16,14 +16,14 @@ const (

 	shimDLLName = "vmcompute.dll"

 	// Container related functions in the shim DLL

-	procCreateComputeSystem             = "CreateComputeSystem"

-	procStartComputeSystem              = "StartComputeSystem"

-	procCreateProcessInComputeSystem    = "CreateProcessInComputeSystem"

-	procWaitForProcessInComputeSystem   = "WaitForProcessInComputeSystem"

-	procShutdownComputeSystem           = "ShutdownComputeSystem"

-	procTerminateComputeSystem          = "TerminateComputeSystem"

-	procTerminateProcessInComputeSystem = "TerminateProcessInComputeSystem"

-	procResizeConsoleInComputeSystem    = "ResizeConsoleInComputeSystem"

+	procCreateComputeSystem                        = "CreateComputeSystem"

+	procStartComputeSystem                         = "StartComputeSystem"

+	procCreateProcessWithStdHandlesInComputeSystem = "CreateProcessWithStdHandlesInComputeSystem"

+	procWaitForProcessInComputeSystem              = "WaitForProcessInComputeSystem"

+	procShutdownComputeSystem                      = "ShutdownComputeSystem"

+	procTerminateComputeSystem                     = "TerminateComputeSystem"

+	procTerminateProcessInComputeSystem            = "TerminateProcessInComputeSystem"

+	procResizeConsoleInComputeSystem               = "ResizeConsoleInComputeSystem"

 	// Storage related functions in the shim DLL

 	procLayerExists         = "LayerExists"

@@ -39,6 +39,7 @@ const (

 	procExportLayer         = "ExportLayer"

 	procImportLayer         = "ImportLayer"

 	procGetSharedBaseImages = "GetBaseImages"

+	procNameToGuid          = "NameToGuid"

 	// Name of the standard OLE dll

 	oleDLLName = "Ole32.dll"

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

 // functionality.

 import (

+	"path/filepath"

 	"syscall"

 	"github.com/Sirupsen/logrus"

@@ -84,9 +85,14 @@ func layerPathsToDescriptors(parentLayerPaths []string) ([]WC_LAYER_DESCRIPTOR,

 	var layers []WC_LAYER_DESCRIPTOR

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

-		// Create a layer descriptor, using the folder path

+		// Create a layer descriptor, using the folder name

 		// as the source for a GUID LayerId

-		g := NewGUID(parentLayerPaths[i])

+		_, folderName := filepath.Split(parentLayerPaths[i])

+		g, err := NameToGuid(folderName)

+		if err != nil {

+			logrus.Debugf("Failed to convert name to guid %s", err)

+			return nil, err

+		}

 		p, err := syscall.UTF16PtrFromString(parentLayerPaths[i])

 		if err != nil {

@@ -95,7 +101,7 @@ func layerPathsToDescriptors(parentLayerPaths []string) ([]WC_LAYER_DESCRIPTOR,

 		}

 		layers = append(layers, WC_LAYER_DESCRIPTOR{

-			LayerId: *g,

+			LayerId: g,

 			Flags:   0,

 			Pathp:   p,

 		})

new file mode 100644

@@ -0,0 +1,46 @@

+package hcsshim

+

+import (

+	"fmt"

+	"syscall"

+	"unsafe"

+

+	"github.com/Sirupsen/logrus"

+)

+

+func NameToGuid(name string) (id GUID, err error) {

+	title := "hcsshim::NameToGuid "

+	logrus.Debugf(title+"Name %s", name)

+

+	// Load the DLL and get a handle to the procedure we need

+	dll, proc, err := loadAndFind(procNameToGuid)

+	if dll != nil {

+		defer dll.Release()

+	}

+	if err != nil {

+		return

+	}

+

+	// Convert name to uint16 pointer for calling the procedure

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

+	if err != nil {

+		err = fmt.Errorf(title+" - Failed conversion of name %s to pointer %s", name, err)

+		logrus.Error(err)

+		return

+	}

+

+	// Call the procedure itself.

+	logrus.Debugf("Calling proc")

+	r1, _, _ := proc.Call(

+		uintptr(unsafe.Pointer(namep)),

+		uintptr(unsafe.Pointer(&id)))

+

+	if r1 != 0 {

+		err = fmt.Errorf(title+" - Win32 API call returned error r1=%d err=%s name=%s",

+			r1, syscall.Errno(r1), name)

+		logrus.Error(err)

+		return

+	}

+

+	return

+}

deleted file mode 100644

@@ -1,22 +0,0 @@

-# Compiled Object files, Static and Dynamic libs (Shared Objects)

-*.o

-*.a

-*.so

-

-# Folders

-_obj

-_test

-

-# Architecture specific extensions/prefixes

-*.[568vq]

-[568vq].out

-

-*.cgo1.go

-*.cgo2.c

-_cgo_defun.c

-_cgo_gotypes.go

-_cgo_export.*

-

-_testmain.go

-

-*.exe

deleted file mode 100644

@@ -1,8 +0,0 @@

-The MIT License (MIT)

-Copyright (c) 2013 npipe authors

-

-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

-

-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

-

-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

\ No newline at end of file

deleted file mode 100644

@@ -1,308 +0,0 @@

-npipe  [![Build status](https://ci.appveyor.com/api/projects/status/00vuepirsot29qwi)](https://ci.appveyor.com/project/natefinch/npipe) [![GoDoc](https://godoc.org/gopkg.in/natefinch/npipe.v2?status.svg)](https://godoc.org/gopkg.in/natefinch/npipe.v2)

-=====

-Package npipe provides a pure Go wrapper around Windows named pipes.

-

-Windows named pipe documentation: http://msdn.microsoft.com/en-us/library/windows/desktop/aa365780

-

-Note that the code lives at https://github.com/natefinch/npipe (v2 branch)

-but should be imported as gopkg.in/natefinch/npipe.v2 (the package name is

-still npipe).

-

-npipe provides an interface based on stdlib's net package, with Dial, Listen,

-and Accept functions, as well as associated implementations of net.Conn and

-net.Listener.  It supports rpc over the connection.

-

-### Notes

-* Deadlines for reading/writing to the connection are only functional in Windows Vista/Server 2008 and above, due to limitations with the Windows API.

-

-* The pipes support byte mode only (no support for message mode)

-

-### Examples

-The Dial function connects a client to a named pipe:

-

-

-	conn, err := npipe.Dial(`\\.\pipe\mypipename`)

-	if err != nil {

-		<handle error>

-	}

-	fmt.Fprintf(conn, "Hi server!\n")

-	msg, err := bufio.NewReader(conn).ReadString('\n')

-	...

-

-The Listen function creates servers:

-

-

-	ln, err := npipe.Listen(`\\.\pipe\mypipename`)

-	if err != nil {

-		// handle error

-	}

-	for {

-		conn, err := ln.Accept()

-		if err != nil {

-			// handle error

-			continue

-		}

-		go handleConnection(conn)

-	}

-

-

-

-

-

-## Variables

-``` go

-var ErrClosed = PipeError{"Pipe has been closed.", false}

-```

-ErrClosed is the error returned by PipeListener.Accept when Close is called

-on the PipeListener.

-

-

-

-## type PipeAddr

-``` go

-type PipeAddr string

-```

-PipeAddr represents the address of a named pipe.

-

-

-

-

-

-

-

-

-

-

-

-### func (PipeAddr) Network

-``` go

-func (a PipeAddr) Network() string

-```

-Network returns the address's network name, "pipe".

-

-

-

-### func (PipeAddr) String

-``` go

-func (a PipeAddr) String() string

-```

-String returns the address of the pipe

-

-

-

-## type PipeConn

-``` go

-type PipeConn struct {

-    // contains filtered or unexported fields

-}

-```

-PipeConn is the implementation of the net.Conn interface for named pipe connections.

-

-

-

-

-

-

-

-

-

-### func Dial

-``` go

-func Dial(address string) (*PipeConn, error)

-```

-Dial connects to a named pipe with the given address. If the specified pipe is not available,

-it will wait indefinitely for the pipe to become available.

-

-The address must be of the form \\.\\pipe\<name> for local pipes and \\<computer>\pipe\<name>

-for remote pipes.

-

-Dial will return a PipeError if you pass in a badly formatted pipe name.

-

-Examples:

-

-

-	// local pipe

-	conn, err := Dial(`\\.\pipe\mypipename`)

-	

-	// remote pipe

-	conn, err := Dial(`\\othercomp\pipe\mypipename`)

-

-

-### func DialTimeout

-``` go

-func DialTimeout(address string, timeout time.Duration) (*PipeConn, error)

-```

-DialTimeout acts like Dial, but will time out after the duration of timeout

-

-

-

-

-### func (\*PipeConn) Close

-``` go

-func (c *PipeConn) Close() error

-```

-Close closes the connection.

-

-

-

-### func (\*PipeConn) LocalAddr

-``` go

-func (c *PipeConn) LocalAddr() net.Addr

-```

-LocalAddr returns the local network address.

-

-

-

-### func (\*PipeConn) Read

-``` go

-func (c *PipeConn) Read(b []byte) (int, error)

-```

-Read implements the net.Conn Read method.

-

-

-

-### func (\*PipeConn) RemoteAddr

-``` go

-func (c *PipeConn) RemoteAddr() net.Addr

-```

-RemoteAddr returns the remote network address.

-