Comment utiliser le pseudo terminal (pty) en langage golang

Dans les systèmes d'exploitation modernes, la fenêtre du terminal est l'un des moyens les plus élémentaires d'interaction homme-machine. Cependant, notre compréhension de la fenêtre du terminal ne doit pas se limiter aux entrées et aux sorties. En fait, la fenêtre du terminal doit avoir plusieurs fonctions telles que « répondre aux signaux », « modifier la taille de la fenêtre », etc., afin de répondre aux divers besoins des utilisateurs. Dans le système Linux, nous pouvons utiliser un pseudo-terminal (PTY) pour implémenter ces fonctions, et le langage Golang fournit également de nombreuses API pratiques pour faire fonctionner PTY, nous permettant de contrôler et d'interagir facilement avec le terminal.

1. Qu'est-ce qu'un pseudo-terminal ? Tout d'abord, pour comprendre en profondeur le pseudo-terminal, il faut d'abord comprendre les deux fichiers spéciaux sous le système Linux-tty et pty. Le fichier tty se trouve généralement dans /dev/ttyx et constitue l'interface permettant aux utilisateurs d'interagir avec le noyau Linux. Par exemple, lorsque vous entrez des commandes dans le terminal, vous interagissez via l'interface tty. PTY est un concept logique qui représente un pseudo-terminal. Il se trouve généralement dans /dev/ptmx dans les systèmes Linux et constitue l'interface permettant aux utilisateurs d'interagir avec les terminaux. Le but du pseudo-terminal est de créer une fenêtre de terminal virtuel à travers celui-ci, de lire le descripteur de fichier créé par le verrou lorsque l'utilisateur saisit des caractères, et en même temps de transmettre le flux d'octets de l'application au processus enfant et de renvoyer le flux de sortie du processus enfant vers les utilisateurs.

En fait, le pseudo-terminal est un concept de simulation (terminal simulé). Il s'agit d'un ensemble d'interfaces de terminal fournies par le noyau, grâce à elles, les utilisateurs et les programmes de terminaux peuvent interagir avec les terminaux via des flux d'entrée et de sortie standard. Le pseudo-terminal créera deux descripteurs de fichiers, un pour la lecture et un pour l'écriture. Un descripteur de fichier peut être utilisé pour écrire les entrées de l'utilisateur et l'autre peut être utilisé pour lire les données renvoyées par le programme du terminal. Grâce à ce mécanisme, nous pouvons contrôler la fenêtre du terminal pour réaliser des opérations plus flexibles.

2. Comment utiliser le pseudo-terminal en langage golang

En langage golang, les étapes pour utiliser le pseudo-terminal sont divisées en trois étapes :

Créer pty

1. En langage golang, nous pouvons utiliser la bibliothèque os La fonction StartProcess crée un pty. Cette fonction renvoie une valeur de type *os.Process, et cette valeur est le handle du pty que nous pouvons contrôler. Elle contient les flux d'entrée et de sortie et d'autres informations liées au processus. Le code est le suivant :

import (
    "os"
    "os/exec"
    "syscall"
)

cmd := "sh"
exe := exec.Command(cmd)
// 设置ptmx为console
exe.SysProcAttr = &syscall.SysProcAttr{Setctty: true, Setsid: true}

// 打开ptmx
ptmx, err := os.OpenFile("/dev/ptmx", os.O_RDWR, 0)

// 解锁ptmx
tmp := make([]byte, 0)
if _, err := ptmx.Read(tmp); err != nil {
    panic(err)
}

// 给pty配置大小
ws := &Winsize{Width: 80, Height: 40, Xpixel: 0, Ypixel: 0}
if err := IoctlSetWinsize(int(ptmx.Fd()), uintptr(unsafe.Pointer(ws))); err != nil {
    panic(err)
}

// 创建子进程pty
exe.Stdout = ptmx  //配置pty的输入输出流
exe.Stdin = ptmx
exe.Stderr = ptmx
if err := exe.Start(); err != nil {
    panic(err)
}
pid := exe.Process.Pid

Lire et écrire pty

2. Une fois pty créé, nous pouvons écrire et lire des données sur pty via les méthodes Read et Write de la bibliothèque os. Le code est le suivant :

//读取输出
buf := make([]byte, 1024)
n, err := ptmx.Read(buf)
if err != nil {
    panic(err)
}
fmt.Println(string(buf[:n]))

//写入输入
if _, err := ptmx.Write([]byte("ls -al\n")); err != nil {
    panic(err)
}

.

En attente de pty Le processus se termine

3. Enfin, nous devons attendre que le processus pty se termine via la méthode exe.Wait().

Résumé

Grâce aux étapes ci-dessus, nous pouvons implémenter pty en langage golang. Dans l'ensemble, le pseudo-terminal est un mécanisme très important du système Linux. En l'utilisant, nous pouvons réaliser des fonctions de contrôle et d'interaction de terminal très puissantes. Bien que cela apporte une certaine complexité, si vous le comprenez, vous aurez de meilleures chances de créer d'excellentes applications interactives pour fenêtres de terminal.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!