# 查看当前终端对应的设备文件
$ tty
/dev/ttys003    # macOS 示例
/dev/pts/0      # Linux 示例

package main

import (
  "fmt"
  "os"
)

func main() {
  // os.File 类型有 Fd() 方法，返回 uintptr
  // 需要转换为 int 才能传给 term 包的函数
  stdinFd  := int(os.Stdin.Fd())   // 通常为 0
  stdoutFd := int(os.Stdout.Fd())  // 通常为 1
  stderrFd := int(os.Stderr.Fd())  // 通常为 2

  fmt.Printf("stdin  fd: %d\n", stdinFd)
  fmt.Printf("stdout fd: %d\n", stdoutFd)
  fmt.Printf("stderr fd: %d\n", stderrFd)
}

// C 语言定义（Linux/macOS）
struct termios {
  tcflag_t c_iflag;   // 输入模式标志  (Input flags)
  tcflag_t c_oflag;   // 输出模式标志  (Output flags)
  tcflag_t c_cflag;   // 控制模式标志  (Control flags)
  tcflag_t c_lflag;   // 本地模式标志  (Local flags) — 最重要
  cc_t     c_cc[NCCS]; // 控制字符     (Control characters)
  // ... 波特率等字段
};

// C 系统调用
#include <termios.h>

// 读取终端属性
int tcgetattr(int fd, struct termios *termios_p);

// 设置终端属性
// action: TCSANOW(立即生效) / TCSADRAIN(排空后生效) / TCSAFLUSH(清空后生效)
int tcsetattr(int fd, int action, const struct termios *termios_p);

package main

import (
  "fmt"
  "os"
  "golang.org/x/sys/unix"
)

func showTermiosFlags() {
  fd := int(os.Stdin.Fd())

  // 读取当前 termios 属性
  termios, err := unix.IoctlGetTermios(fd, unix.TIOCGETA) // macOS
  // termios, err := unix.IoctlGetTermios(fd, unix.TCGETS) // Linux
  if err != nil {
    panic(err)
  }

  fmt.Printf("c_lflag: 0x%08X\n", termios.Lflag)

  // 检查各标志位
  if termios.Lflag & unix.ECHO != 0 {
    fmt.Println("ECHO: 开启（输入会回显）")
  }
  if termios.Lflag & unix.ICANON != 0 {
    fmt.Println("ICANON: 开启（行缓冲模式）")
  }
  if termios.Lflag & unix.ISIG != 0 {
    fmt.Println("ISIG: 开启（处理 Ctrl+C 等信号）")
  }
}

// 等价于 term.MakeRaw 的手动实现（仅作说明，实际请使用 term.MakeRaw）
func makeRawManual(fd int) (*term.State, error) {
  // 1. 读取当前状态（保存备份）
  termios, _ := unix.IoctlGetTermios(fd, unix.TIOCGETA)
  oldState := *termios  // 深拷贝

  // 2. 修改为 Raw 模式
  // 关闭回显、行缓冲、信号处理、扩展处理
  termios.Lflag &^= unix.ECHO | unix.ECHONL | unix.ICANON | unix.ISIG | unix.IEXTEN
  // 关闭输入转换
  termios.Iflag &^= unix.ICRNL | unix.INPCK | unix.ISTRIP | unix.IXON
  // 设置字符大小为 8 位
  termios.Cflag |= unix.CS8
  // VMIN=1: 读取至少 1 个字符才返回
  // VTIME=0: 不设置超时
  termios.Cc[unix.VMIN] = 1
  termios.Cc[unix.VTIME] = 0

  // 3. 应用新状态
  unix.IoctlSetTermios(fd, unix.TIOCSETA, termios)

  // 返回旧状态，用于后续恢复
  // return &term.State{oldState}, nil  // (实际 State 字段是私有的)
  return nil, nil
}

// Cooked 模式示例（默认，无需特殊设置）
package main

import (
  "fmt"
)

func main() {
  fmt.Print("请输入（Cooked 模式，按 Enter 结束）: ")

  var input string
  fmt.Scanln(&input)  // 程序在此阻塞，直到用户按 Enter

  // 期间用户可以：
  // - 看到自己输入的字符（回显）
  // - 用 Backspace 修改错误
  // - 按 Ctrl+C 终止程序
  fmt.Printf("收到: %q\n", input)
}

// Raw 模式示例
package main

import (
  "fmt"
  "os"
  "golang.org/x/term"
)

func main() {
  fd := int(os.Stdin.Fd())

  // 切换到 Raw 模式，保存旧状态
  oldState, err := term.MakeRaw(fd)
  if err != nil {
    panic(err)
  }
  // 用 defer 确保即使 panic 也能恢复
  defer term.Restore(fd, oldState)

  fmt.Print("Raw 模式，逐字符读取（按 q 退出）:\r\n")

  buf := make([]byte, 1)
  for {
    n, err := os.Stdin.Read(buf)
    if err != nil || n == 0 {
      break
    }

    ch := buf[0]

    // 手动处理 Ctrl+C（字节值 3）
    if ch == 3 {
      fmt.Print("\r\n收到 Ctrl+C，退出\r\n")
      return
    }

    // 手动处理退出
    if ch == 'q' || ch == 'Q' {
      fmt.Print("\r\n退出\r\n")
      return
    }

    // 注意：Raw 模式下换行需要 \r\n，仅 \n 只换行不回车
    fmt.Printf("收到: %c (0x%02X)\r\n", ch, ch)
  }
}

go get golang.org/x/term

package main

import (
  "fmt"
  "os"
  "golang.org/x/term"
)

func main() {
  stdinFd := int(os.Stdin.Fd())

  if term.IsTerminal(stdinFd) {
    fmt.Println("运行在交互式终端中，可以使用终端控制功能")
  } else {
    // 例如：echo "hello" | go run main.go
    fmt.Println("stdin 被重定向（管道/文件），不是终端")
    // 此时调用 term.MakeRaw 等会失败
  }
}

package main

import (
  "fmt"
  "os"
  "golang.org/x/term"
)

func main() {
  width, height, err := term.GetSize(int(os.Stdout.Fd()))
  if err != nil {
    fmt.Println("获取终端大小失败:", err)
    return
  }
  fmt.Printf("终端大小: %d 列 × %d 行\n", width, height)

  // 实际应用：绘制分隔线
  for i := 0; i < width; i++ {
    fmt.Print("─")
  }
  fmt.Println()
}

struct winsize {
  unsigned short ws_row;    // 行数
  unsigned short ws_col;    // 列数
  unsigned short ws_xpixel; // 像素宽（通常为 0）
  unsigned short ws_ypixel; // 像素高（通常为 0）
};

package main

import (
  "fmt"
  "os"
  "golang.org/x/term"
)

func main() {
  fd := int(os.Stdin.Fd())

  // MakeRaw 会：
  // 1. 调用 tcgetattr(fd) 读取当前状态
  // 2. 修改标志位（关闭 ECHO、ICANON、ISIG 等）
  // 3. 调用 tcsetattr(fd, TCSANOW) 立即应用
  // 4. 返回第 1 步保存的旧状态
  oldState, err := term.MakeRaw(fd)
  if err != nil {
    panic(err)
  }
  defer term.Restore(fd, oldState) // 必须恢复！

  fmt.Print("现在是 Raw 模式\r\n")
  // ... 在 Raw 模式下做事情
}

// 正确的状态恢复模式
oldState, err := term.MakeRaw(fd)
if err != nil {
  return err
}
// 方式 1：defer（推荐，即使 panic 也会执行）
defer term.Restore(fd, oldState)

// 方式 2：手动（需要确保所有代码路径都调用）
// 注意：不要使用 defer 时，记得在每个 return 前调用
// term.Restore(fd, oldState)

package main

import (
  "fmt"
  "os"
  "golang.org/x/term"
)

func main() {
  fmt.Print("密码: ")

  // 注意：ReadPassword 不会在行尾打印换行
  // 调用后需要手动 fmt.Println()
  password, err := term.ReadPassword(int(os.Stdin.Fd()))
  if err != nil {
    fmt.Println("\n错误:", err)
    return
  }

  fmt.Println() // 补充换行，避免下一行输出紧跟在密码提示后面

  // password 是 []byte，包含用户输入的原始字节
  // 生产环境不应打印密码！这里仅作演示
  fmt.Printf("密码长度: %d\n", len(password))
}

package main

import (
  "fmt"
  "os"
  "golang.org/x/term"
)

func main() {
  fd := int(os.Stdin.Fd())
  oldState, err := term.MakeRaw(fd)
  if err != nil {
    panic(err)
  }
  defer term.Restore(fd, oldState)

  // NewTerminal 内部实现了行编辑（左右方向键、历史记录等）
  t := term.NewTerminal(os.Stdin, "> ")

  for {
    line, err := t.ReadLine()
    if err != nil {
      break
    }
    if line == "exit" {
      break
    }
    fmt.Fprintln(t, "你输入了: "+line)
  }
}

// 04_t.go - 用 PTY 创建一个完整的 Shell 会话
package main

import (
  "io"
  "os"
  "os/exec"
  "os/signal"
  "syscall"

  "github.com/creack/pty"
  "golang.org/x/term"
)

func main() {
  // 1. 创建要运行的 shell 命令
  cmd := exec.Command("bash")

  // 2. pty.Start() 做了以下事情：
  //    - 打开 /dev/ptmx 获得 master fd（ptmx）
  //    - 通过 grantpt/unlockpt 解锁对应的 slave 设备 /dev/pts/N
  //    - fork + exec "bash"，将 bash 的 stdin/stdout/stderr 连接到 slave
  //    - 返回 master fd 的 *os.File
  ptmx, err := pty.Start(cmd)
  if err != nil {
    panic(err)
  }
  defer ptmx.Close()

  // 3. 将当前终端（os.Stdin）切到 Raw 模式
  //    这样我们的按键可以不经过本地 TTY 处理，直接转发给 bash
  oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
  if err != nil {
    panic(err)
  }
  defer term.Restore(int(os.Stdin.Fd()), oldState)

  // 4. 处理窗口大小变化
  //    当终端窗口调整大小时，内核发送 SIGWINCH 信号
  //    我们需要将新的大小同步到 PTY slave，否则 bash 不知道窗口变了
  ch := make(chan os.Signal, 1)
  signal.Notify(ch, syscall.SIGWINCH)
  go func() {
    for range ch {
      // pty.InheritSize 读取 os.Stdin 的窗口大小
      // 并通过 ioctl(ptmx, TIOCSWINSZ) 设置给 PTY
      pty.InheritSize(os.Stdin, ptmx)
    }
  }()
  ch <- syscall.SIGWINCH // 初始同步一次当前窗口大小

  // 5. 双向数据拷贝：
  //    os.Stdin → ptmx：用户输入转发给 bash
  //    ptmx → os.Stdout：bash 输出转发给用户终端
  go func() {
    _, _ = io.Copy(ptmx, os.Stdin) // 键盘输入 → bash
  }()
  _, _ = io.Copy(os.Stdout, ptmx) // bash 输出 → 屏幕
  // 当 bash 退出时，ptmx 的读取端返回 EOF，io.Copy 返回，main 函数退出
}

package main

import (
  "fmt"
  "os"
  "golang.org/x/term"
)

func main() {
  fmt.Print("请输入密码: ")

  // term.ReadPassword 内部：
  // 1. tcgetattr 保存状态
  // 2. 关闭 ECHO 标志
  // 3. tcsetattr 应用
  // 4. 逐字节读取直到 \n 或 \r
  // 5. tcsetattr 恢复原状态
  password, err := term.ReadPassword(int(os.Stdin.Fd()))
  if err != nil {
    panic(err)
  }

  fmt.Println()
  fmt.Printf("密码长度: %d\n", len(password))
}

package main

import (
  "fmt"
  "os"
  "golang.org/x/term"
)

// Cooked 模式演示：默认行为，无需特殊设置
func demonstrateCookedMode() {
  fmt.Println("=== Cooked 模式 ===")
  fmt.Println("（可以看到输入，可以 Backspace，按 Enter 结束）")
  fmt.Print("输入: ")

  var input string
  fmt.Scanln(&input) // 阻塞直到 Enter，期间 TTY 驱动处理所有行编辑

  fmt.Printf("程序收到: %q（共 %d 字节）\n\n", input, len(input))
}

// Raw 模式演示：逐字符读取，完全控制
func demonstrateRawMode() {
  fmt.Println("=== Raw 模式 ===")
  fmt.Println("（看不到输入，每个字符立即发给程序，按 Enter 结束）")

  oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
  if err != nil {
    panic(err)
  }
  defer term.Restore(int(os.Stdin.Fd()), oldState)

  var chars []byte
  buf := make([]byte, 1)

  for {
    n, err := os.Stdin.Read(buf)
    if err != nil || n == 0 {
      break
    }

    if buf[0] == '\n' || buf[0] == '\r' {
      break
    }

    if buf[0] == 3 { // Ctrl+C
      fmt.Print("\r\n中断\r\n")
      return
    }

    chars = append(chars, buf[0])
    // Raw 模式下 \n 只换行不回车，需要 \r\n
    fmt.Printf("\r\n收到字节: %c (ASCII: %d, 0x%02X)", buf[0], buf[0], buf[0])
  }

  fmt.Printf("\r\n程序收到: %q（共 %d 字节）\r\n", string(chars), len(chars))
}

func main() {
  demonstrateCookedMode()
  demonstrateRawMode()
}

package main

import (
  "fmt"
  "os"
  "golang.org/x/term"
)

func readPasswordWithStars() ([]byte, error) {
  oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
  if err != nil {
    return nil, err
  }
  defer term.Restore(int(os.Stdin.Fd()), oldState)

  var password []byte
  buf := make([]byte, 1)

  for {
    n, err := os.Stdin.Read(buf)
    if err != nil || n == 0 {
      break
    }

    switch buf[0] {
    case '\n', '\r': // Enter 键：结束输入
      return password, nil

    case 3: // Ctrl+C (ASCII ETX)
      fmt.Print("\r\n")
      os.Exit(1)

    case 127, 8: // Backspace（ASCII DEL=127 或 BS=8）
      if len(password) > 0 {
        password = password[:len(password)-1]
        // 终端转义序列：退格 + 空格（覆盖星号）+ 退格（移回光标）
        fmt.Print("\b \b")
      }

    default:
      // 忽略其他控制字符（< 32 且不是上面已处理的）
      if buf[0] < 32 {
        continue
      }
      password = append(password, buf[0])
      fmt.Print("*") // 显示星号代替实际字符
    }
  }

  return password, nil
}

func main() {
  fmt.Print("密码（显示 *）: ")

  password, err := readPasswordWithStars()
  if err != nil {
    panic(err)
  }

  fmt.Println()
  fmt.Printf("密码: %s\n", string(password))
}

package main

import (
  "fmt"
  "os"
  "syscall"

  "golang.org/x/term"
)

func main() {
  fd := int(os.Stdin.Fd())

  // --- 1. 文件描述符信息 ---
  fmt.Printf("stdin  fd: %d\n", fd)
  fmt.Printf("stdout fd: %d\n", int(os.Stdout.Fd()))
  fmt.Printf("stderr fd: %d\n", int(os.Stderr.Fd()))

  // --- 2. 终端检测 ---
  if !term.IsTerminal(fd) {
    fmt.Println("不是终端，退出")
    return
  }
  fmt.Println("是终端设备")

  // --- 3. 获取终端大小 ---
  width, height, _ := term.GetSize(fd)
  fmt.Printf("终端: %d×%d\r\n", width, height)

  // --- 4. 进入 Raw 模式，用 syscall.Read 直接读取 ---
  oldState, _ := term.MakeRaw(fd)
  defer term.Restore(fd, oldState)

  fmt.Print("按键（q 退出）:\r\n")
  buf := make([]byte, 1)

  for {
    // syscall.Read 是最底层的读取，等同于 C 的 read(fd, buf, 1)
    // 在 Raw 模式下，每个字符键入后立即返回
    n, err := syscall.Read(fd, buf)
    if err != nil || n == 0 {
      break
    }

    fmt.Printf("字节: %c  ASCII: %3d  十六进制: 0x%02X\r\n",
      buf[0], buf[0], buf[0])

    if buf[0] == 'q' || buf[0] == 'Q' {
      break
    }
  }
}

package main

import (
  "io"
  "os"
  "os/exec"
  "os/signal"
  "syscall"

  "github.com/creack/pty"
  "golang.org/x/term"
)

func main() {
  // 步骤 1: 准备要在 PTY 中运行的命令
  cmd := exec.Command("bash")

  // 步骤 2: 启动 PTY
  // pty.Start 内部操作：
  //   fd = open("/dev/ptmx", O_RDWR)     // 打开 master
  //   ptsname(fd) → "/dev/pts/N"          // 获取 slave 路径
  //   grantpt(fd); unlockpt(fd)           // 解锁 slave
  //   slave_fd = open("/dev/pts/N", ...)  // 打开 slave
  //   fork(); exec("bash")               // 子进程，stdin/stdout/stderr = slave_fd
  ptmx, err := pty.Start(cmd)
  if err != nil {
    panic(err)
  }
  defer ptmx.Close()

  // 步骤 3: 本终端切为 Raw 模式
  // 目的：让键盘输入不经本地 TTY 处理，直接转发给 PTY
  oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
  if err != nil {
    panic(err)
  }
  defer term.Restore(int(os.Stdin.Fd()), oldState)

  // 步骤 4: 监听窗口大小变化信号
  ch := make(chan os.Signal, 1)
  signal.Notify(ch, syscall.SIGWINCH)
  go func() {
    for range ch {
      // 将父终端的窗口大小同步给 PTY slave
      // 内部调用: ioctl(ptmx, TIOCSWINSZ, &winsize)
      pty.InheritSize(os.Stdin, ptmx)
    }
  }()
  ch <- syscall.SIGWINCH // 立即同步一次

  // 步骤 5: 双向数据桥接
  go func() {
    io.Copy(ptmx, os.Stdin) // 用户键盘 → bash stdin
  }()
  io.Copy(os.Stdout, ptmx) // bash stdout → 用户屏幕
  // bash 退出 → ptmx EOF → io.Copy 返回 → main 退出
}

// ✅ 正确做法：用 defer 确保恢复
oldState, err := term.MakeRaw(fd)
if err != nil {
  return err
}
defer term.Restore(fd, oldState) // panic 时也会执行

// ❌ 错误做法：依赖手动调用
oldState, _ := term.MakeRaw(fd)
// 如果下面某行 panic 了，Restore 不会被调用
doSomething()
term.Restore(fd, oldState) // 可能不会执行到这里

# 方法 1: 用 reset 命令重置终端
reset

# 方法 2: 用 stty 恢复
stty sane

# 方法 3: 输入 stty echo（可能看不见，但盲打有效）
stty echo

// ❌ Raw 模式下
fmt.Println("hello") // 等同于 "hello\n"，光标位置不对

// ✅ Raw 模式下
fmt.Print("hello\r\n") // 明确指定回车+换行

fd := int(os.Stdin.Fd())

if !term.IsTerminal(fd) {
  // 非交互式模式：从管道/文件读取，或使用默认值
  fmt.Fprintln(os.Stderr, "警告：非交互式模式，跳过密码输入")
  return
}

// 只在确认是终端时才操作
oldState, err := term.MakeRaw(fd)
// ...