export PATH=$PATH:/home/thanatos/sokoban

#define CHEMIN_MUSIQUE  "./sons/musique.mp3"

thanatos@thanatos-VirtualBox:~$ kurkkoban
The current working directory is /home/thanatos
Initisalisation du son : 0
Cannot load sound file sons/caisseok.wav :
 Error code :  23
thanatos@thanatos-VirtualBox:~$

Citation : Pouet_forever

Normalement, le chemin pris en compte lors de l'exécution de ton programme est le répertoire courant (celui où est lancé l'exécutable). Tu ne devrais rien avoir à faire, à moins de vouloir changer radicalement le dossier.

• tu regardes argv[0] ; si c'est un chemin absolu (test hyper-facile à effectuer, sous Linux, le 1er caractère est '/'), alors ce chemin absolu est le dossier de ton exécutable ;
• sinon, tu regardes si c'est un chemin relatif (sous Linux, commence par "./"), si c'est le cas, tu concatènes le chemin d'exécution et argv[0] (sans oublier un éventuel '/' entre les 2) ;
• sinon, c'est sans doute que ton exécutable a été appelé depuis le PATH. Il faut donc que tu fasses comme l'interpréteur de commande : tu parcours la variable PATH en ouvrant chacun des chemins qu'elle contient, jusqu'à trouver un fichier qui porte le nom de ton exécutable (argv[0]) dans un des dossiers. Ce dossier est donc le dossier où se trouve ton exécutable.
• J'ai oublié les alias : apparemment, l'interpréteur de commande remplace bien l'alias par son contenu (je viens de tester), donc pas de problèmes.

Citation : thanke

Mais ce qui m'étonne c'est que quand le tape une partie du nom du programme, l'auto complétion se fait mais quand je tape "wereis monprogramme", il ne trouve rien.
J'ai bien regardé $PATH et le chemin du dossier ou se trouve l'exécutable est bien là.
En fait, si quelqu'un peut me renseigner, quelle méthode "standard" doit-on appliquer pour installer un programme perso.
Par exemple dans windows, je déploie mes fichiers dans "program file"s et mon script d'installation me fait un lien sur le bureau et dans le menu démarrer.
C'est plutôt intuitif.
La j'essaie d'appliquer la même logique mais ça ne semble pas être la bonne.

• Sous Windows comme sous Linux (je pense), lorsque tu lances un programme depuis une interface graphique (un raccourci), argv[0] contient le chemin absolu de ton fichier exécutable (incluant le nom du fichier lui-même), et le dossier d'exécution est le dossier où il se trouve (ça j'en suis moins sûr, mais quand même). Tu n'as donc aucun problème dans ce cas-là.
   
• Lorsque tu lances le programmes depuis une console, c'est une autre histoire. En effet, le dossier d'exécution est celui dans lequel on se trouvait lorsqu'on a appelé le programme.
  
  Considérons une commande, par exemple : CHEMINPROG arg1 arg2 …. Dans ce cas, argv[0] (argv étant le 2è argument de main, de type char**) contient "CHEMINPROG", quoi que tu aies tapé (dans le cas d'un alias, celui-ci est remplacé par sa valeur par la console, tu n'as donc pas à t'en soucier). Or, tu peux avoir tapé :
  • le chemin absolu ;
  • le chemin relatif ;
  • le nom du fichier tout court ; dans ce cas l'interpréteur de commande va consulter la variable PATH (oui, c'est pareil sous Windows, elle existe aussi) jusqu'à trouver un fichier qui porte le bon nom dans les dossiers qu'elle contient.
    NB: Sous Windows, tu n'as pas moyen de différencier un chemin relatif sans dossiers intermédiaires d'un nom de fichier simple. C'est pourquoi l'interpréteur regarde d'abord dans le dossier courant si un fichier avec un tel nom existe, avant de chercher dans les chemins du PATH.
  
  

• Si c'est un chemin absolu (commence par "X:\\" sous Windows, "/" sous Linux), c'est bon, on l'a directement ;
   
• Si c'est un chemin relatif (pas de début particulier sous Windows, commence par "./" ou "../" sous Linux), tu dois le concaténer au chemin d'exécution obtenu avec getcwd ;
   
• Si c'est le nom du fichier tout court, tu regardes la variable PATH comme dit précédemment. Pour chaque chemin de dossier (noté CHEMIN) contenu dans PATH dans l'ordre, tu testes l'existence du fichier CHEMIN/FICHIER (ou FICHIER est le nom du fichier exécutable, contenu dans argv[0]) ; dès que tu trouves un fichier existant, tu arrêtes les recherches. Le chemin correspondant peut être relatif (mais sans commencer par "./" ou "../" cette fois), il faudra alors le traiter comme ci-dessus.
  Ce dernier cas n'est pas fiable à 100%, car on peut imaginer qu'un nouveau fichier portant le même nom que notre exécutable ait été créé dans un dossier contenu dans le PATH depuis le lancement du programme, mais étant donné que notre fonction ne serait destinée qu'à être appelée une seule fois au tout début du programme, ça ne devrait pas poser trop de problèmes (il faudrait vraiment ne pas avoir de chance). Remarque, ça ne constituerait pas une faille de sécurité exploitable ?
  Il y a une complication sous Windows, c'est que l'invite de commande accepte les extensions implicites. Par exemple, pour lancer test.exe, taper test suffit. Lors de la recherche du fichier, il faudra donc essayer sans rajouter d'extension, puis avec les différentes extensions implicites (contenues dans une autre variable d'environnement dont je ne me souviens plus du nom) ; ou, plus simple, étant donné que les programmes sous Windows portent l'extension .exe, il suffit de regarder si argv[0] se termine par ".exe", et le rajouter si ce n'est pas le cas, avant de faire les tests normalement.

system( "echo `printenv PATH` >> /home/thanatos/test.txt");

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <regex.h>

char* getAppPath (char* fullString)
{
   int res;
   regex_t objRegex;
   const char *str_request = fullString;
   const char *s_Patern = "(:+[/+[a-z]*]*+sokoban)";
   res = regcomp (&objRegex, s_Patern, REG_EXTENDED);
   if (res == 0)
   {
      int match;
      size_t nb_patern_found = 0;
      regmatch_t *pmatch = NULL;

      nb_patern_found = objRegex.re_nsub;
      pmatch = malloc (sizeof (*pmatch) * nb_patern_found);
      if (pmatch)
      {
         match = regexec (&objRegex, str_request, nb_patern_found, pmatch, 0);

         regfree (&objRegex);

         if (match == 0)
         {
            char *group = NULL;
            int start = pmatch[0].rm_so;
            int end = pmatch[0].rm_eo;
            size_t size = end - start;

            group = malloc (sizeof (*group) * (size + 1));
            if (group)
            {
               strncpy (group, &str_request[start], size);
               group[size] = '\0';
             return group;

            }
         }

         else if (match == REG_NOMATCH)
         {
            printf ("%s Pas de chaione correspondante trouvée\n", str_request);
         }

         else
         {
            char *text;
            size_t size;


            size = regerror (res, &objRegex, NULL, 0);
            text = malloc (sizeof (*text) * size);
            if (text)
            {

               regerror (res, &objRegex, text, size);
               fprintf (stderr, "%s\n", text);
               free (text);
            }

         }
      }

   }


   return (NULL);
}


int main ()


{
  printf("%s", getAppPath("/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/home/thanatos/sokoban"));
}

/*Je récupère le chemin avec 'getenv' et je lui passe un coup de regex : je récupère donc ":/home/thanatos/sokoban"*/
char* path = getAppPath(getenv("PATH"));
/*Je vire les ':'*/
path++;
/*Je modifie le répertoire d'exécution*/
   chdir(path);

Citation : Pouet_forever

getenv et chdir ne sont pas portables sous windows.

char * t = getcwd(NULL, 0);

Citation : man getcwd

Comme extension du standard POSIX.1, getcwd() alloue le buffer dynamiquement, en utilisant malloc(), si buf est NULL lors de l'appel. Alors, le buffer alloué a la longueur size à moins que size soit inférieure à zéro, dans ce cas buf a la taille nécessaire.

Citation : Maëlan

C'est bizarre, selon le man

Citation : man getcwd

As an extension to the POSIX.1-2001 standard, Linux (libc4, libc5, glibc) getcwd() allocates the buffer dynamically using malloc(3) if buf is NULL. In this case, the allocated buffer has the length size unless size is zero, when buf is allocated as big as necessary. The caller should free(3) the returned buffer.

Citation : Maëlan

PS: getcwd non plus n'est pas présente sous Windows (bien que j'ai du mal avec les différents standards et conformités ).

• Sous Linux, un chemin relatif peut commencer par "./", mais aussi par "../" !
• Toujours sous Linux, $PATH ne contient pas forcément un chemin absolu ! On peut spécifier un chemin relatif (et même sans le faire commencer par "./", ou "../").

Citation : gouttegd

@ Maëlan : À noter que pour un programme ciblant uniquement Windows, il y a aussi la fonction GetModuleFileName (doc), qui permet de faire plus directement ce que le PO semble vouloir faire. En lui passant NULL comme premier argument, elle remplit un tampon avec le chemin complet de l’exécutable courant — il n’y a plus qu’à chercher le dernier séparateur de répertoires ('/' ou '\') pour obtenir le dossier contenant ledit exécutable.

• sous Windows, difficulté supplémentaire de la méthode proposée (parcours de PATH), due aux extensions implicites ;
• général, fiabilité non garantie de la méthode « parcours de PATH », mise en défaut si un fichier du même nom que l'exécutable a été créé dans un dossier du PATH après le lancement (voire faille de sécurité exploitable ?).

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>



/* buffer global (restreint à ce fichier source) pour y stocker le chemin absolu
   d'installation du programme, et éventuellement un chemin relatif après*/
static struct {
	char buf[4096];
	size_t size;   /* taille du chemin d'installation lui-même (car le
	                  buffer peut contenir du contenu supplémentaire après) */
}  appDir=  {"", 0};
#define  SIZEOFBUF   (sizeof(appDir.buf)/sizeof(*appDir.buf))



/* vérifie l'existence du fichier dont le chemin a été passé en argument ;
   renvoie 1 si l'entité existe et est un fichier, 0 sinon. */
int fileExists(const char* path) {
	struct stat s;
	return !stat(path, &s)  &&  S_ISREG(s.st_mode);
}



/* écrit, dans le buffer global `appDir`, une chaîne au format */
static char* writePathInAppDir(const char* path, const char* stopP, const char* file, const char* stopF) {
	if(path==NULL || file==NULL)   return NULL;
	size_t size1= (stopP!=NULL)? (unsigned)(stopP-path) : strlen(path),
	       size2= (stopF!=NULL)? (unsigned)(stopF-file) : strlen(file);
	appDir.size= size1 + 1 + size2;   // +1 for '/'
	if(SIZEOFBUF <= appDir.size)   return NULL;
	/* on copie le contenu de `path` jusqu'à `stopP` exclus, puis '/',
	   puis le contenu de `file` jusqu'à `stopF` exclus */
	strncpy(appDir.buf, path, size1);
	appDir.buf[size1]= '/';
	strncpy(appDir.buf+size1+1, file, size2);
	appDir.buf[appDir.size]= '\0';
	return appDir.buf;
}



/* écrit le chemin d'installation d'après le chemin absolu passé en argument ;
   `stop` indique la fin (exclue) du chemin à lire. */
static char* writeAppDirFromAbs(const char* abs, const char* stop) {
	if(abs==NULL)   return NULL;
	/* on copie le contenu de `abs` jusqu'à `stop` exclus */
	appDir.size= (stop!=NULL)? (unsigned)(stop-abs) : strlen(abs);
	if(SIZEOFBUF <= appDir.size)   return NULL;
	strncpy(appDir.buf, abs, appDir.size);
	/* si le chemin ne se finit pas par '/' et que la taille du buffer nous
	   le permet, on l'ajoute */
	if(appDir.buf[appDir.size-1]!='/' && SIZEOFBUF > appDir.size+1)
		appDir.buf[appDir.size++]= '/';
	appDir.buf[appDir.size]= '\0';
	return appDir.buf;
}



/* écrit le chemin d'installation d'après le chemin relatif passé en argument ;
   `stop` indique la fin (exclue) du chemin à lire. */
static char* writeAppDirFromRel(const char* rel, const char* stop) {
	if(rel==NULL)   return NULL;
	size_t size1, size2;
	/* on écrit le chemin absolu 'exécution */
	if(getcwd(appDir.buf, SIZEOFBUF) == NULL)
		return NULL;
	size1= strlen(appDir.buf);
	size2= (stop!=NULL)? (unsigned)(stop-rel) : strlen(rel);
	appDir.size= size1 + 1 + size2;   // +1 for '/'
	if(SIZEOFBUF <= appDir.size)   return NULL;
	/* on ajoute '/' */
	appDir.buf[size1]= '/';
	/* on copie le contenu de `rel` jusqu'à `stop` exclus */
	strncpy(appDir.buf+size1+1, rel, size2);
	/* si le chemin ne se finit pas par '/' et que la taille du buffer nous
	   le permet, on l'ajoute */
	if(appDir.buf[appDir.size-1]!='/' && SIZEOFBUF > appDir.size+1)
		appDir.buf[appDir.size++]= '/';
	appDir.buf[appDir.size]= '\0';
	return appDir.buf;
}



/* retourne le chemin d'exécution du programme, en fonction de `argv` ; celui-ci
   doit correspondre à `argv[0]`, où `argv` est le 2è argument de `main` (de
   type `char**`) ; retourne NULL en cas d'échec ; le buffer retourné n'est pas
   à libérer. */
const char* getAppDir(const char* argv) {
	if(argv==NULL)   return NULL;
	/* si on a déjà écrit avec succès le chemin d'installation */
	if(*appDir.buf!='\0') {
		appDir.buf[appDir.size]= '\0';   // on réajuste la fin de la chaîne (la fonction `getAbsoluteResourcePath` peut l'agrandir)
		return appDir.buf;
	}
	
	const char* p;
	
	p= strrchr(argv, '/');
	
	/* nom du fichier */
	if(p==NULL) {   // pas de '/'
		p= getenv("PATH");
		if(p==NULL)   return NULL;
		
		const char* q;
		do {   /* pour chaque chemin contenu dans $PATH … */
			q= strchr(p, ':');
			/* … on écrit "chemin/argv" dans `appDir.buf` … */
			if(writePathInAppDir(p, q, argv, NULL) == NULL)
				return NULL;
			/* … pour pouvoir tester l'existence du fichier */
			if(fileExists(appDir.buf))   q= NULL;   // si le fichier est trouvé, on sort de la boucle
			else {
				*appDir.buf= '\0';   // indique qu'on a pas trouvé
				p= q+1;   // on passe au chemin suivant
			}
		} while(q!=NULL);
		
		if(*appDir.buf=='\0')   return NULL;   // si on n'a pas trouvé
		if(*appDir.buf=='/') {   // si le chemin trouvé est absolu
			/* on garde ce qui est déjà écrit dans `appDir`, en
			  tronquant juste le nom du fichier */
			strrchr(appDir.buf, '/')[1]= '\0';
			appDir.size= (q!=NULL)? (unsigned)(q-p): strlen(appDir.buf);
		} else   // si le chemin trouvé est relatif
			if(writeAppDirFromRel(p, q) == NULL)
				{*appDir.buf='\0'; return NULL;}
	}
	
	/* chemin absolu */
	else if(*argv=='/') {   // commence par "/"
		if(writeAppDirFromAbs(argv, p) == NULL)
			return NULL;
	}
	
	/* chemin relatif */
	else /*if(argv[0]=='.' && (argv[1]=='/' || argv[1]=='.' && argv[2]=='/'))*/ {   // commence par "./" ou "../"
		if(writeAppDirFromRel(argv, p) == NULL)
			{*appDir.buf='\0'; return NULL;}
	}
	
	/* invalide (contient au moins un '/' mais n'est ni absolu ni relatif) */
	//else   return NULL;
	
	
	return appDir.buf;
}



/* retourne le chemin absolu du fichier ou dossier dont le chemin, relatif au
   dossier d'installation, est passé en argument ; le buffer retourné n'est pas
   à libérer (écrit directement dans le buffer global `appDir`) */
const char* getAbsoluteResourcePath(const char* path) {
	if(path==NULL)   return NULL;
	if(*path=='/')   return path;   // si le chemin est déjà absolu
	if(SIZEOFBUF <= appDir.size+strlen(path))   return NULL;
	strcpy(appDir.buf+appDir.size, path);
	return appDir.buf;
}

Citation : Taurre

Il me semble juste qu'il y a une erreur dans la fonction writeAppDirFromAbs. En effet, tu vérifies si le chemin est terminé par un '/' et si ce n'est pas le cas, tu ajoutes ce caractère s'il y a encore de la place. Le problème c'est qu'après tu ajoutes le '\0' final, or il se pourrait très bien que le chemin fasse tout juste la taille du tampon avec le '/' et que tu écrives donc le '\0' une case au delà du tableau.

Citation : Taurre

Sinon, la conversion en unsigned n'est pas nécessaire lorsque tu effectues la différence entre le pointeur vers le début et celui vers la fin du chemin car la conversion en size_t aura lieu de part l'affectation

Citation : Maëlan

À ce titre, je me demandais si 4096 chars suffisaient, si ce n'est pas assez, beaucoup trop …? Dans la grande majorité des cas, ça suffira plus que largement, mais quels sont les cas extrêmes sous Linux ?

Citation : Maëlan

• Sous Linux, un chemin relatif peut commencer par "./", mais aussi par "../" !

• tout chemin qui commence par / est absolu (/bin/ls, /usr/bin/emacs)
• tout chemin qui ne contient pas de / est un fichier dans $PATH
• les autres chemins sont relatifs (./a.out, foo/bar)

Citation : Maëlan

En plus, elle est déclarée dans <stdlib.h>.

Citation : Maëlan

@ Marc Mongenet : C'est exact, mais si on veut appeler foo/bar depuis le shell, il faudra taper ./foo/bar et non foo/bar.

Citation : Marc Mongenet

Citation : Maëlan

@ Marc Mongenet : C'est exact, mais si on veut appeler foo/bar depuis le shell, il faudra taper ./foo/bar et non foo/bar.

Tu as un shell bizarre.
Pour exécuter foo/bar je tape foo/bar. Et . n'est évidemment pas dans mon PATH.