Como verificar se um arquivo é executável no Linux

Introdução

Neste laboratório, você aprenderá como determinar se um arquivo é executável no Linux usando vários métodos. Você começará usando o comando test com a opção -x para verificar as permissões de execução e entender como interpretar seu status de saída.

Em seguida, você explorará como usar o comando ls -l para visualizar as permissões detalhadas do arquivo e identificar o flag de executável. Finalmente, você aprenderá como usar o comando stat para inspecionar as informações de acesso ao arquivo, fornecendo outra maneira de confirmar a executabilidade.

Testar a executabilidade com test -x

Nesta etapa, você aprenderá como verificar se um arquivo é executável usando o comando test com a opção -x. O comando test é um comando de shell embutido que avalia expressões condicionais. A opção -x verifica especificamente a permissão de execução.

Primeiro, vamos criar um arquivo de texto simples no seu diretório ~/project. Usaremos o comando echo para colocar algum texto em um arquivo chamado my_script.sh.

echo "echo 'Hello from the script!'" > ~/project/my_script.sh

Agora, vamos verificar se este arquivo é executável. Por padrão, quando você cria um novo arquivo dessa forma, ele não terá permissões de execução.

Use o comando test -x seguido pelo caminho para o arquivo:

test -x ~/project/my_script.sh

Após executar este comando, você não verá nenhuma saída se o teste for bem-sucedido (o que significa que o arquivo NÃO é executável). Se o arquivo fosse executável, test -x retornaria um status de 0, que é tipicamente interpretado como "true" ou "success" em shell scripting, mas ele não imprime nada no terminal por padrão.

Para ver o resultado do comando test, podemos verificar o status de saída do comando anterior usando $?. Um status de saída de 0 significa que o teste foi verdadeiro (o arquivo é executável), e um status diferente de zero (geralmente 1) significa que o teste foi falso (o arquivo não é executável).

echo $?

Você deve ver uma saída de 1, indicando que my_script.sh atualmente não é executável.

Agora, vamos tornar o arquivo executável usando o comando chmod. chmod é usado para alterar as permissões de arquivos e diretórios. Usaremos +x para adicionar a permissão de execução para o proprietário do arquivo.

chmod +x ~/project/my_script.sh

Agora, vamos testar a executabilidade novamente:

test -x ~/project/my_script.sh

E verificar o status de saída:

echo $?

Desta vez, a saída deve ser 0, confirmando que o arquivo agora é executável.

Finalmente, vamos tentar executar o script para ver a saída:

~/project/my_script.sh

Você deve ver:

Hello from the script!

Isso confirma que você conseguiu tornar o arquivo executável e executá-lo.

Verificar permissões com ls -l

Nesta etapa, você aprenderá como visualizar as permissões detalhadas do arquivo usando o comando ls -l. Este comando fornece um formato de listagem longa, mostrando vários atributos de arquivos e diretórios, incluindo permissões, propriedade, tamanho e tempo de modificação.

Navegue até o seu diretório ~/project se você ainda não estiver lá. Você pode usar o comando cd:

cd ~/project

Agora, liste os arquivos neste diretório usando o comando ls -l:

ls -l

Você deve ver uma saída semelhante a esta (os detalhes exatos como data e hora variarão):

-rwxr-xr-x 1 labex labex   30 <date> <time> my_script.sh

Vamos analisar a primeira parte da saída, que representa as permissões do arquivo: -rwxr-xr-x. Esta string de dez caracteres diz muito sobre quem pode fazer o quê com o arquivo.

O primeiro caractere indica o tipo de arquivo:

• -: Um arquivo regular (como nosso my_script.sh)
• d: Um diretório
• l: Um link simbólico

Os próximos nove caracteres são agrupados em três conjuntos de três, representando permissões para:

1. Owner (Proprietário): O usuário que possui o arquivo (neste caso, labex).
2. Group (Grupo): O grupo que possui o arquivo (também labex).
3. Others (Outros): Todos os outros no sistema.

Dentro de cada conjunto de três caracteres, as permissões são representadas como:

• r: Permissão de leitura (permite visualizar o conteúdo do arquivo)
• w: Permissão de escrita (permite modificar ou excluir o arquivo)
• x: Permissão de execução (permite executar o arquivo como um programa)
• -: Indica que a permissão não foi concedida

Então, para -rwxr-xr-x:

• O proprietário (labex) tem permissões rwx: leitura, escrita e execução.
• O grupo (labex) tem permissões r-x: leitura e execução, mas não escrita.
• Outros têm permissões r-x: leitura e execução, mas não escrita.

Esta saída confirma que, após usar chmod +x na etapa anterior, o proprietário (labex) agora tem permissão de execução (x) para my_script.sh.

Você também pode usar ls -l para verificar as permissões de diretórios. Por exemplo, vamos olhar as permissões para o próprio diretório ~/project:

ls -ld ~/project

A opção -d diz ao ls para listar o próprio diretório, não seu conteúdo. A saída pode ser semelhante a esta:

drwxr-xr-x 2 labex labex 4096 <date> <time> /home/labex/project

Aqui, o primeiro caractere d indica que é um diretório. As permissões rwxr-xr-x significam:

• O proprietário (labex) tem permissões de leitura, escrita e execução no diretório. Para um diretório, a permissão 'executar' permite que você entre no diretório e acesse seu conteúdo.
• O grupo (labex) e Outros têm permissões de leitura e execução no diretório, mas não escrita.

Compreender a saída de ls -l é fundamental para trabalhar com arquivos e permissões no Linux.

Inspecionar acesso a arquivos com stat

Nesta etapa, você usará o comando stat para obter informações detalhadas sobre um arquivo, incluindo seus tempos de acesso, modificação e alteração, bem como suas permissões em um formato mais estruturado do que ls -l.

O comando stat exibe o status do arquivo. Ele pode ser particularmente útil para scripting ou quando você precisa de timestamps precisos.

Vamos usar stat no arquivo my_script.sh que você criou nas etapas anteriores. Certifique-se de estar no diretório ~/project ou forneça o caminho completo para o arquivo.

stat ~/project/my_script.sh

Você verá uma saída semelhante a esta:

  File: /home/labex/project/my_script.sh
  Size: 30              Blocks: 8          IO Block: 4096   regular file
Device: <device_id>     Inode: <inode_number>  Links: 1
Access: (<permissions>/-rwxr-xr-x)  Uid: ( 5000/   labex)   Gid: ( 5000/   labex)
Access: <date> <time>.<nanoseconds> +<timezone_offset>
Modify: <date> <time>.<nanoseconds> +<timezone_offset>
Change: <date> <time>.<nanoseconds> +<timezone_offset>
 Birth: -

Vamos analisar algumas linhas-chave na saída:

• File: O nome e o caminho do arquivo.
• Size: O tamanho do arquivo em bytes.
• Access: (<permissions>/-rwxr-xr-x): Esta linha mostra as permissões do arquivo tanto no formato octal (por exemplo, 0755 que corresponde a rwxr-xr-x) quanto no formato simbólico que você viu com ls -l. Ele também mostra o User ID (Uid) e o Group ID (Gid) do proprietário e grupo do arquivo.
• Access: A última vez que o arquivo foi acessado (lido).
• Modify: A última vez que o conteúdo do arquivo foi modificado.
• Change: A última vez que os metadados do arquivo (como permissões, propriedade, etc.) foram alterados.
• Birth: O tempo de criação do arquivo (pode não estar disponível em todos os sistemas de arquivos).

O comando stat fornece uma visão mais detalhada das informações do arquivo em comparação com ls -l. É especialmente útil quando você precisa examinar timestamps ou a representação numérica das permissões.

Você também pode usar stat em diretórios:

stat ~/project

A saída será semelhante, mas o tipo File indicará que é um diretório.

Experimente com stat em diferentes arquivos e diretórios em seu diretório ~/project para ver as variações na saída.

Resumo

Neste laboratório, você aprendeu como verificar se um arquivo é executável no Linux usando o comando test -x. Você criou um arquivo de script simples, usou test -x e verificou o status de saída (echo $?) para confirmar seu estado inicial não executável (status de saída 1). Em seguida, você usou chmod +x para adicionar permissões de execução e verificou a alteração com test -x e echo $?, observando um status de saída de 0.

Você também explorou métodos alternativos para verificar as permissões do arquivo. Usando ls -l, você aprendeu a interpretar a string de permissão, especificamente o caractere 'x', para identificar arquivos executáveis. Finalmente, você usou o comando stat para visualizar informações detalhadas do arquivo, incluindo permissões de acesso, fornecendo outra maneira de confirmar a executabilidade.