_spawn, _wspawn funções

Artigo
08/25/2010

Cada o _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 participante 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
PATH variável de ambiente é usado para localizar o arquivo para executar.
v
argv, matriz de ponteiros para argumentos de linha de comando, é passado para _spawn função. Esse sufixo costuma ser usado quando um número de parâmetros para um novo processo é variável.

Comentários

The _spawn funções de cada criar e executar um novo processo. Automaticamente tratam argumentos de seqüência de caractere multibyte sistema autônomo apropriado, reconhecendo seqüências de caractere de multibyte de acordo com para a página de código multibyte atualmente em uso.The _wspawn funções são versões de caractere largo do _spawn funciona; eles não manipulam seqüências de caracteres de multibyte. Caso contrário, a _wspawn funções se comportam de forma idêntica para seus _spawn equivalentes.

Mapeamentos de rotina de texto genérica

Rotina tchar.h	_UNICODE e _MBCS não definido	_MBCS 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.The mode argumento determina a ação executada pelo processo de chamada antes e durante _spawn. Os seguintes valores para mode são definidas no processo.h:

_P_OVERLAY
Sobreposições de uma chamada de processo com um novo processo, destruir o processo de chamada (mesmo efeito sistema autônomo _exec chamadas).
_P_WAIT
Suspende um segmento de chamada até que a execução do novo processo é concluído (síncrono _spawn).
_P_NOWAIT ou _P_NOWAITO
Continua a executar um processo de chamada simultaneamente com o novo processo assíncrono (_spawn).
_P_DETACH
Continua a executar o processo de chamada; o novo processo é executado em segundo plano sem acesso ao console ou no teclado.Chamadas para _cwait com o novo processo falhe (assíncrono _spawn).

The cmdname argumento especifica o arquivo que é executado sistema autônomo o novo processo e pode especificar um caminho completo (de raiz), um caminho parcial (do diretório de trabalho corrente) ou um nome de arquivo. If cmdname não tem uma extensão de nome de arquivo ou não termina com um ponto (.), o _spawn função tenta primeiro a extensão de nome de arquivo .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.

If cmdname tem uma extensão de nome de arquivo, só que a extensão é usado. If cmdname termina com um período, o _spawn procura de telefonar cmdname sem extensão de nome de arquivo. The _spawnlp, _spawnlpe, _spawnvp, e _spawnvpe funções de Pesquisar cmdname (usando os mesmos procedimentos) nos diretórios especificados pela PATH variável de ambiente.

If cmdname contém um especificador de unidade ou quaisquer barras (ou seja, se ele é um caminho relativo), o _spawn telefonar procura apenas o arquivo especificado; nenhum caminho de pesquisa é feita.

Visual C++ 2005 apresenta uma alterar significativa na _spawn funções. Em psistema autônomot, algumas dessas funções definidas errno para zero no sucesso; o novo comportamento é deixar errno untouched sucesso, sistema autônomo especificado pelo padrão C. Se você precisar emular o comportamento antigo, defina errno como zero antes de chamar essas funções.

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

Argumentos para o processo gerado

Para passar argumentos para o novo processo, ponteiros um ou mais para seqüências de caractere sistema autônomo argumentos no _spawn Chame. Essas seqüências de caractere de formulário lista de argumento 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 exceder 1024 bytes.O caractere nulo de terminação ('\0') para cada seqüência de caracteres não está incluído na contagem, mas 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" fará com que o novo processo Obtendo dois argumentos: "hi" e "there". Se a intenção era para que o novo processo de em em aberto 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" fará com que o novo processo Obtendo dois argumentos: "hi" e "there". Se a intenção era para que o novo processo de em em aberto 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 se seu conteúdo. _spawn resultará em uma telefonar para CreateProcess assim, tenha em mente esse caminho não qualificado nomes podem levar a vulnerabilidades de segurança potenciais.

Você pode passar o argumento ponteiros sistema autônomo argumentos separados (em _spawnl, _spawnle, _spawnlp, e _spawnlpe) ou sistema autônomo uma matriz de ponteiros (pol _spawnv, _spawnve, _spawnvp, e _spawnvpe). Você deve passar pelo menos um argumento, arg0 ou argv[0], o processo gerado. Por convenção, este argumento é o nome do programa seria a digitada na linha de comando.Um valor diferente não produz um erro.

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

The _spawnv, _spawnve, _spawnvp, e _spawnvpe chamadas são úteis quando há um número variável de argumentos para o novo processo. Ponteiros para sistema autônomo argumentos são passados sistema autônomo uma matriz, argv*.* 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.The argument argv[n +1] must be a NULL pointer to mark the end of the argument list.

Ambiente do processo gerado

Arquivos que estão abertos quando um _spawn telefonar é feita a permanecer em aberto no novo processo. 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 de caracteres terminada com caractere nulo é definir 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 o qual essa variável está definida. (Observe que value não está entre aspas duplas.) O elemento final do envp a matriz deve ser NULL. Quando envp está NULL, o processo gerado herda as configurações de ambiente do processo pai.

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

Você deve liberar explicitamente (usando fflush ou _flushall) ou fechar qualquer fluxo antes de ligar 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 Win32 para criar um pipe e, em seguida, chamar AllocConsole, conjunto os valores de identificador na estrutura de inicialização e telefonar CreateProcess.
De telefonar_popen, _wpopen qual irá criar um pipe e chamar 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" );
}

child process output from SPAWN!