_exec, fonctions de _wexec

Article
03/26/2013

chaque fonction dans cette famille charge et exécute un nouveau processus :

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

La lettre à la fin de le nom de la fonction détermine la variance.

suffixe de fonction de _exec	Description
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' _exec .Généralement utilisé lorsque le nombre de paramètres pour le nouveau processus est connu à 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é à _exec.Généralement utilisé lorsque le nombre de paramètres pour le nouveau processus est variable.

Notes

chaque fonction d' _exec charge et exécute un nouveau processus.toutes les fonctions d' _exec utilisent la même fonction du système d'exploitation (CreateProcess).Les fonctions d' _exec 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' _wexec sont des versions à caractères larges des fonctions d' _exec .Les fonctions d' _wexec se comportent de manière identique à leurs équivalents de la famille d' _exec mais elles ne gèrent pas des chaînes à caractères multioctets.

mappages de routines de texte générique

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

Le paramètre d' cmdname spécifie le fichier à exécuter en tant que nouveau processus.Il 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 un nom de fichier.Si cmdname n'a pas d'extension de nom de fichier ou ne se termine pas par un point (.), les recherches de fonction d' _exec pour le fichier nommé.Si la recherche est infructueuse, elle tente le même nom de base avec l'extension de nom de fichier .com puis avec les extensions de nom de fichier .exe, .bat, et .cmd.Si cmdname a une extension de nom de fichier, seule cette extension est employée dans la recherche.Si cmdname se termine par un point, les recherches de fonction d' _exec pour cmdname sans l'extension de nom de fichier._execlp, _execlpe, _execvp, et recherche d' _execvpe 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' _exec recherche uniquement le fichier spécifié ; le chemin d'accès n'est pas trouvée.

Les paramètres sont passés au nouveau processus en affectant un ou plusieurs pointeurs vers des chaînes de caractères comme paramètres dans l'appel d' _exec .Ces chaînes de caractères qui forment la liste de paramètres du nouveau processus.La longueur combinée des paramètres d'environnement hérités et les chaînes qui forment la liste des paramètres pour le nouveau processus ne doit pas dépasser 32 kilo-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 paramètres) sont comptés.

[!REMARQUE]

Les espaces incorporés dans les chaînes peuvent provoquer un comportement inattendu ; par exemple, en passant _exec 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 à _exec sans activer explicitement son contenu._exec 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é.

les fonctions d' _exec valident leurs paramètres.Si les paramètres attendus sont des pointeurs null, chaînes vides, ou omis, les fonctions d' _exec appellent le gestionnaire de paramètre non valide comme décrit dans Validation des paramètres.Si est autorisé à l'exécution de se poursuivre, ces errno défini par fonctions à EINVAL et à retourner -1.aucun nouveau processus n'est exécuté.

Les pointeurs d'argument peuvent être passés en tant que paramètres distincts (dans _execl, _execle, _execlp, et _execlpe) ou comme tableau de pointeurs (dans _execv, _execve, _execvp, et _execvpe).au moins un paramètre, arg0, doit être passé au nouveau processus ; ce paramètre est argv[0] du nouveau processus.Généralement, ce paramètre est une copie d' cmdname.(La valeur différente d'Une ne produit pas d'erreur.)

_execl, _execle, _execlp, et les appels d' _execlpe sont généralement utilisés lorsque le nombre de paramètres est connu à l'avance.Le paramètre arg0 est généralement un pointeur vers cmdname.Les paramètres arg1 via le point d' argn aux chaînes de caractères qui forment la nouvelle liste de paramètres.un pointeur null doit suivre argn pour marquer la fin de la liste de paramètres.

_execv, _execve, _execvp, et les appels d' _execvpe sont utiles lorsque le nombre de paramètres pour le nouveau processus est variable.Les pointeurs vers des paramètres sont passés en tant que tableau, argv.Le paramètre argv[0] est généralement un pointeur vers cmdname.Les paramètres argv[1] via le point d' argv[]naux chaînes de caractères qui forment la nouvelle liste de paramètres.le paramètre argv[n+1] doit être un pointeur d' NULL pour marquer la fin de la liste de paramètres.

Les fichiers qui sont ouverts lorsque l'appel d' _exec est effectué restent ouverts dans le nouveau processus.Dans _execl, _execlp, _execv, et les appels d' _execvp , le nouveau processus hérite de l'environnement du processus appelant._execle, _execlpe, _execve, et les appels d' _execvpe modifient l'environnement pour le nouveau processus en passant une liste de paramètres d'environnement via le paramètre d' envp .envp est un tableau de pointeurs de caractère, chaque élément dont (à l'exception de le dernier élément) 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 nouveau processus hérite des paramètres d'environnement du processus appelant.

Un programme exécuté avec une des fonctions d' _exec est toujours chargé en mémoire que si le champ d'allocation maximale dans l'en-tête du fichier .exe du programme ont été définis à la valeur par défaut de 0xFFFFH.

les appels d' _exec ne conservent pas les modes de traduction de fichiers ouverts.Si le nouveau processus doit utiliser des fichiers hérités du processus appelant, utilisez la routine de _setmode pour définir un en mode de traduction de ces fichiers en mode souhaité.Vous devez explicitement vide (à l'aide de fflush ou _flushall) ou fermer tout flux de données avant l'appel de fonction d' _exec .Les paramètres de signal ne sont pas conservés dans les nouveaux processus qui sont créés par des appels aux routines d' _exec .les paramètres de signal sont réinitialisés à la valeur par défaut dans le nouveau processus.

Exemple

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

Exécutez le programme suivant à exécuter 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 );
}