Como verifico qual terminal estou usando?

Eu tenho o Ubuntu na minha máquina e estou executando um gerenciador de janelas incrível em cima dele. Como verifico qual terminal estou executando? Existe um comando para isso?

TL; DR

• encontrar o uso do shell atualmente em execução ls -l /proc/$$/exe
• para encontrar o terminal em execução no momento, use xprop _NET_WM_PID WM_CLASS. O valor de pidposterior pode ser passado para o ps -p <pid> -o argscomando.

• Tecnicamente, para o emulador de terminal, você nem precisa de um comando, conforme declarado nos comentários :

  o que você quer dizer com qual? Clique em Ajuda -> Sobre é isso? - JoKeR

Shell vs Terminal

A primeira coisa que precisamos esclarecer é o que exatamente está sendo solicitado - descubra o shell ou terminal em execução. Frequentemente, esses dois termos são usados ​​de forma intercambiável, mas são coisas completamente diferentes. O shell é o intérprete da linha de comando, o shell especificamente interativo é o prompt mais o campo de texto onde você insere comandos. Os shells também podem ser não interativos, por exemplo, um script inicia um shell não interativo ou bash -c 'echo hello world'também um shell não interativo.

Por outro lado, terminal é a interface para o shell (embora também possa ser outra aplicação). Originalmente, o terminal se referia ao hardware real, mas hoje em dia é principalmente software. O que você vê quando pressiona Ctrl+ Alt+ tou clica no ícone do terminal na GUI, que inicia um emulador de terminal, uma janela que imita o comportamento do hardware e, nessa janela, você pode ver o shell em execução. Ctrl+ Alt+ F2(ou qualquer uma das 6 teclas de função) abrirá o console virtual, também conhecido como tty. Eu recomendo a leitura Por que o terminal virtual é "virtual" e o que / por que / onde é o terminal "real"? para mais informações sobre os detalhes.

Obtendo as informações do shell

Cada usuário tem um shell padrão designado /etc/passwdpara seu nome de usuário. Supondo que você esteja usando a configuração padrão e não tenha chamado outro shell explicitamente como um comando, é suficiente:

echo $SHELL

Mas é claro que isso mostra apenas o valor padrão . Suponha que façamos o seguinte:

user@ubuntu:~$ dash
$

Estávamos originalmente no bash, mas começou a sessão interativa de /bin/dash, POSIX do Ubuntu ou shell do sistema . A variável $SHELLnão muda, porque esse não é o seu objetivo - mostra o valor padrão e não o atual. Precisamos abordar isso de outra perspectiva - a perspectiva de um processo, que é algo que abordamos em Estou usando bash ou sh?

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

Aqui aproveitamos o /proc/sistema de arquivos. O nome dos parâmetros do processo e de linha de comando são exibidos no /proc/<pid>/comm. Tudo o que precisamos é fornecer o PID do shell, que é o que $$faz. No exemplo acima, estou adicionando isso separadamente, mas não há nada que nos impeça de fazer apenas

cat /proc/$$/comm

Variações sobre o tema também podem ser

ps -p $$ -o args

Outra maneira de abordarmos isso é verificar onde /proc/<pid>/exe. Este arquivo é um link simbólico que aponta para o arquivo executável. Assim nós podemos fazer

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

Qualquer uma das duas abordagens funciona em 99% dos casos. Obviamente, existem maneiras pelas quais elas podem ser subvertidas. Por exemplo, ligação simbólica não irá apontar em qualquer lugar se o executável foi eliminada logo após o shell começou (e, nesse caso, provavelmente você vai encontrar problemas do sistema, uma vez que a remoção /bin/sh, /bin/dashou até mesmo /bin/bashnão é recomendado - afinal um monte de scripts de contar com eles , especialmente os de nível de sistema). O nome do comando para o shell geralmente é definido como o primeiro argumento no execve()syscall. Isso é abordado em Como o bash sabe como está sendo chamado? , portanto, se você tiver um aplicativo que inicie um shell via execve(), ele poderá fornecer qualquer nome. Mas essas são coisas não padronizadas e não típicas, que devem ser evitadas por uma questão de consistência e segurança.

Obtendo informações do terminal

Podemos começar com as variáveis ​​de ambiente. Muitos terminais parecem se mascarar como xtermincompatíveis, o que é relatado por echo $TERMou echo $COLORTERM. Mas as variáveis ​​de ambiente não são uma ferramenta muito confiável. Eles podem ser definidos e desabilitados. Podemos fazer a mesma coisa com PIDs novamente, exceto que desta vez veremos o PID pai. Como você deve se lembrar, terminal é a interface para o shell e geralmente inicia o próprio shell. Portanto, podemos descobrir qual processo é o processo pai do nosso shell:

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

Vamos tentar com outro aplicativo de terminal sakura:

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

A partir daí, já podemos ver que o que iniciou esse shell é gnome-terminal. É claro que esse método funciona assumindo que você esteja trabalhando com shell interativo. Se estamos tentando descobrir o pai bash -c '...'ou o shell iniciado via ssh, por exemplo, o PID pode muito bem ser de um aplicativo não terminal e talvez não uma GUI.

Portanto, se queremos lidar especificamente com o terminal da GUI, o que podemos fazer é executar xprop, clicar na janela desejada, cumprimentar seu pid e descobrir qual é o nome desse processo correspondente ao pid. Ou em outras palavras:

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

Além disso, conforme as especificações , os gerenciadores de janelas devem definir a WM_CLASSpropriedade. Assim, podemos obter isso xproptambém:

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

Obviamente, isso também tem suas 1% de desvantagens: a configuração de WM_CLASSpropriedades depende do gerenciador de janelas, e não é garantido ao PID que uma janela seja precisa (consulte Qual processo criou essa janela do X11? ), O que pode envolver depuração complexa. E essas não são deficiências dos métodos em si, mas do servidor X11. No entanto, os gerenciadores de janelas mais estáveis ​​e conhecidos (como openbox, Metacity, blackbox) e a maioria dos aplicativos são bem comportados, portanto, não devemos esperar problemas com algo como o Gnome Terminal ou o Terminator.

Mas quando se trata de emuladores de terminal da GUI, nem precisamos encontrar um comando. Podemos apenas usar o Aboutdiálogo da própria janela. A exceção a essa regra é xterm.

A versão curta (thx @Serg )

cat /etc/alternatives/x-terminal-emulator

A versão longa

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

e procure o *na saída

;)

Saída de exemplo

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

Alternativa de seleção
———————————————
    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, graças ao @muru , aqui está uma saída mais detalhada

$ 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'.

Se você deseja conhecer o programa do terminal que está usando, use o seguinte:

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

Execute isso logo após abrir o terminal (shell) sem bifurcar mais nenhuma instância do shell .

Quando você abre o programa do terminal, ele basicamente gera um programa filho, um shell. Portanto, o pai da concha gerada é o próprio terminal. Em outras palavras, o PPID do shell é o PID do programa do terminal.

Aqui estamos encontrando o ID do processo pai (PPID) do shell ( bash) por ps -o 'ppid=' -p $$, que será o ID do processo do programa do terminal.

Em seguida, localizamos o nome do processo no PID:

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

É basicamente um liner de:

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

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

Digite na printenvjanela do terminal para visualizar todas as variáveis ​​da sessão aberta.

Digite na echo $COLORTERMjanela do terminal. OBSERVAÇÃO: isso não funciona com todos os terminais, um deles sakuranão informa isso.

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

o abaixo é de um atermterminal.

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

Se você quiser apenas o nome do programa do terminal, provavelmente o encontrará em Ajuda> Sobre.

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

Saída de amostra:

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

Existe a resposta para o meu sistema: gnome-terminal .

Então, digitar gnome-terminalno meu terminal agora abrirá outra janela de terminal idêntica.

Fontes:

• Comentário de Sergiy Kolodyazhnyy sob a resposta da AB .

Resposta simples. Funciona para console ou ssh.

Exemplo para terminal de caracteres simples:

ssh username@systemname
echo $TERM
dumb

informa que você não pode abrir aplicativos GUI nessa conexão

Exemplo para xterm (também funciona com PuTTY / Xming no Windows)

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

significa que você pode usar comandos da GUI, como abrir o editor de folhetos ou o gerenciador de arquivos do nautilus.

No console, é o mesmo:

Open terminal window
echo $TERM
xterm