Funzioni _spawn, _wspawn_spawn, _wspawn Functions

Ognuna delle funzioni _spawn crea ed esegue un nuovo processo:Each of the _spawn functions creates and executes a new process:

_spawnl, _wspawnl_spawnl, _wspawnl _spawnv, _wspawnv_spawnv, _wspawnv
_spawnle, _wspawnle_spawnle, _wspawnle _spawnve, _wspawnve_spawnve, _wspawnve
_spawnlp, _wspawnlp_spawnlp, _wspawnlp _spawnvp, _wspawnvp_spawnvp, _wspawnvp
_spawnlpe, _wspawnlpe_spawnlpe, _wspawnlpe _spawnvpe, _wspawnvpe_spawnvpe, _wspawnvpe

La lettera alla fine del nome della funzione determina la variazione.The letters at the end of the function name determine the variation.

e
envp, matrice di puntatori alle impostazioni d'ambiente, viene passata al nuovo processo.envp, array of pointers to environment settings, is passed to new process.

l
Gli argomenti della riga di comando vengono passati singolarmente alla funzione _spawn.Command-line arguments are passed individually to _spawn function. Il suffisso viene utilizzato in genere quando un numero di parametri per un nuovo processo è noto in anticipo.This suffix is typically used when a number of parameters to a new process is known in advance.

p
Per trovare il file da eseguire viene usata la variabile di ambiente PATH.PATH environment variable is used to find the file to execute.

v
argv, matrice di puntatori agli argomenti della riga di comando, viene passata alla funzione _spawn.argv, array of pointers to command-line arguments, is passed to _spawn function. Il suffisso viene utilizzato in genere quando un numero di parametri per un nuovo processo è variabile.This suffix is typically used when a number of parameters to a new process is variable.

NoteRemarks

Le funzioni _spawn creano ed eseguono un nuovo processo.The _spawn functions each create and execute a new process. Gestiscono automaticamente gli argomenti stringa di caratteri multibyte in base alle esigenze, riconoscendo le sequenze di caratteri multibyte in base alla tabella codici multibyte attualmente in uso.They automatically handle multibyte-character string arguments as appropriate, recognizing multibyte-character sequences according to the multibyte code page currently in use. Le funzioni _wspawn sono versioni a caratteri wide delle funzioni _spawn; non gestiscono le stringhe di caratteri multibyte.The _wspawn functions are wide-character versions of the _spawn functions; they do not handle multibyte-character strings. In caso contrario, le funzioni _wspawn si comportano in modo identico alle controparti _spawn.Otherwise, the _wspawn functions behave identically to their _spawn counterparts.

Mapping di routine di testo genericoGeneric-Text Routine Mappings

Routine Tchar.hTchar.h routine _UNICODE e _MBCS non definiti_UNICODE and _MBCS not defined _MBCS definito_MBCS defined _UNICODE definito_UNICODE defined
_tspawnl _spawnl _spawnl _wspawnl
_tspawnle _spawnle _spawnle _wspawnle
_tspawnlp _spawnlp _spawnlp _wspawnlp
_tspawnlpe _spawnlpe _spawnlpe _wspawnlpe
_tspawnv _spawnv _spawnv _wspawnv
_tspawnve _spawnve _spawnve _wspawnve
_tspawnvp _spawnvp _spawnvp _wspawnvp
_tspawnvpe _spawnvpe _spawnvpe _wspawnvpe

Deve essere disponibile memoria sufficiente per il caricamento e l'esecuzione del nuovo processo.Enough memory must be available for loading and executing the new process. L'argomento mode determina l'azione eseguita dal processo chiamante prima e durante _spawn.The mode argument determines the action taken by the calling process before and during _spawn. I valori seguenti per mode sono definiti in Process.h:The following values for mode are defined in Process.h:

_P_OVERLAY
Sovrappone un processo chiamante con un nuovo processo, distruggendo il processo chiamante (lo stesso effetto delle chiamate _exec).Overlays a calling process with a new process, destroying the calling process (same effect as _exec calls).

_P_WAIT
Sospende un thread chiamante finché l'esecuzione del nuovo processo non è stata completata (_spawn sincrono).Suspends a calling thread until execution of the new process is complete (synchronous _spawn).

_P_NOWAIT o _P_NOWAITO_P_NOWAIT or _P_NOWAITO
Continua ad eseguire un processo chiamante contemporaneamente al nuovo processo (_spawn asincrono).Continues to execute a calling process concurrently with the new process (asynchronous _spawn).

_P_DETACH
Continua l'esecuzione del processo chiamante; il nuovo processo viene eseguito in background senza accesso alla console o alla tastiera.Continues to execute the calling process; the new process is run in the background with no access to the console or keyboard. Le chiamate a _cwait rispetto al nuovo processo non vengono eseguite (_spawn asincrono).Calls to _cwait against the new process fail (asynchronous _spawn).

L'argomento cmdname specifica il file che viene eseguito come nuovo processo e può specificare un percorso completo (dalla radice), un percorso parziale (dalla cartella di lavoro corrente) o, semplicemente, un nome file.The cmdname argument specifies the file that is executed as the new process and can specify a full path (from the root), a partial path (from the current working directory), or just a file name. Se cmdname non presenta un'estensione del nome file o non termina con un punto (.), la funzione _spawn tenta, innanzitutto, l'estensione del nome file .com, quindi l'estensione del nome file .exe, l'estensione del nome file .bat e, infine, l'estensione del nome file .cmd.If cmdname does not have a file name extension or does not end with a period (.), the _spawn function first tries the .com file name extension and then the .exe file name extension, the .bat file name extension, and finally the .cmd file name extension.

Se cmdname ha un'estensione del nome file, viene utilizzata solo tale estensione.If cmdname has a file name extension, only that extension is used. Se cmdname termina con un punto, la chiamata _spawn cerca cmdname senza estensioni del nome file.If cmdname ends with a period, the _spawn call searches for cmdname with no file name extension. Le funzioni _spawnlp, _spawnlpe, _spawnvp e _spawnvpe cercano cmdname (usando le stesse procedure) nella directory specificata dalla variabile di ambiente PATH.The _spawnlp, _spawnlpe, _spawnvp, and _spawnvpe functions search for cmdname (using the same procedures) in the directories specified by the PATH environment variable.

Se cmdname contiene un identificatore di unità o delle barre (ovvero se si tratta di un percorso relativo), la chiamata _spawn cerca soltanto il file specificato; il percorso non viene cercato.If cmdname contains a drive specifier or any slashes (that is, if it is a relative path), the _spawn call searches only for the specified file; no path searching is done.

In passato, alcune di queste funzioni impostavano errno su zero in caso di esito positivo; il comportamento corrente è di non modificare errno in caso di esito positivo, come specificato dallo standard C.In the past, some of these functions set errno to zero on success; the current behavior is to leave errno untouched on success, as specified by the C standard. Se è necessario emulare il comportamento precedente, impostare errno su zero prima di chiamare queste funzioni.If you need to emulate the old behavior, set errno to zero just before calling these functions.

Nota

Per garantire l'inizializzazione e terminazione sovrapposta appropriata, non utilizzare la funzione setjmp o longjmp per immettere o lasciare una routine sovrapposta.To ensure proper overlay initialization and termination, do not use the setjmp or longjmp function to enter or leave an overlay routine.

Argomenti per il processo generatoArguments for the Spawned Process

Per passare argomenti al nuovo processo, specificare uno o più puntatori alle stringhe di caratteri come argomenti nella chiamata _spawn.To pass arguments to the new process, give one or more pointers to character strings as arguments in the _spawn call. Queste stringhe di caratteri formano un elenco di argomenti per il processo generato.These character strings form the argument list for the spawned process. La lunghezza combinata delle stringhe che compongono l'elenco di argomenti per il nuovo processo non deve superare i 1024 byte.The combined length of the strings forming the argument list for the new process must not exceed 1024 bytes. Il carattere di terminazione null ('\0') per ogni stringa non è incluso nel conteggio, ma i caratteri di spazio (inseriti automaticamente per separare gli argomenti) sono inclusi.The terminating null character ('\0') for each string is not included in the count, but space characters (automatically inserted to separate arguments) are included.

Nota

La presenza di spazi incorporati nelle stringhe può causare comportamenti imprevisti; ad esempio, passare a _spawn la stringa "hi there" comporterà la presenza nel nuovo processo di due argomenti, "hi" e "there".Spaces embedded in strings may cause unexpected behavior; for example, passing _spawn the string "hi there" will result in the new process getting two arguments, "hi" and "there". Se lo scopo è quello di far aprire al nuovo processo un file denominato "hi there", il processo avrà esito negativo.If the intent was to have the new process open a file named "hi there", the process would fail. Per evitarlo, racchiudere la stringa tra virgolette doppie: "\"hi there\"".You can avoid this by quoting the string: "\"hi there\"".

Importante

Non passare input utente a _spawn senza verificarne esplicitamente il contenuto.Do not pass user input to _spawn without explicitly checking its content. _spawn determinerà una chiamata a CreateProcess, per cui è bene tenere presente che i nomi di percorsi non qualificati possono creare vulnerabilità a livello di sicurezza._spawn will result in a call to CreateProcess so keep in mind that unqualified path names could lead to potential security vulnerabilities.

È possibile passare i puntatori dell'argomento come argomenti separati (in _spawnl, _spawnle, _spawnlp e _spawnlpe) o come una matrice di puntatori (in _spawnv, _spawnve, _spawnvp e _spawnvpe).You can pass argument pointers as separate arguments (in _spawnl, _spawnle, _spawnlp, and _spawnlpe) or as an array of pointers (in _spawnv, _spawnve, _spawnvp, and _spawnvpe). È necessario passare almeno un argomento, arg0 o argv[0], al processo generato.You must pass at least one argument, arg0 or argv[0], to the spawned process. Per convenzione, questo argomento è il nome del programma che si digiterebbe sulla riga di comando.By convention, this argument is the name of the program as you would type it on the command line. Un valore diverso non produce un errore.A different value does not produce an error.

Le chiamate _spawnl, _spawnle, _spawnlp e _spawnlpe in genere vengono utilizzate nei casi in cui il numero di argomenti è noto in anticipo.The _spawnl, _spawnle, _spawnlp, and _spawnlpe calls are typically used in cases where the number of arguments is known in advance. L'argomento arg0 è solitamente un puntatore a cmdname.The arg0 argument is usually a pointer to cmdname. Gli argomenti da arg1 a argn sono puntatori alle stringhe di caratteri che costituiscono il nuovo elenco di argomenti.The arguments arg1 through argn are pointers to the character strings forming the new argument list. Dopo argn, ci deve essere un puntatore NULL per contrassegnare la fine dell'elenco di argomenti.Following argn, there must be a NULL pointer to mark the end of the argument list.

Le chiamate _spawnv, _spawnve, _spawnvp e _spawnvpe sono utili quando esiste un numero variabile di argomenti al nuovo processo.The _spawnv, _spawnve, _spawnvp, and _spawnvpe calls are useful when there is a variable number of arguments to the new process. I puntatori agli argomenti vengono passati come matrice, argv.Pointers to the arguments are passed as an array, argv. L'argomento argv[0] è in genere un puntatore a un percorso in modalità reale o al nome del programma in modalità protetta e argv[1] con argv[n] sono puntatori alle stringhe di caratteri che costituiscono il nuovo elenco di argomenti.The argument argv[0] is usually a pointer to a path in real mode or to the program name in protected mode, and argv[1] through argv[n] are pointers to the character strings forming the new argument list. L'argomento argv[n +1] deve essere un puntatore NULL per contrassegnare la fine dell'elenco di argomenti.The argument argv[n +1] must be a NULL pointer to mark the end of the argument list.

Ambiente del processo generatoEnvironment of the Spawned Process

I file che vengono aperti quando viene effettuata una chiamata _spawn rimangono aperti nel nuovo processo.Files that are open when a _spawn call is made remain open in the new process. Nelle chiamate _spawnl, _spawnlp, _spawnv e _spawnvp, il nuovo processo eredita l'ambiente del processo chiamante.In the _spawnl, _spawnlp, _spawnv, and _spawnvp calls, the new process inherits the environment of the calling process. È possibile utilizzare le chiamate _spawnle, _spawnlpe, _spawnve e _spawnvpe per modificare l'ambiente per il nuovo processo passando un elenco delle impostazioni di ambiente tramite l'argomento envp.You can use the _spawnle, _spawnlpe, _spawnve, and _spawnvpe calls to alter the environment for the new process by passing a list of environment settings through the envp argument. L'argomento 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.The argument envp is an array of character pointers, each element (except the final element) of which points to a null-terminated string defining an environment variable. 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.Such a string usually has the form NAME=value where NAME is the name of an environment variable and value is the string value to which that variable is set. (Notare che value non è racchiuso tra virgolette doppie.) L'elemento finale della matrice envp dovrebbe essere NULL.(Note that value is not enclosed in double quotation marks.) The final element of the envp array should be NULL. Quando la stessa envp è NULL, il processo generato eredita le impostazioni di ambiente del processo padre.When envp itself is NULL, the spawned process inherits the environment settings of the parent process.

Le funzioni _spawn possono passare tutte le informazioni sui file aperti, inclusa la modalità di traduzione, al nuovo processo.The _spawn functions can pass all information about open files, including the translation mode, to the new process. Queste informazioni vengono passate in modalità reale tramite la voce C_FILE_INFO nell'ambiente.This information is passed in real mode through the C_FILE_INFO entry in the environment. Il codice di avvio in genere elabora questa voce, quindi la elimina dall'ambiente.The startup code normally processes this entry and then deletes it from the environment. Tuttavia, se una funzione _spawn genera un processo non C, questa voce rimane nell'ambiente.However, if a _spawn function spawns a non-C process, this entry remains in the environment. La stampa dell'ambiente indica i caratteri grafici nella stringa di definizione per la voce poiché le informazioni sull'ambiente vengono passate in forma binaria in modalità reale.Printing the environment shows graphics characters in the definition string for this entry because the environment information is passed in binary form in real mode. Non dovrebbe avere altri effetti sulle operazioni normali.It should not have any other effect on normal operations. In modalità protetta, le informazioni sull'ambiente vengono passate in forma di testo e pertanto non contengono caratteri grafici.In protected mode, the environment information is passed in text form and therefore contains no graphics characters.

È necessario svuotare o chiudere in modo esplicito qualsiasi flusso (utilizzando fflush o _flushall) prima di chiamare una funzione _spawn.You must explicitly flush (using fflush or _flushall) or close any stream before calling a _spawn function.

I nuovi processi creati dalle chiamate alle routine _spawn non mantengono le impostazioni del segnale.New processes created by calls to _spawn routines do not preserve signal settings. Al contrario, il processo generato reimposta le impostazioni del segnale ai valori predefiniti.Instead, the spawned process resets signal settings to the default.

Reindirizzamento dell'outputRedirecting Output

Se si chiama _spawn da un'applicazione DLL o GUI e si desidera reindirizzare l'output a una pipe, sono disponibili due opzioni:If you are calling _spawn from a DLL or a GUI application and want to redirect the output to a pipe, you have two options:

  • Usare l'API Win32 per creare una pipe, quindi chiamare AllocConsole, impostare i valori di handle nella struttura di avvio e chiamare CreateProcess.Use the Win32 API to create a pipe, then call AllocConsole, set the handle values in the startup structure, and call CreateProcess.

  • Chiamare _popen, _wpopen che creerà una pipe e richiamerà l'app con cmd.exe /c (o command.exe /c).Call _popen, _wpopen which will create a pipe and invoke the app using cmd.exe /c (or command.exe /c).

EsempioExample

// crt_spawn.c  
// This program accepts a number in the range  
// 1-8 from the command line. Based on the number it receives,  
// it executes one of the eight different procedures that  
// spawn the process named child. For some of these procedures,  
// the CHILD.EXE file must be in the same directory; for  
// others, it only has to be in the same path.  
//  

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

char *my_env[] =  
{  
   "THIS=environment will be",  
   "PASSED=to child.exe by the",  
   "_SPAWNLE=and",  
   "_SPAWNLPE=and",  
   "_SPAWNVE=and",  
   "_SPAWNVPE=functions",  
   NULL  
};  

int main( int argc, char *argv[] )  
{  
   char *args[4];  

   // Set up parameters to be sent:   
   args[0] = "child";  
   args[1] = "spawn??";  
   args[2] = "two";  
   args[3] = NULL;  

   if (argc <= 2)  
   {  
      printf( "SYNTAX: SPAWN <1-8> <childprogram>\n" );  
      exit( 1 );  
   }  

   switch (argv[1][0])   // Based on first letter of argument   
   {  
   case '1':  
      _spawnl( _P_WAIT, argv[2], argv[2], "_spawnl", "two", NULL );  
      break;  
   case '2':  
      _spawnle( _P_WAIT, argv[2], argv[2], "_spawnle", "two",   
               NULL, my_env );  
      break;  
   case '3':  
      _spawnlp( _P_WAIT, argv[2], argv[2], "_spawnlp", "two", NULL );  
      break;  
   case '4':  
      _spawnlpe( _P_WAIT, argv[2], argv[2], "_spawnlpe", "two",   
                NULL, my_env );  
      break;  
   case '5':  
      _spawnv( _P_OVERLAY, argv[2], args );  
      break;  
   case '6':  
      _spawnve( _P_OVERLAY, argv[2], args, my_env );  
      break;  
   case '7':  
      _spawnvp( _P_OVERLAY, argv[2], args );  
      break;  
   case '8':  
      _spawnvpe( _P_OVERLAY, argv[2], args, my_env );  
      break;  
   default:  
      printf( "SYNTAX: SPAWN <1-8> <childprogram>\n" );  
      exit( 1 );  
   }  
   printf( "from SPAWN!\n" );  
}  
child process output  
from SPAWN!  

Vedere ancheSee Also

Controllo processo e ambiente Process and Environment Control
abort abort
atexit atexit
Funzioni _exec, _wexec _exec, _wexec Functions
exit, _Exit, _exit exit, _Exit, _exit
_flushall _flushall
_getmbcp _getmbcp
_onexit, _onexit_m _onexit, _onexit_m
_setmbcp _setmbcp
system, _wsystemsystem, _wsystem