Warum enthält argv den Programmnamen?

Typische Unix / Linux-Programme akzeptieren die Kommandozeilen-Eingaben als Argument count ( int argc) und als Argument vector ( char *argv[]). Das erste Element von argvist der Programmname, gefolgt von den eigentlichen Argumenten.

Warum wird der Programmname als Argument an die ausführbare Datei übergeben? Gibt es Beispiele für Programme, die ihren eigenen Namen verwenden (möglicherweise in einer bestimmten execSituation)?

Beachten Sie zunächst, dass dies argv[0]nicht unbedingt der Programmname ist. Dies ist, was der Aufrufer in argv[0]den execveSystemaufruf einfügt (siehe z. B. diese Frage zum Stapelüberlauf ). (Alle anderen Varianten von execsind keine Systemaufrufe, sondern Schnittstellen zu execve.)

Angenommen, zum Beispiel execl:

execl("/var/tmp/mybackdoor", "top", NULL);

/var/tmp/mybackdoorwird ausgeführt, argv[0]ist aber auf gesetzt top, und dies wird angezeigt psoder (der echte) top. Weitere Informationen finden Sie in dieser Antwort auf U & L SE.

Das alles beiseite legen: Vor dem Aufkommen von ausgefallenen Dateisystemen wie /proc, argv[0]war der einzige Weg für einen Prozess, etwas über seinen eigenen Namen zu lernen. Wofür wäre das gut?

• Einige Programme passen ihr Verhalten an den Namen an, unter dem sie aufgerufen wurden (normalerweise über symbolische oder feste Verknüpfungen, z. B. die Dienstprogramme von BusyBox ; weitere Beispiele finden Sie in anderen Antworten auf diese Frage).
• Darüber hinaus stellen Dienste, Daemons und andere Programme, die sich über syslog anmelden, ihren Namen häufig den Protokolleinträgen voran. Ohne dies wäre die Ereignisverfolgung so gut wie unmöglich.

Reichlich:

• Bash läuft im POSIX - Modus , wenn argv[0]ist sh. Es wird als Anmeldeshell ausgeführt, wenn argv[0]mit begonnen wird -.
• Vim verhält sich anders , wenn laufen , wie vi, view, evim, eview, ex, vimdiff, usw.
• Busybox, wie schon erwähnt.
• In Systemen mit systemd als init, shutdown, rebootusw. sind Symlinkssystemctl .
• und so weiter.

Historisch gesehen argvist es nur ein Array von Zeigern auf die "Wörter" der Kommandozeile, daher ist es sinnvoll, mit dem ersten "Wort" zu beginnen, das zufällig der Name des Programms ist.

Und es gibt eine ganze Reihe von Programmen, die sich je nach dem Namen, unter dem sie aufgerufen werden, unterschiedlich verhalten. Sie können also einfach verschiedene Links zu ihnen erstellen und verschiedene "Befehle" abrufen. Das extremste Beispiel, an das ich denken kann, ist die Busybox , die sich je nach Aufruf wie ein Dutzend verschiedener "Befehle" verhält .

Bearbeiten : Referenzen für Unix 1. Ausgabe, wie angefordert

Man kann beispielsweise von der siehe Hauptfunktion dass und wurden bereits verwendet. Die Shell - Kopien Argumente an die im Inneren der Teil der Schlaufe, während die sich als die Argumente in der gleichen Art und Weise der Behandlung von Befehl. (Später führt es natürlich nur das erste Argument aus, das der Name des Befehls ist.) Anscheinend gab es damals keine Verwandten.ccargcargvparbufnewargexecv

Anwendungsfälle:

Sie können den Programmnamen verwenden , um das Programmverhalten zu ändern .

Beispielsweise könnten Sie einige Symlinks zur eigentlichen Binärdatei erstellen.

Ein bekanntes Beispiel für diese Technik ist das Projekt busybox, bei dem nur eine einzige Binärdatei und viele Symlinks darauf installiert werden. (ls, cp, mv, etc). Sie tun dies , um Speicherplatz zu sparen, da ihre Ziele kleine eingebettete Geräte sind.

Dies wird auch in setarchutil-linux verwendet:

$ ls -l /usr/bin/ | grep setarch
lrwxrwxrwx 1 root root           7 2015-11-05 02:15 i386 -> setarch
lrwxrwxrwx 1 root root           7 2015-11-05 02:15 linux32 -> setarch
lrwxrwxrwx 1 root root           7 2015-11-05 02:15 linux64 -> setarch
-rwxr-xr-x 1 root root       14680 2015-10-22 16:54 setarch
lrwxrwxrwx 1 root root           7 2015-11-05 02:15 x86_64 -> setarch

Hier verwenden sie diese Technik im Wesentlichen , um viele doppelte Quelldateien zu vermeiden oder um die Quellen besser lesbar zu halten.

Ein weiterer Anwendungsfall wäre ein Programm, das zur Laufzeit einige Module oder Daten laden muss. Mit dem Programmpfad können Sie Module von einem Pfad relativ zum Programmspeicherort laden .

Darüber hinaus geben viele Programme Fehlermeldungen aus, einschließlich des Programmnamens .

Warum :

1. Weil es eine POSIX-Konvention ist ( man 3p execve):

argv ist ein Array von Argumenten, die an das neue Programm übergeben werden. Gemäß der Konvention sollte die erste dieser Zeichenfolgen den Dateinamen enthalten, der der ausgeführten Datei zugeordnet ist.

2. Es ist C-Standard (mindestens C99 und C11):

Wenn der Wert von argc größer als Null ist, repräsentiert der String, auf den argv [0] zeigt, den Programmnamen. argv [0] [0] muss das Nullzeichen sein, wenn der Programmname in der Hostumgebung nicht verfügbar ist.

Beachten Sie, dass der C-Standard "Programmname" und nicht "Dateiname" sagt.

Zusätzlich zu Programmen, die ihr Verhalten je nach Aufruf ändern, kann ich argv[0]die Verwendung eines Programms folgendermaßen drucken:

printf("Usage: %s [arguments]\n", argv[0]);

Dies bewirkt, dass die Verwendungsnachricht immer den Namen verwendet, unter dem sie aufgerufen wurde. Wenn das Programm umbenannt wird, ändert sich seine Verwendungsmeldung mit. Es enthält sogar den Pfadnamen, mit dem es aufgerufen wurde:

# cat foo.c 
#include <stdio.h>
int main(int argc, char **argv) { printf("Usage: %s [arguments]\n", argv[0]); }
# gcc -Wall -o foo foo.c
# mv foo /usr/bin 
# cd /usr/bin 
# ln -s foo bar
# foo
Usage: foo [arguments]
# bar
Usage: bar [arguments]
# ./foo
Usage: ./foo [arguments]
# /usr/bin/foo
Usage: /usr/bin/foo [arguments]

Es ist eine nette Geste, besonders für kleine Spezialwerkzeuge / Skripte, die überall zu finden sind.

Dies scheint auch in GNU-Tools üblich zu sein, siehe lszum Beispiel:

% ls --qq
ls: unrecognized option '--qq'
Try 'ls --help' for more information.
% /bin/ls --qq
/bin/ls: unrecognized option '--qq'
Try '/bin/ls --help' for more information.

Man führt das Programm die Eingabe: program_name0 arg1 arg2 arg3 ....

Die Shell sollte das Token also bereits teilen, und das erste Token ist bereits der Programmname. Übrigens gibt es auf der Programmseite und auf der Shell die gleichen Indizes.

Ich denke, dies war nur ein Convenience-Trick (von Anfang an), und wie Sie in anderen Antworten sehen, war er auch sehr praktisch, sodass diese Tradition fortgesetzt und als API festgelegt wurde.

Grundsätzlich enthält argv den Programmnamen, so dass Sie Fehlermeldungen wie prgm: file: No such file or directorydie folgenden schreiben können :

    fprintf( stderr, "%s: %s: No such file or directory\n", argv[0], argv[1] );

Ein weiteres Anwendungsbeispiel hierfür ist dieses Programm, das sich durch ... sich selbst ersetzt, bis Sie etwas eingeben, das nicht mehr vorhanden ist y.

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main (int argc, char** argv) {

  (void) argc;

  printf("arg: %s\n", argv[1]);
  int count = atoi(argv[1]);

  if ( getchar() == 'y' ) {

    ++count;

    char buf[20];
    sprintf(buf, "%d", count);

    char* newargv[3];
    newargv[0] = argv[0];
    newargv[1] = buf;
    newargv[2] = NULL;

    execve(argv[0], newargv, NULL);
  }

  return count;
}

Offensichtlich ein ausgeklügeltes, wenn auch interessantes Beispiel, aber ich denke, dies könnte realen Nutzen haben - zum Beispiel eine sich selbst aktualisierende Binärdatei, die ihren eigenen Speicherplatz mit einer neuen Version von sich selbst überschreibt, die sie heruntergeladen oder geändert hat.

Beispiel:

$ ./res 1
arg: 1
y
arg: 2
y
arg: 3
y
arg: 4
y
arg: 5
y
arg: 6
y
arg: 7
n

7 | $

Quelle und ein paar mehr Infos .

Der Pfad zum Programm lautet argv[0], damit das Programm Konfigurationsdateien usw. aus seinem Installationsverzeichnis abrufen kann.
Ohne wäre das unmöglich argv[0].

ccache verhält sich so, um verschiedene Aufrufe von Compiler-Binärdateien nachzuahmen. ccache ist ein Kompilierungscache - der springende Punkt ist, niemals denselben Quellcode zweimal zu kompilieren, sondern den Objektcode, wenn möglich, aus dem Cache zurückzugeben.

Auf der Manpage " ccache " gibt es zwei Möglichkeiten, ccache zu verwenden. Sie können Ihren Kompilierungsbefehlen entweder ccache voranstellen oder ccache als Compiler maskieren lassen, indem Sie einen symbolischen Link (als Compiler bezeichnet) zu ccache erstellen. Die erste Methode Dies ist am praktischsten, wenn Sie Ccache nur ausprobieren oder für bestimmte Projekte verwenden möchten. Die zweite Methode ist am nützlichsten, wenn Sie Ccache für alle Ihre Kompilierungen verwenden möchten. "

Bei der symlinks-Methode werden die folgenden Befehle ausgeführt:

cp ccache /usr/local/bin/
ln -s ccache /usr/local/bin/gcc
ln -s ccache /usr/local/bin/g++
ln -s ccache /usr/local/bin/cc
ln -s ccache /usr/local/bin/c++
... etc ...

... die Folge ist, dass ccache alle Befehle abfängt, die ansonsten an die Compiler gegangen wären. Auf diese Weise kann ccache eine zwischengespeicherte Datei zurückgeben oder den Befehl an den eigentlichen Compiler weiterleiten.