Retour
CreateProcess (Win32)
BOOL CreateProcess(lpszImageName, lpszCommandLine, lpsaProcess, lpsaThread, fInheritHandles,
fdwCreate, lpvEnvironment, lpszCurDir, lpsi, lppi)
LPCTSTR lpszImageName; /* adresse del'image du nom du fichier */
LPCTSTR lpszCommandLine; /* adresse de la command line */
LPSECURITY_ATTRIBUTES lpsaProcess; /* attributs optionels pour le process */
LPSECURITY_ATTRIBUTES lpsaThread; /* attributs optionels pour le lien */
BOOL fInheritHandles; /* le process cible hérite-il des propriétés de son parent? */
DWORD fdwCreate; /* flags de création */
LPVOID lpvEnvironment; /* adresse d'un environment optionel*/
LPTSTR lpszCurDir; /* adresse du nouveau répertoir courrant */
LPSTARTUPINFO lpsi; /* adresse de la structure STARTUPINFO */
LPPROCESS_INFORMATION lppi; /* adresse de la structure PROCESSINFORMATION */
La fonction CreateProcess crée un nouveau process et lien, et démarre l'application indiquée dans
ce nouveau process.
Paramètre Description
lpszImageName Pointe sur une chaîne de caractères terminée par un NULL, laquelle
représente le nom et le chemin entier pour accéder au fichier à lancer.
Si ce paramètre est NULL, le nom du fichier doit être le premier signe
de l'espace vide de la ligne de commande. Si les arguments doivent être
passés au nouveau process, ce paramètre doit être NULL et l'image - le
nom du fichier et des arguments doivent être spécifiés sur la ligne de
commande.
lpszCommandLine Pointe sur une chaîne de caractères terminée par un NULL, laquelle
représente la ligne de commande de l'application qui doit fonctionner
dans le nouveau process. Si lpszImageName est NULL, le premier signe
de l'espace vide de la ligne de commande représente l'image - le nom
du fichier. Si le nom du fichier ne contient pas d'extension, alors
*.EXE lui est assigné. Si le nom du fichier ne contient pas de chemin
de renseignements, les Windows cherchera le fichier exécutable dans :
1 Le répertoire actuelle.
2 Le répertoire Système de Windows.
3 Le répertoire Windows.
4 Les répertoires formants le chemin jusqu'à la cible.
lpsaProcess Pointe sur une structure de données SECURITY_ATTRIBUTES laquelle
spécifie les attributs de sécurité pour le process créé.
Si lpsaProcess est NULL, le process est créé sans descripteur de
sécurité et le handle résultant n'est pas hérité.
lpsaThread Pointe sur une structure de données SECURITY_ATTRIBUTES laquelle
spécifie les attributs de sécurité pour le lien créé.
Si lpsaThread est NULL, le lien est créé sans descripteur de
sécurité et le handle résultant n'est pas hérité.
fInheritHandles Si ce paramètre est TRUE, chaque handle dans le process d'appel ayant
été créé avec l'option de handle hérité est hérité par le nouveau
process. Les Handles héritées ont la même valeur et accès aux
privilèges que les handles originaux.
-----------------------------------------------------------------------
fdwCreate Fournit des Flags supplémentaires qui contrôlent la création du process,
comme le montre la liste suivante :
Valeur Signification
IDLE_PRIORITY_CLASS
Le process sera lancé seulement quand le système sera inoccupé. Un
process inoccupé sera toujours mis en attente par rapport à n'importe
quel autre process ayant une classe de priorité plus haute. Un
économiseur d'écran est un exemple d'un process de priorité Inoccupé.
NORMAL_PRIORITY_CLASS
Le process sera une application normale sans besoins de planifications
spéciales. C'est la classe de priorité par défaut. Des process normaux
déjà en route auront toujours la propriété sur un process Inoccupé; le
process inoccupé partira seulement quand le process normal sera bloqué
et à l'inverse, le process normal reprendra la priorité sur le process
inoccupé à chaque fois que ce process normal reprendra son cours.
HIGH_PRIORITY_CLASS
Le process possède une priorité de haut niveau. Il a besoin de
planifications spéciales qui doivent être adressés pour cela pour
fonctionner correctement. Un bon exemple d'un tel besoin serait une
application de fond qui est normalement inoccupé (un Screen Saver). En
réponse à un quelconque événement externe, il a besoin d'afficher une
fenêtre popup en acquérant la priorité sur les autres applications qui
sont en cours mais qui possèdent des classes de priorités normales ou
inoccupées.
Une attention particulière doit être prise en employant classe de haute
priorité. Il est possible de créer une application UC-ATTACHÉE dans la
haute classe de priorité qui peut absorber presque tous les cycles
disponibles. (les ressources de votre ordi)
DEBUG_PROCESS
Si ce Flag est mis, le process d'appel est traité comme un programme
de type DEBUGGER et le nouveau process est un DEBUGGER. Le noyau
(Windows) notifie (informe) le programme Debugger de tous les événements
de mise au point (les Debugging événements) qui se produisent dans le
process cible. Si ce Flag n'est pas mis et que le process d'appel est
debuggué, alors le nouveau process devient un autre process se faisant
débuggué par le programme debugger du process d'appel. Si ce Flag n'est
pas mis et que le process d'appel n'est pas un process cible, aucunes
actions ayant une relation de type debugging ne se produit.
DEBUG_ONLY_THIS_PROCESS
Si ce Flag est mis, le process d'appel est traité comme un programme
Debugger et le nouveau process est un process cible. Si le nouveau
process (la cible) crée des process complémentaires, le noyau (windows)
ne notifiera pas (n'informera pas) le Debugger d'aucuns Debugging
événements qui se produissent dans les process complémentaires de la
cible.
CREATE_SUSPENDED
Le lien primaire du process ne sera pas actif avant que le process
n'est appelé la fonction ResumeThread.
CREATE_NEW_CONSOLE
Le process créé aura une nouvelle console, au lieu d'hériter des mêmes
propriétés que celles de son parent.
Ce Flag ne peut pas être employé avec le Flag DETACHED_PROCESS.
CREATE_NO_WINDOW
Le process créé n'aura une console, mais aucune fenêtre. Le process
ne sera pas capable d'obtenir une fenêtre. Ce Flag doit seulement
être employé avec les VDMs.
DETACHED_PROCESS
Le process créé n'aura pas de console. Le fait d'appel une console pour
un process n'en n'ayant pas provoque une erreur. Le process peut appeler
la fonction AllocConsole par la suite s'il veut en obtenir une.
Ce Flag ne peut pas être employé avec le Flag CREATE_NEW_CONSOLE.
-----------------------------------------------------------------------
lpvEnvironment Pointe sur un bloc d'environnement pour le nouveau process. Si ce
paramètre est NULL, le nouveau process emploie l'environnement du
process d'appel.
lpszCurDir Pointe sur une chaîne de caractères |terminée par un NULL, laquelle
représente le lecteur et le répertoire actuels du nouveau process.
La chaîne de caractères doit être un nom de chemin entièrement définit
qui inclut la lettre représentant le lecteur.
Si lpszCurDir est NULL, le nouveau process est créé dans le même
répertoire que le process d'appel. Cette option est principalement
utilisée pour les Shells qui veulent commencer une application et
spécifier leur lecteur et répertoire initiaux.
lpsi Pointe sur une structure STARTUPINFO laquelle indique comment la
fenêtre principale du process cible doit apparaître.
lppi Pointe sur une structure PROCESS_INFORMATION laquelle reçoit les
informations d'identification du process cible.
Retours
La valeur en retour est TRUE si la fonction est couronnée de succès, ou FALSE si une erreur
s'est produite. Employez la fonction GetLastError pour obtenir l'information à propos de
l'erreur étendue.
Commentaires
La fonction CreateProcess doit être employée dans Win32 pour lancer un nouveau programme. Les
fonctions WinExec et LoadModule sont toujours disponibles, mais elles sont exécutées comme des
appels pour la fonction CreateProcess.
La fonction CreateProcess peut être employée ou bien comme fonction de caractères large (où les
arguments de texte doivent employer Unicode) ou bien comme fonction ANSI (où les arguments de
texte doivent employer le jeu de caractères de Windows 3.x).
Le process créé reste dans le système avant que tous les liens dans le process ne se soient
terminés et tous les handles du process et tous ses liens aient été fermés par des appels
CloseHandle. Les handles et le lien principal doivent être fermées par des appels CloseHandle.
Si ces handles ne sont pas nécessaires, il est préférable de les refermer immédiatement après
que le process ait été créé.
Quand le dernier lien du process se termine, tous les objets ouverts par le process sont
refermés automatiquement. Le statut de terminaison du process change de valeur laquelle était
à l'origine STATUS_PENDING et passe alors au statut de terminaison du dernier lien qui doit
être terminer.
En plus de la création d'un process, CreateProcess crée aussi un objet de lien. Le lien est
créé avec une pile initiale dont la taille est décrite dans l'entête d'image du fichier
exécutable du programme indiqué. Le lien commence l'exécution à l'entrypoint de l'image.
Un identificateur de process 32 bits est assigné au process. L'ID est valable jusqu'à ce que
le process ne se termine. Il peut être employé pour identifier le process, ou ouvrir le handle
du process pour exécuter n'importe quelle action dans le process. Un identificateur de lien
32 bits est aussi assigné au lien initial du process. L'ID est valable jusqu'à ce que le lien
ne se termine, et comme d'habitude identifie un lien unique dans le système.
La voie préférée pour refermer un process est d'employer la commande ExitProcess, parce que
cette fonction notifie (informe) toutes les DLLs attachées au process de la terminaison
prochaine. Les autres moyens de fermeture du process ci-dessous ne notifient pas les DLLs
attachées.
Dans un process qu'on lance (comme avec un appel de CreateProcess), ExitProcess, ExitThread,
CreateThread sont arrangés comme un sorte de feuilleton les uns par rapport aux autres dans
le process. Seulement un de ces événements à la fois peut se produire dans un espace d'adresse.
Ça signifie que :
- Pendant le démarrage du process et des routines d'initialisation des DLL, de nouveaux liens
peuvent être créés, mais ils ne commenceront pas leur exécution tant que l'initialisation de
la DLL ne soient fait pour le process.
- Seulement un lien du process à la fois peut être lié à une DLL ou détaché de la routine.
ExitProcess ne se réalise pas tant qu'il restent des liens vers une DLL ou ne se soient pas
détachés des routines.
Exemple
Cet d'exemple montre comment créer un process, attend pour en sortir, obtient son statut de
sortie et referme le lien et le handle :
fSuccess = CreateProcess(...); /* try to create a process */
if (fSuccess) { /* if we were successful... */
hProcess = ProcessInformation.hProcess;
hThread = ProcessInformation.hThread;
/* wait for the process to complete */
dw = WaitForSingleObject(hProcess, INFINITE) ;
if (dw != 0xFFFFFFFF) { /* if we saw success ... */
/* pick up an exit code for the process */
fExit = GetExitCodeProcess(hProcess, &dwExitCode) ;
}
/* close the process and thread object handles */
CloseHandle(hThread) ;
CloseHandle(hProcess) ;
}
Cet exemple montre comment créer un process isolé. Le lien et des handles du process peuvent
être fermés immédiatement après que le nouveau process (de la cible) soit créé.
fSuccess = CreateProcess(...); /* try to create a process */
if (fSuccess) { /* if we were successful... */
/* close the thread and process object handles */
CloseHandle(ProcessInformation.hThread) ;
CloseHandle(ProcessInformation.hProcess) ;
}
Voir Aussi
CloseHandle, ExitProcess, OpenProcess, TerminateProcess
Retour