Esiste un comando per eseguire uno script in base alla sua riga shebang?

Se voglio eseguire uno script bash che non ha il permesso di esecuzione impostato, posso fare:

bash script.sh

Cosa devo usare invece che bashse lo script non è eseguibile e non conosco l'interprete corretto? Esiste un comando che cerca l'interprete dalla riga shebang ed esegue lo script con esso?

Sì. Si chiama perl:

perl foo.bash    # works
perl foo.lua     # works
perl foo.clisp   # works
perl foo.csh     # works
perl foo.php     # works
perl foo.gnuplot # works (no arguments)
perl foo.pl      # works (obviously)
perl foo.py      # works
perl foo.sh      # works
perl foo.tcl     # works
perl foo.rb      # works
perl foo.nodejs  # works
perl foo.r       # works
perl foo.oct     # works
perl foo.csharp  # works (no arguments)

Questo è menzionato nella documentazione di Perl :

Se la #!riga non contiene la parola "perl" né la parola "indir", il programma che prende il nome #!viene eseguito al posto dell'interprete Perl. Questo è leggermente bizzarro, ma aiuta le persone su macchine che non lo fanno #!, perché possono dire a un programma che il loro SHELL è / usr / bin / perl, e Perl invierà quindi il programma all'interprete corretto per loro.

Gli script non hanno necessariamente un shebang

Se lo script è stato eseguito dall'interprete, non puoi essere sicuro che ha la baracca a tutti . Gli script eseguiti dall'interprete non necessitano dello shebang , se si chiama l'interprete per eseguire il codice.

La risposta è quindi no, non esiste alcun comando che scoprirà con certezza qual è la lingua (interprete) con cui eseguire lo script. Puoi comunque sempre guardare all'interno dello script e vedere se ha lo shebang per scoprirlo.

Le regole in breve:

1. Quando si esegue lo script, la chiamata all'interprete esclude sempre eventuali shebang, eseguibili o meno, shebang o no.
2. Se non è eseguibile e lanciarlo dal l'interprete, lo script non ha bisogno di baracca.
3. Se lo script viene eseguito senza prima chiamare l'interprete, ha bisogno (e usa) lo shebang per scoprire quale interprete chiamare e deve essere eseguibile per avere il "permesso" di chiamare l'interprete dal suo shebang.

Se lo script non ha alcun shebang, non ci sono informazioni (dirette *) all'interno dello script per dire quale interprete usare.

Avendolo detto

Naturalmente puoi sempre scrivere uno script wrapper per provare a scoprire se lo script ha lo shebang e leggere l'interprete da quello, successivamente eseguirlo dall'interprete trovato.

Un esempio

#!/usr/bin/env python3
import subprocess
import sys

args = sys.argv[1:]; script = args[0]

try:
    lang = open(script).readlines()[0].replace("#!", "").strip().split()[-1]
    cmd = [lang, script]+args[1:]
    subprocess.call(cmd)
except (PermissionError, FileNotFoundError, IndexError):
    print("No valid shebang found")

• Salvarlo come tryrunin $PATH(ad esempio ~/bin, rendere la directory se non esiste, disconnettersi e riconnettersi), renderla eseguibile . Quindi in esecuzione:

  tryrun /path/to/nonexecutablescript

  chiama (testato) l'interprete corretto sul mio non eseguibile pythone sugli bashscript.

Spiegazione

• Lo script legge semplicemente la prima riga dello script, rimuove #!e usa il resto per chiamare l'interprete.
• Se non riesce a chiamare un interprete valido, genererà a PermissionErroro a FileNotFoundError.

Nota

L'estensione ( .sh, .pyecc.) Non svolge alcun ruolo nel determinare l'interprete appropriato su Linux.

(* È ovviamente possibile sviluppare un algoritmo di ipotesi "intelligente" per determinare la sintassi dal codice.)

Puoi farlo con uno script come questo:

#!/bin/bash

copy=/tmp/runner.$$
cp $1 ${copy}
chmod u+x ${copy}
${copy}
rm ${copy}

Così:

$ echo "echo hello" > myscript
$ ./myscript
bash: ./myscript: Permission denied
$ ./runscript myscript 
hello

Consiglio di non farlo. Le autorizzazioni sono lì per un motivo. Questo è un programma per sovvertire le autorizzazioni.

Si noti che la gestione di shebang è una funzione del kernel (nel codice sorgente di Linux - fs/binfmt_script.c). Fondamentalmente il processo che invoca direttamente uno script non è a conoscenza del #!- il kernel lo usa per capire che deve avviare un interprete.