// getNativeConsole returns the console modes ('state') for the native Windows console func getNativeConsole() (State, error) { var ( err error state State ) // Get the handle to stdout if state.outHandle, err = syscall.GetStdHandle(syscall.STD_OUTPUT_HANDLE); err != nil { return state, err } // Get the console mode from the consoles stdout handle if err = syscall.GetConsoleMode(state.outHandle, &state.outMode); err != nil { return state, err } // Get the handle to stdin if state.inHandle, err = syscall.GetStdHandle(syscall.STD_INPUT_HANDLE); err != nil { return state, err } // Get the console mode from the consoles stdin handle if err = syscall.GetConsoleMode(state.inHandle, &state.inMode); err != nil { return state, err } return state, nil }
func (pr passwordReader) PromptForPassword(promptText string, args ...interface{}) (passwd string) { hStdin := syscall.Handle(os.Stdin.Fd()) var originalMode uint32 err := syscall.GetConsoleMode(hStdin, &originalMode) if err != nil { return } var newMode uint32 = (originalMode &^ ENABLE_ECHO_INPUT) err = setConsoleMode(hStdin, newMode) defer setConsoleMode(hStdin, originalMode) if err != nil { return } // Display the prompt. fmt.Printf(promptText+": ", args...) defer fmt.Println("") rd := bufio.NewReader(os.Stdin) line, err := rd.ReadString('\r') if err == nil { return strings.TrimSpace(line) } return "" }
// NewTerminal creates a terminal and sets it to raw input mode. func NewTerminal() (*Terminal, error) { term := &Terminal{ In: os.Stdin, Out: os.Stdout, History: make([]string, 0, 10), histIdx: -1, terminal: new(terminal), } err := syscall.GetConsoleMode(syscall.Handle(term.In.Fd()), &term.origMode) if err != nil { return term, nil } mode := term.origMode term.isTerm = true // Set new mode flags. mode &^= (echoInputFlag | insertModeFlag | lineInputFlag | mouseInputFlag | processedInputFlag | windowInputFlag) ret, _, err := setConsoleMode.Call(term.In.Fd(), uintptr(mode)) if ret == 0 { return nil, err } return term, nil }
// newFile returns a new File with the given file handle and name. // Unlike NewFile, it does not check that h is syscall.InvalidHandle. func newFile(h syscall.Handle, name string) *File { f := &File{&file{fd: h, name: name}} var m uint32 if syscall.GetConsoleMode(f.fd, &m) == nil { f.isConsole = true } runtime.SetFinalizer(f.file, (*file).close) return f }
// DisableFlags disables the terminal flags specified in the function // argument 'flags', and returns the previous state of the terminal // so that it can be restored. func DisableFlags(fd FileDescriptor, flags Flag) (*State, error) { var st uint32 err := syscall.GetConsoleMode(handle(fd), &st) if err != nil { return nil, err } st &^= uint32(flags) err = win.SetConsoleMode(handle(fd), st) return &State{st}, err }
// Might not catch everything... func IsAtty(fd uintptr) bool { handle := syscall.Handle(fd) var mode uint32 err := syscall.GetConsoleMode(handle, &mode) if err != nil { return false } return true }
// NewFile returns a new File with the given file descriptor and name. func NewFile(fd uintptr, name string) *File { h := syscall.Handle(fd) if h == syscall.InvalidHandle { return nil } var m uint32 if syscall.GetConsoleMode(h, &m) == nil { return newConsoleFile(h, name) } return newFile(h, name) }
// NewFile returns a new File with the given file descriptor and name. func NewFile(fd uintptr, name string) *File { h := syscall.Handle(fd) if h == syscall.InvalidHandle { return nil } f := &File{&file{fd: h, name: name}} var m uint32 if syscall.GetConsoleMode(f.fd, &m) == nil { f.isConsole = true } runtime.SetFinalizer(f.file, (*file).close) return f }
func main() { var mode uint32 err := syscall.GetConsoleMode(syscall.Stdin, &mode) isConsole := err == nil commandName := filepath.Base(os.Args[0]) if isConsole == true || commandName != names.Jujud { runConsole() } else { runService() } }
// useNativeConsole determines if the docker client should use the built-in // console which supports ANSI emulation, or fall-back to the golang emulator // (github.com/azure/go-ansiterm). func useNativeConsole() bool { osv, err := system.GetOSVersion() if err != nil { return false } // Native console is not available major version 10 if osv.MajorVersion < 10 { return false } // Must have a late pre-release TP4 build of Windows Server 2016/Windows 10 TH2 or later if osv.Build < 10578 { return false } // Environment variable override if e := os.Getenv("USE_NATIVE_CONSOLE"); e != "" { if e == "1" { return true } return false } // Get the handle to stdout stdOutHandle, err := syscall.GetStdHandle(syscall.STD_OUTPUT_HANDLE) if err != nil { return false } // Get the console mode from the consoles stdout handle var mode uint32 if err := syscall.GetConsoleMode(stdOutHandle, &mode); err != nil { return false } // Legacy mode does not have native ANSI emulation. // https://msdn.microsoft.com/en-us/library/windows/desktop/ms683167(v=vs.85).aspx const enableVirtualTerminalProcessing = 0x0004 if mode&enableVirtualTerminalProcessing == 0 { return false } // TODO Windows (Post TP4). The native emulator still has issues which // mean it shouldn't be enabled for everyone. Change this next line to true // to change the default to "enable if available". In the meantime, users // can still try it out by using USE_NATIVE_CONSOLE env variable. return false }
func makeRaw(console syscall.Handle) (func(), error) { // Get old mode so that we can recover later var oldMode uint32 if err := syscall.GetConsoleMode(console, &oldMode); err != nil { return nil, err } var newMode uint32 = uint32(int(oldMode) & ^ENABLE_ECHO_INPUT) if err := setConsoleMode(console, newMode); err != nil { return nil, err } return func() { setConsoleMode(console, oldMode) }, nil }
func getPassword() (password string, err error) { var oldMode uint32 err = syscall.GetConsoleMode(syscall.Stdin, &oldMode) if err != nil { return } var newMode uint32 = (oldMode &^ ENABLE_ECHO_INPUT) err = setConsoleMode(syscall.Stdin, newMode) defer setConsoleMode(syscall.Stdin, oldMode) if err != nil { return } return readline() }
func read(f *os.File) (string, error) { handle := syscall.Handle(f.Fd()) // Grab the old console mode so we can reset it. We defer the reset // right away because it doesn't matter (it is idempotent). var oldMode uint32 if err := syscall.GetConsoleMode(handle, &oldMode); err != nil { return "", err } defer setConsoleMode(handle, oldMode) // The new mode is the old mode WITHOUT the echo input flag set. var newMode uint32 = uint32(int(oldMode) & ^ENABLE_ECHO_INPUT) if err := setConsoleMode(handle, newMode); err != nil { return "", err } return readline(f) }
func (ui terminalUI) AskForPassword(prompt string, args ...interface{}) (passwd string) { hStdin := syscall.Handle(os.Stdin.Fd()) var originalMode uint32 err := syscall.GetConsoleMode(hStdin, &originalMode) if err != nil { return } var newMode = uint32(originalMode &^ EnableEchoInput) err = setConsoleMode(hStdin, newMode) defer setConsoleMode(hStdin, originalMode) defer ui.Say("") if err != nil { return } return ui.Ask(prompt, args...) }
func (ui terminalUI) AskForPassword(prompt string) (passwd string) { hStdin := syscall.Handle(os.Stdin.Fd()) var originalMode uint32 err := syscall.GetConsoleMode(hStdin, &originalMode) if err != nil { return } var newMode uint32 = (originalMode &^ ENABLE_ECHO_INPUT) err = setConsoleMode(hStdin, newMode) defer setConsoleMode(hStdin, originalMode) defer ui.Say("") if err != nil { return } return ui.Ask(prompt) }
// getColorableWriter will return a writer that is capable // of interpreting ANSI escape codes for terminal colors. func getColorableWriter() io.Writer { if strings.ToLower(os.Getenv("ConEmuANSI")) == "on" { // The ConEmu terminal is installed. Use it. return os.Stdout } const ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004 h, err := syscall.GetStdHandle(syscall.STD_OUTPUT_HANDLE) if err != nil { return os.Stdout } var m uint32 err = syscall.GetConsoleMode(h, &m) if err != nil { return os.Stdout } if m&ENABLE_VIRTUAL_TERMINAL_PROCESSING != 0 { return os.Stdout } return colorable.NewColorableStdout() }
// NewTerminal creates a terminal and sets it to raw input mode. func NewTerminal() (*Terminal, error) { if inReader == nil { inReader = bufio.NewReader(os.Stdin) } term := &Terminal{In: os.Stdin, Out: os.Stdout} err := syscall.GetConsoleMode(syscall.Handle(term.In.Fd()), &term.origMode) if err != nil { return term, nil } mode := term.origMode term.isTerm = true // Set new mode flags. mode &^= (echoInputFlag | insertModeFlag | lineInputFlag | mouseInputFlag | processedInputFlag | windowInputFlag) ret, _, err := setConsoleMode.Call(term.In.Fd(), uintptr(mode)) if ret == 0 { return nil, errors.NewStackError(err) } return term, nil }
// GetConsoleMode gets the console mode for given file descriptor // See http://msdn.microsoft.com/en-us/library/windows/desktop/ms683167(v=vs.85).aspx. func GetConsoleMode(handle uintptr) (mode uint32, err error) { err = syscall.GetConsoleMode(syscall.Handle(handle), &mode) return mode, err }
// IsTerminal returns true if the given file descriptor is a terminal. func IsTerminal(fd FileDescriptor) (is bool) { var mode uint32 is = syscall.GetConsoleMode(handle(fd), &mode) == nil return }
func GetConsoleMode(fileDesc uintptr) (uint32, error) { var mode uint32 err := syscall.GetConsoleMode(syscall.Handle(fileDesc), &mode) return mode, err }