_exec, funzioni di _wexec

Ogni funzione in questo gruppo viene caricata ed eseguita un nuovo processo:

La lettera alla fine del nome della funzione determina la variazione.

Note

ciascuno _exec la funzione viene caricata ed eseguita un nuovo processo.tutti _exec le funzioni utilizzano la stessa funzione del sistema operativo (CreateProcess)._exec di funzioni argomenti della stringa con caratteri multibyte gestiscono automaticamente in base alle proprie esigenze, riconoscere le sequenze di caratteri multibyte in base alla tabella codici multibyte in uso._wexec le funzioni disponibili versioni a caratteri estesi di _exec funzioni._wexec le funzioni si comportano in modo identico al loro _exec le controparti con la differenza che verranno della famiglia non gestiscono le stringhe di caratteri multibyte.

Mapping di routine a testo generico

cmdname il parametro 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 file.se cmdname non presenta un'estensione di file o non termina con un punto (.), _exec ricerca di funzione del file denominato.Se la ricerca ha esito negativo, tenta lo stesso nome di base con l'estensione di file .com e quindi a estensioni di file exe, bat e cmd.se cmdname estensione di file, solo tale estensione viene utilizzata la ricerca.se cmdname terminare con un punto, _exec ricerca della funzione cmdname senza estensione di file._execlp, _execlpe, _execvpe _execvpe ricerca di cmdname utilizzando le stesse procedure) nelle directory specificate da PATH variabile di ambiente.se cmdname contiene un identificatore di unità o tutte le barre (ovvero se è un percorso relativo), _exec la chiamata viene cercato soltanto il file specificato; il percorso non viene trovato.

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

[!NOTA]

Gli spazi incorporati nelle stringhe possono causare un comportamento imprevisto, ad esempio, passare _exec la stringa "hi there" restituisce il nuovo processo ottenere due argomenti, "hi" e "there".Se lo scopo è necessario che il nuovo processo aprire un file denominato “hello ovvero„, il processo produrrà alcun esito.È possibile evitare questo citando la stringa: "\"hi there\"".

Nota sulla sicurezza
Non passare l'input dell'utente _exec senza controllare in modo esplicito il contenuto._exec restituisce una chiamata a CreateProcess pertanto è importante ricordare che i nomi di percorso non qualificati possono creare vulnerabilità della sicurezza.

_exec le funzioni convalidano i relativi parametri.Se previsto i parametri sono puntatori null, stringhe vuote, oppure omesso, _exec le funzioni richiamare il gestore non valido di parametro come descritto in Convalida dei parametri.Se l'esecuzione è consentita per continuare, queste funzioni impostate errno in EINVAL e restituiscono -1.Nessun nuovo processo viene eseguito.

I puntatori dell'argomento possono essere passati come parametri separati (in _execl, _execle, _execlpe _execlpe) o come matrice di puntatori (in _execv, _execve, _execvpe _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.(Valore diverso di un oggetto non produce un errore.)

_execl, _execle, _execlpe _execlpe le chiamate vengono in genere utilizzate quando il numero di parametri è noto in anticipo.il parametro arg0 è in genere un puntatore a cmdname.i parametri arg1 in argn passaggio 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.

_execv, _execve, _execvpe _execvpe le chiamate sono utili quando il numero di parametri al nuovo processo è variabile.I puntatori ai parametri vengono passati come matrice, argv.il parametro argv[0] è in genere un puntatore a cmdname.i parametri argv[1] tramite argv[n] punto alle stringhe di caratteri che costituiscono il nuovo elenco di parametri.il parametro argv[n+1) devono essere a NULL puntatore per contrassegnare la fine dell'elenco di parametri.

File aperti quando _exec la chiamata viene effettuata rimane aperta nel nuovo processo.in _execl, _execlp, _execve _execvp le chiamate, il nuovo processo eredita l'ambiente del processo chiamante._execle, _execlpe, _execvee _execvpe le chiamate modificano l'ambiente per il nuovo processo passando un elenco delle impostazioni di ambiente con envp parametro.envp è una matrice di puntatori di carattere, ogni elemento della matrice (fatta eccezione per l'elemento finale) indica una stringa con terminazione null che definisce una variabile di ambiente.Tale stringa in genere presenta il formato NAME=value dove NAME è il nome di una variabile di ambiente o value è il valore stringa in cui la variabile è impostata su.Si noti che value non è racchiuso tra virgolette doppie.) L'elemento finale di envp la matrice deve essere NULL.quando envp costituisce NULL, il nuovo processo eredita le impostazioni di ambiente del processo chiamante.

Un programma eseguito con uno di _exec le funzioni viene caricata sempre in memoria come se il campo di allocazione massima intestazione del file EXE del programma sia stato impostato sul valore predefinito di 0xFFFFH.

_exec le chiamate non mantengono le modalità di conversione dei file aperti.Se il nuovo processo deve utilizzare file ereditati dal processo chiamante, utilizzare _setmode procedura per impostare la modalità di traduzione di questi file in modalità desiderata.È necessario specificare in modo esplicito arrossirti (tramite fflush o _flushall) o chiudere il flusso prima di _exec chiamata di funzione.Le impostazioni del segnale non vengono mantenute in corso i nuovi processi in cui vengono creati dalle chiamate _exec routine.Le impostazioni del segnale vengono reimpostate sul valore predefinito nel processo.

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

equivalente di .NET Framework

• System:: diagnostica:: Classe processo

• System:: diagnostica:: classe di ProcessStartInfo

intestazione: process.h

Vedere anche

Riferimenti

Processo e controllo ambiente

abort

atexit

exit, _exit

_onexit, _onexit_m

_spawn, funzioni di _wspawn

system, _wsystem