Discussion :

[scary]

Bonsoir,

Voila j'essaie de porter un code que je me suis amusé à faire sous linux sous windows. Celui-ci un mini shell. Seulement je ne connais pas les équivalents de certaines fonctions sous windows . Voici le code que j'essaie de porter:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
/* Interpretation de la ligne de commande */

void	interpreter ()

{
	printf("\n\nInterpretation");
	if (strcmp (commandes [PREMIERE_COMMANDE] [0], "exit") == 0) {printf ("\n"); exit (0);}
	if (commandes [PREMIERE_COMMANDE] [0])
	{
		if ((pid_commande_1 = fork ()) == -1)
		{
			printf("\n*** Premier fils non cree ***");
			exit(0);
		}
		/* printf ("\n --> Fils pour la premiere commande cree"); */

		if (pid_commande_1) 	/* Chez le pere */
		{
			wait (0);
		}
		else 			/* Chez le fils */
		{
			if (commandes [SECONDE_COMMANDE] [0])
			{
				if (pipe (num_pipe) == -1)  /* Creation du tube */
				{
					printf("\n*** Tube non ouvert ***");
					exit (1);
				}
				/* printf("\n  ** Fils 1 : --> Tube cree dans le premier fils"); */
				
				if ((pid_commande_2 = fork()) == -1)  /* Creation du fils */
				{
					printf("\n*** Second fils non cree ***");
					exit(0);
				}
				/* printf ("\n  ** Fils 1 : --> Fils pour la seconde commande cree"); */

				if (pid_commande_2)  	/* Processus pere */
				{
					if (position_fichier_entree)
					{
						fd1 = open (fichier_entree, 0);
						dup2 (fd1, ENTREE_STANDARD);
						/* printf("\n  ** Fils 1 : --> Creation de la redirection en entree"); */
					}
					close (num_pipe [LECTURE]);
					/* printf("\n  ** Fils 1 : --> Creation de la redirection en sortie sur le pipe"); */
					dup2 (num_pipe [ECRITURE], SORTIE_STANDARD);
					/* printf("\n  ** Fils 1 : --> Recouvrement de la premiere commande"); */
					execvp (commandes [PREMIERE_COMMANDE] [0], commandes [0]);
				}
				else			/* Processus fils */
				{
					if (position_fichier_sortie)
					{
						fd2 = creat (fichier_sortie, 0644);
						dup2 (fd2, SORTIE_STANDARD);
						/* printf("\n  ** Fils 2 : --> Creation de la redirection en sortie"); */
					}
					close (num_pipe [ECRITURE]);
					/* printf("\n    **** Fils 2 : --> Creation de la redirection en entree sur le pipe"); */
					dup2 (num_pipe [LECTURE], ENTREE_STANDARD);
					/* printf("\n    **** Fils 2 : --> Recouvrement de la seconde commande"); */
					execvp (commandes [1] [0], commandes [1]);
				}
			}
			else	/* Il n'y a pas de seconde commande */
			{
				if (position_fichier_entree)
				{
					fd1 = open (fichier_entree, 0);
					dup2 (fd1, ENTREE_STANDARD);
					/* printf("\n  ** Fils 1 : --> Creation de la redirection en entree"); */
				}
				if (position_fichier_sortie)
				{
					fd2 = creat (fichier_sortie, 0644);
					dup2 (fd2, SORTIE_STANDARD);
					/* printf("\n  ** Fils 1 : --> Creation de la redirection en sortie"); */
				}

				/* printf("\n  ** Fils 1 : --> Recouvrement de l'unique commande\n\n"); */
				execvp (commandes [PREMIERE_COMMANDE] [0], commandes [PREMIERE_COMMANDE]);
			}
		}

	}
	else
	{
		/* printf("\n*** Pas de commande ***\n\n"); */
		exit (0);
	}
}

Si quelqu'un à une idée de à quoi cela pourrait ressembler sous windows je l'en remercie d'avance de bien vouloir me le montrer

[Melem]

Tout est pratiquement dans [MSDN] Creating a Child Process with Redirected Input and Output.

[scary]

Oula j'aurais jamais pensé que cela serait aussi compliqué que ça les 3/4 des types utilisés me sont inconnus et je ne sais même pas à quoi ils correspondent

[Melem]

Bah oui bienvenu dans le monde de Windows . Les types que tu ne connais pas sont en fait de simples typedefs de int, de pointeurs, de structures, etc. Mais je peux te donner quelques notions :

1. Les descriptors (que ce soit des file descriptors ou des je ne sais quoi descriptors) sont appelés des HANDLEs. Pour les E/S :
- creat -> CreateFile
- open -> OpenFile
- read -> ReadFile
- write -> WriteFile
- close -> CloseFile
- pipe -> CreatePipe
- dup2 -> DuplicateHandle

2. Processus
- Le plus simple c'est d'aller voir la FAQ C.

3. Généralités sur la programmation Windows
- Documentation gratuite sur l'API Windows

[scary]

Alors voila ce que j'ai fais, par contre je ne sais pas si cela correspond bien à mon code plus haut.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
75
76
77
78
79
80
81
82
83
84
85
86
87
void interpreter ()
{
    PROCESS_INFORMATION processus_info1;
    PROCESS_INFORMATION processus_info2;
    STARTUPINFO info_demarage1;
    STARTUPINFO info_demarage2;
    typedef DWORD id1;
    typedef DWORD id2;
    SECURITY_ATTRIBUTES attributs;
    
    ZeroMemory (&info_demarrage1, sizeof (STARTUPINFO));
    ZeroMemory (&info_demarrage2, sizeof (STARTUPINFO));
    attributs.nLength = sizeof (SECURITY_ATTRIBUTES);
    attributs.bInheritHandle = TRUE;
    attributs.lpSecurityDescriptor = NULL;
    if (CreateProcess ("nom_executable", NULL, NULL, NULL, FALSE, 0, NULL, NULL, &info_demarrage1, &processus_info1))
    {
        *id1 = processus_info1.dwProcessId;
        
        if (!(*id1))
        {
            if (commandes[SECONDE_COMMANDE][0])
            {
                if (CreatePipe (num_pipe[LECTURE], num_pipe[ecriture], &attributs, 0)
                {
                    if (CreateProcess ("nom_executable", NULL, NULL, NULL, FALSE, 0, NULL, NULL, &info_demarrage2, &processus_info2))
                    {
                        *id2 = processus_info2.dwProcessId;
                    
                        if (*id2)
                        {
                            if (position_fichier_entree)
                            {
                                fd1 = open (fichier_entree, 0);
                                
                                dup2 (fd1, ENTREE_STANDARD);
                            }
                            close (num_pipe[LECTURE]);
                            dup2 (num_pipe[ECRITURE], SORTIE_STANDARD);
                            _spawnvp (_P_WAIT, commandes[PREMIERE_COMMANDE][0], commandes[0]);
                        }
                        else
                        {
                            if (position_fichier_sortie)
                            {
                                fd2 = creat (fichier_sortie, 0644);
                                
                                dup2 (fd2, SORTIE_STANDARD);
                            }
                            close (num_pipe[ECRITURE]);
                            dup2 (num_pipe[LECTURE], ENTREE_STANDARD);
                            _spawnvp (_P_WAIT, commandes[1][0], commandes[1];
                        }
                    }
                    else
                    {
                        printf ("probleme de precessus numero 2");
                    }
                }
                else
                {
                    printf ("probleme de pipe");
                }
            }
            else
            {
                if (position_fichier_entree)
                {
                    fd1 = open (fichier_entree, 0);
                    
                    dup2 (fd1, ENTREE_STANDARD);
                }
                if (position_fichier_sortie)
                {
                    fd2 = open (fichier_sortie, 0644);
                    
                    dup2 (fd2, SORTIE_STANDARD);
                }
                _spawnvp (commandes[PREMIERE_COMMANDE][0], commandes[PREMIERE_COMMANDE]);
            }
        }
    }
    else
    {
        printf ("probleme de processus numero 1");
    }
}

J'ai juste modifié pour:
fork => CreateProcess
pipe => CreatePipe
execvp => _spawnvp

Pour les autres elles existent bien (vue qu'elles sont POSIX) mais elles sont juste déprécié, ce qui n'est pas trop grave, je m'occuperais ça ensuite car c'est pas le plus important.

[Melem]

Mélanger du Win32 avec du POSIX, ce n'est pas une très bonne idée. CreatePipe par exemple te retourne des HANDLEs alors que tu passes ensuite ces handles à dup2, close, etc. qui elles attendent des files descriptors ... tu peux cependant créer un file descriptor qui encapsule un HANDLE à l'aide de _open_osfhanle.