_spawn, fonctions de _wspawn

Article
03/26/2013

chacune des fonctions d' _spawn crée et exécute un nouveau processus :

_spawnl, _wspawnl	_spawnv, _wspawnv
_spawnle, _wspawnle	_spawnve, _wspawnve
_spawnlp, _wspawnlp	_spawnvp, _wspawnvp
_spawnlpe, _wspawnlpe	_spawnvpe, _wspawnvpe

Les lettres à la fin de le nom de la fonction déterminent la variance.

e
envp, un tableau de pointeurs vers des paramètres d'environnement, est passé au nouveau processus.
l
Les arguments de ligne de commande sont passés individuellement à la fonction d' _spawn .Ce suffixe est généralement utilisé lorsque plusieurs paramètres à un nouveau processus est connus à l'avance.
p
la variable d'environnementPATH est utilisée pour rechercher le fichier pour exécuter.
v
argv, un tableau de pointeurs vers des arguments de ligne de commande, est passé à la fonction d' _spawn .Ce suffixe est généralement utilisé lorsque plusieurs paramètres à un nouveau processus est variable.

Notes

_spawn fonctions et créent et exécutent un nouveau processus.Ils gèrent automatiquement les arguments de chaîne de caractères multioctets comme approprié, l'identification des séquences de caractères multioctets d'après la page de codes multioctets en cours de utilisation.les fonctions d' _wspawn sont des versions à caractères larges des fonctions d' _spawn ; ils ne gèrent pas des chaînes à caractères multioctets.Sinon, les fonctions d' _wspawn se comportent de manière identique à leurs équivalents d' _spawn .

mappages de routines de texte générique

routine de Tchar.h	_UNICODE et _MBCS non définis	_MBCS défini	_UNICODE défini
_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

Suffisamment de mémoire doit être disponible pour charger et exécuter le nouveau processus.l'argument d' mode détermine l'action effectuée par le processus appelant avant et pendant _spawn.les valeurs suivantes pour mode sont définies dans Process.h :

_P_OVERLAY
Chevauche un processus appelant avec un nouveau processus, détruisant le processus d'appel (le même effet que les appels d' _exec ).
_P_WAIT
Suspend un thread appelant jusqu'à ce que l'exécution du nouveau processus terminée ( _spawnsynchrone).
_P_NOWAIT ou _P_NOWAITO
Continue à exécuter un processus appelant simultanément au nouveau processus ( _spawnasynchrone).
_P_DETACH
continue à exécuter le processus appelant ; le nouveau processus est exécuté en arrière-plan sans l'accès à la console ou au clavier.Les appels à _cwait concernant le nouveau processus échouent ( _spawnasynchrone).

L'argument d' cmdname spécifie le fichier qui est exécuté lorsque le nouveau processus et peut spécifier un chemin d'accès complet (racine), un chemin d'accès partiel (à partir de le répertoire de travail actuel), ou simplement un nom de fichier.Si cmdname n'a pas d'extension de nom de fichier ou ne se termine pas par un point (.), la fonction d' _spawn essaie d'abord l'extension de nom de fichier .com puis l'extension de nom de fichier .exe, l'extension de nom de fichier .bat, et enfin l'extension de nom de fichier .cmd.

Si cmdname a une extension de nom de fichier, seule cette extension est utilisée.Si cmdname se termine par un point, les recherches d'appel d' _spawn pour cmdname sans l'extension de nom de fichier._spawnlp, _spawnlpe, _spawnvp, et recherche de fonctions d'_spawnvpe pour cmdname (à l'aide de les mêmes procédures) dans les répertoires spécifiés par la variable d'environnement PATH .

Si cmdname contient un spécificateur de lecteur ou des barres obliques (autrement dit, s'il s'agit d'un chemin d'accès relatif), l'appel d' _spawn recherche uniquement le fichier spécifié ; aucun rechercher de chemin d'accès n'est effectué.

Dans le passé, certaines de ces derniers s'exécutent errno la valeur zéro en cas de réussite ; le comportement actuel est de laisser errno intact en cas de réussite, comme spécifié par la norme C.Si vous devez émuler l'ancien comportement, définissez errno à zéro juste avant l'appel de ces fonctions.

[!REMARQUE]

Pour garantir l'initialisation appropriée et de superposition, n'utilisez pas la fonction d' setjmp ou d' longjmp pour écrire ou conserver une routine de superposition.

arguments pour le processus engendré

Pour passer des arguments au nouveau processus, donnez un ou plusieurs pointeurs vers des chaînes de caractères comme des arguments dans l'appel d' _spawn .Ces chaînes de caractères qui forment la liste d'arguments pour le processus lancé.La longueur combinée des chaînes qui forment la liste d'arguments pour le nouveau processus ne doit pas dépasser 1024 octets.Le caractère NULL de fin (" \ 0 ") pour chaque chaîne n'est pas inclus dans le nombre, mais les espaces (insérés automatiquement pour séparer les arguments) sont inclus.

[!REMARQUE]

Les espaces incorporés dans les chaînes peuvent provoquer un comportement inattendu ; par exemple, en passant _spawn la chaîne "hi there" entraîne le nouveau processus obtenant deux arguments, "hi" et "there".Si l'objectif était d'exécuter le nouveau processus ouvrez un fichier nommé « salut there », le processus échoue.Vous pouvez éviter ceci en instanciation la chaîne : "\"hi there\"".

Note de sécurité
ne passez pas l'entrée d'utilisateur à _spawn sans activer explicitement son contenu._spawn entraîne un appel à CreateProcess donc n'oubliez pas que les noms de chemin d'accès non qualifiés peuvent provoquer des failles de sécurité.

Vous pouvez passer des pointeurs d'argument en tant qu'arguments séparés (dans _spawnl, _spawnle, _spawnlp, et _spawnlpe) ou comme tableau de pointeurs (dans _spawnv, _spawnve, _spawnvp, et _spawnvpe).Vous devez passer au moins un argument, arg0 ou argv[0], au processus lancé.Par convention, cet argument est le nom du programme comme vous le tapez sur la ligne de commande.Une valeur différente ne produit pas d'erreur.

_spawnl, _spawnle, _spawnlp, et les appels d' _spawnlpe sont généralement utilisés dans les cas où le nombre d'arguments est connu à l'avance.L'argument d' arg0 est généralement un pointeur vers cmdname.Les arguments arg1 via argn sont des pointeurs vers les chaînes de caractères qui forment la nouvelle liste d'arguments.Après argn, il doit exister un pointeur d' NULL pour marquer la fin de la liste d'arguments.

_spawnv, _spawnve, _spawnvp, et les appels d' _spawnvpe sont utiles lorsqu'il existe un nombre variable d'arguments au nouveau processus.Les pointeurs vers des arguments passés en tant que tableau, argv*.* L'argument argv[0] est généralement un pointeur vers un chemin d'accès en mode réel ou le nom du programme en mode protégé, et argv[1] via argv[]nsont des pointeurs vers les chaînes de caractères qui forment la nouvelle liste d'arguments.l'argument argv[n +1] doit être un pointeur d' NULL pour marquer la fin de la liste d'arguments.

environnement du processus engendré

Les fichiers qui sont ouverts lorsque l'appel d' _spawn est effectué restent ouverts dans le nouveau processus.Dans _spawnl, _spawnlp, _spawnv, et les appels d' _spawnvp , le nouveau processus hérite de l'environnement du processus appelant.Vous pouvez utiliser _spawnle, _spawnlpe, _spawnve, et les appels d' _spawnvpe pour modifier l'environnement pour le nouveau processus en passant une liste de paramètres d'environnement via l'argument d' envp .L'argument envp est un tableau de pointeurs de caractère, chaque élément (sauf le dernier élément) qui pointe vers une chaîne terminée par le caractère NULL définissant une variable d'environnement.Une telle chaîne a généralement le formulaire NAME=value où NAME est le nom d'une variable d'environnement et value est la valeur de chaîne à laquelle cette variable est définie.(Notez qu' value n'est pas placé entre guillemets doubles.) Le dernier élément du tableau d' envp doit être NULL.Lorsque envp lui-même est NULL, le processus engendré hérite des paramètres d'environnement du processus parent.

Les fonctions d' _spawn peuvent passer toutes les informations sur les fichiers ouverts, y compris l'à mode de traduction, au nouveau processus.Ces informations sont passées en mode réel via l'entrée d' C_FILE_INFO dans l'environnement.Le code de démarrage gère normalement cette entrée et la supprime ensuite de l'environnement.Toutefois, si une fonction d' _spawn engendre un processus de non-C, cette entrée reste de l'environnement.L'impression l'environnement montre des caractères graphiques dans la chaîne de définition pour cette entrée parce que les informations d'environnement sont passées sous forme binaire en mode réel.Il ne doit effectuer aucun effet sur les opérations normales.En mode protégé, les informations d'environnement sont passées sous forme de texte et ne contiennent aucun caractère graphique.

Vous devez explicitement vide (à l'aide de fflush ou _flushall) ou fermer tout flux de données avant d'appeler une fonction d' _spawn .

Les nouveaux processus créés par des appels aux routines d' _spawn ne conservent pas les paramètres du signal.À la place, les paramètres de processus engendrés de signal " Reset " à la valeur par défaut.

rediriger la sortie

Si vous appelez _spawn d'une DLL ou d'une application GUI et souhaitez rediriger la sortie dans un canal, vous disposez de deux options :

Utilisez l'API Win32 pour créer un canal, l'appel AllocConsole, définit les valeurs de gestion dans la structure de démarrage, et l'appel CreateProcess.
Appelez _popen, _wpopen qui crée un canal et appelez l'application à l'aide de cmd.exe /c (ou command.exe /c).

Exemple

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