_exec, _wexec Funktionen
CAB
Uhr
EOF
TOC
Inhaltsverzeichnis reduzieren
Inhaltsverzeichnis erweitern
Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

_exec, _wexec Funktionen

Jede Funktion in dieser Familie lädt und führt einen neuen Prozess aus:

Der Buchstabe am Ende des Funktionsnamens bestimmt die Variante.

_exec dem Suffix Funktionen

Beschreibung

e

envpArray, ein Array von Zeigern auf die Umgebungseinstellungen, wird dem neuen Prozess übergeben.

l

Befehlszeilenargumente werden einzeln an die _exec-Funktion übergeben. In der Regel verwendet, wenn die Anzahl der Parameter zum neuen Prozess im Voraus bekannt ist.

p

PATH Umgebungsvariable wird verwendet, um die auszuführende Datei zu finden.

v

argv, Array von Zeigern auf Befehlszeilenargumente, wird an _exec übergeben. In der Regel verwendet, wenn die Anzahl der Parameter des neuen Prozesses variabel ist.

Jede _exec-Funktion lädt und führt einen neuen Prozess aus. Alle _exec-Funktionen verwenden die gleiche Funktion des Betriebssystems (CreateProcess). Die _exec-Funktionen behandeln Mehrbyte-Zeichenfolgen-Argumente automatisch richtig und erkennen Mehrbytezeichensequenzen entsprechend der aktuell verwendeten Mehrbyte-Codepage. Die _wexec-Funktionen sind Breitzeichenversionen der _exec-Funktionen. Die _wexec-Funktionen verhalten sich identisch zur ihren _exec-Entsprechungen, mit der Ausnahme, dass letztere keine Mehrbyte-Zeichenfolgen nutzen.

Zuweisung generischer Textroutinen

Tchar.h-Routine

_UNICODE und _MBCS undefiniert

_MBCS definiert

_UNICODE definiert

_texecl

_execl

_execl

_wexecl

_texecle

_execle

_execle

_wexecle

_texeclp

_execlp

_execlp

_wexeclp

_texeclpe

_execlpe

_execlpe

_wexeclpe

_texecv

_execv

_execv

_wexecv

_texecve

_execve

_execve

_wexecve

_texecvp

_execvp

_execvp

_wexecvp

_texecvpe

_execvpe

_execvpe

_wexecvpe

Der Parameter cmdname gibt die als neuen Prozess auszuführende Datei an. Er kann einen vollständigen Pfad (ab Stammverzeichnis), einen partiellen Pfad (im aktuellen Arbeitsverzeichnis) oder einen Dateinamen angeben. Wenn cmdname über keine Dateinamenerweiterung verfügt oder nicht mit einem Punkt (.) endet, sucht die _exec-Funktion die benannte Datei. Wenn die Suche fehlschlägt, versucht sie denselben Basisnamen mit der Dateinamenerweiterung .com- und dann mit den .bat, exe, und .cmd-Dateinamenerweiterungen. Wenn cmdname eine Dateinamenerweiterung hat, werden nur diese Erweiterung in der Suche verwendet. Wenn cmdname mit einem Punkt endet,sucht die _exec-Funktion nach cmdname ohne Dateinamenerweiterung. _execlp , _execlpe, _execvpund _execvpe suchen nach cmdname (nach dem selbenVerfahren) in den durch die Umgebungsvariable PATH definierten Verzeichnissen. Wenn cmdname einen Laufwerksbezeichner oder Schrägstriche enthält (das heißt, wenn es sich um einen relativen Pfad handelt), sucht der _exec Aufruf nur für die angegebene Datei. Mit dem Pfad wird nicht gesucht.

Parameter werden an den neuen Prozess übergeben, indem ein oder mehrere Zeiger auf Zeichenfolgen als Parameter beim _exec Aufruf übergeben werden. Diese Zeichenfolgen bilden die Parameterliste für den neuen Prozess. Die Gesamtlänge der geerbten Umgebungseinstellungen und der Zeichenfolgen, die die Parameterliste für den neuen Prozess bilden, darf 32 KB nicht überschreiten. Das abschließende Null-Zeichen ('\ 0') für jede Zeichenfolge ist nicht in der Anzahl enthalten; Leerzeichen (die automatisch eingefügt werden, um die Parameter zu trennen) werden jedoch gezählt.

Hinweis Hinweis

Die Leerzeichen, die in Zeichenfolgen enthalten sind, können unerwartetes Verhalten verursachen. Wenn z.B. die Zeichenfolge "hi there" an _exec übergeben wird, wird der neue Prozess mit zwei Argumenten, "hi" und "there",aufgerufen. Wenn die Absicht war, dass der neue Prozess eine Datei mit dem Namen "hi there“ öffnet, wird der Prozess fehlschlagen. Sie können dies verhindern, indem Sie die Zeichenfolge mit Anführungszeichen versehen: "\"hi there\"".

Sicherheitshinweis Sicherheitshinweis

Übergeben Sie keine Benutzereingabe an _exec , ohne deren Inhalt selbst zu überprüfen. _exec wird zu einem Aufruf von CreateProcess führen. Daher sollten Sie beachten, dass nicht qualifizierte Pfadnamen Sicherheitslücken ermöglichen können.

Die _exec-Funktionen überprüfen ihre Parameter. Wenn die erwartete Parameter NULL-Zeiger sind, leere Zeichenfolgen sind, oder weggelassen wurden, rufen die _exec-Funktionen den Handler für ungültige Parameter auf, wie in Parametervalidierung beschrieben. Wenn die Ausführung fortgesetzt werden darf, setzen diese Funktionen errno auf EINVAL und geben -1 zurück. Es wird kein neuer Prozess ausgeführt.

Die Zeiger auf die Argumente können als separate Parameter übergeben werden (an _execl, _execle, _execlp und _execlpe) oder als Array von Zeigern (an _execv, _execve, _execvp und _execvpe). Mindestens ein Parameter, arg0, muss an den neuen Prozess übergeben werden. Dieser Parameter ist argv[0] des neuen Prozesses. In der Regel ist dieser Parameter eine Kopie von cmdname. (Ein abweichender Wert erzeugt keinen Fehler.)

Aufrufe von _execl, _execle, _execlp und _execlpe werden in der Regel verwendet, wenn die Anzahl der Parameter im Voraus bekannt ist. Der Parameter arg0 ist normalerweise ein Zeiger auf cmdname. Die Parameter arg1 bis argn zeigen auf Zeichenfolgen, die die neuen Parameter bilden. Ein NULL-Zeiger muss auf argn folgen, um das Ende der Parameterliste zu kennzeichnen.

Aufrufe von _execv, _execve, _execvp und _execvpe sind nützlich, wenn die Anzahl der Parameter des neuen Prozesses variabel ist. Zeiger auf die Parameter werden als Array, argv, übergeben. Der Parameter argv[0] ist normalerweise ein Zeiger auf cmdname. Die Parameter argv[1] bis argv[n] zeigen auf Zeichenfolgen, die die neue Parameterliste bilden. Der Parameter argv[n+1] muss ein NULL-Zeiger sein, um das Ende der Parameterliste zu kennzeichnen.

Dateien, die geöffnet sind, wenn ein _exec Aufruf ausgeführt wird, bleiben im neuen Prozess geöffnet. Aufrufe von _execl, _execlp, _execv und _execvp erben die Umgebung des aufrufenden Prozesses. Aufrufe von _execle, _execlpe, _execve und _execvpe ändern die Umgebung des neuen Prozesses, indem eine Liste von Umgebungseinstellungen über den envp-Parameter übergeben wird. envp ist ein Array von Zeichenzeigern, von denen jedes Element (außer dem letzten Element) auf eine NULL-terminierten Zeichenfolge zeigt, die eine Umgebungsvariable definiert. Eine solche Zeichenfolge hat normalerweise die Form NAME=value, wobei NAME der Name einer Umgebungsvariablen und value der Zeichenfolgenwert der Variable ist. (Beachten Sie, dass value nicht in Anführungszeichen eingeschlossen ist). Das letzte Element des Arrays envp sollte NULL sein. Wenn envp selbst NULL ist, erbt die neue Prozess die Umgebungseinstellungen des aufrufenden Prozesses.

Ein Programm, das durch eine _exec-Funktionen ausgeführt wird, wird immer so in den Arbeitsspeicher geladen, als ob das Feld für die maximalen Zuordnung des Programms im Header der .exe-Datei-Header den Standardwert 0xFFFFH hätte.

Die _exec-Aufrufe behalten den Konvertierungsmodus der geöffneten Dateien nicht bei. Wenn der neue Prozess die Dateien verwenden muss, die vom aufrufenden Prozess geerbt werden, verwenden Sie die _setmode Routine, um den Konvertierungsmodus dieser Dateien auf den gewünschten Modus festzulegen. Sie müssen jeden Stream vor dem _exec-Funktionsaufruf explizit leeren (mithilfe von fflush oder _flushall) oder schließen. Signaleinstellungen werden in neuen Prozessen, die durch Aufrufe von _exec-Routinen erzeugt wurden, nicht beibehalten. Die Signaleinstellungen werden im neuen Prozess auf Standardwerte zurückgesetzt.

// crt_args.c
// Illustrates the following variables used for accessing
// command-line arguments and environment variables:
// argc  argv  envp
// This program will be executed by crt_exec which follows.


#include <stdio.h>

int main( int argc,  // Number of strings in array argv
 char *argv[],       // Array of command-line argument strings
 char **envp )       // Array of environment variable strings
{
    int count;

    // Display each command-line argument.
    printf( "\nCommand-line arguments:\n" );
    for( count = 0; count < argc; count++ )
        printf( "  argv[%d]   %s\n", count, argv[count] );

    // Display each environment variable. 
    printf( "\nEnvironment variables:\n" );
    while( *envp != NULL )
        printf( "  %s\n", *(envp++) );

    return;
}

Führen Sie das folgende Programm aus, um Crt_args.exe auszuführen:

// crt_exec.c
// Illustrates the different versions of exec, including
//      _execl          _execle          _execlp          _execlpe
//      _execv          _execve          _execvp          _execvpe
//
// Although CRT_EXEC.C can exec any program, you can verify how 
// different versions handle arguments and environment by 
// compiling and specifying the sample program CRT_ARGS.C. See 
// "_spawn, _wspawn Functions" for examples of the similar spawn 
// functions.


#include <stdio.h>
#include <conio.h>
#include <process.h>

char *my_env[] =     // Environment for exec?e
{
   "THIS=environment will be",
   "PASSED=to new process by",
   "the EXEC=functions",
   NULL
};

int main( int ac, char* av[] )
{
   char *args[4];
   int ch;
   if( ac != 3 ){
      fprintf( stderr, "Usage: %s <program> <number (1-8)>\n", av[0] );
      return;
   }

   // Arguments for _execv? 
   args[0] = av[1];
   args[1] = "exec??";
   args[2] = "two";
   args[3] = NULL;

   switch( atoi( av[2] ) )
   {
   case 1:
      _execl( av[1], av[1], "_execl", "two", NULL );
      break;
   case 2:
      _execle( av[1], av[1], "_execle", "two", NULL, my_env );
      break;
   case 3:
      _execlp( av[1], av[1], "_execlp", "two", NULL );
      break;
   case 4:
      _execlpe( av[1], av[1], "_execlpe", "two", NULL, my_env );
      break;
   case 5:
      _execv( av[1], args );
      break;
   case 6:
      _execve( av[1], args, my_env );
      break;
   case 7:
      _execvp( av[1], args );
      break;
   case 8:
      _execvpe( av[1], args, my_env );
      break;
   default:
      break;
   }

   // This point is reached only if exec fails. 
   printf( "\nProcess was not execed." );
   exit( 0 );
}

Header: process.h

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2016 Microsoft