Comment vérifier quel terminal j'utilise?

J'ai Ubuntu sur ma machine et j'exécute un gestionnaire de fenêtres génial en plus. Comment vérifier quel terminal j'utilise? Y a-t-il une commande pour cela?

TL; DR

• pour trouver l'utilisation du shell en cours d'exécution ls -l /proc/$$/exe
• pour trouver le terminal en cours d'exécution, utilisez xprop _NET_WM_PID WM_CLASS. La valeur de pidlater peut être transmise à ps -p <pid> -o argscommand.

• Techniquement, pour l'émulateur de terminal, vous n'avez même pas besoin d'une commande, comme indiqué dans les commentaires :

  que voulez-vous dire par quoi? Cliquez sur Aide -> À propos est-ce que c'est? - JoKeR

Shell vs Terminal

La première chose que nous devons clarifier est ce qui est exactement demandé - découvrez le shell en cours d'exécution ou le terminal en cours d'exécution. Souvent, ces deux termes sont utilisés de manière interchangeable, mais ce sont des choses complètement différentes. Shell est l'interpréteur de ligne de commande, spécifiquement le shell interactif est le champ de texte d'invite plus où vous entrez des commandes. Les shells peuvent également être non interactifs, par exemple un script démarre un shell non interactif, ou bash -c 'echo hello world'démarre également un shell non interactif.

En revanche, le terminal est l'interface avec le shell (bien qu'il puisse également s'agir d'une autre application). À l'origine, le terminal faisait référence au matériel réel, mais de nos jours, il s'agit principalement de logiciels. Ce que vous voyez lorsque vous appuyez sur Ctrl+ Alt+ tou cliquez sur l'icône du terminal dans l'interface graphique, qui démarre un émulateur de terminal, une fenêtre qui imite le comportement du matériel, et dans cette fenêtre, vous pouvez voir le shell en cours d'exécution. Ctrl+ Alt+ F2(ou l'une des 6 touches de fonction) ouvrira la console virtuelle, alias tty. Je recommande de lire Pourquoi un terminal virtuel est-il «virtuel», et quel / pourquoi / où est le «vrai» terminal? pour plus d'informations sur les spécificités.

Obtention des informations sur le shell

Chaque utilisateur se voit attribuer un shell par défaut /etc/passwdpour son nom d'utilisateur. En supposant que vous utilisez la configuration par défaut et que vous n'avez pas appelé explicitement un autre shell en tant que commande, il suffit de faire:

echo $SHELL

Mais bien sûr, cela ne montre que la valeur par défaut . Supposons que nous procédions comme suit:

user@ubuntu:~$ dash
$

Nous étions à l' origine dans bash, mais il a commencé session interactive de /bin/dash, Posix ou shell système d'Ubuntu . La variable $SHELLne changera pas, car ce n'est pas son objectif - elle affiche la valeur par défaut et non actuelle. Nous devrons aborder cette question dans une autre perspective - la perspective d'un processus, qui est quelque chose que j'ai couvert dans Suis-je en utilisant bash ou sh?

$ echo $$
4824
$ cat /proc/4824/comm                                                          
mksh
$ bash
xieerqi@eagle:~$ echo $$
6197
xieerqi@eagle:~$ cat /proc/6197/comm
bash

Ici, nous profitons du /proc/système de fichiers. Le nom du processus et les paramètres de ligne de commande sont affichés dans /proc/<pid>/comm. Tout ce dont nous avons besoin est de fournir le PID du shell, ce qui est le $$cas. Dans l'exemple ci-dessus, j'ajoute cela séparément, mais rien ne nous empêche de faire juste

cat /proc/$$/comm

Une variation sur le thème pourrait également être

ps -p $$ -o args

Une autre façon de procéder est de vérifier où /proc/<pid>/exe. Ce fichier est un lien symbolique qui pointe vers le fichier exécutable. Ainsi nous pouvons faire

user@ubuntu:~$ ls -l /proc/$$/exe
lrwxrwxrwx 1 adminx adminx 0 Apr  4 18:20 /proc/1241/exe -> /bin/bash
user@ubuntu:~$ sh
$ ls -l /proc/$$/exe
lrwxrwxrwx 1 adminx adminx 0 Apr  4 18:20 /proc/1255/exe -> /bin/dash

L'une ou l'autre des deux approches fonctionne dans 99% des cas. Bien sûr, il existe des moyens de les renverser. Par exemple, symlink ne pointera nulle part si l'exécutable a été supprimé peu de temps après la coquille a commencé (et dans ce cas , vous aurez probablement rencontrer des problèmes de système, depuis la suppression /bin/sh, /bin/dashou même /bin/bashn'est pas recommandé - après tout beaucoup de scripts comptent sur eux , en particulier au niveau du système). Le nom de commande du shell est généralement défini comme le tout premier argument dans execve()syscall. Ceci est traité dans Comment bash sait-il comment il est appelé? , donc si vous avez une application qui lance un shell via execve(), elle pourrait lui donner n'importe quel nom. Mais ce sont des choses non standard et non typiques, qui devraient être évitées pour des raisons de cohérence et de sécurité.

Obtenir des informations sur le terminal

Nous pouvons commencer avec les variables d'environnement. De nombreux terminaux semblent se masquer comme xtermcompatibles, ce qui est signalé par echo $TERMou echo $COLORTERM. Mais alors les variables d'environnement ne sont pas un outil très fiable. Ils peuvent être activés et désactivés. Nous pouvons à nouveau faire la même chose avec les PID, sauf que cette fois, nous allons examiner le PID parent. Comme vous vous en souvenez peut-être, le terminal est l'interface avec le shell et démarre souvent le shell lui-même. Par conséquent, nous pouvons découvrir quel processus est le processus parent de notre shell:

$ ps -p $$ -o args,ppid
COMMAND                      PPID
bash                         1234
$ ps -p 1234 -o args
COMMAND
/usr/lib/gnome-terminal/gnome-terminal-server

Essayons avec une autre application de terminal sakura:

$ ps -p $$ -o args,ppid
COMMAND                      PPID
/bin/bash                   16950
$ ps -p 16950 -o args
COMMAND
sakura

De là, nous pouvons déjà voir que ce qui a commencé cet obus est gnome-terminal. Cette méthode fonctionne bien sûr en supposant que vous travaillez avec un shell interactif. Si nous essayons de découvrir le parent de bash -c '...'ou le shell démarré via ssh, par exemple, le PID peut très bien provenir d'une application non terminale et peut-être pas du tout GUI.

Donc, si nous voulons traiter spécifiquement du terminal GUI, ce que nous pouvons faire est d'exécuter xprop, cliquez sur la fenêtre souhaitée, grep son pid et découvrez quel est le nom de ce processus correspondant au pid. Ou en d'autres termes:

$ ps aux | grep $(xprop | awk -F'='  '/PID/ {print $2}')                       
xieerqi   2124  0.6  1.7 208068 34604 ?        Sl   18:47   1:49 gnome-terminal

En outre, conformément aux spécifications , les gestionnaires de fenêtres doivent définir la WM_CLASSpropriété. Ainsi, nous pouvons également obtenir cela xprop:

$ xprop WM_CLASS 
WM_CLASS(STRING) = "sakura", "Sakura"

Bien sûr, cela a aussi ses 1% d'inconvénients: la définition des WM_CLASSpropriétés dépend du gestionnaire de fenêtres, et le PID n'est pas garanti pour qu'une fenêtre soit précise (voir Quel processus a créé cette fenêtre X11? ), Ce qui peut impliquer un débogage complexe. Et ce ne sont pas des défauts des méthodes elles-mêmes mais du serveur X11. Cependant, la plupart des gestionnaires de fenêtres stables et bien connus (comme openbox, Metacity, blackbox) et la plupart des applications se comportent bien, nous ne devons donc pas nous attendre à des problèmes avec quelque chose comme Gnome Terminal ou Terminator.

Mais en ce qui concerne les émulateurs de terminaux GUI, nous n'avons même pas besoin de trouver une commande. Nous pouvons simplement utiliser la Aboutboîte de dialogue de la fenêtre elle-même. Une exception à cette règle est xterm.

La version courte (thx @Serg )

cat /etc/alternatives/x-terminal-emulator

La version longue

sudo update-alternatives --config x-terminal-emulator

et recherchez le *dans la sortie

;)

Exemple de sortie

There are 7 alternatives which provide `x-terminal-emulator’.

Alternative de sélection
———————————————–
    1 / usr / bin / xterm
    2 / usr / bin / uxterm
    3 / usr / bin / koi8rxterm
    4 / usr / bin / lxterm
 * + 5 /usr/bin/gnome-terminal.wrapper
    6 / usr / bin / konsole
    7 /usr/bin/xfce4-terminal.wrapper

Press enter to keep the default[*], or type selection number:

Ou, grâce à @muru , voici une sortie plus détaillée

$ update-alternatives --display x-terminal-emulator
x-terminal-emulator - auto mode
  link currently points to /usr/bin/gnome-terminal.wrapper
/usr/bin/gnome-terminal.wrapper - priority 40
  slave x-terminal-emulator.1.gz: /usr/share/man/man1/gnome-terminal.1.gz
/usr/bin/koi8rxterm - priority 20
  slave x-terminal-emulator.1.gz: /usr/share/man/man1/koi8rxterm.1.gz
/usr/bin/lxterm - priority 30
  slave x-terminal-emulator.1.gz: /usr/share/man/man1/lxterm.1.gz
/usr/bin/mate-terminal.wrapper - priority 30
  slave x-terminal-emulator.1.gz: /usr/share/man/man1/mate-terminal.1.gz
/usr/bin/uxterm - priority 20
  slave x-terminal-emulator.1.gz: /usr/share/man/man1/uxterm.1.gz
/usr/bin/xterm - priority 20
  slave x-terminal-emulator.1.gz: /usr/share/man/man1/xterm.1.gz
Current 'best' version is '/usr/bin/gnome-terminal.wrapper'.

Si vous voulez connaître le programme de terminal que vous utilisez, utilisez ceci:

ps -o 'cmd=' -p $(ps -o 'ppid=' -p $$)

Exécutez ceci juste après avoir ouvert le terminal (shell) sans bifurquer d'autre instance de shell .

Lorsque vous ouvrez le programme terminal, il génère essentiellement un programme enfant, un shell. Le parent du shell généré est donc le terminal lui-même. En d'autres termes, le PPID du shell est le PID du programme terminal.

Nous trouvons ici l'ID de processus parent (PPID) du shell ( bash) par ps -o 'ppid=' -p $$, qui sera l'ID de processus du programme terminal.

Ensuite, nous trouvons le nom du processus à partir du PID:

$ ps -o 'cmd=' -p $(ps -o 'ppid=' -p $$)
gnome-terminal

Il s'agit essentiellement d'une ligne de:

$ ps -o 'ppid=' -p $$
 2268

$ ps -o 'cmd=' -p 2268
gnome-terminal

Tapez dans printenvla fenêtre du terminal pour afficher toutes les variables de la session ouverte.

Tapez dans echo $COLORTERMla fenêtre du terminal. REMARQUE: cela ne fonctionne pas avec tous les terminaux, un comme sakurane le signale pas.

root@terrance-Linux:~# echo $COLORTERM
gnome-terminal

celui ci-dessous provient d'un atermterminal.

root@terrance-Linux:~$ echo $COLORTERM
rxvt-xpm

Si vous voulez juste le nom du programme du terminal, vous le trouverez très probablement sous Aide> À propos.

cat /etc/alternatives/x-terminal-emulator | grep exec

Exemple de sortie:

exec ('gnome-terminal', @ args);

Il y a la réponse pour mon système: gnome-terminal .

Donc, taper gnome-terminaldans mon terminal ouvrira maintenant une autre fenêtre de terminal identique.

Sources:

• Commentaire de Sergiy Kolodyazhnyy sous la réponse d'AB .

Réponse simple. Fonctionne à la fois sur console ou ssh.

Exemple pour un terminal de caractères simple:

ssh username@systemname
echo $TERM
dumb

vous indique que vous ne pouvez pas ouvrir d'applications GUI sur cette connexion

Exemple pour xterm (fonctionne également avec PuTTY / Xming sous Windows)

ssh -Y username@systemname      -- omit this if using PuTTY --
echo $TERM
xterm

signifie que vous pouvez utiliser des commandes GUI comme ouvrir l'éditeur Leafpad ou le gestionnaire de fichiers Nautilus.

Sur la console c'est pareil:

Open terminal window
echo $TERM
xterm