_spawn, _wspawn funções

Artigo
02/25/2013

Cada um a _spawn funções cria e executa um novo processo:

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

As letras no final do nome da função determinam a variação.

e
envp, matriz de ponteiros para as configurações de ambiente, é passado para o novo processo.
l
Argumentos de linha de comando são passados individualmente para _spawn função.Esse sufixo é normalmente usado quando um número de parâmetros para um novo processo é conhecido antecipadamente.
p
PATHvariável de ambiente é usado para localizar o arquivo para executar.
v
argv, matriz de ponteiros para os argumentos de linha de comando, é passado para _spawn função.Esse sufixo é normalmente usado quando um número de parâmetros para um novo processo é variável.

Comentários

O _spawn funções de cada um e executar um novo processo.Elas manipulam 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 _wspawn funções são versões de caracteres largos da _spawn funciona; eles não manipulam seqüências de caracteres de multibyte.Caso contrário, o _wspawn funções se comportam de forma idêntica para seus _spawn contrapartes.

Mapeamentos de rotina de texto genérico

Rotina de TCHAR.h	_ Unicode e _ MBCS do arquivo não definido	_ MBCS do arquivo definido	_ Unicode definido
_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

Memória suficiente deve estar disponível para carregar e executar o novo processo.O mode argumento determina a ação realizada pelo processo de chamada antes e durante a _spawn.Os seguintes valores para mode são definidos no Process.h:

_P_OVERLAY
Sobreposições de uma chamada de processo com um novo processo, destruir o processo de chamada (mesmo efeito como _exec chamadas).
_P_WAIT
Suspende o thread de chamada até que a execução do novo processo seja concluída (síncrona _spawn).
_P_NOWAITou _P_NOWAITO
Continua a executar um processo simultaneamente com o novo processo de chamada (assíncrona _spawn).
_P_DETACH
Continua a executar o processo de chamada; o novo processo é executado em segundo plano sem acesso ao console ou teclado.Chamadas para _cwait contra o novo processo falhar (assíncrona _spawn).

O cmdname argumento especifica o arquivo que é executado como o novo processo e 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 _spawn função primeiro tenta a extensão de nome de arquivo de .com e, em seguida, a extensão de nome de arquivo. exe, a extensão de nome de arquivo. bat e finalmente a extensão de nome de arquivo. cmd.

Se cmdname tem uma extensão de arquivo, só que a extensão é usado.Se cmdname termina com um período, o _spawn chamar procura por cmdname sem extensão de nome de arquivo.O _spawnlp, _spawnlpe, _spawnvp, e _spawnvpe funções 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 _spawn chamar pesquisa apenas o arquivo especificado. Nenhum caminho de pesquisa é feita.

No passado, algumas dessas funções conjunto errno como zero em caso de sucesso; o comportamento atual é deixar errno untouched em caso de sucesso, conforme especificado pelo padrão C.Se você precisar emular o comportamento antigo, defina errno em zero antes de chamar estas funções.

Observação
Para garantir a inicialização adequada de sobreposição e rescisão, não use o setjmp ou longjmp a função para entrar ou sair de uma rotina de sobreposição.

Argumentos para o processo gerado

Para passar argumentos para o novo processo, dar um ou mais ponteiros para seqüências de caracteres como argumentos na _spawn de chamada.Essas cadeias de caracteres formam a lista de argumentos para o processo gerado.O comprimento combinado das seqüências de caracteres que formam a lista de argumentos para o novo processo não deve ultrapassar 1024 bytes.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 (automaticamente inseridos para separar os argumentos) são incluídos.

Observação
Espaços incorporados em seqüências de caracteres podem causar um comportamento inesperado; Por exemplo, passando _spawn 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\"".

Espaços incorporados em seqüências de caracteres podem causar um comportamento inesperado; Por exemplo, passando _spawn 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 _spawn sem verificar explicitamente o seu conteúdo._spawnresultará em uma chamada para CreateProcess assim, tenha em mente esse caminho não qualificado nomes poderiam levar a vulnerabilidades de segurança potenciais.

Você pode passar ponteiros de argumento, separe os argumentos (em _spawnl, _spawnle, _spawnlp, e _spawnlpe) ou como uma matriz de ponteiros (em _spawnv, _spawnve, _spawnvp, e _spawnvpe).Você deve passar pelo menos um argumento, arg0 ou argv[0], para o processo gerado.Por convenção, este argumento é o nome do programa, como você digitaria na linha de comando.Um valor diferente não produz um erro.

O _spawnl, _spawnle, _spawnlp, e _spawnlpe chamadas são usadas normalmente em casos onde o número de argumentos é conhecido antecipadamente.O arg0 argumento é geralmente um ponteiro para cmdname.Os argumentos arg1 por meio de argn são ponteiros para seqüências de caracteres, formando a nova lista de argumentos.A seguir argn, deve haver uma NULL o ponteiro para marcar o final da lista de argumentos.

O _spawnv, _spawnve, _spawnvp, e _spawnvpe chamadas são úteis quando há um número variável de argumentos para o novo processo.Ponteiros para os argumentos são passados como uma matriz, argv*.* O argumento argv[0] é geralmente um ponteiro para um caminho em modo real ou o nome do programa em modo protegido, e argv[1] por meio de argvn são ponteiros para seqüências de caracteres, formando a nova lista de argumentos.O argumento argvn + 1] deve ser um NULL o ponteiro para marcar o final da lista de argumentos.

Ambiente do processo gerado

Arquivos que são abertas quando uma _spawn chamada é feita a permanecer aberto no processo de novo.No _spawnl, _spawnlp, _spawnv, e _spawnvp chamadas, o novo processo herda o ambiente do processo de chamada.Você pode usar o _spawnle, _spawnlpe, _spawnve, e _spawnvpe chamadas para alterar o ambiente para o novo processo, passando uma lista das configurações de ambiente por meio do envp argumento.O argumento envp é uma matriz de ponteiros de caractere, cada elemento (exceto o elemento final) que aponta para uma seqüência terminada por caractere nulo, definindo 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 processo gerado herda as configurações de ambiente do processo pai.

O _spawn funções podem passar todas as informações sobre os arquivos abertos, incluindo o modo de tradução para o novo processo.Essas informações são passadas em modo real por meio do C_FILE_INFO a entrada no ambiente.O código de inicialização normalmente processa essa entrada e depois a exclui do ambiente.No entanto, se um _spawn função gera um processo de não-C, essa entrada permanecerá no ambiente.O ambiente de impressão mostra os caracteres gráficos na seqüência de definição para esta entrada porque as informações de ambiente são passadas na forma binária em modo real.Ele não deve ter qualquer outro efeito as operações normais.No modo protegido, as informações de ambiente são transmitidas na forma de texto em, portanto, não contém nenhum caractere de elementos gráficos.

Você deve liberar explicitamente (usando fflush ou _flushall) ou fechar qualquer fluxo antes de chamar um _spawn função.

Novos processos criados por chamadas para _spawn rotinas não preservam as configurações de sinal.Em vez disso, o processo gerado redefine as configurações de sinal para o padrão.

Redirecionando a saída

Se você estiver chamando _spawn de uma DLL ou um aplicativo GUI e deseja redirecionar a saída para um pipe, você tem duas opções:

Usar a API do Win32 para criar um pipe, em seguida, chame AllocConsole, defina os valores de identificador na estrutura de inicialização e chamada CreateProcess.
Chame _popen, _wpopen que criará um pipe e invocar o aplicativo usando cmd.exe /c (ou command.exe /c).

Exemplo

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