Funções _spawn, _wspawn

Artigo
06/09/2015

Cada uma das funções de _spawn 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 de função determinam a variável.

e
envp, matriz de ponteiros para as configurações de ambiente, é passado para o novo processo.
l
Os argumentos de linha de comando são passados individualmente à função de _spawn . Esse sufixo geralmente é usado quando um número de parâmetros para um novo processo são conhecidos com antecedência.
p
a variável de ambiente dePATH usado para localizar o arquivo para executar.
v
argv, matriz de ponteiros para os argumentos de linha de comando, é transmitido à função de _spawn . Esse sufixo geralmente é usado quando um número de parâmetros para um novo processo são variáveis.

Comentários

_spawn funções cada um cria e executa um novo processo. Controla automaticamente argumentos de cadeia de caracteres de multibyte- caracteres conforme apropriado, confirmando sequências de multibyte- caractere de acordo com a página de código de multibyte atualmente em uso. As funções de _wspawn são versões ampla de caracteres das funções de _spawn ; não tratam cadeias de caracteres de multibyte- caractere. Caso contrário, as funções de _wspawn se comportam idêntica à sua contraparte de _spawn .

Mapeamentos da rotina de texto genérico

Rotina Tchar.h	_UNICODE e _MBCS não definidos	_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. O argumento de mode determina a ação tomada pelo processo de chamada antes e durante _spawn. Os seguintes valores para mode são definidos em Process.h:

_P_OVERLAY
Cobre um processo de chamada com um novo processo, destruindo o processo de chamada (mesmo efeito que chamadas de _exec ).
_P_WAIT
Suspende um thread de chamada até que a execução do novo processo está completo _spawn(síncrono).
_P_NOWAIT ou _P_NOWAITO
Continuará a executar um processo de chamada simultaneamente com o novo processo _spawn(assíncrono).
_P_DETACH
Continua executando o processo de chamada; o novo processo é executado em segundo plano sem acesso ao console ou ao teclado. As chamadas a _cwait no novo processo falhar ( _spawnassíncrono).

O argumento de cmdname especifica o arquivo que será executada conforme o novo processo e pode especificar um caminho completo (raiz), parcial (um caminho do diretório de trabalho atual), ou apenas um nome de arquivo. Se cmdname não tiver uma extensão de nome de arquivo ou não a terminar com um ponto (.), a função de _spawn tenta primeiro a extensão de nome de arquivo .com e na 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 nome de arquivo, somente essa extensão será usada. Se cmdname terminar com um período, a chamada de _spawn pesquisa por cmdname sem a extensão de nome de arquivo. _spawnlp, _spawnlpe, _spawnvp, e as funções de _spawnvpe pesquisam por cmdname (usando os mesmos procedimentos) nos diretórios especificados pela variável de ambiente de PATH .

Se cmdname contém um especificador de unidade ou qualquer barras (isto é, se for um caminho relativo), as pesquisas de chamada de _spawn apenas para o arquivo especificado; nenhuma pesquisa de caminho é feita.

No passado, algumas dessas funções definem errno a zero ao obter êxito; o comportamento atual é deixar errno não tocará no êxito, como especificado pelo padrão C. Se você precisar emular o comportamento antigo, defina errno como zero imediatamente antes de chamar essas funções.

Dica

Para assegurar a inicialização e o término da sobreposição adequadas, não use a função de setjmp ou de longjmp para inserir ou deixar uma rotina de sobreposição.

Argumentos para o processo gerado

Para transmitir argumentos para o novo processo, dê um ou vários ponteiros em cadeias de caracteres como argumentos na chamada de _spawn . Essas cadeias de caracteres formam a lista de argumentos do processo gerado. O tamanho combinado das cadeias de caracteres que formam a lista de argumentos para o novo processo não deve exceder 1024 bytes. O caractere terminador nulo (\ “0 ") para cada cadeia de caracteres não estão incluídas na contagem, mas os caracteres de espaço (inseridos automaticamente para separar argumentos) são incluídos.

Dica

Espaços inseridos nas cadeias de caracteres podem provocar comportamento inesperado; por exemplo, passando _spawn a cadeia de caracteres "hi there" resultará no novo processo que obtém dois argumentos, "hi" e "there".Se a tentativa teve ter o novo processo para abrir um arquivo denominado “hello world " não”, o processo falhará.É possível impedir isso colocando aspas na cadeia de caracteres: "\"hi there\"".

Observação de segurança
Não transmitir a entrada do usuário a _spawn sem explicitamente verificar seu conteúdo._spawn resultará em uma chamada para CreateProcess assim que tenha em mente que os nomes de caminho não qualificados podem resultar em vulnerabilidades de segurança.

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

_spawnl, _spawnle, _spawnlp, e as chamadas de _spawnlpe são usados normalmente nos casos em que o número de argumentos é conhecida antecipadamente. O argumento arg0 é geralmente um ponteiro para cmdname. Os argumentos arg1 a argn são ponteiros para as cadeias de caracteres que formam a nova lista de argumentos. Depois de argn, deve haver um ponteiro de NULL para marcar o fim da lista de argumentos.

_spawnv, _spawnve, _spawnvp, e as chamadas de _spawnvpe são úteis quando há um número variável de argumentos para o novo processo. Os ponteiros para os argumentos são passados como uma matriz, argv*.* O argumento argv[0] é geralmente um ponteiro para um caminho no modo real ou para o nome do programa no modo protegido, e argv[1] em argv[n] são ponteiros para as cadeias de caracteres que formam a nova lista de argumentos. O argumento argv[n +1] deve ser um ponteiro NULL para marcar o fim da lista de argumentos.

Ambiente do processo gerado

Os arquivos que estão abertos quando uma chamada de _spawn é feito permanecem abertos no novo processo. Em _spawnl, em _spawnlp, em _spawnv, e em chamadas de _spawnvp , o novo processo herda o ambiente do processo de chamada. Você pode usar _spawnle, _spawnlpe, _spawnve, e chamadas de _spawnvpe para alterar o ambiente do para o novo processo passando uma lista de configurações do ambiente pelo argumento de envp . O argumento envp é uma matriz de ponteiros de caractere, cada elemento (exceto o elemento final) que aponta para uma cadeia de caracteres com terminação nula definindo uma variável de ambiente. Uma cadeia de caracteres normalmente tem a forma NAME=valueNAME onde é o nome de uma variável de ambiente e value é o valor da cadeia de caracteres ao qual a variável está definido. (Observe que value não está incluído entre aspas duplas.) O elemento final da matriz de envp deve ser NULL. Quando envp próprio é NULL, o processo gerado herda as configurações do ambiente do processo pai.

As funções de _spawn podem passar todas as informações sobre os arquivos abertos, inclusive o modo de conversão, para o novo processo. Essas informações são passadas no modo real na entrada de C_FILE_INFO no ambiente. O código de inicialização normalmente processa esta entrada e excluí-lo do ambiente. No entanto, se uma função de _spawn gerencie um processo de non-C, essa entrada permanece no ambiente. Imprimindo o ambiente mostra caracteres de gráficos na cadeia de caracteres de definição para esta entrada como as informações de ambiente é transmitido no formato binário no modo real. Não devem ter nenhum outro efeito em operações normais. No modo protegido, as informações sobre o ambiente é transmitido no formulário de texto e não contém nenhum caractere como consequência de gráficos.

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

Novos processos criados por chamadas às rotinas de _spawn não preserva as configurações de sinal. Em vez disso, as configurações geradas de sinal redefinições do processo da opção.

Redirecionando a saída

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

Use a API do Win32 para criar um pipe em seguida, chame AllocConsole, define os valores de identificador na estrutura de inicialização, e na chamada CreateProcess.
Chame _popen, _wpopen que criarão 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" );
}