Discussion :

[zaraki31700]

Bonjour à tous !

Voilà tout est dans le titre. Je voudrais savoir si on peut faire 2 execvp à la suite. Merci d'avance.

[gerald3d]

Pourquoi pas. Mais si tu poses la question c'est que tu dois avoir une contrainte. Laquelle?

[zaraki31700]

En fait, je fais un mini-shell et je veux implémenter le ";" permettant de lancer plusieurs commandes à la suite. Je pensais donc faire plusieurs execvp pour lancer les différentes commandes à la suite.
Est-ce une bonne solution ?

[gerald3d]

Pourquoi pas. Mais execvp est bloquant il me semble. Donc tant que la première application n'est pas finie le lanceur attend. Est-ce que ce comportement te gène ou pas?

[zaraki31700]

Effectivement le execvp est bloquant. J'ai testé en mettant un execvp dans un while afin de l'exécuter plusieurs fois mais seul le premier execvp est exécuté. Dès le premier execvp rencontré le programme l'exécute et sort de la boucle.
Une idée pour que je puisse faire plusieurs execvp à la suite ?

[gerald3d]

execvp retourne une valeur. Je pense qu'il faut travailler avec ce retour. Pourrais-tu nous montrer ton code actuel avec la boucle while pour voir pourquoi un seul execvp est exécuté.

[zaraki31700]

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
char ligne[4096];       /* contient la ligne d\'entrée */
char* mots[NBMAX];	/* tableau de pointeurs des mots de la ligne */
char withComa[4096];
 
void lancerCmd()
{
	pid_t pid;
	int status;
	char *trouve;
	/* On saute les lignes vides */
	if (mots[0] == NULL) 
		return;
 
	switch(pid = fork())
	{
		case -1 : 
			perror("Echec du fork");
			exit(-1);
			break;
 
		case 0 : /* fils */ 
			/* Traitement des listes de commandes */	
			trouve = strchr(ligne,';');
			if(trouve == NULL)
			{	
				execvp(mots[0],mots);
			}
			else
			{
				int i = 0;
				strcpy(withComa,ligne);
				char **tab = str_split(withComa, ";");
				while(tab[i] != NULL)
				{	
					//puts(tab[i]);
					char* temp[NBMAX];
					temp[i] = tab[i];
					temp[i+1] = NULL;
					//puts(temp[i]);
					execvp(temp[0],temp);
					i++;	
				}
			}
			break;
 
		default : /* père */
			waitpid(pid,&status,0);
			break;
	}
}

Voilà il s'agit du execvp qui est dans le while.

[gerald3d]

Comme j' ai un peu de mal à lire ton code ( je ne suis pas vraiment un spécialiste dans le fork ) j'ai écris un petit code exemple le plus dépouillé possible.

Ce code exécute dans deux processus fils la fonction "ls -al". En espérant que cela puisse t'aider...

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
#include <stdlib.h>
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
 
int main (int argc,char *argv[])
{
  char *arguments[]={"-a", "-l", 0};
  pid_t pid;
  int status;
  int boucle=2, i=0;
 
  while (i<boucle)
  {
    if ((pid = fork()) < 0)
    {     /* fork a child process           */
      fprintf(stderr, "*** ERROR: forking child process failed\n");
      exit(1);
    }
    else
    if (pid == 0)
    {          /* for the child process:         */
      if (execvp("ls" ,arguments) < 0)
      {     /* execute the command  */
         fprintf(stderr, "*** ERROR: exec failed\n");
         exit(1);
      }
    }
    else
    {                                  /* for the parent:      */
      while (wait(&status) != pid);
    }
    i++;
  }
 
  return EXIT_SUCCESS;
}

[matafan]

Tu ne peux plus rien faire après un execvp(). execvp() ne rend pas la main. Il ne retourne pas. Jamais. Sauf évidemment en cas d'erreur s'il n'arrive pas à exécuter le programme.

Si tu veux exécuter successivement deux programmes comme dans l'expression shell "prog1; prog2" alors il faut forker, exécuter prog1 dans le fils, attendre dans le père, forker à nouveau dans le père, exécuter prog2 dans le fil, attendre dans le père.

Il faut forker un nouveau process à chaque fois.