Como posso executar um arquivo sem executar permissões?

Como posso executar um arquivo sem me dar permissões de execução (com chmod u+x) para ele?

Se eu tentar marcar a caixa de seleção 'Permitir a execução de arquivo como programa', a marca de seleção será removida imediatamente.

Verifique a propriedade do arquivo

Faça isso antes de mais nada (a menos que tenha certeza de que é o proprietário do arquivo).

Verifique e verifique se você possui o arquivo que você está tentando executar com um dos seguintes métodos.

Gráfico

1. Clique com o botão direito do mouse no arquivo.
2. Clique em 'Propriedades'.
3. Clique na guia 'Permissões'.
4. Verifique se o campo "Proprietário" diz seu nome de usuário. Se não aparecer "Alterar propriedade do arquivo" abaixo

Linha de comando

1. Execute este comando em um terminal

   [ ! -O "/path/to/file" ] && echo "You don't own the file"
   

2. Se imprimir " You don't own the file", consulte "Alterar a propriedade do arquivo" abaixo.

Alterar a propriedade do arquivo

Execute este comando em um terminal

sudo chown $USER:$(id -gn $USER) "/path/to/file"

Arquivos executáveis

Uma resposta que encontrei de um comentário de Lekensteyn sobre uma resposta para uma pergunta sobre chmodpartições NTFS que acho que merece sua própria pergunta e resposta, crédito total para Lekensteyn.

Use este comando para arquivos executáveis ​​(substituindo /path/to/executablepelo caminho correto):

• Arquivos executáveis ​​de 64 bits:

  /lib64/ld-linux-x86-64.so.2 /path/to/executable
  

• Arquivos executáveis ​​de 32 bits:

  /lib/ld-linux.so.2 /path/to/executable
  

Se o procedimento acima não funcionar (ou gerar erros de arquivo não encontrado), tente usá-lo antes do comando acima

cd "$(dirname /path/to/executable)"

Todos os comandos acima não funcionarão para scripts baseados em texto (Bash, Python, Perl, etc.), veja abaixo.

Verifique se um programa é de 64 ou 32 bits

Use este comando para descobrir se um executável tem 32 ( x86) ou 64 ( x86-64) bits

objdump -f "$file" | grep '^architecture' | cut -d, -f1 | sed 's/architecture: //'

Se diz i386:x86-64, então é de 64 bits. Se diz i386apenas, então é de 32 bits.

Scripts

Para scripts baseados em texto (Bash, Python, Perl, etc.), você deve usar o comando especificado na primeira #!linha do arquivo.

Por exemplo, se a primeira linha do arquivo for

#!/usr/bin/env python3

em seguida, execute esses comandos em um terminal (substituindo /path/to/filepelo caminho correto)

cd "$(dirname /path/to/file)"       # Not strictly necessary, see section below

# Replace '/usr/bin/env python3' with the first line without the front #!
/usr/bin/env python3 /path/to/file  # Use './file' if you want

.jarArquivos Java

Para jar executáveis ​​em Java, você pode simplesmente usar estes comandos (substituindo /path/to/jarpelo caminho correto):

cd "$(dirname /path/to/jar)"   # Not strictly necessary, see section below
java -jar /path/to/jar

Quando você não precisa cd "$(dirname /path/to/file)"

Estas são circunstâncias possíveis em que você não precisará usar cd "$(dirname /path/to/file)"antes de executar o programa com qualquer método: Se pelo menos um for verdadeiro, você não precisará cdprimeiro.

• O programa não realiza nenhuma operação de arquivo (por exemplo: ele usa apenas apt-get)
• O programa usa cd(ou equivalente) para mudar para um caminho absoluto antes de executar qualquer operação de arquivo (exemplo cd "$(dirname "$0")":)
• O programa não faz referência a nenhum caminho relativo (caminhos iniciados ./ou iniciados sem barra)

Se não tiver certeza, adicione cd "$(dirname "$0")"(ou equivalente) à parte superior do script (se aplicável) ou use cd "$(dirname /path/to/file)"assim mesmo.

Se for um script de shell, você pode "originar" de outro script de shell, ou seja:

#!/bin/bash
# This script runs another script indirectly, by sucking in its contents and evaluating inline:

source /path/to/script/which/lost/its/exec/flag "$@"

O "$ @" acrescenta os parâmetros da linha de comando, se necessário.

Dito isto, essa provavelmente não é a melhor solução para o problema subjacente, mas não sabemos o suficiente sobre esse problema para oferecer alternativas.