_exec, _wexec funções

Cada função nesta família carrega e executa um novo processo:

A letra no final do nome da função determina a variação.

Comentários

Cada _exec função carrega e executa um novo processo.Todos os _exec funções usam a mesma função de sistema operacional (CreateProcess).O _exec funções tratar automaticamente os argumentos de seqüência de caracteres multibyte conforme apropriado, reconhecendo as seqüências de caracteres multibyte de acordo com para a página de código multibyte atualmente em uso.O _wexec funções são versões de caracteres largos da _exec funções.O _wexec funções se comportam de forma idêntica para seus _exec contrapartes da família, exceto que eles não manipulam seqüências de caracteres de multibyte.

Mapeamentos de rotina de texto genérico

O cmdname parâmetro especifica o arquivo a ser executado como o novo processo.Ele pode especificar um caminho completo (da raiz), um caminho parcial (a partir do diretório de trabalho atual) ou um nome de arquivo.Se cmdname não tem uma extensão de nome de arquivo ou não termina com um ponto (.), o _exec funciona procura o arquivo nomeado.Se a pesquisa for bem-sucedido, ele tenta o mesmo nome de base com a extensão de nome de arquivo de .com e, em seguida, com extensões de nome de arquivo. cmd,. bat e. exe.Se cmdname tem uma extensão de nome de arquivo, somente essa extensão é usado na pesquisa.Se cmdname termina com um período, o _exec a função de pesquisa para cmdname sem extensão de nome de arquivo._execlp, _execlpe, _execvp, e _execvpe procurar cmdname (usando os mesmos procedimentos) nos diretórios especificados pelo PATH variável de ambiente.Se cmdname contém um especificador de unidade ou quaisquer barras (ou seja, se ele é um caminho relativo), o _exec chamar pesquisa apenas o arquivo especificado. o caminho não será pesquisado.

Parâmetros são passados para o novo processo, oferecendo um ou mais ponteiros para seqüências de caracteres como parâmetros na _exec de chamada.Essas cadeias de caracteres formam a lista de parâmetros para o novo processo.O tamanho combinado das configurações do ambiente herdado e as seqüências de caracteres que formam a lista de parâmetros para o novo processo não deve exceder 32 kilobytes.O caractere nulo de terminação ('\0') para cada seqüência de caracteres não está incluído na contagem, mas os caracteres de espaço (inseridos automaticamente para separar os parâmetros) são contados.

Observação
Espaços incorporados em seqüências de caracteres podem causar um comportamento inesperado; Por exemplo, passando _exec a seqüência de caracteres "hi there" resultará em um novo processo Obtendo dois argumentos, "hi" e "there".Se a intenção era ter o novo processo de abrir um arquivo chamado "Olá lá", o processo falhará.Você pode evitar isso citando a seqüência de caracteres: "\"hi there\"".

Observação de segurança
Não passe a entrada do usuário para _exec sem verificar explicitamente o seu conteúdo._execresultará em uma chamada para CreateProcess assim, tenha em mente esse caminho não qualificado nomes poderiam levar a vulnerabilidades de segurança potenciais.

O _exec funções validar seus parâmetros.Se esperava parâmetros são ponteiros nulos, vazia de seqüências de caracteres ou omitido, o _exec funções chamar o manipulador de parâmetro inválido, conforme descrito em Validação de parâmetro.Se a execução terá permissão para continuar, essas funções definir errno para EINVAL e retornar -1.Nenhum novo processo é executado.

Os ponteiros de argumento podem ser passados como parâmetros separados (em _execl, _execle, _execlp, e _execlpe) ou como uma matriz de ponteiros (em _execv, _execve, _execvp, e _execvpe).Pelo menos um parâmetro, arg0, deve ser passado para o novo processo; Este parâmetro é argv[0] do novo processo.Normalmente, este parâmetro é uma cópia do cmdname.(Um valor diferente não produz um erro.)

O _execl, _execle, _execlp, e _execlpe chamadas normalmente são usadas quando o número de parâmetros é conhecido antecipadamente.O parâmetro arg0 geralmente é um ponteiro para cmdname.Os parâmetros arg1 por meio de argn aponte para seqüências de caracteres, formando a nova lista de parâmetro.Um ponteiro nulo deve seguir argn para marcar o final da lista de parâmetros.

O _execv, _execve, _execvp, e _execvpe chamadas são úteis quando o número de parâmetros para o novo processo é variável.Ponteiros para os parâmetros são passados como uma matriz, argv.O parâmetro argv[0] normalmente é um ponteiro para cmdname.Os parâmetros argv[1] por meio de argvn aponte para seqüências de caracteres, formando a nova lista de parâmetro.O parâmetro argvn+ 1] deve ser um NULL o ponteiro para marcar o final da lista de parâmetros.

Arquivos que são abertas quando uma _exec chamada é feita a permanecer aberto no processo de novo.Na _execl, _execlp, _execv, e _execvp chamadas, o novo processo herda o ambiente do processo de chamada._execle, _execlpe, _execve, e _execvpe chamadas de alteram o ambiente para o novo processo, passando uma lista das configurações de ambiente por meio do envp parâmetro.envpuma matriz de ponteiros de caractere, cada elemento do qual (exceto para o elemento final) aponta para uma seqüência terminada por caractere nulo é a definição de uma variável de ambiente.Uma seqüência de caracteres geralmente tem a forma NAME=value onde NAME é o nome de uma variável de ambiente e value é o valor de seqüência de caracteres para os quais essa variável é definida.(Observe que value não está entre aspas duplas.) O elemento final da envp matriz deve ser NULL.Quando envp está NULL, o novo processo herda as configurações de ambiente do processo de chamada.

Um programa executado com um do _exec funções é sempre carregado na memória, como se o campo máximo de alocação no cabeçalho de arquivo. exe do programa foram definido para o valor padrão de 0xFFFFH.

O _exec chamadas não preservam os modos de conversão de arquivos abertos.Se o novo processo deve usar arquivos herdados do processo de chamada, use o _setmode rotina para definir o modo de conversão desses arquivos para o modo desejado.Você deve liberar explicitamente (usando fflush ou _flushall) ou qualquer fluxo antes de fechar o _exec chamada de função.Configurações de sinal não são preservadas em novos processos criados por chamadas para _exec rotinas.As configurações de sinal são redefinidas para o padrão no novo processo.

Exemplo

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

Execute o programa a seguir para executar o 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 do NET Framework

• Classe System::Diagnostics::Process

• Classe System::Diagnostics::ProcessStartInfo

Cabeçalho: process.h

Consulte também

Referência

Processo e controle do ambiente

anulação

atexit

sair, _exit

_onexit, _onexit_m

_spawn, _wspawn funções

sistema, _wsystem