Como determinar o shell atual em que estou trabalhando

Como posso determinar o shell atual em que estou trabalhando?

psSomente a saída do comando seria suficiente?

Como isso pode ser feito em diferentes sabores do Unix?

• Existem três abordagens para encontrar o nome do executável do shell atual:

  Observe que todas as três abordagens podem ser enganadas se o executável do shell for /bin/sh, mas é realmente renomeado bash, por exemplo (o que geralmente acontece).

  Assim, sua segunda pergunta sobre se a pssaída servirá é respondida com " nem sempre ".

  1. echo $0 - imprimirá o nome do programa ... que, no caso do shell, é o shell real.

  2. ps -ef | grep $$ | grep -v grep- isso procurará o ID do processo atual na lista de processos em execução. Como o processo atual é o shell, ele será incluído.

     Isso não é 100% confiável, pois você pode ter outros processos cuja pslista inclui o mesmo número que o ID do processo do shell, especialmente se esse ID for um número pequeno (por exemplo, se o PID do shell for "5", você poderá encontrar processos chamados "java5" ou "perl5" na mesma grepsaída!). Este é o segundo problema com a abordagem "ps", além de não poder confiar no nome do shell.

  3. echo $SHELL- O caminho para o shell atual é armazenado como a SHELLvariável para qualquer shell. A ressalva é que, se você iniciar um shell explicitamente como um subprocesso (por exemplo, não é o seu shell de login), obterá o valor do shell de login. Se for possível, use a abordagem psou $0.

  ---

• Se, no entanto, o executável não corresponder ao seu shell real (por exemplo, /bin/shé realmente bash ou ksh), você precisará de heurísticas. Aqui estão algumas variáveis ​​ambientais específicas para várias conchas:

  • $version está definido no tcsh

  • $BASH é definido no bash

  • $shell (minúsculo) é definido como o nome real do shell em csh ou tcsh

  • $ZSH_NAME está definido no zsh

  • O ksh possui $PS3e $PS4define, enquanto o shell Bourne normal ( sh) apenas possui $PS1e $PS2define. Isso geralmente parece ser o mais difícil de distinguir - a única diferença em todo o conjunto de variáveis de ambiente entre she kshtemos instalado no Solaris boxen é $ERRNO, $FCEDIT, $LINENO, $PPID, $PS3, $PS4, $RANDOM, $SECONDS, e $TMOUT.

ps -p $$

deve funcionar em qualquer lugar que as soluções que envolvem ps -efe funcionem grep(em qualquer variante Unix que suporte opções POSIXps ) e não sofrerá com os falsos positivos introduzidos pelo grepping para uma sequência de dígitos que pode aparecer em outro lugar.

Tentar

ps -p $$ -oargs=

ou

ps -p $$ -ocomm=

Se você apenas deseja garantir que o usuário esteja chamando um script com o Bash:

if [ ! -n "$BASH" ] ;then echo Please run this script $0 with bash; exit 1; fi

Podes tentar:

ps | grep `echo $$` | awk '{ print $4 }'

Ou:

echo $SHELL

$SHELLnem sempre é necessário mostrar o shell atual. Ele reflete apenas o shell padrão a ser chamado.

Para testar o que bashfoi dito acima, digamos que é o shell padrão, tente echo $SHELLe, no mesmo terminal, entre em outro shell ( KornShell (ksh), por exemplo) e tente $SHELL. Você verá o resultado como bash nos dois casos.

Para obter o nome do shell atual, use cat /proc/$$/cmdline. E o caminho para o shell executável por readlink /proc/$$/exe.

ps é o método mais confiável. Não é garantido que a variável de ambiente SHELL seja configurada e, mesmo que seja, ela pode ser facilmente falsificada.

Eu tenho um truque simples para encontrar o shell atual. Basta digitar uma sequência aleatória (que não é um comando). Ele falhará e retornará um erro "não encontrado", mas no início da linha, ele dirá qual shell é:

ksh: aaaaa: not found [No such file or directory]
bash: aaaaa: command not found

O seguinte sempre fornecerá o shell real usado - ele obtém o nome do executável real e não o nome do shell (por exemplo, em ksh93vez de kshetc.). Pois /bin/sh, mostrará o shell atual usado, ie dash.

ls -l /proc/$$/exe | sed 's%.*/%%'

Sei que muitos dizem que a lssaída nunca deve ser processada, mas qual é a probabilidade de você usar um shell nomeado com caracteres especiais ou colocado em um diretório nomeado com caracteres especiais? Se esse ainda for o caso, há muitos outros exemplos de como fazê-lo de maneira diferente.

Conforme apontado por Toby Speight , essa seria uma maneira mais adequada e mais limpa de conseguir o mesmo:

basename $(readlink /proc/$$/exe)

Eu tentei muitas abordagens diferentes e a melhor para mim é:

ps -p $$

Também funciona com Cygwin e não pode produzir falsos positivos como grepping de PID. Com alguma limpeza, ele gera apenas um nome executável (em Cygwin com path):

ps -p $$ | tail -1 | awk '{print $NF}'

Você pode criar uma função para não precisar memorizá-la:

# Print currently active shell
shell () {
  ps -p $$ | tail -1 | awk '{print $NF}'
}

... e então apenas execute shell.

Foi testado no Debian e Cygwin.

Minha variante na impressão do processo pai:

ps -p $$ | awk '$1 == PP {print $4}' PP=$$

Não execute aplicativos desnecessários quando o AWK puder fazer isso por você.

Existem muitas maneiras de descobrir o shell e sua versão correspondente. Aqui estão alguns que funcionaram para mim.

Direto

1. $> echo $ 0 (fornece o nome do programa. No meu caso, a saída era -bash .)
2. $> $ SHELL (Isso leva você para o shell e, no prompt, você obtém o nome e a versão do shell. No meu caso, bash3.2 $ .)
3. $> echo $ SHELL (Isso fornecerá um caminho executável. No meu caso / bin / bash .)
4. $> $ SHELL --version (Isso fornecerá informações completas sobre o software shell com o tipo de licença)

Abordagem Hackish

$> ******* (Digite um conjunto de caracteres aleatórios e, na saída, você obterá o nome do shell. No meu caso -bash: chapter2-a-sample-isomorphic-app: comando não encontrado )

Desde que você /bin/shsuporte o padrão POSIX e seu sistema possua o lsofcomando instalado - uma possível alternativa possível lsofneste caso pid2path- você também pode usar (ou adaptar) o seguinte script que imprime caminhos completos:

#!/bin/sh
# cat /usr/local/bin/cursh
set -eu
pid="$$"

set -- sh bash zsh ksh ash dash csh tcsh pdksh mksh fish psh rc scsh bournesh wish Wish login

unset echo env sed ps lsof awk getconf

# getconf _POSIX_VERSION  # reliable test for availability of POSIX system?
PATH="`PATH=/usr/bin:/bin:/usr/sbin:/sbin getconf PATH`"
[ $? -ne 0 ] && { echo "'getconf PATH' failed"; exit 1; }
export PATH

cmd="lsof"
env -i PATH="${PATH}" type "$cmd" 1>/dev/null 2>&1 || { echo "$cmd not found"; exit 1; }

awkstr="`echo "$@" | sed 's/\([^ ]\{1,\}\)/|\/\1/g; s/ /$/g' | sed 's/^|//; s/$/$/'`"

ppid="`env -i PATH="${PATH}" ps -p $pid -o ppid=`"
[ "${ppid}"X = ""X ] && { echo "no ppid found"; exit 1; }

lsofstr="`lsof -p $ppid`" || 
   { printf "%s\n" "lsof failed" "try: sudo lsof -p \`ps -p \$\$ -o ppid=\`"; exit 1; }

printf "%s\n" "${lsofstr}" | 
   LC_ALL=C awk -v var="${awkstr}" '$NF ~ var {print $NF}'

Se você quiser apenas verificar se está executando (uma versão específica do) Bash, a melhor maneira de fazer isso é usar a $BASH_VERSINFOvariável de matriz. Como uma variável de matriz (somente leitura), ela não pode ser definida no ambiente, portanto, você pode ter certeza de que está vindo (se houver) do shell atual.

No entanto, como o Bash tem um comportamento diferente quando chamado como sh, você também precisa verificar a $BASHvariável de ambiente que termina com /bash.

Em um script que escrevi que usa nomes de funções com -(sem sublinhado) e depende de matrizes associativas (adicionadas no Bash 4), tenho a seguinte verificação de integridade (com mensagem de erro útil do usuário):

case `eval 'echo $BASH@${BASH_VERSINFO[0]}' 2>/dev/null` in
    */bash@[456789])
        # Claims bash version 4+, check for func-names and associative arrays
        if ! eval "declare -A _ARRAY && func-name() { :; }" 2>/dev/null; then
            echo >&2 "bash $BASH_VERSION is not supported (not really bash?)"
            exit 1
        fi
        ;;
    */bash@[123])
        echo >&2 "bash $BASH_VERSION is not supported (version 4+ required)"
        exit 1
        ;;
    *)
        echo >&2 "This script requires BASH (version 4+) - not regular sh"
        echo >&2 "Re-run as \"bash $CMD\" for proper operation"
        exit 1
        ;;
esac

Você pode omitir a verificação funcional um tanto paranóica de recursos no primeiro caso e apenas assumir que versões futuras do Bash seriam compatíveis.

Nenhuma das respostas funcionou com o fishshell (ele não possui as variáveis $$ou $0).

Isso funciona para mim (testadas sh, bash, fish, ksh, csh, true, tcsh, e zsh; openSUSE 13.2):

ps | tail -n 4 | sed -E '2,$d;s/.* (.*)/\1/'

Este comando gera uma string como bash. Aqui eu só estou usando ps, taile sed(sem extesions GNU; tentar adicionar --posixpara verificá-lo). Todos eles são comandos POSIX padrão. Tenho certeza que tailpode ser removido, mas meu sedfu não é forte o suficiente para fazer isso.

Parece-me que esta solução não é muito portátil, pois não funciona no OS X. :(

Minha solução:

ps -o command | grep -v -e "\<ps\>" -e grep -e tail | tail -1

Isso deve ser portátil em diferentes plataformas e shells. Ele usa pscomo outras soluções, mas não depende sedou awkfiltra o lixo da tubulação e psele próprio, para que o shell sempre seja a última entrada. Dessa forma, não precisamos confiar em variáveis ​​PID não portáveis ​​ou escolher as linhas e colunas certas.

Eu testei no Debian e no macOS com Bash, Z shell ( zsh) e fish (que não funciona com a maioria dessas soluções sem alterar a expressão especificamente para fish, porque ele usa uma variável PID diferente).

echo $$ # Gives the Parent Process ID 
ps -ef | grep $$ | awk '{print $8}' # Use the PID to see what the process is.

De Como você sabe qual é o seu shell atual? .

No Mac OS X (e FreeBSD):

ps -p $$ -axco command | sed -n '$p' 

Não é necessário receber o PID da saída de "ps", porque você pode ler a respectiva linha de comando para qualquer PID da estrutura de diretório / proc:

echo $(cat /proc/$$/cmdline)

No entanto, isso pode não ser melhor do que simplesmente:

echo $0

Sobre a execução de um shell realmente diferente do que o nome indica, uma idéia é solicitar a versão do shell usando o nome que você obteve anteriormente:

<some_shell> --version

sh parece falhar com o código de saída 2, enquanto outros fornecem algo útil (mas não consigo verificar tudo porque não os tenho):

$ sh --version
sh: 0: Illegal option --
echo $?
2

Esta não é uma solução muito limpa, mas faz o que você deseja.

# MUST BE SOURCED..
getshell() {
    local shell="`ps -p $$ | tail -1 | awk '{print $4}'`"

    shells_array=(
    # It is important that the shells are listed in descending order of their name length.
        pdksh
        bash dash mksh
        zsh ksh
        sh
    )

    local suited=false
    for i in ${shells_array[*]}; do
        if ! [ -z `printf $shell | grep $i` ] && ! $suited; then
            shell=$i
            suited=true
        fi
    done

    echo $shell
}
getshell

Agora você pode usar $(getshell) --version.

Isso funciona, porém, apenas em conchas do tipo KornShell (ksh).

Faça o seguinte para saber se o seu shell está usando o Dash / Bash.

ls –la /bin/sh:

• se o resultado for /bin/sh -> /bin/bash==> Então seu shell está usando o Bash.

• se o resultado for /bin/sh ->/bin/dash==> Então seu shell está usando o Dash.

Se você deseja mudar de Bash para Dash ou vice-versa, use o código abaixo:

ln -s /bin/bash /bin/sh (mude o shell para Bash)

Nota : Se o comando acima resultar em um erro dizendo: / bin / sh já existe, remova o / bin / sh e tente novamente.

E eu vim com isso

sed 's/.*SHELL=//; s/[[:upper:]].*//' /proc/$$/environ

Por favor, use o comando abaixo:

ps -p $$ | tail -1 | awk '{print $4}'

Este funciona bem no Red Hat Linux (RHEL), macOS, BSD e alguns AIXes :

ps -T $$ | awk 'NR==2{print $NF}' 

alternativamente, o seguinte também deve funcionar se pstree estiver disponível,

pstree | egrep $$ | awk 'NR==2{print $NF}'