deleted file mode 100644

@@ -1,67 +0,0 @@

-package term // import "github.com/docker/docker/pkg/term"

-

-import (

-	"fmt"

-	"strings"

-)

-

-// ASCII list the possible supported ASCII key sequence

-var ASCII = []string{

-	"ctrl-@",

-	"ctrl-a",

-	"ctrl-b",

-	"ctrl-c",

-	"ctrl-d",

-	"ctrl-e",

-	"ctrl-f",

-	"ctrl-g",

-	"ctrl-h",

-	"ctrl-i",

-	"ctrl-j",

-	"ctrl-k",

-	"ctrl-l",

-	"ctrl-m",

-	"ctrl-n",

-	"ctrl-o",

-	"ctrl-p",

-	"ctrl-q",

-	"ctrl-r",

-	"ctrl-s",

-	"ctrl-t",

-	"ctrl-u",

-	"ctrl-v",

-	"ctrl-w",

-	"ctrl-x",

-	"ctrl-y",

-	"ctrl-z",

-	"ctrl-[",

-	"ctrl-\\",

-	"ctrl-]",

-	"ctrl-^",

-	"ctrl-_",

-}

-

-// ToBytes converts a string representing a suite of key-sequence to the corresponding ASCII code.

-// Deprecated: use github.com/moby/term.ToBytes

-func ToBytes(keys string) ([]byte, error) {

-	codes := []byte{}

-next:

-	for _, key := range strings.Split(keys, ",") {

-		if len(key) != 1 {

-			for code, ctrl := range ASCII {

-				if ctrl == key {

-					codes = append(codes, byte(code))

-					continue next

-				}

-			}

-			if key == "DEL" {

-				codes = append(codes, 127)

-			} else {

-				return nil, fmt.Errorf("Unknown character: '%s'", key)

-			}

-		} else {

-			codes = append(codes, key[0])

-		}

-	}

-	return codes, nil

-}

deleted file mode 100644

@@ -1,25 +0,0 @@

-package term // import "github.com/docker/docker/pkg/term"

-

-import (

-	"testing"

-

-	"gotest.tools/v3/assert"

-	is "gotest.tools/v3/assert/cmp"

-)

-

-func TestToBytes(t *testing.T) {

-	codes, err := ToBytes("ctrl-a,a")

-	assert.NilError(t, err)

-	assert.Check(t, is.DeepEqual([]byte{1, 97}, codes))

-

-	_, err = ToBytes("shift-z")

-	assert.Check(t, is.ErrorContains(err, ""))

-

-	codes, err = ToBytes("ctrl-@,ctrl-[,~,ctrl-o")

-	assert.NilError(t, err)

-	assert.Check(t, is.DeepEqual([]byte{0, 27, 126, 15}, codes))

-

-	codes, err = ToBytes("DEL,+")

-	assert.NilError(t, err)

-	assert.Check(t, is.DeepEqual([]byte{127, 43}, codes))

-}

new file mode 100644

@@ -0,0 +1,84 @@

+// Package term provides structures and helper functions to work with

+// terminal (state, sizes).

+//

+// Deprecated: use github.com/moby/term instead

+package term // import "github.com/docker/docker/pkg/term"

+

+import (

+	"github.com/moby/term"

+)

+

+// EscapeError is special error which returned by a TTY proxy reader's Read()

+// method in case its detach escape sequence is read.

+// Deprecated: use github.com/moby/term.EscapeError

+type EscapeError = term.EscapeError

+

+// State represents the state of the terminal.

+// Deprecated: use github.com/moby/term.State

+type State = term.State

+

+// Winsize represents the size of the terminal window.

+// Deprecated: use github.com/moby/term.Winsize

+type Winsize = term.Winsize

+

+var (

+	// ASCII list the possible supported ASCII key sequence

+	ASCII = term.ASCII

+

+	// ToBytes converts a string representing a suite of key-sequence to the corresponding ASCII code.

+	// Deprecated: use github.com/moby/term.ToBytes

+	ToBytes = term.ToBytes

+

+	// StdStreams returns the standard streams (stdin, stdout, stderr).

+	// Deprecated: use github.com/moby/term.StdStreams

+	StdStreams = term.StdStreams

+

+	// GetFdInfo returns the file descriptor for an os.File and indicates whether the file represents a terminal.

+	// Deprecated: use github.com/moby/term.GetFdInfo

+	GetFdInfo = term.GetFdInfo

+

+	// GetWinsize returns the window size based on the specified file descriptor.

+	// Deprecated: use github.com/moby/term.GetWinsize

+	GetWinsize = term.GetWinsize

+

+	// IsTerminal returns true if the given file descriptor is a terminal.

+	// Deprecated: use github.com/moby/term.IsTerminal

+	IsTerminal = term.IsTerminal

+

+	// RestoreTerminal restores the terminal connected to the given file descriptor

+	// to a previous state.

+	// Deprecated: use github.com/moby/term.RestoreTerminal

+	RestoreTerminal = term.RestoreTerminal

+

+	// SaveState saves the state of the terminal connected to the given file descriptor.

+	// Deprecated: use github.com/moby/term.SaveState

+	SaveState = term.SaveState

+

+	// DisableEcho applies the specified state to the terminal connected to the file

+	// descriptor, with echo disabled.

+	// Deprecated: use github.com/moby/term.DisableEcho

+	DisableEcho = term.DisableEcho

+

+	// SetRawTerminal puts the terminal connected to the given file descriptor into

+	// raw mode and returns the previous state. On UNIX, this puts both the input

+	// and output into raw mode. On Windows, it only puts the input into raw mode.

+	// Deprecated: use github.com/moby/term.SetRawTerminal

+	SetRawTerminal = term.SetRawTerminal

+

+	// SetRawTerminalOutput puts the output of terminal connected to the given file

+	// descriptor into raw mode. On UNIX, this does nothing and returns nil for the

+	// state. On Windows, it disables LF -> CRLF translation.

+	// Deprecated: use github.com/moby/term.SetRawTerminalOutput

+	SetRawTerminalOutput = term.SetRawTerminalOutput

+

+	// MakeRaw puts the terminal connected to the given file descriptor into raw

+	// mode and returns the previous state of the terminal so that it can be restored.

+	// Deprecated: use github.com/moby/term.MakeRaw

+	MakeRaw = term.MakeRaw

+

+	// NewEscapeProxy returns a new TTY proxy reader which wraps the given reader

+	// and detects when the specified escape keys are read, in which case the Read

+	// method will return an error of type EscapeError.

+	// Deprecated: use github.com/moby/term.NewEscapeProxy

+	NewEscapeProxy = term.NewEscapeProxy

+)

new file mode 100644

@@ -0,0 +1,20 @@

+// +build !windows

+

+package term // import "github.com/docker/docker/pkg/term"

+

+import (

+	"github.com/moby/term"

+)

+

+// Termios is the Unix API for terminal I/O.

+// Deprecated: use github.com/moby/term.Termios

+type Termios = term.Termios

+

+var (

+	// ErrInvalidState is returned if the state of the terminal is invalid.

+	ErrInvalidState = term.ErrInvalidState

+

+	// SetWinsize tries to set the specified window size for the specified file descriptor.

+	// Deprecated: use github.com/moby/term.GetWinsize

+	SetWinsize = term.SetWinsize

+)

deleted file mode 100644

@@ -1,90 +0,0 @@

-package term // import "github.com/docker/docker/pkg/term"

-

-import (

-	"io"

-)

-

-// EscapeError is special error which returned by a TTY proxy reader's Read()

-// method in case its detach escape sequence is read.

-// Deprecated: use github.com/moby/term.EscapeError

-type EscapeError struct{}

-

-func (EscapeError) Error() string {

-	return "read escape sequence"

-}

-

-// escapeProxy is used only for attaches with a TTY. It is used to proxy

-// stdin keypresses from the underlying reader and look for the passed in

-// escape key sequence to signal a detach.

-type escapeProxy struct {

-	escapeKeys   []byte

-	escapeKeyPos int

-	r            io.Reader

-	buf          []byte

-}

-

-// NewEscapeProxy returns a new TTY proxy reader which wraps the given reader

-// and detects when the specified escape keys are read, in which case the Read

-// method will return an error of type EscapeError.

-// Deprecated: use github.com/moby/term.NewEscapeProxy

-func NewEscapeProxy(r io.Reader, escapeKeys []byte) io.Reader {

-	return &escapeProxy{

-		escapeKeys: escapeKeys,

-		r:          r,

-	}

-}

-

-func (r *escapeProxy) Read(buf []byte) (n int, err error) {

-	if len(r.escapeKeys) > 0 && r.escapeKeyPos == len(r.escapeKeys) {

-		return 0, EscapeError{}

-	}

-

-	if len(r.buf) > 0 {

-		n = copy(buf, r.buf)

-		r.buf = r.buf[n:]

-	}

-

-	nr, err := r.r.Read(buf[n:])

-	n += nr

-	if len(r.escapeKeys) == 0 {

-		return n, err

-	}

-

-	for i := 0; i < n; i++ {

-		if buf[i] == r.escapeKeys[r.escapeKeyPos] {

-			r.escapeKeyPos++

-

-			// Check if the full escape sequence is matched.

-			if r.escapeKeyPos == len(r.escapeKeys) {

-				n = i + 1 - r.escapeKeyPos

-				if n < 0 {

-					n = 0

-				}

-				return n, EscapeError{}

-			}

-			continue

-		}

-

-		// If we need to prepend a partial escape sequence from the previous

-		// read, make sure the new buffer size doesn't exceed len(buf).

-		// Otherwise, preserve any extra data in a buffer for the next read.

-		if i < r.escapeKeyPos {

-			preserve := make([]byte, 0, r.escapeKeyPos+n)

-			preserve = append(preserve, r.escapeKeys[:r.escapeKeyPos]...)

-			preserve = append(preserve, buf[:n]...)

-			n = copy(buf, preserve)

-			i += r.escapeKeyPos

-			r.buf = append(r.buf, preserve[n:]...)

-		}

-		r.escapeKeyPos = 0

-	}

-

-	// If we're in the middle of reading an escape sequence, make sure we don't

-	// let the caller read it. If later on we find that this is not the escape

-	// sequence, we'll prepend it back to buf.

-	n -= r.escapeKeyPos

-	if n < 0 {

-		n = 0

-	}

-	return n, err

-}

deleted file mode 100644

@@ -1,208 +0,0 @@

-package term // import "github.com/docker/docker/pkg/term"

-

-import (

-	"bytes"

-	"testing"

-

-	"gotest.tools/v3/assert"

-	is "gotest.tools/v3/assert/cmp"

-)

-

-func TestEscapeProxyRead(t *testing.T) {

-	t.Run("no escape keys, keys [a]", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("")

-		keys, _ := ToBytes("a")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, len(keys))

-		nr, err := reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, nr, len(keys))

-		assert.DeepEqual(t, keys, buf)

-	})

-

-	t.Run("no escape keys, keys [a,b,c]", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("")

-		keys, _ := ToBytes("a,b,c")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, len(keys))

-		nr, err := reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, nr, len(keys))

-		assert.DeepEqual(t, keys, buf)

-	})

-

-	t.Run("no escape keys, no keys", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("")

-		keys, _ := ToBytes("")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, len(keys))

-		nr, err := reader.Read(buf)

-		assert.Assert(t, is.ErrorContains(err, ""), "Should throw error when no keys are to read")

-		assert.Equal(t, nr, 0)

-		assert.Check(t, is.Len(keys, 0))

-		assert.Check(t, is.Len(buf, 0))

-	})

-

-	t.Run("DEL escape key, keys [a,b,c,+]", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("DEL")

-		keys, _ := ToBytes("a,b,c,+")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, len(keys))

-		nr, err := reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, nr, len(keys))

-		assert.DeepEqual(t, keys, buf)

-	})

-

-	t.Run("DEL escape key, no keys", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("DEL")

-		keys, _ := ToBytes("")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, len(keys))

-		nr, err := reader.Read(buf)

-		assert.Assert(t, is.ErrorContains(err, ""), "Should throw error when no keys are to read")

-		assert.Equal(t, nr, 0)

-		assert.Check(t, is.Len(keys, 0))

-		assert.Check(t, is.Len(buf, 0))

-	})

-

-	t.Run("ctrl-x,ctrl-@ escape key, keys [DEL]", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("ctrl-x,ctrl-@")

-		keys, _ := ToBytes("DEL")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, len(keys))

-		nr, err := reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, nr, 1)

-		assert.DeepEqual(t, keys, buf)

-	})

-

-	t.Run("ctrl-c escape key, keys [ctrl-c]", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("ctrl-c")

-		keys, _ := ToBytes("ctrl-c")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, len(keys))

-		nr, err := reader.Read(buf)

-		assert.Error(t, err, "read escape sequence")

-		assert.Equal(t, nr, 0)

-		assert.DeepEqual(t, keys, buf)

-	})

-

-	t.Run("ctrl-c,ctrl-z escape key, keys [ctrl-c],[ctrl-z]", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")

-		keys, _ := ToBytes("ctrl-c,ctrl-z")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, 1)

-		nr, err := reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, nr, 0)

-		assert.DeepEqual(t, keys[0:1], buf)

-

-		nr, err = reader.Read(buf)

-		assert.Error(t, err, "read escape sequence")

-		assert.Equal(t, nr, 0)

-		assert.DeepEqual(t, keys[1:], buf)

-	})

-

-	t.Run("ctrl-c,ctrl-z escape key, keys [ctrl-c,ctrl-z]", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")

-		keys, _ := ToBytes("ctrl-c,ctrl-z")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, 2)

-		nr, err := reader.Read(buf)

-		assert.Error(t, err, "read escape sequence")

-		assert.Equal(t, nr, 0, "nr should be equal to 0")

-		assert.DeepEqual(t, keys, buf)

-	})

-

-	t.Run("ctrl-c,ctrl-z escape key, keys [ctrl-c],[DEL,+]", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")

-		keys, _ := ToBytes("ctrl-c,DEL,+")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, 1)

-		nr, err := reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, nr, 0)

-		assert.DeepEqual(t, keys[0:1], buf)

-

-		buf = make([]byte, len(keys))

-		nr, err = reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, nr, len(keys))

-		assert.DeepEqual(t, keys, buf)

-	})

-

-	t.Run("ctrl-c,ctrl-z escape key, keys [ctrl-c],[DEL]", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")

-		keys, _ := ToBytes("ctrl-c,DEL")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, 1)

-		nr, err := reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, nr, 0)

-		assert.DeepEqual(t, keys[0:1], buf)

-

-		buf = make([]byte, len(keys))

-		nr, err = reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, nr, len(keys))

-		assert.DeepEqual(t, keys, buf)

-	})

-

-	t.Run("a,b,c,d escape key, keys [a,b],[c,d]", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("a,b,c,d")

-		keys, _ := ToBytes("a,b,c,d")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, 2)

-		nr, err := reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, 0, nr)

-		assert.DeepEqual(t, keys[0:2], buf)

-

-		buf = make([]byte, 2)

-		nr, err = reader.Read(buf)

-		assert.Error(t, err, "read escape sequence")

-		assert.Equal(t, 0, nr)

-		assert.DeepEqual(t, keys[2:4], buf)

-	})

-

-	t.Run("ctrl-p,ctrl-q escape key, keys [ctrl-p],[a],[ctrl-p,ctrl-q]", func(t *testing.T) {

-		escapeKeys, _ := ToBytes("ctrl-p,ctrl-q")

-		keys, _ := ToBytes("ctrl-p,a,ctrl-p,ctrl-q")

-		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)

-

-		buf := make([]byte, 1)

-		nr, err := reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, 0, nr)

-

-		buf = make([]byte, 1)

-		nr, err = reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, 1, nr)

-		assert.DeepEqual(t, keys[:1], buf)

-

-		buf = make([]byte, 2)

-		nr, err = reader.Read(buf)

-		assert.NilError(t, err)

-		assert.Equal(t, 1, nr)

-		assert.DeepEqual(t, keys[1:3], buf)

-

-		buf = make([]byte, 2)

-		nr, err = reader.Read(buf)

-		assert.Error(t, err, "read escape sequence")

-		assert.Equal(t, 0, nr)

-	})

-}

deleted file mode 100644

@@ -1,20 +0,0 @@

-// +build !windows

-

-package term // import "github.com/docker/docker/pkg/term"

-

-import (

-	"syscall"

-	"unsafe"

-

-	"golang.org/x/sys/unix"

-)

-

-func tcget(fd uintptr, p *Termios) syscall.Errno {

-	_, _, err := unix.Syscall(unix.SYS_IOCTL, fd, uintptr(getTermios), uintptr(unsafe.Pointer(p)))

-	return err

-}

-

-func tcset(fd uintptr, p *Termios) syscall.Errno {

-	_, _, err := unix.Syscall(unix.SYS_IOCTL, fd, setTermios, uintptr(unsafe.Pointer(p)))

-	return err

-}

deleted file mode 100644

@@ -1,136 +0,0 @@

-// +build !windows

-

-// Package term provides structures and helper functions to work with

-// terminal (state, sizes).

-//

-// Deprecated: use github.com/moby/term instead

-package term // import "github.com/docker/docker/pkg/term"

-

-import (

-	"errors"

-	"fmt"

-	"io"

-	"os"

-	"os/signal"

-

-	"golang.org/x/sys/unix"

-)

-

-var (

-	// ErrInvalidState is returned if the state of the terminal is invalid.

-	ErrInvalidState = errors.New("Invalid terminal state")

-)

-

-// State represents the state of the terminal.

-// Deprecated: use github.com/moby/term.State

-type State struct {

-	termios Termios

-}

-

-// Winsize represents the size of the terminal window.

-// Deprecated: use github.com/moby/term.Winsize

-type Winsize struct {

-	Height uint16

-	Width  uint16

-	x      uint16

-	y      uint16

-}

-

-// StdStreams returns the standard streams (stdin, stdout, stderr).

-// Deprecated: use github.com/moby/term.StdStreams

-func StdStreams() (stdIn io.ReadCloser, stdOut, stdErr io.Writer) {

-	return os.Stdin, os.Stdout, os.Stderr

-}

-

-// GetFdInfo returns the file descriptor for an os.File and indicates whether the file represents a terminal.

-// Deprecated: use github.com/moby/term.GetFdInfo

-func GetFdInfo(in interface{}) (uintptr, bool) {

-	var inFd uintptr

-	var isTerminalIn bool

-	if file, ok := in.(*os.File); ok {

-		inFd = file.Fd()

-		isTerminalIn = IsTerminal(inFd)

-	}

-	return inFd, isTerminalIn

-}

-

-// IsTerminal returns true if the given file descriptor is a terminal.

-// Deprecated: use github.com/moby/term.IsTerminal

-func IsTerminal(fd uintptr) bool {

-	var termios Termios

-	return tcget(fd, &termios) == 0

-}

-

-// RestoreTerminal restores the terminal connected to the given file descriptor

-// to a previous state.

-// Deprecated: use github.com/moby/term.RestoreTerminal

-func RestoreTerminal(fd uintptr, state *State) error {

-	if state == nil {

-		return ErrInvalidState

-	}

-	if err := tcset(fd, &state.termios); err != 0 {

-		return err

-	}

-	return nil

-}

-

-// SaveState saves the state of the terminal connected to the given file descriptor.

-// Deprecated: use github.com/moby/term.SaveState

-func SaveState(fd uintptr) (*State, error) {

-	var oldState State

-	if err := tcget(fd, &oldState.termios); err != 0 {

-		return nil, err

-	}

-

-	return &oldState, nil

-}

-

-// DisableEcho applies the specified state to the terminal connected to the file

-// descriptor, with echo disabled.

-// Deprecated: use github.com/moby/term.DisableEcho

-func DisableEcho(fd uintptr, state *State) error {

-	newState := state.termios

-	newState.Lflag &^= unix.ECHO

-

-	if err := tcset(fd, &newState); err != 0 {

-		return err

-	}

-	handleInterrupt(fd, state)

-	return nil

-}

-

-// SetRawTerminal puts the terminal connected to the given file descriptor into

-// raw mode and returns the previous state. On UNIX, this puts both the input

-// and output into raw mode. On Windows, it only puts the input into raw mode.

-// Deprecated: use github.com/moby/term.SetRawTerminal

-func SetRawTerminal(fd uintptr) (*State, error) {

-	oldState, err := MakeRaw(fd)

-	if err != nil {

-		return nil, err

-	}

-	handleInterrupt(fd, oldState)

-	return oldState, err

-}

-

-// SetRawTerminalOutput puts the output of terminal connected to the given file

-// descriptor into raw mode. On UNIX, this does nothing and returns nil for the

-// state. On Windows, it disables LF -> CRLF translation.

-// Deprecated: use github.com/moby/term.SetRawTerminalOutput

-func SetRawTerminalOutput(fd uintptr) (*State, error) {

-	return nil, nil

-}

-

-func handleInterrupt(fd uintptr, state *State) {

-	sigchan := make(chan os.Signal, 1)

-	signal.Notify(sigchan, os.Interrupt)

-	go func() {

-		for range sigchan {

-			// quit cleanly and the new terminal item is on a new line

-			fmt.Println()

-			signal.Stop(sigchan)

-			close(sigchan)

-			RestoreTerminal(fd, state)

-			os.Exit(1)

-		}

-	}()

-}

deleted file mode 100644

@@ -1,117 +0,0 @@

-//+build linux

-

-package term // import "github.com/docker/docker/pkg/term"

-

-import (

-	"io/ioutil"

-	"os"

-	"testing"

-

-	"github.com/google/go-cmp/cmp"

-	"gotest.tools/v3/assert"

-)

-

-// RequiresRoot skips tests that require root, unless the test.root flag has

-// been set

-func RequiresRoot(t *testing.T) {

-	if os.Getuid() != 0 {

-		t.Skip("skipping test that requires root")

-		return

-	}

-}

-

-func newTtyForTest(t *testing.T) (*os.File, error) {

-	RequiresRoot(t)

-	return os.OpenFile("/dev/tty", os.O_RDWR, os.ModeDevice)

-}

-

-func newTempFile() (*os.File, error) {

-	return ioutil.TempFile(os.TempDir(), "temp")

-}

-

-func TestGetWinsize(t *testing.T) {

-	tty, err := newTtyForTest(t)

-	assert.NilError(t, err)

-	defer tty.Close()

-	winSize, err := GetWinsize(tty.Fd())

-	assert.NilError(t, err)

-	assert.Assert(t, winSize != nil)

-

-	newSize := Winsize{Width: 200, Height: 200, x: winSize.x, y: winSize.y}

-	err = SetWinsize(tty.Fd(), &newSize)

-	assert.NilError(t, err)

-	winSize, err = GetWinsize(tty.Fd())

-	assert.NilError(t, err)

-	assert.DeepEqual(t, *winSize, newSize, cmpWinsize)

-}

-

-var cmpWinsize = cmp.AllowUnexported(Winsize{})

-

-func TestSetWinsize(t *testing.T) {

-	tty, err := newTtyForTest(t)

-	assert.NilError(t, err)

-	defer tty.Close()

-	winSize, err := GetWinsize(tty.Fd())

-	assert.NilError(t, err)

-	assert.Assert(t, winSize != nil)

-	newSize := Winsize{Width: 200, Height: 200, x: winSize.x, y: winSize.y}

-	err = SetWinsize(tty.Fd(), &newSize)

-	assert.NilError(t, err)

-	winSize, err = GetWinsize(tty.Fd())

-	assert.NilError(t, err)

-	assert.DeepEqual(t, *winSize, newSize, cmpWinsize)

-}

-

-func TestGetFdInfo(t *testing.T) {

-	tty, err := newTtyForTest(t)

-	assert.NilError(t, err)

-	defer tty.Close()

-	inFd, isTerminal := GetFdInfo(tty)

-	assert.Equal(t, inFd, tty.Fd())

-	assert.Equal(t, isTerminal, true)

-	tmpFile, err := newTempFile()

-	assert.NilError(t, err)

-	defer tmpFile.Close()

-	inFd, isTerminal = GetFdInfo(tmpFile)

-	assert.Equal(t, inFd, tmpFile.Fd())

-	assert.Equal(t, isTerminal, false)

-}

-

-func TestIsTerminal(t *testing.T) {

-	tty, err := newTtyForTest(t)

-	assert.NilError(t, err)

-	defer tty.Close()

-	isTerminal := IsTerminal(tty.Fd())

-	assert.Equal(t, isTerminal, true)

-	tmpFile, err := newTempFile()

-	assert.NilError(t, err)

-	defer tmpFile.Close()

-	isTerminal = IsTerminal(tmpFile.Fd())

-	assert.Equal(t, isTerminal, false)

-}

-

-func TestSaveState(t *testing.T) {

-	tty, err := newTtyForTest(t)

-	assert.NilError(t, err)

-	defer tty.Close()

-	state, err := SaveState(tty.Fd())

-	assert.NilError(t, err)

-	assert.Assert(t, state != nil)

-	tty, err = newTtyForTest(t)

-	assert.NilError(t, err)

-	defer tty.Close()

-	err = RestoreTerminal(tty.Fd(), state)

-	assert.NilError(t, err)

-}

-

-func TestDisableEcho(t *testing.T) {

-	tty, err := newTtyForTest(t)

-	assert.NilError(t, err)

-	defer tty.Close()

-	state, err := SetRawTerminal(tty.Fd())

-	defer RestoreTerminal(tty.Fd(), state)

-	assert.NilError(t, err)

-	assert.Assert(t, state != nil)

-	err = DisableEcho(tty.Fd(), state)

-	assert.NilError(t, err)

-}

deleted file mode 100644

@@ -1,233 +0,0 @@

-package term // import "github.com/docker/docker/pkg/term"

-

-import (

-	"io"

-	"os"

-	"os/signal"

-	"syscall" // used for STD_INPUT_HANDLE, STD_OUTPUT_HANDLE and STD_ERROR_HANDLE

-

-	"github.com/Azure/go-ansiterm/winterm"

-	windowsconsole "github.com/docker/docker/pkg/term/windows"

-)

-

-// State holds the console mode for the terminal.

-// Deprecated: use github.com/moby/term.State

-type State struct {

-	mode uint32

-}

-

-// Winsize is used for window size.

-// Deprecated: use github.com/moby/term.Winsize

-type Winsize struct {

-	Height uint16

-	Width  uint16

-}

-

-// vtInputSupported is true if winterm.ENABLE_VIRTUAL_TERMINAL_INPUT is supported by the console

-var vtInputSupported bool

-

-// StdStreams returns the standard streams (stdin, stdout, stderr).

-// Deprecated: use github.com/moby/term.StdStreams

-func StdStreams() (stdIn io.ReadCloser, stdOut, stdErr io.Writer) {

-	// Turn on VT handling on all std handles, if possible. This might

-	// fail, in which case we will fall back to terminal emulation.

-	var emulateStdin, emulateStdout, emulateStderr bool

-	fd := os.Stdin.Fd()

-	if mode, err := winterm.GetConsoleMode(fd); err == nil {

-		// Validate that winterm.ENABLE_VIRTUAL_TERMINAL_INPUT is supported, but do not set it.

-		if err = winterm.SetConsoleMode(fd, mode|winterm.ENABLE_VIRTUAL_TERMINAL_INPUT); err != nil {

-			emulateStdin = true

-		} else {

-			vtInputSupported = true

-		}

-		// Unconditionally set the console mode back even on failure because SetConsoleMode

-		// remembers invalid bits on input handles.

-		winterm.SetConsoleMode(fd, mode)

-	}

-

-	fd = os.Stdout.Fd()

-	if mode, err := winterm.GetConsoleMode(fd); err == nil {

-		// Validate winterm.DISABLE_NEWLINE_AUTO_RETURN is supported, but do not set it.

-		if err = winterm.SetConsoleMode(fd, mode|winterm.ENABLE_VIRTUAL_TERMINAL_PROCESSING|winterm.DISABLE_NEWLINE_AUTO_RETURN); err != nil {

-			emulateStdout = true

-		} else {

-			winterm.SetConsoleMode(fd, mode|winterm.ENABLE_VIRTUAL_TERMINAL_PROCESSING)

-		}

-	}

-

-	fd = os.Stderr.Fd()

-	if mode, err := winterm.GetConsoleMode(fd); err == nil {

-		// Validate winterm.DISABLE_NEWLINE_AUTO_RETURN is supported, but do not set it.

-		if err = winterm.SetConsoleMode(fd, mode|winterm.ENABLE_VIRTUAL_TERMINAL_PROCESSING|winterm.DISABLE_NEWLINE_AUTO_RETURN); err != nil {

-			emulateStderr = true

-		} else {

-			winterm.SetConsoleMode(fd, mode|winterm.ENABLE_VIRTUAL_TERMINAL_PROCESSING)

-		}

-	}

-

-	// Temporarily use STD_INPUT_HANDLE, STD_OUTPUT_HANDLE and

-	// STD_ERROR_HANDLE from syscall rather than x/sys/windows as long as

-	// go-ansiterm hasn't switch to x/sys/windows.

-	// TODO: switch back to x/sys/windows once go-ansiterm has switched

-	if emulateStdin {