536aef9c63
On termios platforms, interrupt signals are not generated in raw mode terminals
as the ISIG setting is not enabled. Remove interrupt handler as it does nothing
for raw mode and prevents other uses of INT signal with this library.
This code seems to go back all the way to moby/moby#214 where signal handling was
improved for monolithic docker repository. Raw mode -ISIG got reintroduced in
https://github.com/moby/moby/commit/3f63b878076, but the INT handler was left
behind.
full diff: abb19827d3...c43b287e0e
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
101 lines
2.6 KiB
Go
101 lines
2.6 KiB
Go
//go:build !windows
|
|
// +build !windows
|
|
|
|
// Package term provides structures and helper functions to work with
|
|
// terminal (state, sizes).
|
|
package term
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"os"
|
|
|
|
"golang.org/x/sys/unix"
|
|
)
|
|
|
|
// ErrInvalidState is returned if the state of the terminal is invalid.
|
|
var ErrInvalidState = errors.New("Invalid terminal state")
|
|
|
|
// State represents the state of the terminal.
|
|
type State struct {
|
|
termios Termios
|
|
}
|
|
|
|
// Winsize represents the size of the terminal window.
|
|
type Winsize struct {
|
|
Height uint16
|
|
Width uint16
|
|
x uint16
|
|
y uint16
|
|
}
|
|
|
|
// StdStreams returns the standard streams (stdin, stdout, stderr).
|
|
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.
|
|
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.
|
|
func IsTerminal(fd uintptr) bool {
|
|
_, err := tcget(fd)
|
|
return err == nil
|
|
}
|
|
|
|
// RestoreTerminal restores the terminal connected to the given file descriptor
|
|
// to a previous state.
|
|
func RestoreTerminal(fd uintptr, state *State) error {
|
|
if state == nil {
|
|
return ErrInvalidState
|
|
}
|
|
return tcset(fd, &state.termios)
|
|
}
|
|
|
|
// SaveState saves the state of the terminal connected to the given file descriptor.
|
|
func SaveState(fd uintptr) (*State, error) {
|
|
termios, err := tcget(fd)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &State{termios: *termios}, nil
|
|
}
|
|
|
|
// DisableEcho applies the specified state to the terminal connected to the file
|
|
// descriptor, with echo disabled.
|
|
func DisableEcho(fd uintptr, state *State) error {
|
|
newState := state.termios
|
|
newState.Lflag &^= unix.ECHO
|
|
|
|
if err := tcset(fd, &newState); err != nil {
|
|
return err
|
|
}
|
|
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.
|
|
func SetRawTerminal(fd uintptr) (*State, error) {
|
|
oldState, err := MakeRaw(fd)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
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.
|
|
func SetRawTerminalOutput(fd uintptr) (*State, error) {
|
|
return nil, nil
|
|
}
|