Gestion des dossiers et des fichiers en C avec la GLib

Date de publication : Non définie

Par Julian Ibarz (home)
 

I. Exploration d'un dossier

			GDir* g_dir_open(const gchar *path, guint flags, GError **error);

• path est la chaîne représentant le chemin. Par exemple sous windows : "c:\\windows".
• flags n'est pour l'instant pas utilisé par la GLib. Celle-ci préconise de le mettre à 0.
• error vous permet de récupérer les erreurs de runtime.

void g_dir_close (GDir* dir);

		
G_CONST_RETURN gchar* g_dir_read_name(GDir* dir);

GDir* monDossier=g_dir_open("c:\\moi\\cours", 0, NULL);
G_CONST_RETURN gchar* file=g_dir_read_name(monDossier);

Notez que "." et ".." qui représentent respectivement le dossier actuel et le dossier parent sont supprimés par la GLib.

L'ordre dans lequel les fichiers sont listés dépend du système.

GDir* monDossier=g_dir_open("c:\\moi\\cours", 0, NULL);
G_CONST_RETURN gchar* file g_dir_read_name(monDossier);

// Affiche tous les fichiers et dossiers contenus dans monDossier sur la sortie standard
while(file != NULL)
{
	printf("%s\n",file);
	file = g_dir_read_name(monDossier);
}

g_dir_rewind(monDossier);

void g_dir_rewind(GDir *dir);

gboolean            g_file_test                         (const gchar *filename,
                                                         GFileTest test);

• filename l'adresse absolue ou relative (par rapport au dossier courant) du fichier à tester.
• test le test à effectuer.

gchar* g_get_current_dir(void);

Ne pas oublier de désallouer la chaîne renvoyée. De manière générale (sauf exception contraire), tout return de type gchar* doit être désalloué avec g_free. Par contre les return de type G_CONST_RETURN ne doivent surtout pas être désalloués.

g_file_test("cours\\fichier.txt",G_FILE_TEST_IS_DIR); // Chemin relatif
g_file_test("c:\\moi\\cours\\fichier.txt",G_FILE_TEST_IS_DIR); // Chemin absolu

II. Gestion de la portabilité

Notez bien la notation standard que j'utilise : un caractère (de type C char) est entouré de '' tandis qu'une chaîne (de type C char*) est entourée de "" ; ce qui n'est vraiment pas pareil. Si vous ne comprenez pas la nuance, je vous suggère de revoir votre cours préféré de C ou d'aller voir l'article sur les chaînes de caractère.

gchar* g_build_filename(const gchar* first_element,...);

gchar* file=g_build_filename("c:","temp","bou.txt",NULL); // le NULL pour dire : "Ca y est, on arrête !". Sinon madame la GLib continue...
g_free(file); // Et on n'oublie pas de désallouer !

c:\temp\bou.txt

gchar* g_build_path(const gchar *separator, const gchar *first_element, ...);

g_build_path("#","c:","temp","bou.txt",NULL);

c:#temp#bou.txt

g_build_filename("c:","","temp","bou.txt",NULL);

g_build_path("#","c:","#","temp","#","bou.txt",NULL);

c:###temp###bou.txt

c:#temp#bou.txt

gchar* g_path_get_basename(const gchar *file_name);

gboolean g_path_is_absolute(const gchar *file_name);

G_CONST_RETURN gchar* g_path_skip_root(const gchar *file_name);

III. Gestion multi-utilisateur

G_CONST_RETURN gchar* g_get_home_dir(void);

G_CONST_RETURN gchar* g_get_tmp_dir(void);

G_CONST_RETURN gchar* g_get_user_name(void);

G_CONST_RETURN gchar* g_get_real_name(void);

IV. Gestion des erreurs

typedef enum
{
  G_FILE_ERROR_EXIST,
  G_FILE_ERROR_ISDIR,
  G_FILE_ERROR_ACCES,
  G_FILE_ERROR_NAMETOOLONG,
  G_FILE_ERROR_NOENT,
  G_FILE_ERROR_NOTDIR,
  G_FILE_ERROR_NXIO,
  G_FILE_ERROR_NODEV,
  G_FILE_ERROR_ROFS,
  G_FILE_ERROR_TXTBSY,
  G_FILE_ERROR_FAULT,
  G_FILE_ERROR_LOOP,
  G_FILE_ERROR_NOSPC,
  G_FILE_ERROR_NOMEM,
  G_FILE_ERROR_MFILE,
  G_FILE_ERROR_NFILE,
  G_FILE_ERROR_BADF,
  G_FILE_ERROR_INVAL,
  G_FILE_ERROR_PIPE,
  G_FILE_ERROR_AGAIN,
  G_FILE_ERROR_INTR,
  G_FILE_ERROR_IO,
  G_FILE_ERROR_PERM,
  G_FILE_ERROR_FAILED
} GFileError;

• G_FILE_ERROR_EXIST Opération non permise : seulement le propriétaire du fichier (ou une autre personne) ou un processus avec les droits appropriés peut effectuer l'opération.
• G_FILE_ERROR_ISDIR Le fichier est un dossier ; vous ne pouvez ouvrir un fichier en mode écriture, ou créer ou effacer des liens (comprenez des fichiers : un dossier est un ensemble de "pointeurs", à comprendre comme les pointeurs en C, qui contiennent l'adresse des fichiers dans le disque dur).
• G_FILE_ERROR_ACCES Permission refusée ; les attributs du fichier ne permettent pas cette opération.
• G_FILE_ERROR_NAMETOOLONG Nom de fichier trop long.
• G_FILE_ERROR_NOENT Impossible de trouver le fichier ou le dossier. Ceci est une erreur de fichier introuvable "This is a "file doesn't exist" error for ordinary files that are referenced in contexts where they are expected to already exist.
• G_FILE_ERROR_NOTDIR Un fichier qui n'est pas un dossier a été donné quand un dossier est attendu.
• G_FILE_ERROR_NXIO Matériel ou adresse introuvable. Le système a essayé d'utiliser le matériel représenté par un fichier que vous avez donné et il ne l'a pas trouvé (pour les nons-unixens, dans le monde unix, le driver d'un matériel dialogue avec le système à travers un banal fichier). Cela peut dire que le fichier du matériel a été mal installé, ou que le matériel physique est en train d'utiliser le fichier ou est mal connecté à l'ordinateur.
• G_FILE_ERROR_NODEV Ce fichier est sur un système de fichier qui ne supporte pas le mapping.
• G_FILE_ERROR_ROFS Le dossier contenant le nouveau lien ne peut pas être modifié car il est sur un système de fichier en lecture seule.
• G_FILE_ERROR_TXTBSY Fichier texte occupé.
• G_FILE_ERROR_FAULT Vous pointez vers une mauvaise zone mémoire. La GLib ne sera plus stable si ceci est retourné.
• G_FILE_ERROR_LOOP Trop de niveau de liens symboliques ont été rencontrés lors de la lecture du nom de fichier. Cela arrive quand il y a un cycle dans les liens symboliques.
• G_FILE_ERROR_NOSPC Plus d'espace disque ; l'opération d'écriture dans un fichier a échouée parce que le disque est plein.
• G_FILE_ERROR_NOMEM Pas assez de mémoire. Le système ne peut plus allouer assez de mémoire virtuelle parce que le disque dur est plein (la mémoire virtuelle a le même rôle qu'une mémoire vive mais son lieu de stockage est le disque dur ; d'où son adjectif virtuelle).
• G_FILE_ERROR_MFILE Le processus courant a trop de fichiers ouverts et ne peut plus en ouvrir d'autres. Duplicate descriptors do count toward this limit.
• G_FILE_ERROR_NFILE Il y a trop de fichiers ouverts en même temps dans le système.
• G_FILE_ERROR_BADF Mauvais descripteur de fichier ; Par exemple, écriture ou lecture sur un descripteur qui a été fermé ou lecture sur un descripteur qui est ouvert seulement pour de l'écriture (ou vice versa).
• G_FILE_ERROR_INVAL Argument invalide. Cette erreur est utilisée pour indiquer différents problèmes qui ont pour origine le passage d'un argument incorrect à une fonction de la librairie.
• G_FILE_ERROR_PIPE Erreur UNIX seulement qui arrive si on utilise des tubes de communication. Tube de communication cassé ; Il n'y a aucun processus en lecture sur ce tube. Tous les fonctions de la librairie qui retournent cette erreur génèrent aussi un signal SIGPIPE ; ce signal termine le programme si ce dernier n'est pas bloqué ou récupéré. Ainsi, votre programme ne verra jamais ce code d'erreur s'il ne bloque pas ou ne récupère pas le signal SIGPIPE.
• G_FILE_ERROR_AGAIN Ressource temporairement inaccessible ; l'appel devrait marchait si vous essayez encore.
• G_FILE_ERROR_INTR Appel de fonction interrompu ; un signal asynchrone est arrivé et a arrêté l'appel de la fonction. Quand cela arrive, vous devriez simplement rappeler la fonction.
• G_FILE_ERROR_IO Erreur de Lecture/Écriture ; généralement utilisé pour des erreurs de lecture ou d'écriture physiques c'est-à-dire que le disque ou un autre matériel physique a rencontré une erreur.
• G_FILE_ERROR_PERM Opération non permise : seulement le propriétaire du fichier (ou une autre personne) ou un processus avec les droits appropriés peut effectuer l'opération.
• G_FILE_ERROR_FAILED Ne correspond pas à un code d'erreur UNIX : ceci est le code d'erreur standard pour une "erreur de cause inconnue" présent dans toutes les énumérations de code d'erreur d'un GError. Utilisé si aucun autre code ne peut être appliqué.

Notez que l'on peut recevoir deux codes d'erreur différents pour une même erreur dans deux systèmes d'exploitation différents. En effet, pour les systèmes UNIX, la GLib se base sur les codes d'erreurs de la GNU C Library et à ceux de Microsoft sous Windows.

V. Remerciements

VI. Références

• Documentation officielle de la GLib sur les dossiers
• Documentation officielle de la GLib sur les fonctions utilitaires
• Gestion des erreurs en C avec la GLib
• FAQ GLib sur la gestion des fichiers
• Cours sur les chaînes de caractère
• Cours sur la récursivité