/usr/bin/env Fragen zu shebang Zeile Eigenheiten

Fragen:

Was macht der kernel tun, wenn Sie stick ein shell-Skript in der shebang-Zeile?
Wie funktioniert der Kernel wissen, welcher interpreter zu starten?

Erklärung:

Ich neulich schreiben wollte, ein wrapper um /usr/bin/env weil mein CGI-Umgebung nicht erlauben, mich um die PFAD Variablen, außer Global (was natürlich nervt!).

Also dachte ich mir, "OK. Lassen Sie uns den PREPENDPATH-und set PFAD in ein wrapper um " env.". Das resultierende Skript (hier genannt env.1) sah so aus:

#!/bin/bash
/usr/bin/env PATH=$PREPENDPATH:$PATH $*

sieht aus wie es funktionieren sollte. Ich habe geprüft, wie Sie beide reagieren nach der Einstellung PREPENDPATH:

$ which /usr/bin/env python
/usr/bin/env
/usr/bin/python

$ which /usr/bin/env.1 python
/usr/bin/env
/home/pi/prepend/bin/python

Look absolut perfekte! So weit, So gut. Aber schauen Sie, was passiert, um "Hallo Welt!".

# Shebang is #!/usr/bin/env python
$ test-env.py
Hello World!

# Shebang is #!/usr/bin/env.1 python
$ test-env.1.py
Warning: unknown mime-type for "Hello World!" -- using "application/*"
Error: no such file "Hello World!"

Ich glaube, ich bin fehlt etwas grundlegendes zu UNIX.

Ich bin ziemlich verloren, auch nach einem Blick auf den source-code des ursprünglichen env. Es stellt die Umgebung und startet das Programm (oder so scheint es mir...).

InformationsquelleAutor pi. | 2008-12-09

6

Erste von allen, sollten Sie sehr selten benutzen $* und Sie sollten fast immer "$@" statt. Es gibt eine Reihe von Fragen auf, SO die erklären, die ins und outs der, warum.

Zweite - die env Befehl hat zwei Haupt-Anwendungen. Man ist zum drucken der aktuellen Umgebung; die andere ist, die komplette Kontrolle über die Umgebung des einen Befehl aus, wenn es ausgeführt wird. Die Dritte, die Sie zeigen, ändern Sie die Umgebung, aber ehrlich gesagt, es gibt keine Notwendigkeit die Schalen sind durchaus in der Lage Umgang mit, dass für Sie.

Modus 1:
```
env
```
Modus 2:
```
env -i HOME=$HOME PATH=$PREPENDPATH:$PATH ... command args
```
Diese version bricht alle geerbten Umgebungsvariablen und läuft command mit exakt der Umwelt festgelegt, die durch die ENVVAR=Wert-Optionen.

Dritten Modus zur änderung des Umwelt - ist weniger wichtig, weil Sie tun können, die gut mit regelmäßigen (zivilisierten) Muscheln. (Das heißt nicht "C-shell" - gibt es wieder andere Fragen auf, SO dass Antworten, die erklären, dass.) Sie könnten zum Beispiel sehr gut tun:
```
#!/bin/bash
export PATH=${PREPENDPATH:?}:$PATH
exec python "$@"
```
Dieser besteht darauf, dass $PREPENDPATH einen nicht-leeren string in der Umwelt, und dann stellt es $PATH ab und exportiert den neuen PFAD einstellen. Dann, mit diesem neuen WEG, er führt die python Programm mit den entsprechenden Argumenten. Die exec ersetzt den shell-Skript mit python. Beachten Sie, dass dies ganz anders aus:
```
#!/bin/bash
PATH=${PREPENDPATH:?}:$PATH exec python "$@"
```
Oberflächlich, das ist das gleiche. Jedoch, dies wird ausgeführt, die python gefunden, die auf den bestehenden PFAD, wenn auch mit dem neuen Wert von PATH in der Prozess-Umgebung. Also, in dem Beispiel, würden Sie am Ende ausführen von Python aus /usr/bin und nicht das von /home/pi/prepend/bin.

In Ihrer situation wäre, würde ich wahrscheinlich nicht verwenden env und würde nur mit einer entsprechenden Variante des Skripts mit den expliziten export.

Den env Befehl ist ungewöhnlich, weil es nicht erkennt, der Doppel-Bindestrich zu trennen Optionen aus dem rest des Befehls. Dies ist zum Teil, weil es nicht viele Optionen, und zum Teil, weil es nicht klar ist, ob die ENVVAR=Wert Optionen sollten vor oder nach dem double dash.

Eigentlich habe ich eine Reihe von Skripten für die Ausführung (unterschiedliche Versionen) ein Datenbank-server. Diese Skripte wirklich env (und ein paar " home-grown-Programme) zur Steuerung der Umgebung des Servers:
```
#!/bin/ksh
#
# @(#)$Id: boot.black_19.sh,v 1.3 2008/06/25 15:44:44 jleffler Exp $
#
# Boot server black_19 - IDS 11.50.FC1

IXD=/usr/informix/11.50.FC1
IXS=black_19
cd $IXD || exit 1

IXF=$IXD/do.not.start.$IXS
if [ -f $IXF ]
then
    echo "$0: will not start server $IXS because file $IXF exists" 1>&2
    exit 1
fi

ONINIT=$IXD/bin/oninit.$IXS
if [ ! -f $ONINIT ]
then ONINIT=$IXD/bin/oninit
fi

tmpdir=$IXD/tmp
DAEMONIZE=/work1/jleffler/bin/daemonize
stdout=$tmpdir/$IXS.stdout
stderr=$tmpdir/$IXS.stderr

if [ ! -d $tmpdir ]
then asroot -u informix -g informix -C -- mkdir -p $tmpdir
fi

# Specialized programs carried to extremes:
#   * asroot sets UID and GID values and then executes
#   * env, which sets the environment precisely and then executes
#   * daemonize, which makes the process into a daemon and then executes
#   * oninit, which is what we really wanted to run in the first place!
# NB: daemonize defaults stdin to /dev/null and could set umask but
#     oninit dinks with it all the time so there is no real point.
# NB: daemonize should not be necessary, but oninit doesn't close its
#     controlling terminal and therefore causes cron-jobs that restart
#     it to hang, and interactive shells that started it to hang, and
#     tracing programs.
# ??? Anyone want to integrate truss into this sequence?

asroot -u informix -g informix -C -a dbaao -a dbsso -- \
    env -i HOME=$IXD \
        INFORMIXDIR=$IXD \
        INFORMIXSERVER=$IXS \
        INFORMIXCONCSMCFG=$IXD/etc/concsm.$IXS \
        IFX_LISTEN_TIMEOUT=3 \
        ONCONFIG=onconfig.$IXS \
        PATH=/usr/bin:$IXD/bin \
        SHELL=/usr/bin/ksh \
        TZ=UTC0 \
    $DAEMONIZE -act -d $IXD -o $stdout -e $stderr -- \
    $ONINIT "$@"

case "$*" in
(*v*) track-oninit-v $stdout;;
esac
```
- Dies ist nützlich, Informationen, aber wie der OP sagt, seine/Ihre kernel laufen nicht non-binaries (wie die bash-stubs, die Sie zur Verfügung stellen) als das erste element einer shebang-Zeile. Mir auch nicht, insbesondere der kernel leise ausfällt, um das Skript auszuführen mit der Problematik shebang-Zeile in die gewünschte (nicht-binären) interpreter, und dann meine shell versuchen, um das Skript auszuführen, statt. (Meine understading ist, dass dies ist eine alte-Zeit-shell-Verhalten, die viele Muscheln behalten.)
- Ich verstehe nicht, was du sagst? Sind Sie behaupten, dass es (noch) Schalen oder Kerne, die nicht behandeln #!/bin/bash oder #!/bin/ksh als die erste Zeile von einem Skript? Ich bin nicht fordern, oder den Nachweis, dass Sie verwenden können #!/some/script als shebang.
- Behaupten nicht die erste. Die OP ' s Frage ist, über die zweite, obwohl: er/Sie fragte "Was hat der kernel tun, wenn Sie stick ein shell-Skript in der shebang-Zeile?" und dann meldet Probleme, die aus der Verwendung env.1 als shebang-Zeile, wo env.1 ist ein Skript. (Wie es passiert, es war auf der Suche nach den Diskussionen der Einschränkungen über die shebang-Zeilen, die mich hierher gebracht. Und ich habe deinen post mal nützliche Informationen, danke für den Beitrag es. Ich war nur darauf aus, für andere Leser, die eventuell kommen später, dass das, was Sie diskutieren nicht hilft, überwinden die Beschränkung der OP hatte, gegen.)
InformationsquelleAutor Jonathan Leffler
4

Sollten Sie sorgfältig Lesen Sie den wikipedia-Artikel über shebang.

Wenn Ihr system sieht die Magische Zahl entsprechend die shebang, es hat eine execve auf den angegebenen Pfad nach der shebang und gibt das Skript selbst als argument.

Ihrem Skript schlägt fehl, weil die Datei, die Sie geben (/usr/bin/env.1) ist nicht eine ausführbare, sondern beginnt, sich durch ein Kram....

Ideal, man könnte es lösen mit... env auf Ihr Skript mit dieser Zeile als shebang:
```
#!/usr/bin/env /usr/bin/env.1 python
```
Funktioniert es nicht, obwohl auf linux wie es behandelt "/usr/bin/env.1 python" als Pfad (nicht die split-Argumente)

Also die einzige Möglichkeit die ich sehe ist, schreiben Sie Ihre env.1 in C

EDIT: scheint, wie niemand hält mich ^^, also ich geschrieben habe, eine einfache und schmutzige env.1.c:
```
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>


const  char* prependpath = "/your/prepend/path/here:";

int main(int argc, char** argv){
  int args_len = argc + 1;
  char* args[args_len];
  const char* env = "/usr/bin/env";
  int i;

  /* arguments: the same */
  args[0] = env;
  for(i=1; i<argc; i++)
    args[i] = argv[i];
  args[argc] = NULL;

  /* environment */
  char* p = getenv("PATH");
  char* newpath = (char*) malloc(strlen(p)
                 + strlen(prependpath));
  sprintf(newpath, "%s%s", prependpath, p);
  setenv("PATH", newpath, 1);

  execv(env, args);
  return 0;
}
```
InformationsquelleAutor Piotr Lesnicki

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.