Faire 2 execvp à la suite

Version imprimable

09/10/2011, 22h29
zaraki31700

Faire 2 execvp à la suite

Bonjour à tous !

Voilà tout est dans le titre. Je voudrais savoir si on peut faire 2 execvp à la suite. Merci d'avance.
09/10/2011, 22h58
gerald3d

Pourquoi pas. Mais si tu poses la question c'est que tu dois avoir une contrainte. Laquelle?
09/10/2011, 23h06
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 ?
10/10/2011, 18h20
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?
10/10/2011, 22h21
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 ?
11/10/2011, 09h39
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é.

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
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.

Comme j' ai un peu de mal à lire ton code ( je ne suis pas vraiment un spécialiste dans le fork :oops:) 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:

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;
}

21/10/2011, 14h44
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.