Rechercher un fichier en C (UNIX)

Bonjour,

Je cherche une fonction qui prend en entrée un chemin, un nom de fichier, et qui me retourne le chemin complet du fichier.
Et le tout sous UNIX...

Ex:  J'ai le répertoire /DEV/DATA/trflog qui contient 31 répertoires. Chacun de ces répertoires contient 24 répertoires, qui contiennent des fichiers de LOG tournants.
Mon programme doit chercher le fichier "logXXX.txt" dans  /DEV/DATA/trflog.

Merci de votre aide.

Si par unix tu entends linux, scandir pour lister les fichiers d'un répertoire.
Sinon, peut-être cette fonction existe t-elle sous unix
Sinon, je sais pas.

C++ (@++)

Je travail sur un deamon de log sur une plateforme SUN, sous UNIX.
Je cherche une fonction qui à partir d'un répertoire et d'un nom de fichier puisse me retourner le chemin du fichier en entrée...

J'ai commencé cette fonction:

void findFile(const char * fileName, const char * Path, char * fullName)
{
   char ssdossier[PATHNAME_LEN];
   struct dirent *lecture;
   DIR *rep;
   rep = opendir(Path);
  
   while ((lecture = readdir(rep)))
   {
         if(!strcmp(lecture->d_name,".") || !strcmp(lecture->d_name,"..")) continue;
         sprintf(ssdossier,"%s/%s",Path,lecture->d_name);
        
         if (opendir(ssdossier) != NULL)
            findFile(fileName, ssdossier, fullName);
           
         if (!strcmp(fileName, lecture->d_name))
         {
            flog("SED0052I", "\n\n FICHIER TROUVE !!!!!!: %s\n\n",ssdossier);
            sprintf(fullName, "%s/%s", Path, lecture->d_name); 
            break;         
         }
   }  
   closedir(rep);
}

fileName = le nom du fichier que je cherche.
Path = le répertoire à partir duquel je fais la recherche
fullName = contiendra le chemin complet du fichier.

Pour l'instant cette fonction se vautre au bout du 238 répertoire lu...
Avec en message d'erreur "cannot open!".
 

Je travail sur un deamon de log sur une plateforme SUN, sous UNIX.
Je cherche une fonction qui à partir d'un répertoire et d'un nom de fichier puisse me retourner le chemin du fichier en entrée...

Y'a t-il un champ d_type dans lecture ?
Si oui, tu devrais être capable de tester ce champ plutôt que d'essayer d'ouvrir un répertoire avec un opendir.

Essais en remplaçant ceci:

if (opendir(ssdossier) != NULL)
            findFile(fileName, ssdossier, fullName);

par ceci:

if (lecture->d_type == DT_DIR)
            findFile(fileName, ssdossier, fullName);

C++ (@++)

Merci, mais malheureusement pas de d_type dans ma structure dirent ...
J'ai allégé la fonction pour ne lister que les répertoires recursivement, mais j'ai tjs le même plantage:

void ListeRepRec(char Path[PATHNAME_LEN])
{
   char ssdossier[PATHNAME_LEN];
   struct dirent *lecture;
   DIR *rep;
   rep = opendir(Path);
  
   while ((lecture = readdir(rep)))
   {
         if(!strcmp(lecture->d_name,".") || !strcmp(lecture->d_name,"..")) continue;
  
         sprintf(ssdossier,"%s/%s", Path, lecture->d_name);
        
         if (opendir(ssdossier) != NULL)
         {
              ListeRepRec(ssdossier);
              flog("SED0052I", "\n\n LISTE DOSSIER: %s\n\n",ssdossier);
         }
   }
   closedir(rep);
}

Je ne sais plus quoi faire
Je ne comprend pas pourquoi il plante sur le 238e répertoire...

Yala !
J'approche du but...

Nouvelle fonction listant intégralement le contenu de mon répertoire et de ses sous-répertoires !
A base de liste chaînée:

void ListeRep(char Path[PATHNAME_LEN])
{
     char ssPath[PATHNAME_LEN];
     DIR * rep;
     struct dirent *entree_repertoire;
     struct ListeFichier
     {
            char nomFichier[64];
            struct ListeFichier * suivant;
     } depart, *noeud, *noeud_precedent, *nouveau_noeud;
    
     if ((rep = opendir(Path)) == NULL)
     {
            flog("SED0052E", "\n\n ERREUR ouverture: %s\n\n", Path);
     }
     else
     {
            depart.suivant = NULL;
            while (entree_repertoire = readdir(rep))
            {
                  noeud_precedent = &depart;
                  noeud = depart.suivant;
                 
                  while ((noeud) && (strcmp(entree_repertoire->d_name, noeud->nomFichier) > 0))
                  {
                        noeud = noeud->suivant;
                        noeud_precedent = noeud_precedent->suivant;
                  }
                 
                  nouveau_noeud = (struct ListeFichier *) malloc(sizeof(struct ListeFichier));
                 
                  if (nouveau_noeud == NULL)
                  {
                        flog("SED0052E", "\n\n MEMOIRE INSUFFISANTE !!");
                        exit(1);
                  }
                 
                  nouveau_noeud->suivant = noeud;     
                  noeud_precedent->suivant = nouveau_noeud;
                  strcpy(nouveau_noeud->nomFichier, entree_repertoire->d_name);
            }
           
            closedir(rep);
            noeud = depart.suivant;
            while (noeud)
            {
                 flog("SED0052E", "\n\n NOEUD->NomFichier: %s\n\n", noeud->nomFichier);
                 if(!strcmp(noeud->nomFichier, ".") || !strcmp(noeud->nomFichier, ".."))
                 {
                    flog("SED0052E", "\n\n . ou ..\n\n");                            
                 }
                 else
                 {
                    sprintf(ssPath, "%s/%s", Path, noeud->nomFichier);
                    flog("SED0052E", "\n\n RECURSIVE POUR: %s\n\n", ssPath); 
                    ListeRep(ssPath);
                 }
                 noeud = noeud->suivant;
            }
     }
}

Quand pensez-vous ? Ce n'est pas trop gourmand ou risqué ?
Pour l'instant ça ne ma pas sauté en pleine face...
Je vais tenter d'intégrer une condition pour sortir une fois le nom du fichier trouvé !