Trouver le répertoire de l'exécutable

**troumad** · 31/03/2011, 08h08

Bonjour

J'aimerai en C, sous Windows et sous Linux (les méthodes sont sûrement différentes) savoir repérer où est l'exécutable. J'avais pensé, travailler à partir de argc , argv et le répertoire courant, mais je viens de penser qu'il existe des liens et le PATH ! Donc, cette méthode devient caduque

Mon but est de pouvoir accéder aux fichiers qui accompagnent mon exécutable comme des images ou d'autres fichiers que mon programme va lire.

En écrivant ceci, je pense à une machine à gaz...
1) chercher dans le path
2) vérifier si c'est un lien et si oui, recommencer le point 2 tant qu'on n'a pas le véritable fichier.

Question : ça donne quoi sous Linux si c'était un alias ?

Remarque : je n'ai pas envie d'inventer la roue... Ça devrait déjà exister non ?

**plxpy** · 31/03/2011, 08h29

Bonjour

petite remarque qui ne répond pas à la totalité de ton message : tu ne peux pas laisser complètement tomber argc/argv car rien n'empêche un utilisateur de lancer un exécutable qui n'est pas dans un des répertoires de PATH (il suffit qu'il mette un chemin absolu/relatif correct).

Donc, PATH ou argc/argv ? les deux mon général !

autre remarque : sous Unix/Linux, le répertoire courant n'est pas, comme sous Windows (je crois) systématiquement "scanné" quand le système recherche un exécutable. Si "." n'est pas dans le PATH, et ben le système ne regarde pas le répertoire courant.

**ram-0000** · 31/03/2011, 08h39

Sous Windows, tu as la fonction GetModuleFileName() qui retourne le chemin complet de l'exécutable. Il suffit d'enlever le nom du fichier et tu as le répertoire de ce fichier.

Par contre, tu te doutes bien que ce n'est pas transposable à Linux

**troumad** · 31/03/2011, 10h02

plxpy a tout à fait raison pour le ".". Le reste, j'y avait déjà pensé.

Envoyé par ram-0000

Par contre, tu te doutes bien que ce n'est pas transposable à Linux

Est-ce possible que pour une fois Windows serait moins compliqué que Linux ?
Il doit bien exister quelque chose pour Linux

**plxpy** · 31/03/2011, 10h19

Sous Linux, pour en faire le moins possible, j'utiliserais la sortie standard de "which" (popen en lecture de la commande "which" pour argv[0]) : ça t'évite de "parser" le PATH et si l'utilisateur a lancé l'outil via un chemin, c'est géré également (puisque le code s'exécute, c'est que le système à trouvé l'exécutable !!!)

Par contre, je crains que ça ne résolve pas le cas du lien symbolique.

Une petite fonction récursive avec, en paramètre, le retour de la commande (pas le code retour mais le chemin lu sur la sortie standard) et qui s'arrête quand le fichier n'est pas un lien symbolique, devrait faire l'affaire.

petit bémol à ce que j'ai écrit plus haut : j'ai raisonné en mode "ligne de commande". Si on lance l'appli (graphique, avec IHM) via un double-click, je ne sais pas trop ce qu'on récupère dans argv[0])

**troumad** · 31/03/2011, 11h28

Envoyé par plxpy

petit bémol à ce que j'ai écrit plus haut : j'ai raisonné en mode "ligne de commande". Si on lance l'appli (graphique, avec IHM) via un double-click, je ne sais pas trop ce qu'on récupère dans argv[0])

C'est aussi une question que je me pose !
Je vais essayer de tester cet après midi

Fait...

On récupère la commande mise dans l’icône => Ça revient au même que la ligne de commande.

**troumad** · 31/03/2011, 13h56

Code :

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

1
2
  sprintf(ch,"ls  -gG /proc/%d/exe",getpid());
  system(ch);

Me renvoie le chemin vers l'exécutable :

Code :

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

lrwxrwxrwx 1 0 mars  31 13:53 /proc/16386/exe -> /home/troumad/Documents/add/gtk/perso/a.out

Même si j'exécute mon programme à partir d'un autre endroit

Code :

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

1
2
$  ll /proc/16386 | grep cwd
lrwxrwxrwx 1 troumad troumad 0 mars  31 13:53 cwd -> /home/troumad/

Je sais qu'il existe une méthode pour traiter une sortie système sans passer par un fichier temporaire : il va falloir que je la trouve !

TROUVÉ : http://c.developpez.com/faq/?page=en...ment#ENV_popen

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
#include <stdio.h>
#include <sys/types.h>
 
#define SEPARATEUR '/'
 
int main (int argc, char *argv[])
{
 
 char ici[1024], *tmp,* tmp1=NULL,*tmp2=NULL;
 char chemin[1024],ch[1024];
 
 FILE *pp;       
 
 
  sprintf(ch,"ls  -gG /proc/%d/exe",getpid());
  if ((pp = popen(ch,"r")) == NULL)
  {
      perror("popen");
  }
  else
  {
        while (fgets(chemin, sizeof chemin, pp))
	{
	  for(tmp=chemin;*tmp!=0;*tmp++)
	  {
	    if (*tmp=='/') tmp1=tmp;
            if (*tmp==' ')
	    {
	      tmp2=tmp;
	      tmp1=NULL;
	    }
	  }
	  if (tmp1!=NULL) *tmp1=0;
	}
  }
 
  printf("Le chemin est %s\n",tmp2);
 
  scanf("%c",ici); /* j'attends pour vérifier */	
}

**troumad** · 31/03/2011, 14h25

Mais, je pense qu'il y a mieux... Lire tout simplement le lien en C ! Mais comment faire ? Je cherche !

**plxpy** · 31/03/2011, 16h30

Je n'ai pas lu en détail les 2 derniers messages mais si "lire le lien en C" signifie récupérer le fichier vers lequel pointe un fichier de type lien symbolique,il faut regarder du côté de readlink

**troumad** · 31/03/2011, 17h20

Envoyé par ram-0000

Sous Windows, tu as la fonction GetModuleFileName() qui retourne le chemin complet de l'exécutable. Il suffit d'enlever le nom du fichier et tu as le répertoire de ce fichier.

Il doit y avoir des paramètres à passer au compilateur pour prendre en compte winbase.h qui est utile pour cette fonction !
J'ai plein d'erreur lors de la compilation de winbase.h

**troumad** · 31/03/2011, 17h31

Envoyé par plxpy

Je n'ai pas lu en détail les 2 derniers messages mais si "lire le lien en C" signifie récupérer le fichier vers lequel pointe un fichier de type lien symbolique,il faut regarder du côté de readlink

J'ai trouvé la réponse pour Linux ici :
http://www.developpez.net/forums/d16...hier-executer/
C'est plus joli que ce que je proposais

Et ça utilise bien readlink !

**ram-0000** · 31/03/2011, 18h14

Envoyé par troumad

Il doit y avoir des paramètres à passer au compilateur pour prendre en compte winbase.h qui est utile pour cette fonction !

Non non, il faut inclure <windows.h> (et pas winbase.h)

**troumad** · 31/03/2011, 18h31

Oui, c'est ce que je viens de voir et ça me fout tout en l'air avec des doublons de #define qui n'ont plus le même sens qui moi !
Quelle idée insensée de mettre par exemple

Code :

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

#define LONG long;

Avec cette bibliothèque, l'exécutable est passé de 246 ko à 535 ko !

**ram-0000** · 31/03/2011, 18h52

Envoyé par troumad

Avec cette bibliothèque, l'exécutable est passé de 246 ko à 535 ko !

Je suis surpris de ce surpoids, tu regardes la taille du binaire debug ou release ?

**troumad** · 31/03/2011, 19h24

Exact... J'étais passé en mode Debug !

Pour info, voici mon code :

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
char * chemin_exe()
{
#ifdef __linux__
 
 char *tmp,* tmp1=NULL;
 char chemin[1024],ch[1024];
 
	  sprintf(ch,"/proc/%d/exe",getpid());
      if (readlink(ch,chemin,1023)<0)
        return NULL;
	  for(tmp=chemin;*tmp!=0;tmp++)
	  {
	    if (*tmp==SEPARATEUR) tmp1=tmp;
	  }
	  if (tmp1!=NULL) *tmp1=0;
 
 return g_strdup(chemin);
 
#else
 
 char ch[1024],* tmp,*tmp1=NULL;
 if (!( GetModuleFileName( NULL, ch, 1023) ))
    return NULL;
 else
 
 {
 
    for (tmp=ch;*tmp!=0;tmp++)
 
        if (*tmp==SEPARATEUR) tmp1=tmp;
 
    if (tmp1!=NULL) *tmp1=0;
 
    return g_strdup(ch);
 
 }
 
#endif
}

**plxpy** · 01/04/2011, 07h14

Je ne suis pas sur que tu utilises correctement readlink. Sur le man, j'ai :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
ssize_t readlink(const char *path, char *buf, size_t bufsiz);

DESCRIPTION
       readlink()  places  the  contents  of  the symbolic link path in the buffer buf,
       which has size bufsiz.  readlink() does not append a null byte to buf.  It  will
       truncate  the contents (to a length of bufsiz characters), in case the buffer is
       too small to hold all of the contents.

RETURN VALUE
       On success, readlink() returns the number of bytes placed in buf.  On error,  -1
       is returned and errno is set to indicate the error.

je n'ai pas essayé ton code mais la condition d'arrêt de la boucle for (*tmp!=0) me semble compromise et hasardeuse vu le man (je me trompe peut-être).

Sinon je n'aime pas trop l'approche qui consiste à aller farfouiller dans /proc :

1 - ca ne tournera pas, par exemple, sous MacOSX (a pas /proc !)

2 - on peut utiliser une méthode plus générale de suivi des liens symboliques qui fonctionne dans des cas plus généraux

Pour les curieux, voici ce que j'ai écrit (il y a surement un peu de peaufinage à faire, mais l'idée est là) :

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
//douviensje.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <string.h>
 
#ifndef PATH_MAX
#define PATH_MAX 1024
#endif
 
#define SEP     '/'
 
void split_path(char *pathname, char *dirname, char *basename)
{
    char *ptr = strrchr(pathname,SEP);
 
    if (ptr)
    {
        strncpy(dirname,pathname,ptr-pathname);
        dirname[ptr-pathname] = '\0';
        strcpy(basename,ptr+1);
    }
    else
    {
        strcpy(dirname,".");
        strcpy(basename,pathname);
    }
}
 
int follow_links(char *start, char *stop)
{
    struct stat struct_stat;
    char iwd[PATH_MAX];
    char dirname[PATH_MAX];
    char basename[PATH_MAX];
    size_t size;
    int code = 0;
 
    getcwd(iwd,PATH_MAX);   // pour pouvoir y revenir
    strcpy(stop,start);     // path courant au debut
    while (1)
    {
        // separation dirname - basename
        split_path(stop,dirname,basename);
 
        // deplacement dans dirname, lecture infos basename
        if (chdir(dirname) || lstat(basename,&struct_stat))
            { code = -1; break; }
 
        // sortie de la boucle infinie
        if (!S_ISLNK(struct_stat.st_mode))
            break;
 
        // lecture du lien symbolique
        size = readlink(basename,stop,PATH_MAX);
        stop[size] = '\0';
 
        // pour suivre le deroulement
        fprintf(stderr,"passage par %s\n",stop);
    }
 
    getcwd(dirname,PATH_MAX); // pour avoir le chemin absolu
    sprintf(stop,"%s%c%s",dirname,SEP,basename);
 
    chdir(iwd);     // retour a la case depart
    return code;
}
 
int main(int argc,char *argv[])
{
    FILE       *pipe;
    char        buffer[PATH_MAX];
    char        pathname[PATH_MAX];
 
    // lecture du chemin vers l'executable
    sprintf(buffer,"which %s",argv[0]);
    pipe = popen(buffer,"r");
    fgets(buffer,PATH_MAX,pipe);
    buffer[strlen(buffer)-1]='\0';
    pclose(pipe);
 
    if (follow_links(buffer,pathname))
        fprintf(stderr,"lien casse ?\n");
    else
        fprintf(stderr,"%s\n",pathname);
}

Je ne l'ai testé que sous Ubuntu, avec des contenus de liens en relatif et en absolu, et ça semble fonctionner :

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
plx@sony:~/Bureau$ 
plx@sony:~/Bureau$ gcc -o /tmp/douviensje douviensje.c 
plx@sony:~/Bureau$ 
plx@sony:~/Bureau$ ls -l lien3
lrwxrwxrwx 1 plx plx 15 2011-04-01 06:19 lien3 -> /home/plx/lien2
plx@sony:~/Bureau$ 
plx@sony:~/Bureau$ ls -l /home/plx/lien2
lrwxrwxrwx 1 plx plx 12 2011-04-01 06:19 /home/plx/lien2 -> Bureau/lien1
plx@sony:~/Bureau$ 
plx@sony:~/Bureau$ ls -l lien1
lrwxrwxrwx 1 plx plx 15 2011-04-01 06:19 lien1 -> /tmp/douviensje
plx@sony:~/Bureau$ 
plx@sony:~/Bureau$ ./lien3
passage par /home/plx/lien2
passage par Bureau/lien1
passage par /tmp/douviensje
/tmp/douviensje
plx@sony:~/Bureau$

Je le testerai aussi plus tard sous MacOSX et, si ça coince, j'y reviendrai.

C'est fait : sous Snow Leopard, pas de problème. Par contre, ça ne gère pas les "raccourcis" créés via le Finder (ce ne sont pas des liens symboliques)

**troumad** · 01/04/2011, 16h09

Je garde ça sous la main si j'ai besoin de réfléchir mac...

Sinon, je prévois assez de place pour le chemin ! Si le chemin est plus long que ce qui est prévu dans cette fonction, j'aurais des problèmes avant dans mon programme.

**plxpy** · 01/04/2011, 16h15

Sinon, je prévois assez de place pour le chemin ! Si le chemin est plus long que ce qui est prévu dans cette fonction, j'aurais des problèmes avant dans mon programme.

C'est supposé être en rapport avec ma remarque sur readlink ?

**plxpy** · 03/04/2011, 08h34

Ce n'est pas (qu') un problème de place !

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
#include <stdio.h>      // readlink.c
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
 
int main(int argc,char *argv[])
{
    char buffer[16],*ptr;
    size_t size;
    memset(buffer,'@',16);
    size = readlink(argv[1],buffer,16);
    printf("%s -> %s\n",argv[1],buffer);
    for (ptr=buffer;*ptr!=0;ptr++)
        printf("lu: '%c'%s",*ptr,ptr-buffer-size ? "\n" : " ... Ooops\n");
}

à l'exécution :

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
plx@sony:~$ ls -l lien
lrwxrwxrwx 1 plx plx 8 2011-04-03 08:20 lien -> ailleurs
plx@sony:~$ gcc -o readlink readlink.c
plx@sony:~$ ./readlink lien
lien -> ailleurs@@@@@@@@
lu: 'a'
lu: 'i'
lu: 'l'
lu: 'l'
lu: 'e'
lu: 'u'
lu: 'r'
lu: 's'
lu: '@' ... Ooops
lu: '@'
lu: '@'
lu: '@'
lu: '@'
lu: '@'
lu: '@'
lu: '@'
plx@sony:~$

**troumad** · 03/04/2011, 20h31

Encore un problème de compréhension de l'anglais

Si j'avais appris mes leçons d'anglais quand j'étais à l'école

J'avais cru comprendre que le 0 en fin de chaîne n'était pas mis en cas de débordement ! Donc, il va falloir que je remplisse la chaîne de 0 avant !

Trouver le répertoire de l'exécutable

C

Discussions similaires

Partager

Partager