_spawn, _wspawn Funktionen

Jede der _spawn-Funktionen erstellt einen neuen Prozess und führt ihn aus:

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

Die Buchstaben am Ende des Funktionsnamens bestimmen die Variante.

Brief	Variant
e	envp: Array von Zeigern zu Umgebungseinstellungen, wird an den neuen Prozess übergeben.
l	Befehlszeilenargumente werden einzeln an die _spawn-Funktion übergeben. Dieses Suffix wird in der Regel verwendet, wenn einige Parameter für einen neuen Prozess im Voraus bekannt sind.
p	Die PATH-Umgebungsvariable wird verwendet, um die auszuführende Datei zu suchen.
v	argv: Array von Zeigern zu Befehlszeilenargumenten, wird an die _spawn-Funktion übergeben. Dieses Suffix wird in der Regel verwendet, wenn mehrere Parameter für einen neuen Prozess variabel sind.

Hinweise

Die _spawn-Funktionen erstellen und führen einen neuen Prozess aus. Sie behandeln Multibyte-Zeichenfolgenargumente automatisch richtig. Die Erkennung von Multibyte-Zeichenfolgen erfolgt auf der Grundlage der aktuell verwendeten Multibyte-Codeseite. Die _wspawn Funktionen sind breitformatige Versionen der _spawn Funktionen; sie behandeln keine Multibyte-Zeichenzeichenfolgen. Andernfalls verhalten sich die _wspawn-Funktionen genauso wie ihre _spawn-Gegenstücke.

Mapping generischer Textroutinen

Tchar.h-Routine	_UNICODE und _MBCS nicht definiert	_MBCS definiert	_UNICODE definiert
_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

Zum Laden und Ausführen des neuen Prozesses muss ausreichend Speicher vorhanden sein. Das mode-Argument bestimmt, welche Aktion durch den aufrufenden Prozess vor und während _spawn durchgeführt wird. Die folgenden Werte mode sind definiert in Process.h:

Wert	Beschreibung
_P_OVERLAY	Überlagert einen aufrufenden Prozess mit einem neuen Prozess, wobei der aufrufende Prozess vernichtet wird (gleiche Auswirkung wie _exec-Aufrufe).
_P_WAIT	Hält einen aufrufenden Thread bis zum Abschluss der Ausführung des neuen Prozesses an (synchrones _spawn).
_P_NOWAIT oder _P_NOWAITO	Setzt die Ausführung eines aufrufenden Prozesses gleichzeitig mit dem neuen Prozess fort (asynchrones _spawn).
_P_DETACH	Setzt die Ausführung des aufrufenden Prozesses fort; der neue Prozess wird im Hintergrund ohne Zugriff auf Konsole oder Tastatur ausgeführt. Aufrufe von _cwait gegen den neuen Prozess schlagen fehl (asynchrones _spawn).

Die cmdname-Argument gibt die Datei an, die als neuer Prozess ausgeführt wird, und kann einen vollständigen Pfad (über den Stamm), einen partiellen Pfad (über das aktuelle Arbeitsverzeichnis) oder nur einen Dateinamen angeben. Wenn cmdname keine Dateinamenerweiterung vorhanden ist oder nicht mit einem Punkt (.) endet, versucht die _spawn Funktion zuerst die .com Dateinamenerweiterung und dann die .exe Dateinamenerweiterung, die .bat Dateinamenerweiterung und schließlich die .cmd Dateinamenerweiterung.

Wenn cmdname eine Dateierweiterung hat, wird nur diese Erweiterung verwendet. Wenn cmdname mit einem Punkt endet, sucht die _spawn-Funktion nach cmdname ohne Dateierweiterung. _spawnlp, _spawnlpe, _spawnvp und _spawnvpe suchen in den Verzeichnissen, die durch die PATH-Umgebungsvariable angegeben werden, nach cmdname (mithilfe des gleichen Verfahrens).

Wenn cmdname ein Laufwerksbezeichner oder Schrägstriche (d. h. wenn es sich um einen relativen Pfad handelt) enthält, wird der _spawn Aufruf nur nach der angegebenen Datei durchsucht. Es wird keine Pfadsuche durchgeführt.

In der Vergangenheit haben einige dieser Funktionen errno bei Erfolg auf null gesetzt; das aktuelle Verhalten lässt errno gemäß dem C-Standard unverändert. Wenn Sie das alte Verhalten emulieren müssen, setzen Sie errno auf null, unmittelbar bevor Sie diese Funktionen aufrufen.

Hinweis

Um eine ordnungsgemäße Überlagerungsinitialisierung und -beendigung sicherzustellen, verwenden Sie die Funktion setjmp oder longjmp nicht, um eine Überlagerungsroutine einzugeben oder zu verlassen.

Argumente für den spawned-Prozess

Um Argumente an den neuen Prozess zu übergeben, geben Sie mindestens einen Zeiger auf Zeichenfolgen als Argument im _spawn-Aufruf an. Diese Zeichenfolgen bilden die Argumentliste für den erzeugten Prozess. Die kombinierte Länge der Zeichenfolgen, die die Argumentliste für den neuen Prozess bilden, darf 1024 Bytes nicht überschreiten. Das endende Nullzeichen ('\0') für jede Zeichenfolge ist nicht in der Anzahl enthalten, aber Leerzeichen (automatisch in separate Argumente eingefügt) sind enthalten.

Hinweis

Die in den Zeichenfolgen eingebetteten Leerzeichen können zu einem unerwarteten Verhalten führen. Zum Beispiel führt die Zeichenfolge _spawn durch die Übergabe von "hi there" dazu, dass der neue Prozess zwei Argumente erhält: "hi" und "there". Wenn der neue Prozess die benannte Datei "hi there" öffnen sollte, schlägt der Prozess fehl. Sie können dies verhindern, indem Sie die Zeichenfolge in Anführungszeichen setzen: "\"hi there\"".

Wichtig

Übergeben Sie Benutzereingaben nicht an _spawn, ohne den Inhalt explizit zu überprüfen. _spawn führt zu einem Aufruf, CreateProcess um zu bedenken, dass nicht qualifizierte Pfadnamen zu potenziellen Sicherheitsrisiken führen könnten.

Sie können Argumentzeiger als separate Parameter übergeben (in _spawnl, _spawnle, _spawnlp und _spawnlpe) oder als ein Array von Zeigern (in _spawnv, _spawnve, _spawnvp und _spawnvpe). Sie müssen mindestens ein Argument arg0 oder argv[0]mindestens ein Argument an den spawnierten Prozess übergeben. Gemäß Konvention ist dieses Argument der Name des Programms so, wie Sie ihn auf der Befehlszeile eingeben würden. Ein anderer Wert erzeugt keinen Fehler.

Die _spawnl-, _spawnle-, _spawnlp- und _spawnlpe-Aufrufe werden normalerweise verwendet, wenn die Anzahl der Argumente im Voraus bekannt ist. Das arg0-Argument ist normalerweise ein Zeiger auf cmdname. Die Argumente arg1 bis argn sind Zeiger auf Zeichenfolgen, die die Argumentliste neu bilden. Nach argnmuss ein NULL -Zeiger stehen, mit dem das Ende der Argumentliste markiert wird.

Die _spawnv, _spawnve, _spawnvp, und _spawnvpe Aufrufe sind nützlich, wenn eine variable Anzahl von Argumenten für den neuen Prozess vorhanden ist. Zeiger auf die Argumente werden als Array übergeben. argv Das Argument argv[0] ist in der Regel ein Zeiger auf einen Pfad im realen Modus oder auf den Programmnamen im geschützten Modus, und argv[1] argv[n] durch die Zeiger auf die Zeichenzeichenfolgen, die die neue Argumentliste bilden. Das Argument argv[n +1] muss ein NULL Zeiger sein, um das Ende der Argumentliste zu markieren.

Umgebung des erzeugten Prozesses

Dateien, die bei einem _spawn-Aufruf geöffnet waren, bleiben im neuen Prozess geöffnet. Bei _spawnl-, _spawnlp-, _spawnv- und _spawnvp-Aufrufen erbt der neue Prozess die Umgebung des aufrufenden Prozesses. Sie können mit _spawnle-, _spawnlpe-, _spawnve- und _spawnvpe-Aufrufen die Umgebung für den neuen Prozess ändern, indem eine Liste der Umgebungseinstellungen durch das envp-Argument übergeben wird. Das Argument envp ist ein Array von Zeichenzeigern, von denen jedes Element (außer dem letzten Element) auf eine auf NULL endende Zeichenfolge verweist, die eine Umgebungsvariable definiert. Solch eine Zeichenfolge hat normalerweise die Form NAME=value, wobei NAME der Name einer Umgebungsvariable und value der Zeichenfolgenwert ist, für den diese Variable festgelegt wird. (Dies value ist nicht in doppelte Anführungszeichen eingeschlossen.) Das letzte Element des envp Arrays sollte sein NULL. Wenn envp selbst NULL ist, erbt der neue Prozess die Umgebungseinstellungen des übergeordneten Prozesses.

Die _spawn-Funktionen können alle Informationen über geöffnete Dateien, auch den Übersetzungsmodus, an den neuen Prozess übergeben. Diese Informationen werden im Echtzeitmodus über den C_FILE_INFO-Eintrag in der Umgebung übergeben. Der Startcode verarbeitet normalerweise diesen Eintrag und löscht ihn dann aus der Umgebung. Wenn jedoch eine _spawn-Funktion einen anderen als einen C-Prozess erzeugt, verbleibt der Eintrag in der Umgebung. Durch Drucken der Umgebung werden Grafikzeichen in der Definitionszeichenfolge für diesen Eintrag angezeigt, da die Umgebungsinformationen in binärer Form im Echtzeitmodus übergeben werden. Es sollte keine andere Auswirkung auf normale Vorgänge haben. Im geschützten Modus werden die Umgebungsinformationen in Textform übergeben und enthalten daher keine Grafikzeichen.

Vor dem _spawn-Funktionsaufruf müssen Sie jeden Stream explizit leeren (mithilfe von fflush oder _flushall) oder explizit schließen.

Neue Prozesse, die von Aufrufen von _spawn Routinen erstellt werden, behalten keine Signaleinstellungen bei. Stattdessen setzt der erzeugte Prozess die Signaleinstellungen auf die Standardeinstellungen zurück.

Umleitung der Ausgabe

Wenn Sie eine DLL oder eine GUI-Anwendung aufrufen _spawn und die Ausgabe an eine Pipe umleiten möchten, haben Sie zwei Optionen:

• Verwenden Sie die Win32-API, um eine Pipe zu erstellen, dann die AllocConsoleHandlewerte in der Startstruktur festzulegen und aufzurufen CreateProcess.

• Rufen Sie _popen auf oder_wpopen , wodurch eine Pfeife erstellt und die App mithilfe cmd.exe /c (odercommand.exe /c) aufgerufen wird.

Beispiel

// 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!

Siehe auch

Prozess- und Umgebungskontrolle
abort
atexit
_exec, _wexec Funktionen
exit, _Exit_exit
_flushall
_getmbcp
_onexit, _onexit_m
_setmbcp
system, _wsystem