Por que eu possa executar uma função Bash com as 000 permissões?

Question

Não é totalmente rigth que eu possa executar uma função Bash com 000 permissões, mas quase. Meu código é:

#!/bin/bash
function hello {
echo Hello! }

O arquivo Olá tem permissões:

-r--------  1 UnixBasics hello_file

Firtsly, eu digitar com as permissões atuais:

$ . ./hello_file;hello

O ajuste é mudar as 400 permissões para 000 direita antes de executar o script bash script:

$ chmod 000 hello_file
$ . ./hello_file;hello                                             [1]
-bash: ./hello_file: Permission denied 
Hello!

Ela dá um erro, mas não parar de correr a função. Eu não entendo. Eu agora retirar a Olá-função: "Olá desactivado". I receber os erros:

-bash: ./hello_file: Permission denied
-bash: hello: command not found

Por que eu não levá-los a primeira vez? Tem algo a ver com cache, tampão ou algo parecido? Por que eu possa executar o script Bash com 000 permissões [1]?

Answer 1

Você está não executar o script, você está terceirização (incluindo)-lo. A fim de fonte de um script, você só precisa da permissão de leitura.

A propósito, as funções simplesmente existem, eles não têm permissão. Uma vez que o arquivo foi originado ea função definida, você pode executá-lo tanto quanto você quiser.

---

Update:

Por que eu não levá-los a primeira vez? Tem algo a ver com cache, tampão ou algo parecido?

Sim, como Pax respondeu, Olá provavelmente foi previamente definido lá a partir de um fornecimento anterior do arquivo. Você pode ser confundido com o sourcing ( "" builtin comando) faz. Fornecimento lê o arquivo e executa todos os seus comandos no shell atual, em seguida, volta para o prompt. Então, se você executar o arquivo uma vez, as suas funções são definidas na instância shell atual, e eles ficam lá até que você termine a sessão shell (ou desativá-los).

Por que eu possa executar o script Bash com 000 permissões [1]?

Você não pode. Note-se que ele apresenta um erro. Citando sua saída:

$ . ./hello_file;hello                                             [1]
-bash: ./hello_file: Permission denied 
Hello!

Você executou dois comandos em uma única linha de comando. O fornecimento falhou com "Permissão negada". O "Olá!" saída é a partir de um fornecimento anterior do arquivo. Você acabou de provar-lo sozinho quando você unset-lo e tentou a mesma linha de comando novamente.

Você não pode chamar que o cache ... é como o shell funciona. Você fonte outro arquivo, todas as suas definições estão incluídas na sessão de shell atual e ficar lá. Se você realmente Executar o script (não terceirização) você não deve ter quaisquer resíduos na sessão atual.

$ chmod +x hello_file
$ ./hello_file           # note: executed, not sourced
$ hello
-bash: hello: command not found

Answer 2

A explicação mais provável é que você correr hello_file antes de ser protegidos e a função já foi criado. Então você protegido o seu roteiro (você diz 100 no comando, mas mencionar 000 em seu texto).

Assim, o script não será executado. Mas Olá () ainda é definida de você corrida anterior.

Tente abrir um novo shell ou apenas executar unset hello.

Answer 3

Você tem origem o script (ou seja run "./hello_file") antes de alterar o modo para 100? Se for esse o caso, então a função "Olá" é simplesmente ainda carregado em bash. Posteriormente tentar fonte de um arquivo ilegível não vai mudar isso. Para testar corretamente, certifique-se de lançar um fresco shell.

Answer 4

A fim de executar um programa (quer se trate de um script ou executável binário), você precisa ter permissões de execução. Quando você digitar um comando, a primeira palavra (como ./foo na abaixo) especifica o comando a ser executado, e que é iniciado como um processo separado; no caso de um shell script, ele executa uma nova cópia do interpretador de shell listada na linha #!, e executa o programa usando esse intérprete.

$ ls -l foo
-rw-r--r--  1 lambda  lambda  23 Mar 25 20:02 foo
$ chmod 744 foo # or chmod u+x foo
$ ls -l foo
-rwxr--r--  1 lambda  lambda  23 Mar 25 20:02 foo
$ ./foo
Hello

Quando você usa o comando ., que é um shell builtin comando que diz a fonte do arquivo no shell atual; Isso significa que ele executa os comandos do arquivo como se você tivesse executado a partir da linha de comando, mesmo no arquivo atual. Você só precisa de permissão de leitura para a fonte de um arquivo. Por exemplo, se você definir uma variável em um sub-processo, isso não muda o valor no shell atual; mas se você fonte um script em shell atual, em seguida, ele muda o valor:

$ foo=bar
$ cat setvariables 
#!/bin/sh

foo=hello
$ ./setvariables
$ echo $foo
bar
$ . ./setvariables
$ echo $foo
hello

A função shell (como no seu exemplo) é muito parecido com uma variável, mas ele age como um comando no shell atual. Assim, quando você fonte sua hello_file usando ., que define essa função no shell atual, e ele pode executar como qualquer outra função shell que você definiu.

Tanto quanto as permissões estão em causa, eu apostaria que antes de alterar as permissões para 100 (o que significa única executável, não legíveis, o que é bastante inútil para um arquivo desde que você precisa para ser capaz de lê-lo e executá-lo para fazer qualquer coisa), você já haviam adquirido o arquivo em seu shell atual. Isso significaria que a função já foi definida, e não importa as permissões do arquivo depois que ele é definido; uma vez que a função é definida no shell atual, você pode até mesmo excluir o arquivo, e enquanto que a Shell ainda está em aberto, ainda será definida a função.

Edit: Como eu vejo a sua pergunta editado, uma vez que você retirar a função, você obterá um erro. Isso indica fortemente que a minha hipótese era correta, e que você já haviam adquirido o arquivo antes da alteração permissões. Como expliquei, abastecimento e executar o arquivo são totalmente diferentes operações, e uma vez que você fonte um arquivo, suas permissões (ou existência) não importa a todos; a função já foi carregado no shell em execução. Você pode dizer, executando a sua experiência original depois de fazer o unset hello; se você chmod 000-lo, você não deve ter permissões de leitura e, em seguida, a função não será definido.