_exec, _wexec Funzioni

Ogni funzione in questa famiglia carica ed esegue un nuovo processo:

_execl, _wexecl
_execv, _wexecv
_execle, _wexecle

_execve, _wexecve
_execlp, _wexeclp
_execvp, _wexecvp

_execlpe, _wexeclpe
_execvpe, _wexecvpe

La lettera alla fine del nome della funzione identifica la modifica.

_exec suffisso della funzione	Descrizione
e	envp, matrice di puntatori alle impostazioni di ambiente, viene passato al nuovo processo.
l	Gli argomenti della riga di comando vengono passati singolarmente alla funzione _exec. Si usa in genere quando il numero di parametri per il nuovo processo è noto a priori.
p	Per trovare il file da eseguire viene usata la variabile di ambiente PATH.
v	argv, matrice di puntatori agli argomenti della riga di comando, viene passato a _exec. Si usa in genere quando il numero di parametri per il nuovo processo è variabile.

Osservazioni:

Ogni funzione _exec carica ed esegue un nuovo processo. Tutte le _exec funzioni usano la stessa funzione del sistema operativo (CreateProcess). La funzione _exec gestisce automaticamente gli argomenti della stringa con caratteri multibyte in base alle esigenze, riconoscendo le sequenze di caratteri multibyte in base alla tabella codici multibyte attualmente in uso. Le funzioni _wexec sono versioni a caratteri wide delle funzioni _exec. Le _wexec funzioni si comportano in modo identico alle controparti _exec della famiglia, ad eccezione del fatto che non gestiscono stringhe di caratteri multibyte.

Mapping di routine di testo generico

Tchar.h routine	_UNICODE e _MBCS non definito	_MBCS definito	_UNICODE definito
_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

Il parametro cmdname specifica il file da eseguire come nuovo processo. È possibile specificare un percorso completo (dalla radice), un percorso parziale (dalla cartella di lavoro corrente), oppure un nome di file. Se cmdname non ha un'estensione di file o non termina con un punto (.), la _exec funzione cerca il file denominato. Se la ricerca ha esito negativo, prova nuovamente con lo stesso nome di base e con l'estensione di file .com e successivamente con .exe, .bat e .cmd. Se cmdname possiede un estensione di file, nella ricerca viene usata solo l'estensione. Se cmdname termina con un punto, la funzione _exec cerca cmdname senza estensione di file. _execlp, _execlpe, _execvp e _execvpe cercano cmdname (usando le stesse procedure) nella directory specificata dalla variabile di ambiente PATH. Se cmdname contiene un identificatore di unità o qualsiasi barra , ovvero se si tratta di un percorso relativo, la _exec chiamata cerca solo il file specificato. Il percorso non viene cercato.

I parametri vengono passati al nuovo processo specificando uno o più puntatori alle stringhe di caratteri come parametri nella chiamata _exec. Queste stringhe di caratteri formano l'elenco dei parametri per il nuovo processo. La lunghezza combinata delle impostazioni di ambiente ereditate e delle stringhe che compongono l'elenco dei parametri del nuovo processo non deve superare i 32 KB. Il carattere di terminazione NULL (\0) per ogni stringa non è incluso nel conteggio, ma vengono conteggiati gli spazi (inseriti automaticamente per separare i parametri).

Nota

La presenza di spazi incorporati nelle stringhe può causare comportamenti imprevisti; ad esempio, passare a _exec la stringa "hi there" comporterà la presenza nel nuovo processo di due argomenti, "hi" e "there". Se lo scopo è quello di far aprire al nuovo processo un file denominato "hi there", il processo avrà esito negativo. Per evitarlo, racchiudere la stringa tra virgolette doppie: "\"hi there\"".

Importante

Non passare input utente a _exec senza verificarne esplicitamente il contenuto. _exec comporterà una chiamata a CreateProcess in modo da tenere presente che i nomi di percorso non qualificati potrebbero causare potenziali vulnerabilità di sicurezza.

Le funzioni _exec convalidano i propri parametri. Se i parametri previsti sono puntatori Null, stringhe vuote o omesse, le _exec funzioni richiamano il gestore di parametri non validi come descritto in Convalida dei parametri. Se l'esecuzione può continuare, queste funzioni impostano errno su EINVAL e restituiscono -1. Non viene eseguito alcun nuovo processo.

Gli argomenti di tipo puntatore possono essere passati come parametri separati (in _execl, _execle, _execlp e _execlpe) o come o matrice di puntatori (in _execv, _execve, _execvp e _execvpe). Almeno un parametro, arg0, deve essere passato al nuovo processo. Questo parametro è argv[0] del nuovo processo. In genere, questo parametro è una copia di cmdname. Un valore diverso non genera un errore.

Le chiamate _execl, _execle, _execlp e _execlpe vengono in genere usate quando il numero di parametri è noto a priori. Il parametro arg0 è generalmente un puntatore a cmdname. I parametri da arg1 a argn puntano alle stringhe di caratteri che costituiscono il nuovo elenco di parametri. Un puntatore null deve seguire argn per contrassegnare la fine dell'elenco di parametri.

Le chiamate _execv, _execve, _execvp e _execvpe sono utili quando il numero di parametri per il nuovo processo è variabile. I puntatori ai parametri vengono passati come matrice, argv. Il parametro argv[0] è generalmente un puntatore a cmdname. I parametri da argv[1] a argv[n] puntano alle stringhe di caratteri che costituiscono il nuovo elenco di parametri. Il parametro argv[n+1] deve essere un NULL puntatore per contrassegnare la fine dell'elenco di parametri.

I file che vengono aperti quando viene effettuata una chiamata _exec rimangono aperti nel nuovo processo. Nelle chiamate _execl, _execlp, _execv e _execvp il nuovo processo eredita l'ambiente del processo chiamante. Le chiamate _execle, _execlpe, _execve e _execvpe alterano l'ambiente del nuovo processo passando un elenco delle impostazioni di ambiente tramite il parametro envp. envp è una matrice di puntatori a caratteri, ogni elemento della matrice (ad eccezione dell'elemento finale) punta alla stringa di terminazione null che definisce una variabile di ambiente. Tale stringa è in genere in formato NAME=value, dove NAME è il nome di una variabile di ambiente e value è il valore stringa su cui è impostata la variabile. L'oggetto value non è racchiuso tra virgolette doppie. L'elemento finale della envp matrice deve essere NULL. Quando envp stesso è NULL, il nuovo processo eredita le impostazioni di ambiente del processo chiamante.

Un programma eseguito con una delle _exec funzioni viene sempre caricato in memoria come se il campo di allocazione massima nell'intestazione .exe file del programma fosse impostato sul valore predefinito di 0xFFFFH.

Le _exec chiamate non mantengono le modalità di conversione dei file aperti. Se il nuovo processo deve usare i file ereditati dal processo chiamante, utilizzare la _setmode routine per impostare la modalità di conversione di questi file sulla modalità desiderata. È necessario scaricare (usando fflush o _flushall) o chiudere esplicitamente qualsiasi flusso prima della chiamata di funzione _exec. Le impostazioni del segnale non vengono mantenute nei nuovi processi creati dalle chiamate alle _exec routine. Le impostazioni dei segnali del nuovo processo vengono reimpostate sui valori predefiniti.

Esempio

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

Eseguire il programma seguente per eseguire Crt_args.exe:

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

Requisiti

Intestazione: process.h

Vedi anche

Processo e controllo dell'ambiente
abort
atexit
exit, _Exit, _exit
_onexit, _onexit_m
_spawn, _wspawn funzioni
system, _wsystem