Bash (concha do Unix)

Bash é um shell Unix e linguagem de comando escrita por Brian Fox para o Projeto GNU como um substituto de software livre para o shell Bourne. Lançado pela primeira vez em 1989, tem sido usado como o shell de login padrão para a maioria das distribuições Linux. O Bash foi um dos primeiros programas que Linus Torvalds portou para o Linux, ao lado do GCC. Uma versão também está disponível para Windows 10 e Windows 11 por meio do Windows Subsystem for Linux. É também o shell de usuário padrão no Solaris 11. Bash também era o shell padrão nas versões do Apple macOS de 10.3 (originalmente, o shell padrão era tcsh) a 10.15 (macOS Catalina), que mudou o shell padrão para zsh, embora Bash permanece disponível como um shell alternativo.

Bash é um processador de comandos que normalmente é executado em uma janela de texto onde o usuário digita comandos que causam ações. O Bash também pode ler e executar comandos de um arquivo, chamado de shell script. Como a maioria dos shells Unix, ele suporta globbing de nome de arquivo (correspondência de curinga), canalização, aqui documentos, substituição de comando, variáveis e estruturas de controle para teste de condição e iteração. As palavras-chave, sintaxe, variáveis com escopo dinâmico e outros recursos básicos da linguagem são todos copiados de sh. Outros recursos, por exemplo, histórico, são copiados de csh e ksh. Bash é um shell compatível com POSIX, mas com várias extensões.

O nome do shell é um acrônimo para Bourne Again Shell, um trocadilho com o nome do shell Bourne que ele substitui e a noção de "nascer de novo".

Uma falha de segurança no Bash datada da versão 1.03 (agosto de 1989), chamada Shellshock, foi descoberta no início de setembro de 2014 e rapidamente levou a uma série de ataques na Internet. Patches para corrigir os bugs foram disponibilizados logo após a identificação dos bugs.

História

Brian Fox começou a codificar o Bash em 10 de janeiro de 1988, depois que Richard Stallman ficou insatisfeito com a falta de progresso feito por um desenvolvedor anterior. Stallman e a Free Software Foundation (FSF) consideraram um shell livre que poderia executar scripts de shell existentes tão estratégicos para um sistema completamente livre construído a partir de código BSD e GNU que este foi um dos poucos projetos que eles próprios financiaram, com a Fox assumindo o trabalho como funcionário da FSF. A Fox lançou o Bash como um beta, versão.99, em 8 de junho de 1989, e permaneceu como o principal mantenedor até meados de 1992 e meados de 1994, quando foi demitido da FSF e sua responsabilidade foi transferida para outro contribuidor inicial, Chet Ramey.

Desde então, o Bash tornou-se de longe o shell mais popular entre os usuários do Linux, tornando-se o shell interativo padrão nas várias distribuições desse sistema operacional (embora o shell Almquist possa ser o shell de script padrão) e no Apple' 39;s lançamentos macOS antes de Catalina em outubro de 2019. Bash também foi portado para Microsoft Windows e distribuído com Cygwin e MinGW, para DOS pelo projeto DJGPP, para Novell NetWare, para OpenVMS pelo projeto GNV, para ArcaOS e para Android através de vários aplicativos de emulação de terminal.

Em setembro de 2014, Stéphane Chazelas, especialista em Unix/Linux, descobriu um bug de segurança no programa. O bug, divulgado pela primeira vez em 24 de setembro, recebeu o nome de Shellshock e recebeu os números CVE-2014-6271, CVE-2014-6277 e CVE-2014-7169. O bug foi considerado grave, já que os scripts CGI usando Bash podem ser vulneráveis, permitindo a execução arbitrária de código. O bug estava relacionado a como o Bash passa definições de função para subshells por meio de variáveis de ambiente.

Recursos

A sintaxe do comando Bash é um superconjunto da sintaxe do comando Bourne shell. O Bash suporta expansão de chaves, conclusão de linha de comando (conclusão programável), depuração básica e manipulação de sinal (usando trap) desde o bash 2.05a, entre outros recursos. O Bash pode executar a grande maioria dos scripts de shell Bourne sem modificação, com exceção dos scripts de shell Bourne que se deparam com um comportamento de sintaxe marginal interpretado de maneira diferente no Bash ou tentando executar um comando do sistema correspondente a um Bash interno mais recente, etc. A sintaxe do comando Bash inclui ideias desenhadas do KornShell (ksh) e do shell C (csh), como edição de linha de comando, histórico de comandos (comando history), pilha de diretórios, $RANDOM e $PPID e sintaxe de substituição de comando POSIX $(…).

Quando um usuário pressiona a tecla tab em um shell de comando interativo, o Bash automaticamente usa a conclusão da linha de comando, desde a versão beta 2.04, para corresponder a nomes de programas parcialmente digitados, nomes de arquivos e nomes de variáveis. O sistema de conclusão de linha de comando Bash é muito flexível e personalizável e geralmente é empacotado com funções que completam argumentos e nomes de arquivos para tarefas e programas específicos.

A sintaxe do Bash tem muitas extensões que faltam no shell Bourne. O Bash pode realizar cálculos inteiros ("avaliação aritmética") sem gerar processos externos. Ele usa o comando ((…)) e a sintaxe de variável $((…)) para essa finalidade. Sua sintaxe simplifica o redirecionamento de E/S. Por exemplo, ele pode redirecionar a saída padrão (stdout) e o erro padrão (stderr) ao mesmo tempo usando o operador &>. Isso é mais simples de digitar do que o equivalente do shell Bourne 'comando > arquivo 2>&1'. O Bash suporta a substituição de processo usando a sintaxe <(command) e >(command), que substitui a saída de (ou entrada para) um comando onde um nome de arquivo é normalmente usado. (Isto é implementado através de pipes não nomeados /proc/fd/ em sistemas que suportam isso, ou através de pipes nomeados temporários quando necessário).

Ao usar a 'função' palavra-chave, declarações de função Bash não são compatíveis com scripts Bourne/Korn/POSIX (o KornShell tem o mesmo problema ao usar 'função'), mas Bash aceita a mesma sintaxe de declaração de função que os shells Bourne e Korn, e é compatível com POSIX. Devido a essas e outras diferenças, os scripts de shell Bash raramente podem ser executados nos interpretadores de shell Bourne ou Korn, a menos que sejam escritos deliberadamente com essa compatibilidade em mente, que está se tornando menos comum à medida que o Linux se torna mais difundido. Mas no modo POSIX, o Bash está em conformidade com o POSIX mais de perto.

Bash suporta aqui documentos. Desde a versão 2.05b, o Bash pode redirecionar a entrada padrão (stdin) de uma "string aqui" usando o operador <<<.

O Bash 3.0 suporta correspondência de expressão regular em processo usando uma sintaxe que lembra Perl.

Em fevereiro de 2009, o Bash 4.0 introduziu suporte para matrizes associativas. Índices de matriz associativa são strings, de maneira semelhante a AWK ou Tcl. Eles podem ser usados para emular arrays multidimensionais. O Bash 4 também muda sua licença para GPL-3.0 ou posterior; alguns usuários suspeitam que essa mudança de licenciamento é o motivo pelo qual o MacOS continua a usar versões mais antigas. A Apple finalmente parou de usar o Bash em seus sistemas operacionais como shell padrão com o lançamento do MacOS Catalina em 2019.

Expansão de colchetes

A expansão de colchetes, também chamada de alternância, é um recurso copiado do shell C. Gera um conjunto de combinações alternativas. Os resultados gerados não precisam existir como arquivos. Os resultados de cada string expandida não são classificados e a ordem da esquerda para a direita é preservada:

$ Echo um(P,c,d,b?e
ace ade abe$ Echo (a,b,c? (d,e,f?ad ae af bd be bf cd ce c

Os usuários não devem usar expansões de colchetes em scripts de shell portáteis, porque o shell Bourne não produz a mesma saída.

$ # Uma concha tradicional não produz a mesma saída$ /bin/sh -c "Eco" 'ASSUNTOS

Quando a expansão de chaves é combinada com curingas, as chaves são expandidas primeiro e, em seguida, os curingas resultantes são substituídos normalmente. Portanto, uma listagem de imagens JPEG e PNG no diretório atual pode ser obtida usando:

É.(jpg, jpeg, png? # expande para *.jpg *.jpeg *.png - após o qual, # os wildcards são processadosEcho *(Png, Jp(E...?g? # echo just show the expansions - # e as tranças em aparelho são possíveis.

Além da alternância, a expansão de colchetes pode ser usada para intervalos sequenciais entre dois números inteiros ou caracteres separados por pontos duplos. As versões mais recentes do Bash permitem que um terceiro inteiro especifique o incremento.

$ Echo (1..10?1 2 3 4 5 6 7 8 9 10$ Echo (01:01..10?01 02 03 04 05 07 08 09 10$ Echo arquivo(1..4?Não.
file1.txt file2.txt file3.txt file4.txt$ Echo (a.e.?a b$ Echo (1..10.3?1 4 7 10$ Echo (a..j..3?a d g j

Quando a expansão de colchetes é combinada com a expansão variável (A.K.A. expansão de parâmetros e substituição de parâmetros), a expansão variável é executada após a expansão de colchetes, que em alguns casos pode exigir o uso do built-in eval, assim:

$ início= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =1; fim= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =10.$ Echo ($start...$end? # Falha em expandir devido à ordem de avaliação(1..10)$ eval Echo ($start...$end? # expansão variável ocorre então string resultante é avaliada1 2 3 4 5 6 7 8 9 10

Scripts de inicialização

Quando o Bash inicia, ele executa os comandos em uma variedade de arquivos de ponto. Ao contrário dos scripts de shell Bash, os arquivos de ponto normalmente não têm permissão de execução habilitada nem uma diretiva de interpretador como #!/bin/bash.

Exemplo de inicialização do Bash compatível com legado

O esqueleto ~/.bash_profile abaixo é compatível com o shell Bourne e fornece semântica semelhante a csh para ~/.bashrc e ~/.bash_login . O [ -r filename ] && cmd é uma avaliação de curto-circuito que testa se filename existe e é legível, pulando a parte após && se não for.

Não. - O que é? ] >. ~/.profile # set up ambiente, uma vez, Bourne-sh sintax onlyse Não. - Não. "$PS1" ] ; então Somos interativos? Não. - O quê? ] >. ~.bashrc # tty/prompt/function setup para shells interativos Não. - O quê? ] >. - Não. # quaisquer tarefas de login apenas para o shell de loginFim # Fim do bloco "if"

Problemas do sistema operacional na inicialização do Bash

Algumas versões de Unix e Linux contêm scripts de inicialização do sistema Bash, geralmente nos diretórios /etc. O Bash os chama como parte de sua inicialização padrão, mas outros arquivos de inicialização podem lê-los em uma ordem diferente da sequência de inicialização do Bash documentada. O conteúdo padrão dos arquivos do usuário raiz também pode ter problemas, bem como os arquivos básicos que o sistema fornece para novas contas de usuário na configuração. Os scripts de inicialização que iniciam o sistema X window também podem fazer coisas surpreendentes com os scripts de inicialização Bash do usuário em uma tentativa de configurar as variáveis de ambiente do usuário antes de iniciar o gerenciador de janelas. Esses problemas geralmente podem ser resolvidos usando um arquivo ~/.xsession ou ~/.xprofile para ler o ~/.profile — que fornece a variáveis de ambiente que as janelas do shell Bash geradas a partir do gerenciador de janelas precisam, como xterm ou Gnome Terminal.

Portabilidade

Invocar o Bash com a opção --posix ou declarar set -o posix em um script faz com que o Bash esteja em conformidade com o padrão POSIX 1003.2. Os scripts de shell Bash destinados à portabilidade devem levar em consideração pelo menos o padrão de shell POSIX. Alguns recursos do bash não encontrados no POSIX são:

Se um pedaço de código usa tal recurso, ele é chamado de "bashism" – um problema para uso portátil. Debian's checkbashisms e Vidar Holen's shellcheck pode ser usado para garantir que um script não contém essas partes. A lista varia dependendo do shell de destino real: a política do Debian permite algumas extensões em seus scripts (como eles estão no shell de traço), enquanto um script que pretende oferecer suporte a shells Bourne pré-POSIX, como autoconf's configurar, são ainda mais limitados nos recursos que podem usar.

Atalhos de teclado

O Bash usa readline para fornecer atalhos de teclado para edição de linha de comando usando as combinações de teclas padrão (Emacs). Vi-bindings podem ser ativados executando set -o vi.

Gestão de processos

O shell Bash possui dois modos de execução para comandos: lote e modo simultâneo.

Para executar comandos em lote (ou seja, em sequência) eles devem ser separados pelo caractere ";", ou em linhas separadas:

comando1; comando2

neste exemplo, quando o comando1 é concluído, o comando2 é executado.

Uma execução em segundo plano do comando1 pode ocorrer usando (símbolo &) no final de um comando de execução, e o processo será executado em segundo plano, retornando imediatamente o controle ao shell e permitindo a execução contínua de comandos.

comando1 >

Ou para ter uma execução simultânea de dois command1 e command2, eles devem ser executados no shell Bash da seguinte maneira:

comando1 > comando2

Neste caso, o comando1 é executado no símbolo & de fundo, retornando imediatamente o controle para o shell que executa o comando2 em primeiro plano.

Um processo pode ser interrompido e o controle retornado ao bash digitando Ctrl+z enquanto o processo está sendo executado em primeiro plano.

Uma lista de todos os processos, em segundo plano e parados, pode ser obtida executando jobs:

$ jobs trabalhos[1]- Executando comando1 &[2]+ Comando parado2

Na saída, o número entre colchetes refere-se ao ID do trabalho. O sinal de mais significa o processo padrão para bg e fg. O texto "Executando" e "Parado" consulte o estado do processo. A última string é o comando que iniciou o processo.

O estado de um processo pode ser alterado usando vários comandos. O comando fg traz um processo para o primeiro plano, enquanto bg define um processo parado em execução em segundo plano. bg e fg podem receber um ID de tarefa como seu primeiro argumento, para especificar o processo a ser executado. Sem um, eles usam o processo padrão, identificado por um sinal de mais na saída de jobs. O comando kill pode ser usado para terminar um processo prematuramente, enviando-lhe um sinal. O ID do trabalho deve ser especificado após um sinal de porcentagem:

Mata-me. %

Execução condicional

O Bash fornece "execução condicional" separadores de comando que tornam a execução de um comando dependente do código de saída definido por um comando precedente. Por exemplo:

cd "$SOMEWHERES" >Alguma coisa. | Echo "Ocorreu um erro" >>2

Onde ./do_something só é executado se o comando cd (alterar diretório) for "bem-sucedido" (retornou um status de saída igual a zero) e o comando echo só seria executado se o comando cd ou ./do_something retornasse um & #34;erro" (status de saída diferente de zero).

Para todos os comandos, o status de saída é armazenado na variável especial $?. Bash também suporta se...;então...;else...;fi e caso $ VARIÁVEL em $pattern)...;;$other_pattern)...;; esac formas de avaliação de comandos condicionais.

Relatório de erros

Um comando externo chamado bashbug relata erros do shell Bash. Quando o comando é invocado, ele traz o editor padrão do usuário com um formulário para preencher. O formulário é enviado para os mantenedores do Bash (ou opcionalmente para outros endereços de e-mail).

Conclusão programável

Bash suporta conclusão programável por meio de complete integrado, compopt e compgen. O recurso está disponível desde a versão beta de 2.04 lançada em 2000. Esses comandos permitem a especificação de conclusão complexa e inteligente para comandos (ou seja, programas instalados), funções, variáveis e nomes de arquivo.

O completo e compopt dois comandos especificam como os argumentos de alguns comandos ou opções disponíveis serão listados na entrada readline. A partir da versão 5.1, a conclusão do comando ou a opção geralmente é ativada pelo pressionamento de tecla Tab ↹ após digitar seu nome.

Histórico de lançamentos