execl, execle, execlp, execlpe, execv, execve, execvp, execvpe, _wexecl, _wexecle, _wexeclp, _wexeclpe, _wexecv, _wexecve, _wexecvp, _wexecvpe

Nach oben zu process.h - Index

Header-Datei

process.h

Kategorie

Prozesssteuerungsroutinen

Prototyp

int execl(char *path, char *arg0 *arg1, ..., *argn, NULL);

int _wexecl(wchar_t *path, wchar_t *arg0 *arg1, ..., *argn, NULL);

int execle(char *path, char *arg0, *arg1, ..., *argn, NULL, char **env);

int _wexecle(wchar_t *path, wchar_t *arg0, *arg1, ..., *argn, NULL, wchar_t **env);

int execlp(char *path, char *arg0,*arg1, ..., *argn, NULL);

int _wexeclp(wchar_t *path, wchar_t *arg0,*arg1, ..., *argn, NULL);

int execlpe(char *path, char *arg0, *arg1, ..., *argn, NULL, char **env);

int _wexeclpe(wchar_t *path, wchar_t *arg0, *arg1, ..., *argn, NULL, wchar_t **env);

int execv(char *path, char *argv[]);

int _wexecv(wchar_t *path, wchar_t *argv[]);

int execve(char *path, char *argv[], char **env);

int _wexecve(wchar_t *path, wchar_t *argv[], wchar_t **env);

int execvp(char *path, char *argv[]);

int _wexecvp(wchar_t *path, wchar_t *argv[]);

int execvpe(char *path, char *argv[], char **env);

int _wexecvpe(wchar_t *path, wchar_t *argv[], wchar_t **env);

Beschreibung

Lädt andere Programme und führt sie aus.

Die Funktionen der exec-Familie laden andere Programme und führen sie aus. Die so gestarteten Prozesse werden als untergeordnete Prozesse (child processes) bezeichnet. Wenn der exec-Aufruf erfolgreich ist, überlagert der untergeordnete Prozess den übergeordneten Prozess. Damit der untergeordnete Prozess geladen und ausgeführt werden kann, muss ausreichend Speicher verfügbar sein.

Der Parameter path enthält den Dateinamen des aufgerufenen untergeordneten Prozesses. Die exec-Funktionen verwenden bei der Suche die Standardsuchalgorithmen:

• Wurde keine Erweiterung angegeben, suchen die Funktionen nach genau dem angegebenen Dateinamen. Wurde die Datei nicht gefunden, wird die Erweiterung .EXE angefügt und erneut gesucht. Ist die Suche erfolglos, wird die Erweiterung .COM angefügt und erneut gesucht. Wurde die Datei gefunden, wird der Kommandozeilen-Interpreter COMSPEC (Windows) oder COMMAND.COM (DOS) verwendet, um die Datei auszuführen.
• Wurde eine Erweiterung oder ein Punkt angegeben, suchen die Funktionen nach genau dem angegebenen Dateinamen.

Die dem "Familiennamen" der exec-Funktionen angefügten Suffixe l, v, p und e geben an, dass die so benannte Funktion über bestimmte Fähigkeiten verfügt.

l	gibt an, dass die Argumentzeiger arg0, arg1, ..., argn als separate Argumente übergeben werden. In der Regel wird das Suffix l dann verwendet, wenn die Anzahl der übergebenen Argumente schon vorher bekannt ist.
v	gibt an, dass die Argumentzeiger argv[0], ..., arg[n] als Zeigerarray übergeben werden. In der Regel wird das Suffix v dann verwendet, wenn eine variable Anzahl von Argumenten zu übergeben ist.
p	gibt an, dass die Funktion in den in der Umgebungsvariablen PATH angegebenen Verzeichnissen nach der Datei sucht (ohne das Suffix p durchsucht die Funktion nur das aktuelle Arbeitsverzeichnis). Enthält der Parameter path keine Verzeichnisangabe, durchsucht die Funktion zunächst das aktuelle Verzeichnis, dann die in der Umgebungsvariablen PATH angegebenen Verzeichnisse.
e	gibt an, dass das Argument envp an den untergeordneten Prozess übergeben werden kann; dadurch können Sie die Umgebung des untergeordneten Prozesses ändern. Ohne das Suffix e erbt der untergeordnete Prozess die Umgebung des übergeordneten Prozesses.

Bei jeder Funktion der exec-Familie muss eines der beiden argumentspezifierenden Suffixe angegeben werden (entweder l oder v). Die Suffixe für Pfadsuche und Umgebungsvererbung (p und e) sind optional. Beispiele:

• execl ist eine exec-Funktion, die separate Argumente übernimmt, nur das aktuelle Verzeichnis nach dem untergeordneten Prozess durchsucht und ihm die Umgebung des übergeordneten Prozesses übergibt.
• execvpe ist eine exec-Funktion, die ein Array von Argumentzeigern übernimmt, in die Suche nach dem untergeordneten Prozess auch die PATH-Angaben einschließt und auch das Argument envp zur Änderung der Umgebung des untergeordneten Prozesses akzeptiert.

Die exec-Funktionen müssen wenigstens ein Argument an den untergeordneten Prozess übergeben (arg0 oder argv[0]); gemäß Konvention ist dieses Argument eine Kopie des Zugriffspfads. (Wird ein anderer Wert für dieses 0te Argument angegeben, führt dies nicht zu einem Fehler.)

Der Parameter path ist für den untergeordneten Prozess verfügbar.

Wenn das Suffix l verwendet wird, dann zeigt arg0 in der Regel auf den Zugriffspfad und arg1, ...., argn zeigen auf die Zeichenstrings, die die neue Liste von Argumenten bilden. Das zwingend erforderliche Nullzeichen markiert das Ende der Liste.

Wenn Sie das Suffix e verwenden, dann übergeben Sie über das Argument envp eine Liste neuer Umgebungseinstellungen. Dieses Umgebungsargument ist ein Array von Zeichenzeigern. Jedes Element zeigt auf einen nullterminierten String der Form

envvar = value

wobei envvar der Name einer Umgebungsvariablen und value der Stringwert ist, der envvar zugewiesen wird. Das letzte Element von envp ist Null. Hat envp den Wert Null, erbt der untergeordnete Prozess die Umgebungseinstellungen des übergeordneten Prozesses.

Die Gesamtlänge von arg0 + arg1 + ... + argn (oder von argv[0] + argv[1] + ... + argv[n]), einschließlich der die Argumente voneinander trennenden Leerzeichen muss kleiner als 260 Bytes sein. Die terminierenden Nullzeichen werden nicht gezählt.

Wird eine exec-Funktion aufgerufen, bleiben offene Dateien auch im untergeordneten Prozess geöffnet.

Rückgabewert

Bei erfolgreicher Ausführung kehren die exec-Funktionen nicht zurück. Bei einem Fehler geben die exec-Funktionen -1 zurück, und die globale Variable errno wird auf einen der folgenden Werte gesetzt:

EACCES	Permission denied (Zugriff verweigert)
EMFILE	Too many open files (Zu viele Dateien geöffnet)
ENOENT	Path or file name not found (Pfad oder Dateiname nicht gefunden)
ENOEXEC	Exec format error (Fehler beim Exec-Format)
ENOMEM	Not enough memory (Speicher nicht ausreichend)

Beispiel

 /* execl()-Beispiel */
 #include <stdio.h>
 #include <process.h>
 
 int main(int argc, char* argv[])
 {
   int loop;
   printf("%s running...\n\n", argv[0]);
 
   if (argc == 1) {    /* prüfen, ob nur ein Befehlszeilenparameter angegeben wurde */
     printf("%s calling itself again...\n", argv[0]);
     execl(argv[0], argv[0], "ONE", "TWO", "THREE", NULL);
     perror("EXEC:");
     exit(1);
   }
   printf("%s called with arguments:\n", argv[0]);
   for (loop = 1; loop <= argc; loop++)
     puts(argv[loop]);       /* Alle Befehlszeilenparameter anzeigen */
   return 0;
 }