_exec, _wexec Funktionen

Artikel
02/26/2013

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

_execl, _wexecl	_execv, _wexecv
_execle, _wexecle	_execve, _wexecve
_execlp, _wexeclp	_execvp, _wexecvp
_execlpe, _wexeclpe	_execvpe, _wexecvpe

Der Buchstabe am Ende des Funktionsnamens bestimmt die Variante.

_exec dem Suffix Funktionen	Beschreibung
e	envpArray, Zeiger auf die Umgebungseinstellungen, wird dem neuen Prozess übergeben.
l	Befehlszeilenargumente werden einzeln zu _exec-Funktion übergeben.In der Regel verwendet, wenn die Anzahl der Parameter zum neuen Prozess im Voraus bekannt.
p	PATH Umgebungsvariable wird verwendet, um die Datei zu suchen.
v	argv, Array von Zeigern auf den Befehlszeilenargumenten, wird auf _execübergeben.In der Regel verwendet, wenn die Anzahl der Parameter zum neuen Prozess variabel ist.

Hinweise

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 und ggf. automatisch Mehrbyte-Zeichenfolgen-Argumente derzeit verwendeten erkennen Mehrbytezeichen sequenzen entsprechend der Mehrbyte-Codepage.Die _wexec-Funktionen sind Breitzeichenversionen der _exec-Funktionen.Die _wexec-Funktionen verhalten sich in ihren äquivalenten Familien _exec identisch, mit der Ausnahme, dass sie nicht behandeln Mehrbyte-Zeichenfolgen.

Zuweisung generischer Textroutinen

Tchar.h-Routine	_UNICODE als auch _MBCS nicht definiert	_MBCS definieren	_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 gibt die cmdname an der neuen Datei Prozess ausgeführt werden soll.Er kann einen vollständigen Pfad vom Stammknoten () einen partiellen Pfad (im aktuellen Arbeitsverzeichnis) oder einen Dateinamen angeben.Wenn cmdname keine Dateinamenerweiterung verfügt oder nicht mit einem Punkt (.) beendet, die _exec-Funktion sucht 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 wird.Wenn cmdname mit einem Punkt beendet, die _exec-Funktion sucht cmdname ohne Dateinamenerweiterung._execlp, _execlpe, _execvpund _execvpe Suche nach cmdname (mit der gleichen Prozeduren) in den Verzeichnissen durch die Umgebungsvariable PATH .Wenn cmdname eines Laufwerks Parameterbezeichner oder Schrägstriche enthalten ist (das heißt wenn es sich um einen relativen Pfad handelt), sucht der _exec Aufruf nur für die angegebene Datei. Der Pfad wurde nicht gefunden.

Parameter werden an den neuen Prozess übergeben, indem eine oder mehrere Zeiger auf die Zeichenfolgen als Parameter im _exec Aufruf gibt.Diese Zeichenfolgen besteht die Parameterliste für den neuen Prozess.Die kombinierte Länge der geerbten Umgebungseinstellungen und der Zeichenfolgen, die die Parameterliste für den neuen Prozess besteht, darf 32 KB nicht überschreiten.Das Null („\ 0 ") für jede Zeichenfolge ist nicht in der Anzahl der Leerzeichen enthalten, jedoch (automatisch eingefügt, um die Parameter zu trennen) gezählt werden.

Hinweis
Die Leerzeichen, die in Zeichenfolgen enthalten sind, kann unerwartetes Verhalten verursachen. Übergeben _exec z. B. die Zeichenfolge ergibt "hi there" den neuen Prozess, der zwei Argumente, "hi" und "there"abruft.Wenn die neuen Prozess besitzen wurde, öffnen Sie eine Datei mit dem Namen dort „Hello“ Prozess würde fehlschlagen.Sie können dies verhindern, indem Sie die Zeichenfolgen zitieren: "\"hi there\"".

Die Leerzeichen, die in Zeichenfolgen enthalten sind, kann unerwartetes Verhalten verursachen. Übergeben _exec z. B. die Zeichenfolge ergibt "hi there" den neuen Prozess, der zwei Argumente, "hi" und "there"abruft.Wenn die neuen Prozess besitzen wurde, öffnen Sie eine Datei mit dem Namen dort „Hello“ Prozess würde fehlschlagen.Sie können dies verhindern, indem Sie die Zeichenfolgen zitieren: "\"hi there\"".

Sicherheitshinweis
Führen Sie Benutzereingaben nicht explizit _exec , ohne seinen Inhalt zu überprüfen._exec ergibt einen Aufruf von CreateProcess . Daher sollten Sie beachten, dass nicht gekennzeichneten Pfadnamen auf potenzielle Sicherheitslücken führen.

Die _exec-Funktionen überprüfen deren Parameter.Wenn die erwartete Parameter NULL-Zeiger, leere Zeichenfolgen sind, oder weggelassen, rufen die _exec-Funktionen der ungültige Parameter für ein, wie in Parametervalidierungbeschrieben.Wenn die Ausführung fortgesetzt werden kann, darf dieses Features zu EINVAL und legen errno return -1.Kein neuer Prozess ausgeführt wird.

Die Zeiger auf das Argument kann als separate Parameter übergeben werden (in _execl, in _execle, in _execlpund _execlpe) oder als Array von Zeigern (in _execv, in _execve, in _execvpund _execvpe).Mindestens ein Parameter muss, um arg0neuen Prozess übergeben werden. dieser Parameter ist argv[0] des neuen Prozesses.In der Regel ist dieser Parameter eine Kopie cmdname.A (Unterschiedlicher Wert erzeugt keinen Fehler.)

_execl, _execle, _execlpund _execlpe Aufrufe werden in der Regel verwendet, wenn die Anzahl der Parameter im Voraus bekannt.Der Parameter arg0 ist normalerweise ein Zeiger auf cmdname.Die Parameter arg1 von argn zeigen Sie auf Zeichenfolgen, die die neue Parameterliste bilden.Ein NULL-Zeiger muss argn ausführen, um das Ende der Parameterliste kennzeichnet.

_execv, _execve, _execvpund _execvpe Aufrufe sind nützlich, wenn die Anzahl der Parameter zum neuen Prozess variabel ist.Zeiger auf den Parameter werden als Array, argvübergeben.Der Parameter argv[0] ist normalerweise ein Zeiger auf cmdname.Die Parameter argv[1] [ argvdurch Punktn] in Zeichenfolgen, die die neue Parameterliste bilden.Der Parameter argv[n+1] NULL muss ein Zeiger sein, um am Ende der Parameterliste kennzeichnet.

Dateien, die geöffnet sind, wenn ein _exec Aufruf ausgeführt wird, verbleiben im neuen Prozess geöffnet.In _execl, in _execlp, in _execvund _execvp Aufrufen erbt die neue Prozess die Umgebung des aufrufenden Prozesses._execle, _execlpe, _execveund _execvpe Aufrufe ändern die Umgebung für den neuen Prozess, indem eine Liste von Umgebungseinstellungen für den envp-Parameter übergeben.envp ist ein Array Zeichenzeiger, von denen jedes Element (außer dem letzten Element) auf eine auf NULL endende Zeichenfolge veranschaulicht, die eine Umgebungsvariable definiert.Eine solche Zeichenfolge weist normalerweise das Formular NAME=value , in dem NAME der Name einer Umgebungsvariablen und value der Zeichenfolgenwert ist, auf den diese Variable festgelegt ist.(Beachten Sie, dass value nicht in Anführungszeichen eingeschlossen ist). Das letzte Element des Arrays sollte envpNULLsein.Wenn envp selbst NULList, erbt die neue Prozess die Umgebungseinstellungen des aufrufenden Prozesses.

Ein Programm, das einer der _exec-Funktionen ausgeführt wird, wird immer in den Arbeitsspeicher geladen, als ob das Feld den maximalen Zuordnung im EXE-Datei-Header des Programms auf den Standardwert von 0xFFFFH festgelegt wurden.

Die _exec Aufrufe behalten die nicht Übersetzungs ändert der geöffneten Dateien bei.Wenn der neue Prozess die Dateien verwenden muss, die vom aufrufenden Prozess geerbt werden, verwenden Sie die _setmode Routine, um den Modus Übersetzungs dieser Dateien auf den gewünschten Modus festzulegen.Sie müssen jeden beliebigen Datenstream vor dem _exec-Funktionsaufruf explizit leeren (mithilfe fflush oder _flushall) oder schließen.Signal in neuen Einstellungen werden nicht beibehalten Prozesse, die durch Aufrufe von _exec Routinen erstellt werden.Die Einstellungen werden an den Standardwert im Signal neuen Prozesses zurückgesetzt.

Beispiel

// 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 );
}