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.

[scary]

Ok et bien dans ce cas, j'ai donc remplacer aussi toute les fonctions POSIX par des WIN32. Cela correspont-il mieux à mon code version Linux ?

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
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;
    HANDLE fd1;
    HANDLE fd2;
    
    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 = CreateFile (fichier_entree, NULL, NULL, PEN_ALWAYS, NULL, NULL);
                                
                                DuplicateHandle (fd1, NULL, ENTREE_STANDARD, NULL, NULL, NULL, NULL);
                            }
                            CloseHandle (num_pipe[LECTURE]);
                            DuplicateHandle (num_pipe[ECRITURE], NULL, SORTIE_STANDARD, NULL, NULL, NULL, NULL);
                            _spawnvp (_P_WAIT, commandes[PREMIERE_COMMANDE][0], commandes[0]);
                        }
                        else
                        {
                            if (position_fichier_sortie)
                            {
                                fd2 = CreateFile (fichier_sortie, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, PEN_ALWAYS, NULL, NULL);
                                
                                DuplicateHandle (fd2, NULL, SORTIE_STANDARD, NULL, NULL, NULL, NULL);
                            }
                            CloseHandle (num_pipe[ECRITURE]);
                            DuplicateHandle (num_pipe[LECTURE], NULL, ENTREE_STANDARD, NULL, NULL, NULL, NULL);
                            _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 = CreateFile (fichier_entree, NULL, NULL, PEN_ALWAYS, NULL, NULL);
                    
                    DuplicateHandle (fd1, NULL, ENTREE_STANDARD, NULL, NULL, NULL, NULL);
                }
                if (position_fichier_sortie)
                {
                    fd2 = CreateFile (fichier_sortie, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, PEN_ALWAYS, NULL, NULL);
                    
                    DuplicateHandle (fd2, NULL, SORTIE_STANDARD, NULL, NULL, NULL, NULL);
                }
                _spawnvp (commandes[PREMIERE_COMMANDE][0], commandes[PREMIERE_COMMANDE]);
            }
        }
    }
    else
    {
        printf ("probleme de processus numero 1");
    }
}

[Melem]

id1 et id2 même si c'étaient des DWORD ou des pointeurs de DWORD ne servent à rien (et déjà dans ton code ce sont des types ...). En plus, si tu fais un programme qui peut être aussi bien le père que le fils, ce n'est pas en testant le pid comme avec fork sous UNIX mais à l'aide d'une option de lia ligne de commande par exemple. Ex : mon_exe /fils pour lancer en mode fils. Puis il faut mettre dans dans le STARTUPINFO les HANDLEs de pipes que tu veux que le fils utilisent comme entrée et sortie standard. Regarde l'exemple de MSDN que je t'ai donné.

[scary]

Justement je n'arrive pas à faire le lien entre ce que je sais de la programmation système sous Unix et l'exemple que tu m'as donné

C'est beaucoup trop compliqué pour moi

Surtout ce que je ne comprends pas c'est pourquoi transformé une chose aussi simple sur beaucoup de systèmes en une chose aussi complexe sur windows

[Mac LAK]

Justement je n'arrive pas à faire le lien entre ce que je sais de la programmation système sous Unix et l'exemple que tu m'as donné

Parce qu'il n'y a PAS de lien à faire : c'est de la programmation système, donc tu dois utiliser les commandes propres à chaque OS.
Tu as certes des notions "universelles" comme le fait d'avoir des processus, des PID, des entrées/sorties, etc. mais par défaut, Windows n'a pas exactement la même notion de ce qu'est un processus qu'Unix.

Surtout ce que je ne comprends pas c'est pourquoi transformé une chose aussi simple sur beaucoup de systèmes en une chose aussi complexe sur windows

C'est marrant : tu vois, moi, ce sont les fork Unix que je n'ai jamais pu piger complètement... Je trouve toujours incompréhensible et illogique la manière dont c'est fait, surtout quand c'est utilisé en lieu et place d'un bête thread. Je trouve ça excessivement complexe et coûteux (en ressources) pour le résultat obtenu.

Sous Windows, un processus est créé dans le contexte du système, et non pas dans le contexte du processus père comme avec un fork. D'où le nombre d'arguments importants pour CreateProcess... Certes, tu peux passer des arguments à NULL pour hériter des données du processus père, mais ce n'est pas obligatoire. Sous Windows, on ne crée pas un processus "pour rien", c'est une opération coûteuse. On privilégie très fortement les threads en lieu et place.

Tu peux regarder cette page du MSDN qui te donne les grandes lignes de différences entre les deux mondes, puis ce guide pour entrer dans les détails.

Mais côté programmation système, il faut bien comprendre que les deux systèmes d'exploitation sont réellement différents : si tu veux t'intéresser à ce domaine, il faut être conscient qu'il est parfois préférable de repenser complètement son application (=revenir au besoin initial et refaire une conception) plutôt que de tenter un portage "sauvage". Pour le portage brutal, tu as toujours la possibilité de passer par Cygwin qui effectuera les conversions à ta place, au prix d'une dépendance de DLL mais l'avantage sera que tu n'auras pas à modifier tes sources.

[scary]

A bon et bien moi qui me cassais la tête pour essayé de trouver un lien j'étais mal barré

J'aurais pourtant cru que tout les systèmes fonctionnaient plus ou moins de la même façon, on en apprend tout les jours Je vais donc reporter mon apprentissage de la programmation système sous Windows à un autre jour donc car cela me prendrait trop de temps pour réapprendre tout ce que je sais de la programmation système Unix sous Windows.

Sinon si je comprend bien avec cygwin je pourrais compiler mon code de départ et la DLL s'occupera de faire les traductions pour moi, c'est bien ça ? Ainsi peut importe que je face de la programmation système sous Unix ou Windows le même code aura le même effet sur les deux types de système, c'est bien ça ?

[Mac LAK]

A bon et bien moi qui me cassais la tête pour essayé de trouver un lien j'étais mal barré

Tu as bien sûr des éléments communs, comme la notion de processus, de PID, d'utilisateur, d'administrateur, des fichiers, des droits d'accès aux fichiers, etc.

Simplement, si tu désires utiliser l'API système NATIVE de l'OS, alors il te faut repartir sur la "mentalité" de l'OS... Typiquement, sous Unix, tout (ou presque !) est un fichier. Sous Windows, tout (ou presque) est un handle. Par contre, un handle n'est pas un fichier, et réciproquement. Des différences comme ça, tu en as pas mal. Cela ne change absolument pas le principe global d'un système d'exploitation, ni la fonctionnalité finale obtenue. Cela change la manière d'effectuer l'action.

Pour te donner un parallèle : tu peux exprimer la même pensée en français et en anglais, tu as des éléments communs aux deux langues (des sujets, des verbes, des compléments et autres adjectifs...). Par contre, il est rare que traduire mot à mot une phrase française donne quelque chose de compréhensible en anglais... Tout comme certains mots "simples" dans une langue n'existent pas dans l'autre, et doivent être traduits avec une quantité de mots non négligeable pour transmettre le sens initial.

C'est pareil en programmation système : tu pourras faire les mêmes choses avec les deux systèmes d'exploitation, mais par contre tu n'utiliseras pas forcément les mêmes techniques ou principes pour y arriver.

Sinon si je comprend bien avec cygwin je pourrais compiler mon code de départ et la DLL s'occupera de faire les traductions pour moi, c'est bien ça ? Ainsi peut importe que je face de la programmation système sous Unix ou Windows le même code aura le même effet sur les deux types de système, c'est bien ça ?

C'est presque ça. Cygwin va porter les API Unix sous Windows, et te permettre de les utiliser telles quelles.

Par contre, tu n'iras pas très très loin en programmation système Windows de cette manière, car tu te priveras alors de beaucoup de fonctionnalités qui n'ont pas d'équivalent Unix, et qui n'existent donc pas dans Cygwin.

[scary]

Bon je suis déjà rassurer de savoir que tout les principes que je connais des systèmes d'exploitations marchent partout c'est donc la manière d'y parvenir qui change si j'ai bien compris.

Sinon vu qu'en cours nous somme exclusivement sous Linux, Solaris ou FreeBSD les codes orientées systèmes que je ferais seront donc que pour ces systèmes, le fait donc que je ne puisse bénéficié de l'API WIN32 n'est pas utile. Car tout ce que je veux est que le code que je développe sous Windows (qu'il soit orienté système avec des fork, pipe, etc... ou non) compile et fonctionne sans changement sous Unix.

Je ferais mon apprentissage dans cet API plus tard quand j'aurais plus de temps pour moi.

Sinon est-il possible de compiler avec cygwin sous Visual Studio, ou autrement dit peut-on modifier le type de compilateur qu'il utilise ?

[Mac LAK]

Bon je suis déjà rassurer de savoir que tout les principes que je connais des systèmes d'exploitations marchent partout c'est donc la manière d'y parvenir qui change si j'ai bien compris.

C'est bien ça, tu n'es pas fou et tu n'as pas non plus les "bases élémentaires" à réapprendre...

Sinon vu qu'en cours nous somme exclusivement sous Linux, Solaris ou FreeBSD les codes orientées systèmes que je ferais seront donc que pour ces systèmes, le fait donc que je ne puisse bénéficié de l'API WIN32 n'est pas utile.

En effet, vu ce que tu cites, apprendre l'API système Win32 n'est pas franchement une priorité pour toi, je pense.

Sinon est-il possible de compiler avec cygwin sous Visual Studio, ou autrement dit peut-on modifier le type de compilateur qu'il utilise ?

Je n'utilise pas Cygwin de façon générale, mais de mémoire, il me semble qu'il compile via MinGW (GCC pour Win32), avec les mêmes makefiles que pour Unix. Tu peux toujours te servir de Visual comme IDE, mais tu ne pourras pas lui faire utiliser GCC à la place de CL (cl.exe est le compilateur de Visual Studio).
Il existe toutefois des IDE adaptés à GCC, comme Dev-C++ ou Code::Blocks.

[scary]

Parfait et bien merci beaucoup de toutes ses précisions, je vais donc installer cygwin