Add conpty (pseudo console) package

[dcantah]

This change adds a conpty package (and necessary bindings) that houses go friendly wrappers around
the Pseudo Console API in Windows. This will be used to support tty scenarios for Host Process containers.

There's not many tests I can add here as you need to hook this up to a running
process, where that work is coming soon. I've included a video of this working below using the
new process execution package I've been working on.

conpty.mp4

Code for the demo for a sneak peak at the API:

package main

import (
	"context"
	"fmt"
	"io"
	"log"
	"os"
	"syscall"

	"github.com/Microsoft/hcsshim/internal/conpty"
	"github.com/Microsoft/hcsshim/internal/exec"
	"github.com/Microsoft/hcsshim/internal/jobobject"
	"github.com/containerd/console"
)

type rawConReader struct {
	f *os.File
}

func (r rawConReader) Read(b []byte) (int, error) {
	n, err := syscall.Read(syscall.Handle(r.f.Fd()), b)
	if n == 0 && len(b) != 0 && err == nil {
		// A zero-byte read on a console indicates that the user wrote Ctrl-Z.
		b[0] = 26
		return 1, nil
	}
	return n, err
}

func main() {
	cpty, err := conpty.New(80, 20, 0)
	if err != nil {
		log.Fatal(err)
	}
	defer cpty.Close()

	job, err := jobobject.Create(context.Background(), &jobobject.Options{Name: "test"})
	if err != nil {
		log.Fatal(err)
	}
	defer job.Close()

	e, err := exec.New(
		`C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe`,
		"powershell",
		exec.WithJobObject(job),
		exec.WithConPty(cpty),
		exec.WithDir("C:\\"),
		exec.WithEnv(os.Environ()),
	)
	if err != nil {
		log.Fatal(err)
	}

	err = e.Start()
	if err != nil {
		log.Fatalf("failed to start process: %v", err)
	}

	var osStdin io.Reader = os.Stdin
	con, err := console.ConsoleFromFile(os.Stdin)
	if err == nil {
		err = con.SetRaw()
		if err != nil {
			log.Fatal(err)
		}
		defer func() {
			_ = con.Reset()
		}()
		// Console reads return EOF whenever the user presses Ctrl-Z.
		// Wrap the reads to translate these EOFs back.
		osStdin = rawConReader{os.Stdin}
	}

	go func() {
		_, _ = io.Copy(os.Stdout, cpty.OutPipe())
	}()

	go func() {
		_, _ = io.Copy(cpty.InPipe(), osStdin)
	}()

	err = e.Wait()
	if err != nil {
		log.Fatalf("error waiting for process: %v", err)
	}
	fmt.Printf("exit code was: %d\n", e.ExitCode())
}

[dcantah]

fyi @jsturtevant @marosset

[anmaxvl]

small nit, otherwise LGTM