¿Cómo verifico qué terminal estoy usando?

Tengo Ubuntu en mi máquina y estoy ejecutando un increíble administrador de ventanas encima. ¿Cómo verifico qué terminal estoy ejecutando? ¿Hay un comando para ello?

TL; DR

• para encontrar el uso actual de shell ls -l /proc/$$/exe
• para encontrar el terminal actualmente en ejecución, use xprop _NET_WM_PID WM_CLASS. El valor de pidlater se puede pasar al ps -p <pid> -o argscomando.

• Técnicamente, para el emulador de terminal ni siquiera necesita un comando, como se indica en los comentarios :

  que quieres decir con cual? Haga clic en Ayuda -> Acerca de ¿es eso? - JoKeR

Shell vs Terminal

Lo primero que debemos aclarar es qué es exactamente lo que se pregunta: averiguar el shell o el terminal en ejecución. A menudo, estos dos términos se usan indistintamente, pero son cosas completamente diferentes. Shell es el intérprete de línea de comandos, específicamente el shell interactivo es el indicador más el campo de texto donde ingresa los comandos. Los shells también pueden ser no interactivos, por ejemplo, un script inicia un shell no interactivo o bash -c 'echo hello world'también inicia un shell no interactivo.

Por el contrario, el terminal es la interfaz de shell (aunque también podría ser otra aplicación). Originalmente, el terminal se refería al hardware real, pero hoy en día son principalmente software. Lo que ve cuando presiona Ctrl+ Alt+ to hace clic en el icono del terminal en la GUI, que inicia un emulador de terminal, una ventana que imita el comportamiento del hardware, y dentro de esa ventana puede ver el shell en ejecución. Ctrl+ Alt+ F2(o cualquiera de las 6 teclas de función) abrirá la consola virtual, también conocido como tty. Recomiendo leer ¿Por qué un terminal virtual es "virtual" y qué / por qué / dónde está el terminal "real"? Para más información sobre los detalles.

Obteniendo la información del shell

Cada usuario tiene un shell predeterminado asignado /etc/passwdpara su nombre de usuario. Suponiendo que está utilizando la configuración predeterminada y no ha llamado explícitamente a otro shell como comando, es suficiente hacer lo siguiente:

echo $SHELL

Pero, por supuesto, esto solo muestra el valor predeterminado . Supongamos que hacemos lo siguiente:

user@ubuntu:~$ dash
$

Estábamos originalmente en bash, pero empezamos sesión interactiva de /bin/dash, POSIX de Ubuntu o shell del sistema . La variable $SHELLno cambiará, porque ese no es su propósito: muestra el valor predeterminado no actual. Tendremos que abordar esto desde otra perspectiva: la perspectiva de un proceso, que es algo que he cubierto ¿Estoy usando bash o sh?

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

Aquí aprovechamos el /proc/sistema de archivos. El nombre del proceso y los parámetros de la línea de comandos se muestran en /proc/<pid>/comm. Todo lo que necesitamos es proporcionar el PID de shell, que es lo que $$hace. En el ejemplo anterior, estoy agregando eso por separado, pero no hay nada que nos impida hacer solo

cat /proc/$$/comm

La variación sobre el tema también podría ser

ps -p $$ -o args

Otra forma de abordar esto es mediante la comprobación de dónde /proc/<pid>/exe. Este archivo es un enlace simbólico que apunta al archivo ejecutable. Así podemos hacer

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

Cualquiera de los dos enfoques funciona en el 99% de los casos. Por supuesto, hay formas en que se pueden subvertir. Por ejemplo, el enlace simbólico no apuntará a ninguna parte si el ejecutable se eliminó poco después de la cáscara comenzó (y en ese caso es probable que se encontrará con problemas en el sistema, ya que la remoción /bin/sh, /bin/dasho incluso /bin/bashno se recomienda - después de todo, una gran cantidad de secuencias de comandos dependen de ellos , especialmente los de nivel de sistema). El nombre del comando para shell generalmente se establece como el primer argumento en execve()syscall. Esto está cubierto en ¿Cómo sabe bash cómo se invoca? , por lo que si tiene una aplicación que inicia un shell a través de execve(), podría darle cualquier nombre. Pero estas son cosas no estándar y no típicas, que deben evitarse en aras de la coherencia y la seguridad.

Obteniendo información del terminal

Podemos comenzar con las variables de entorno. Muchos terminales parecen enmascararse como xtermcompatibles, lo cual es informado por echo $TERMo echo $COLORTERM. Pero entonces las variables de entorno no son una herramienta muy confiable. Se pueden activar y desactivar. Podemos hacer lo mismo con los PID nuevamente, excepto que esta vez veremos el PID primario. Como recordará, el terminal es la interfaz del shell y, a menudo, inicia el shell en sí. Por lo tanto, podemos averiguar qué proceso es el proceso padre de nuestro shell:

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

Probemos con otra aplicación de terminal sakura:

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

A partir de ahí ya podemos ver que lo que inició este shell es gnome-terminal. Este método, por supuesto, funciona asumiendo que está trabajando con un shell interactivo. Si estamos tratando de averiguar el padre bash -c '...'o el shell iniciado a través de ssh, por ejemplo, PID puede muy bien ser de una aplicación no terminal y tal vez no GUI.

Entonces, si queremos ocuparnos específicamente del terminal GUI, lo que podemos hacer es ejecutar xprop, hacer clic en la ventana deseada, seleccionar su pid y descubrir cuál es el nombre de ese proceso que coincide con pid. O en otras palabras:

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

Además, según las especificaciones , los administradores de ventanas deben establecer la WM_CLASSpropiedad. Por lo tanto, podemos obtener eso xproptambién:

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

Por supuesto, esto también tiene su 1% de desventajas: establecer WM_CLASSpropiedades depende de que el administrador de ventanas lo haga, y PID no garantiza que una ventana sea precisa (consulte ¿Qué proceso creó esta ventana X11? ), Lo que puede implicar una depuración compleja. Y estos no son defectos de los métodos en sí, sino del servidor X11. Sin embargo, los gestores de ventanas más estables y conocidos (como openbox, Metacity, blackbox) y la mayoría de las aplicaciones se comportan bien, por lo que no deberíamos esperar problemas con algo como Gnome Terminal o Terminator.

Pero cuando se trata de emuladores de terminal GUI, ni siquiera necesitamos encontrar un comando. Podemos usar el Aboutdiálogo de la ventana en sí. La excepción a esa regla es xterm.

La versión corta (thx @Serg )

cat /etc/alternatives/x-terminal-emulator

La versión larga

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

y busque el *en la salida

;)

Salida de ejemplo

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

Alternativa de selección
———————————————–
    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:

O, gracias a @muru , aquí hay una salida más detallada

$ 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 desea conocer el programa de terminal que está utilizando, use esto:

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

Ejecute esto justo después de abrir el terminal (shell) sin bifurcar ninguna otra instancia de shell .

Cuando abres el programa terminal, básicamente genera un programa hijo, un shell. Entonces el padre del shell generado es el terminal en sí. En otras palabras, el PPID del shell es el PID del programa terminal.

Aquí estamos encontrando el ID del proceso padre (PPID) del shell ( bash) por ps -o 'ppid=' -p $$, que será el ID del proceso del programa terminal.

Luego estamos encontrando el nombre del proceso del PID:

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

Básicamente es un trazador de líneas de:

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

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

Escriba printenvdesde la ventana de terminal para ver todas las variables de la sesión abierta.

Escriba echo $COLORTERMdesde la ventana de terminal. NOTA: esto no funciona con todos los terminales, uno como sakurano informa de esto.

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

el de abajo es de una atermterminal.

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

Si solo desea el nombre del programa de terminal, probablemente lo encontrará en Ayuda> Acerca de.

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

Salida de muestra:

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

Ahí está la respuesta para mi sistema: gnome-terminal .

Entonces, escribir gnome-terminalen mi terminal ahora abrirá otra ventana de terminal idéntica.

Fuentes:

• Comentario de Sergiy Kolodyazhnyy bajo la respuesta de AB .

Respuesta simple Funciona tanto para consola como para ssh.

Ejemplo para terminal de caracteres simple:

ssh username@systemname
echo $TERM
dumb

le dice que no puede abrir aplicaciones GUI en esa conexión

Ejemplo para xterm (también funciona con PuTTY / Xming en Windows)

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

significa que puede usar comandos GUI como abrir el editor de hojas o el administrador de archivos nautilus.

En la consola es lo mismo:

Open terminal window
echo $TERM
xterm