Informations sur les lecteurs.

Informations sur les lecteurs.

GetVolumeInformation

Voir version :

Pas de dépendances

Télécharger :

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <string.h>

void type(LPCTSTR lecteur)
{
    char* Stype[7] = {"inconnu","invalide","amovible","fixe","reseau","cdrom","ramdisk"};
    int type = GetDriveType(lecteur);
    printf(" type = %s\n",Stype[type]);
}

BOOL informations(LPCTSTR lecteur)
{
    TCHAR nom[500];
    TCHAR filesystemname[500];
    DWORD serialnum;
    DWORD MaximumComponentLength;
    DWORD flags;
    BOOL ret = GetVolumeInformation(lecteur,nom,500,&serialnum,&MaximumComponentLength,&flags,filesystemname,500);
    if (ret)
    {
        _tprintf(_T(" nom : %s\t serial : %X maxcomp : %d\n flags : %X systname : %s\n"),nom,serialnum,MaximumComponentLength,flags,filesystemname);
        return TRUE;
    }
    else
    {    
        printf(" infos indisponibles\n");
        return FALSE;
    }
}

void freespace(LPCTSTR lecteur)
{
    DWORD sectors,octetsparsect,numfreeclusts,totalclust;
    GetDiskFreeSpace(lecteur,&sectors,&octetsparsect,&numfreeclusts,&totalclust);
    printf(" secteurs : %u\t oct/sect : %u\t clustlibres :%u\t totalclust :%u\n",sectors,octetsparsect,numfreeclusts,totalclust);
    printf(" octets total : %u \t libres : %u\t -> %.1f%%\n",sectors*octetsparsect*totalclust,sectors*octetsparsect*numfreeclusts,numfreeclusts*100.0/totalclust);
}

void Analyse(LPCTSTR lecteur)
{
    int res;
    type(lecteur);
    res = informations(lecteur);
    if (res == 0)
    {
        printf("\n");
        return;
    }
    freespace(lecteur);
    printf("\n");
}

void InterpreterChaine(LPCTSTR buf)
{
    int curs = 0;
    printf("Interpretation buffer (GetLogicalDriveStrings)\n");
    while(buf[curs]!='\0')
    {
        int len = _tcslen(buf);  // strlen, ou wcslen selon UNICODE actif ou non.
        printf("Lecteur %s present : \n",buf+curs);
        Analyse(buf+curs);
        curs+=len+1;
    }
}

int main()
{
    TCHAR buf[5000];
    GetLogicalDriveStrings(5000,buf);
    InterpreterChaine(buf);
    return 0;
}



Commentaires


Voici la suite du programme précédent, qui va plus loin dans l'analyse des différents lecteurs que vous possédez sur votre machine.

Tout d'abord, si on regarde le main, on constate que j'utiliser GetLogicalDriveStrings, puis ma fonction InterpreterChaine comme l'exemple précédent.

Je rentre, après séparation des sous chaines, dans une fonction que j'appelle Analyse.

Concrètement, je rentre dans cette fonction avec "C:\"   "D:\" ... et tous les lecteurs que vous possédez.
Je vais faire une analyse de chacun de ces lecteurs.

Regardons ma fonction Analyse.
En premier lieu, j'appelle une autre fonction que j'ai faite pour l'occasion : type. 
Dans cette fonction, j'appelle la fonction Windows  GetDriveType.

GetDriveType
************

doc : http://msdn.microsoft.com/en-us/library/aa364939(VS.85).aspx
Cette fonction va nous donner le type du lecteur :

Elle renvoie concretement un nombre entre 0 et 6. J'ai fait un petit tableau pour pouvoir afficher le type plutot que le nombre directement : 
c'est plus explicite.


Vous pouvez voir dans la doc dont le lien est ci dessus qu'il y a plusieurs types :
On détectera les types invalides, inconnus, fixes (disques durs par exemple), amovibles (disquettes, lecteur de carte), réseau, CD-ROM, et RAMDISK.


La fonction information invoque la fonction GetVolumeInformation :

GetVolumeInformation
********************

La doc : http://msdn.microsoft.com/en-us/library/aa364993(VS.85).aspx

Cette fonction va aller chercher des infos intéressantes sur le volume inséré.
Il est a noter que cette fonction renverra false si le lecteur est vide (CD ROM, Lecteur de cartes, de disquettes)
Sinon, elle renverra les infos suivantes :

- le nom du volume.
- le format de fichier (FAT, NTFS...)
- taille maximale d'un nom de fichier (habituellement 255 caracteres max)
- et des flags.
Alors je n'ai pas illustrer les flags par des printf, je l'ai juste affiché en hexa, il convient donc de regarder la doc, 
pour voir ce qu'il peut y avoir comme informations. On peut ensuite le comparer aux DEFINE spécifiés dans la doc pour voir si le flag est actif ou non.

Par exemple :

if (flags&FILE_READ_ONLY_VOLUME)  

passera dans le if si le lecteur est en lecture seule (un CDROM par exemple)

Nous saurons, grace aux flags, si le volume est compressé, en lecture seule, en unicode, et d'autres options que je ne maitrise pas encore bien.
Mais gardons ça en tete pour le jour ou on en aura besoin.



La fonction freespace va appeler la fonction Windows GetDiskFreeSpace


GetDiskFreeSpace
****************

doc : http://msdn.microsoft.com/en-us/library/aa364935(VS.85).aspx

Cette fonction va nous dire combien d'espace il reste sur le disque.
Notez qu'il ne faut pas appeler cette fonction si il n'y a pas de cartes/disquettes dans un lecteur amovible.
Concretement, si GetVolumeInformation renvoie FALSE, il ne faut pas l'appeler.

Un disque est divisé en clusters, eux memes divisés en secteurs, eux meme divisés en octets.

La fonction nous dit 
- combien le disque a d'octets par secteurs, 
- combien le disque a de secteurs par clusteurs
- combien il y a de clusters au total
- combien il y a de clusters libres

De simples multiplications permettent de calculer le nombre d'octets total sur le disque, le nombre libre, comme je le fais dans ma fonction freespace


Laissez un commentaire / post a comment