Créer un processus sur windows et le fermer grâce à CreateProcess.

Version imprimable

Bonjour à tous,

Voila j'ai un petit problème je suis en train de créer une application permettant de lancer 3 autres programmes et de pouvoir les fermer.
J'ai réussi à créer les processus mais voila lorsque je kill les processus un des trois ne se ferme pas alors qu'il devrait se fermer.
Je kill les processus grace à TerminateProcess peut etre faut il que j'utilise ExitProcess mais je ne vois pas comment utiliser cette fonction.

Voici le bout de code qui nous intéresse :

Code:

1
2
3
4
5
6
typedef struct  s_process
{
    STARTUPINFO         si;         /* Requis par CreateProcess */
    PROCESS_INFORMATION pi; /* Requis par CreateProcess */
    int                 etat;
}               t_process;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
void        kill_process(t_process *proc)
{
    printf("kill process\n");
    TerminateProcess(proc->pi.hProcess, 0);
    printf("fin kill\n");
    WaitForSingleObject(proc->pi.hProcess, INFINITE);
    printf("fin attente\n");
    CloseHandle(proc->pi.hProcess); /* Fermer le handle vers le processus                            */
    CloseHandle(proc->pi.hThread);
    proc->etat = 0;
}
 
t_process        *create_process(t_process *proc, char *path)
{
    if (proc != NULL && proc->etat == 1)
        kill_process(proc);
    if (proc == NULL)
    {
        if (my_test_malloc(proc = malloc(sizeof(*proc))) < 0)
            return (NULL);
    }
    ZeroMemory(&(proc->si), sizeof(proc->si));
    if (CreateProcess( path,       /* Nom de l'exécutable                    */
                       NULL,      /* Arguments de la ligne de commande                             */
                       NULL,      /* Attributs de sécurité du nouveau processus (processus fils)   */
                       NULL,      /* Attributs de sécurité du thread principal                     */
                       FALSE,     /* Le processus fils héritera t-il des handles du processus père */
                       0,         /* Flags de création                                             */
                       NULL,      /* Variables d'environnement                                     */
                       NULL,      /* Répertoire courant                                            */
                       &(proc->si),       /* Paramètres d'initialisation du processus                      */
                       &(proc->pi)        /* Informations sur le processus                                 */ ))
    {
        proc->etat = 1;
        return (proc);
    }
    return (NULL);
}
 
void        *thread_vgo(void *ptr)
{
    t_gobio *gobio = (t_gobio *)ptr;
 
    gobio->proc_vgo = create_process(gobio->proc_vgo, "c:\\Program Files (x86)\\VGo\\VGoApp.exe");
    return (NULL);
}
 
void        *thread_tab(void *ptr)
{
    t_gobio *gobio = (t_gobio *)ptr;
 
    gobio->proc_tab = create_process(gobio->proc_tab, "c:\\Program Files (x86)\\TOOTI Visio\\TootiVisio.exe");
    return (NULL);
}
 
void        *thread_domo(void *ptr)
{
    t_gobio *gobio = (t_gobio *)ptr;
    int     ret;
 
    gobio->proc_domo = create_process(gobio->proc_domo, "C:\\Users\\Johan\\Documents\\test\\domotique\\bin\\Debug\\domotique.exe");
    return (NULL);
}
 
void            lunch_thread_app(t_gobio *gobio)
{
    pthread_t    thread;
    pthread_t    thread2;
    pthread_t    thread3;
 
    pthread_create(&thread, NULL, thread_vgo, (void *)gobio);
    pthread_create(&thread2, NULL, thread_tab, (void *)gobio);
    pthread_create(&thread3, NULL, thread_domo, (void *)gobio);
}

Ma fonction create_process kill le process si il est ouvert puis l'execute.
J'attend vos réponses avec impatience :)

27/08/2014, 12h50
Médinoc

En ignorant le fait que killer un processus soit crade, es-tu sûr que ces processus ne créent pas eux-mêmes de nouveaux processus? Killer un processus n'est pas récursif.
27/08/2014, 12h59
lecuye_j

Si justement exist-il un moyen de fermer le programme proprement avec tous les processus qu'il lance ?
Je n'ai pas trouvé grand chose en c qui permette ça.
27/08/2014, 14h33
Médinoc

Proprement non, mais créer les processus dans un Job et tuer le Job tue les enfants du processus avec (sauf ceux créés spécifiquement pour "sortir" du job si celui-ci l'autorise).

Super ça marche merci :D
Je met le résultat si jamais y en a qui ont le même problème.

Code:

1
2
3
4
5
6
7
typedef struct  s_process
{
    STARTUPINFO         si;         /* Requis par CreateProcess */
    PROCESS_INFORMATION pi; /* Requis par CreateProcess */
    HANDLE              job;
    int                 etat;
}               t_process;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
int        kill_process(t_process *proc)
{
    if (proc == NULL || proc->etat == 0)
        return (0);
    printf("kill job\n");
    TerminateJobObject(proc->job, 0);
    CloseHandle(proc->job);
    CloseHandle(proc->pi.hProcess);
    CloseHandle(proc->pi.hThread);
    proc->etat = 0;
    return (0);
}
 
t_process        *create_process(t_process *proc, char *path)
{
    kill_process(proc);
    if (proc == NULL)
    {
        if (my_test_malloc(proc = malloc(sizeof(*proc))) < 0)
            return (NULL);
    }
    proc->job = CreateJobObject(NULL, NULL);
    ZeroMemory(&(proc->si), sizeof(proc->si));
    if (CreateProcess( path,       /* Nom de l'exécutable                    */
                       NULL,      /* Arguments de la ligne de commande                             */
                       NULL,      /* Attributs de sécurité du nouveau processus (processus fils)   */
                       NULL,      /* Attributs de sécurité du thread principal                     */
                       FALSE,     /* Le processus fils héritera t-il des handles du processus père */
                       0,         /* Flags de création                                             */
                       NULL,      /* Variables d'environnement                                     */
                       NULL,      /* Répertoire courant                                            */
                       &(proc->si),       /* Paramètres d'initialisation du processus                      */
                       &(proc->pi)        /* Informations sur le processus                                 */ ))
    {
        if (AssignProcessToJobObject(proc->job, proc->pi.hProcess) == 0)
        {
            printf("erreur assigne\n");
            TerminateProcess(proc->pi.hProcess, 0);
            CloseHandle(proc->pi.hProcess);
            CloseHandle(proc->pi.hThread);
            return (NULL);
        }
        proc->etat = 1;
        return (proc);
    }
    return (NULL);
}

27/08/2014, 16h21
Médinoc

Attention, tu leakes pi.hThread.
27/08/2014, 16h54
lecuye_j

A oui je pensais que ça servait pour createthread et pas pour createprocess merci :D
29/08/2014, 12h42
lecuye_j

AssignProcessToJobObject

Je réouvre le sujet car j'ai encore un problème lors de l'assignement du process au job.
Quand je lance avec code blocks tout marche niquel mais quand je lance l'executable en cliquant dessus ça ne veut pas assigné le process au job.
Pourtant je n'ai aucune erreur lors de la création du job ni du processe.
D'ou ça peut venir? des permissions ? une dll manquante?
Merci d'avance :)