Discussion :

[lylo01]

Bonjour,

Etant debutant dans la programation systeme, j'essaie de resoudre un exercice sur les processus.


Le but de l'exercice est de faire un programme en ligne de commande prenant pour argument une chaine de la forme : " COMMANDE ARGUMENTS &> FICHIER" qui execute COMMANDE ARGUMENT en dirigeant stdin et stderr vers FICHIER.

exemple:
touch dummy
chmod 200 dummy
./programme "cat *.c &> file.out"

qui devrait envoyer dans file.out tous les fichiers avec extension ".c" et un message d'erreur pour le fichier dummy.

Je dois utiliser les fonctions fork, une version d'exec, strtok, et dup/dup2. (2 versions demandées une avec dup une avec dup2)

J'ai codé la version suivante, mais j'ai un souci lorsque j'appelle une commande utilisant un argumant de la forme *.extension comme dans l'exemple ci dessus, pour le reste je pense que ca marche. Le probleme est que je ne vois pas du tout ou est le probleme. Auriez vous une idée ?


Voici ce que j'obtiens avec mon programme:

$ ./programme "cat *.c &> file.out"
$ cat file.out
cat: *.c: Aucun fichier ou dossier de ce type

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
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/wait.h>
#include <string.h>
#include <fcntl.h>
 
 
void usage()
{
  fprintf(stderr,"Usage: execute \"command argument &> file\"\n");
  exit(1);
}
int main(int argc, char * argv[])
{
  char *command,*currStr;
  char * fileName;
  int fd,i;
  char ** arg=NULL;
  pid_t exc=0;
 
  if (argc!=2) usage();
 
  command = strtok(argv[1],"&>");
  fileName = strtok(NULL,"&> ");
 
 
  currStr = strtok(command," ");
  i=1;
  do{
 
    arg=(char**) realloc(arg,i * sizeof(char*));
    arg[i-1]=currStr;
    i++;
    currStr=strtok(NULL," ");
  } while(currStr!=NULL);
 
  arg=(char**) realloc(arg,i * sizeof(char*));
  arg[i-1]=NULL;
 
  exc=fork();
 
  if (exc==-1)
  {
    fprintf(stderr,"error in fork()");
    exit(1);
  }
 
  if (exc==0)
  {
    fd=open(fileName,O_WRONLY | O_CREAT | O_APPEND,0644);
 
    if (fd < 0)
    {
      perror("open");
      exit(1);
    }
    close (STDOUT_FILENO);
    close (STDERR_FILENO);
    if (dup(fd)<0 || dup(fd)<0) {
      perror ("dup");
      exit(1);
    }
    close(fd);
 
    execvp(arg[0],arg);
    printf("brr");
  }
 
  wait(NULL);
}

[gangsoleil]

Bonjour,

Quelques remarques en vrac sur ton programme :
C'est dommage de devoir utiliser strtok et pas sscanf ; strtok a pour probleme de modifier son argument, et est complexe a bien utiliser. Pour info, tu as un bon tuto dessus ici. Mais passons.
Pourquoi realloc alors que tu n'as pas encore fait d'allocation ?
Tu ne testes pas le code de retour de realloc, ce qui conduit a un crash en cas de refus d'allocation.
Tu n'utilises pas bien realloc, puisqu'en cas de probleme d'allocation, tu perds l'espace memoire deja alloue (fuite memoire). Tu me diras que ce n'est pas grave puisque tu crash dans ce cas....
Tu ne liberes pas la memoire allouee. man free.

Et enfin, je ne suis pas certain que ton algorithme soit vraiment ce qui se fait de plus simple pour le probleme que tu as. Je te conseille de le revoir, puis ensuite seulement de passer a l'implementation.

[Sve@r]

Pourquoi realloc alors que tu n'as pas encore fait d'allocation ?

Il me semble (enfin ça fait longtemps que je fais plus de C donc je peux me tromper) que realloc, si on lui passe un pointeur NULL en premier argument, se comporte comme malloc. Ce qui évite ainsi de devoir faire le test "suis-je en première allocation ou en réallocation" lors des boucles de remplissage...

[Jenna]

Il me semble (enfin ça fait longtemps que je fais plus de C donc je peux me tromper) que realloc, si on lui passe un pointeur NULL en premier argument, se comporte comme malloc. Ce qui évite ainsi de devoir faire le test "suis-je en première allocation ou en réallocation" lors des boucles de remplissage...

Oui, tout à fait

[gangsoleil]

Bonjour,

Il me semble (enfin ça fait longtemps que je fais plus de C donc je peux me tromper) que realloc, si on lui passe un pointeur NULL en premier argument, se comporte comme malloc. Ce qui évite ainsi de devoir faire le test "suis-je en première allocation ou en réallocation" lors des boucles de remplissage...

C'est tout a fait le cas. Mais je trouve que ca nuit a la lisibilite du programme, et que ce n'est pas si complique de commencer par faire une allocation a la bonne taille, puis de ne la redimensionner que si cela s'avere necessaire par la suite, plutot que la boucle d'allocation que propose lylo01.