Newsgroup: it.comp.programmare.win32
Titolo: come visitare il file system di windows

ciao a tutti.
qualcuno sa come visitare il file system di windows?
Io sto provando a usare le funzioni FindFirstFile e FindNextFile con
visual studio ma non ne riesco a venire a capo.
ciao grazie.

 visual studio ma non ne riesco a venire a capo.
Esamina prima l'esempio MSDN, poi magari discutiamo nel dettaglio di 
cosa non ti quadra.
http://snipurl.com/9hsi

...

Ciao Vincent,
  l'esempio che hai indicato permette di stampare tutti
  i nomi dei file presenti in una directory. Il problema
  di Carmelo e' che lui vuole visitare un filesytem nella
  sua profondita', a partire da un una directory in giu'.
 ciao,
  Enrico

 wrote in message
news:ba429128.04100...@posting.google.com

Questo l'ho scritto un po' di tempo fa. Non e' detto che sia il modo
migliore per visitare il file system (e riguardandolo, non mi sembra
nemmeno il modo migliore di scrivere codice, ma all'epoca e' stato
fatto per sperimentare funzioni che non conoscevo), ma funziona (o
almeno cosi' sembra). :-)
HTH
<CODE>
#include <stdio.h>
#include <windows.h>
#include <iostream.h>
#ifndef DOT_DIR
#define DOT_DIR 1
#endif
 
int nFiles = 0;
DWORD printFileInfo(WIN32_FIND_DATA*);
DWORD scanSubDir(char*);
void  printErrorMessage(void);
void printErrorMessage(void)
{
   LPVOID lpMsgBufP = NULL;
   FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
                 NULL,
                 GetLastError(),
                 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default
language
                 (LPTSTR) &lpMsgBufP,
                 0,
                 NULL 
                );
   cout << (LPTSTR)lpMsgBufP << endl;
   if(NULL != LocalFree(lpMsgBufP))
   {
      cout << "Memory problem. Program end" << endl;
      exit(1);
   }
}
DWORD printFileInfo
(
   WIN32_FIND_DATA* pFileInfoP
)
{
   unsigned int idx    = 0;
   unsigned int jdx    = 0;
   int          oddCyphers = 0;
   int          displacement = 0;
   unsigned int nSep   = 0;
   unsigned int strLen = 0;
   __int64 fileSize    = 0;
   char    dirName[2*MAX_PATH] = "";
   char    fileDimStr[20] = "";
   char    wrFileDimStr[40] = "";
   char    day[8] = "";
   char    hour[8] = "";
   char    month[8] = "";
   char    minute[8] = "";
   char    seconds[8] = "";
   char    milliseconds[8] = "";
   BOOL    bfRes     = TRUE;
   LPTSTR  lpMsgBufP = NULL;
   SYSTEMTIME cTimeInfo; // File creation info
   SYSTEMTIME aTimeInfo; // File last access info
   SYSTEMTIME wTimeInfo; // File last modification info
   if(NULL == pFileInfoP)
      return DOT_DIR;
// Non vengono considerati i file "." e ".."
// -----------------------------------------   
   if(0 != strcmp(".", pFileInfoP->cFileName))
   {
      if(0 == strcmp("..", pFileInfoP->cFileName))
         return DOT_DIR;
   }
   else
      return DOT_DIR;
 
   memset(&cTimeInfo, 0, sizeof(cTimeInfo));
   memset(&aTimeInfo, 0, sizeof(aTimeInfo));
   memset(&wTimeInfo, 0, sizeof(wTimeInfo));
   GetCurrentDirectory(sizeof(dirName), dirName);
   bfRes = FileTimeToSystemTime(&(pFileInfoP->ftCreationTime),
&cTimeInfo);
   if(bfRes)
   {
      bfRes = FileTimeToSystemTime(&(pFileInfoP->ftLastAccessTime),
&aTimeInfo);
      if(bfRes)
      {
         bfRes = FileTimeToSystemTime(&(pFileInfoP->ftLastWriteTime),
&wTimeInfo);
      }
   }
   if(FALSE == bfRes)
      printErrorMessage();
// Attributi del file
// ------------------
   cout << (FILE_ATTRIBUTE_DIRECTORY == (pFileInfoP->dwFileAttributes &
FILE_ATTRIBUTE_DIRECTORY) ? "D" : "F") << " ";
   cout << (FILE_ATTRIBUTE_ARCHIVE == (pFileInfoP->dwFileAttributes &
FILE_ATTRIBUTE_ARCHIVE) ? "A" : " ") << " ";
   cout << (FILE_ATTRIBUTE_COMPRESSED == (pFileInfoP->dwFileAttributes &
FILE_ATTRIBUTE_COMPRESSED) ? "C" : " ") << " ";
   cout << (FILE_ATTRIBUTE_HIDDEN == (pFileInfoP->dwFileAttributes &
FILE_ATTRIBUTE_HIDDEN) ? "H" : " ") << " ";
   cout << (FILE_ATTRIBUTE_NORMAL == (pFileInfoP->dwFileAttributes &
FILE_ATTRIBUTE_OFFLINE) ? "O" : " ") << " ";
   cout << (FILE_ATTRIBUTE_OFFLINE == (pFileInfoP->dwFileAttributes &
FILE_ATTRIBUTE_ARCHIVE) ? "A" : " ") << " ";
   cout << (FILE_ATTRIBUTE_READONLY == (pFileInfoP->dwFileAttributes &
FILE_ATTRIBUTE_READONLY) ? "R" : " ") << " ";
   cout << (FILE_ATTRIBUTE_SYSTEM == (pFileInfoP->dwFileAttributes &
FILE_ATTRIBUTE_SYSTEM) ? "S" : " ") << " ";
   cout << (FILE_ATTRIBUTE_TEMPORARY == (pFileInfoP->dwFileAttributes &
FILE_ATTRIBUTE_TEMPORARY) ? "T" : " ") << " ";
// Date di creazione, ultimo accesso e ultima modifica.
// ----------------------------------------------------
   sprintf(month, "%02d",cTimeInfo.wMonth);
   sprintf(day, "%02d",cTimeInfo.wDay);
   sprintf(hour, "%02d",cTimeInfo.wHour);
   sprintf(minute, "%02d",cTimeInfo.wMinute);
   sprintf(seconds, "%02d",cTimeInfo.wSecond);
   sprintf(milliseconds, "%03d",cTimeInfo.wMilliseconds);
   cout << cTimeInfo.wYear << "/" << month << "/" << day << " " <<
hour<< ":" << minute << ":" << seconds << "." << milliseconds << " ";
   sprintf(month, "%02d", aTimeInfo.wMonth);
   sprintf(day, "%02d", aTimeInfo.wDay);
   sprintf(hour, "%02d", aTimeInfo.wHour);
   sprintf(minute, "%02d", aTimeInfo.wMinute);
   sprintf(seconds, "%02d", aTimeInfo.wSecond);
   sprintf(milliseconds, "%03d",aTimeInfo.wMilliseconds);
   cout << aTimeInfo.wYear << "/" << month << "/" << day << " " <<
hour<< ":" << minute << ":" << seconds << "." << milliseconds << " ";
   sprintf(month, "%02d", wTimeInfo.wMonth);
   sprintf(day, "%02d", wTimeInfo.wDay);
   sprintf(hour, "%02d", wTimeInfo.wHour);
   sprintf(minute, "%02d", wTimeInfo.wMinute);
   sprintf(seconds, "%02d", wTimeInfo.wSecond);
   sprintf(milliseconds, "%03d", wTimeInfo.wMilliseconds);
   cout << wTimeInfo.wYear << "/" << month << "/" << day << " " <<
hour<< ":" << minute << ":" << seconds << "." << milliseconds << " ";
// Nome del file
// -------------
   cout << dirName;
   if(0 != strcmp(&dirName[strlen(dirName) -1], "\\"))
      cout << "\\";
 
   cout << pFileInfoP->cFileName;
 
   if(FILE_ATTRIBUTE_DIRECTORY == (pFileInfoP->dwFileAttributes &
FILE_ATTRIBUTE_DIRECTORY))
      cout << "\\";
// Dimensione del file
// -------------------
   ((__int32*)(&fileSize))[0] = pFileInfoP->nFileSizeLow;
   ((__int32*)(&fileSize))[1] = pFileInfoP->nFileSizeHigh;
   if(FILE_ATTRIBUTE_DIRECTORY != (pFileInfoP->dwFileAttributes &
FILE_ATTRIBUTE_DIRECTORY))
   {
      // fileSize = pFileInfoP->nFileSizeLow;
      _i64toa(fileSize, fileDimStr, 10);
      strLen = strlen(fileDimStr);
      nSep = (int)(strLen/3);
      oddCyphers = strLen%3;
      if(0 < oddCyphers)
      {
         strncpy(wrFileDimStr, fileDimStr, oddCyphers);
         wrFileDimStr[oddCyphers] = '\'';
         displacement = oddCyphers +1;
      }
      for(idx = 0; idx < nSep; idx++)
      {
         strncpy(wrFileDimStr + displacement, fileDimStr + oddCyphers
+idx*3,3);
         displacement += 3;
         wrFileDimStr[displacement] = '\'';
         displacement++;
      }
      wrFileDimStr[displacement -1] = '\0';
      cout << " " << wrFileDimStr;
   }      
   cout << endl;
   nFiles++;
   return 0;
}
DWORD scanSubDir(char* pSubDirP)
{
   HANDLE  retHnd      = 0;
   BOOL    bfRes       = TRUE;
   DWORD   lastErr     = 0;
   LPVOID  lpMsgBufP   = NULL;
   char            curDir[MAX_PATH] = "";
   char            scanDir[MAX_PATH] = "";
   WIN32_FIND_DATA retData;
   if(NULL != pSubDirP)
   {
   // Memorizza la directory correntemente in
   // scansione prima che venga cambiata. Questo
   // consente di riprendere la scansione della
   // directory corrente
   // -------------------------------------------
      GetCurrentDirectory(sizeof(curDir), curDir);
   // Questo codice funziona perche' curDir e' stata
   // completamente azzerata.
   // ----------------------------------------------
      strcat(scanDir, curDir);
      if(0 != strcmp(&curDir[strlen(curDir) -1], "\\"))
      {
         strcat(curDir, "\\");
         strcat(scanDir, "\\");
      }
      strcat(scanDir, pSubDirP);
      strcat(scanDir, "\\");
      bfRes = SetCurrentDirectory(scanDir);
      if(FALSE != bfRes)
      {
         strcat(scanDir, "*");
      // Avvio della ricerca e strampa delle informazioni del file.
      // ----------------------------------------------------------
         retHnd = FindFirstFile(scanDir, &retData);      
         while(INVALID_HANDLE_VALUE != retHnd && lastErr !=
ERROR_NO_MORE_FILES)
         {
         // Verifica di quanto letto da FindFirstFile().
         // --------------------------------------------
            switch(retData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            {
               case FILE_ATTRIBUTE_DIRECTORY : lastErr =
printFileInfo(&retData);
                                               if(0 == lastErr)
scanSubDir(retData.cFileName);
                                               break;
               default : printFileInfo(&retData);
                         break;
            }
            bfRes = FindNextFile(retHnd, &retData);
            if(FALSE == bfRes)
            {
               lastErr = GetLastError();
               if(ERROR_NO_MORE_FILES != lastErr)
                  printErrorMessage();
            }
         }
      }
      else
      {
         lastErr = GetLastError();
         if(ERROR_NO_MORE_FILES != lastErr)
            printErrorMessage();
      }
      SetCurrentDirectory(curDir);
   }
   return 0;
}
int main(int argc, char* argv[])
{
   BOOL             bfRet       = TRUE;
   DWORD            retVal      = 0;
   DWORD            lastErr     = 0;
   DWORD            nCharRet    = 0;
   DWORD            lastErrCode = 0;
   LPVOID           lpMsgBufP   = NULL;
   LPCTSTR          startDirP   = NULL;
   char             buff[_MAX_PATH +5] = {'\0'};
   HANDLE           retHnd;
   WIN32_FIND_DATA  retData;   
   memset(&retHnd,0, sizeof(retHnd));
   memset(&retData, 0, sizeof(retData));
// Nel caso in cui l'utente non immetta nessun argomento, la
// ricerca parte dalla directory corrente, in caso contrario
// la ricerca parte dalla directory specificata dall'utente.
// Se quanto specificato dall'utente non e' una directory ma
// un file, al percorso completo del fie viene tolto il nome
// del file e la scansione viene fatta a partire dalla base
// dir del file.
// ---------------------------------------------------------
   if(2 > argc)
   {
      nCharRet = GetCurrentDirectory(sizeof(buff), buff);
      if(0 == nCharRet)
         printErrorMessage();
   }
   else
      strcpy(buff, argv[1]);
   startDirP = buff;
// Se viene eseguito questo codice sicuramente in buff e' contenuta
// una directory. Se il carattere finale e' '\\' allora e' una directory
// radice, in questo caso in coda alla stringa deve essere aggiunto il
// carattere '*' altrimenti la FindFirstFile() non recupera un cazzo:
// MS sempre un passo avanti!.
// ---------------------------------------------------------------------
   if(0 != strcmp(&buff[strlen(buff) -1], "\\"))
      strcat(buff, "\\");
   SetCurrentDirectory(buff);
   strcat(buff, "*");
// Avvio della ricerca e strampa delle informazioni del file.
// ----------------------------------------------------------
   retHnd = FindFirstFile(startDirP, &retData);
   while(INVALID_HANDLE_VALUE != retHnd && lastErr !=
ERROR_NO_MORE_FILES)
   {
   // Verifica di quanto letto da FindFirstFile().
   // --------------------------------------------
      switch(retData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
      {
         case FILE_ATTRIBUTE_DIRECTORY : lastErr =
printFileInfo(&retData);
                                         if(DOT_DIR != lastErr)
scanSubDir(retData.cFileName);
                                         break;
         default : printFileInfo(&retData);
                   break;
      }
      bfRet = FindNextFile(retHnd, &retData);
      if(FALSE == bfRet)
      {
         lastErr = GetLastError();
         if(ERROR_NO_MORE_FILES == lastErr)
            FindClose(retHnd);
         else
            printErrorMessage();
      }
   }
   cout <<"\n\n\n" << "File trovati " << nFiles << endl;
   cerr << "\n" << "File trovati " << nFiles << endl;
	return 0;
}
</CODE>
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG