Utilisation de la LibZip
Date de publication : 10 décembre 2011.
Par
Loïc BARTOLETTI (_-Slash-_)
Tutoriel sur l'utilisation de la bibliothèque LibZip.
Commentez 
1. Introduction
Pour utiliser les archives zip plusieurs bibliothèques sont disponibles. Dans ce tutoriel nous allons nous intéresser à la
libzip. Cette bibliothèque est écrite en C et permet de lire, créer ou modifier les archives zip. À ce jour, la dernière version est la 0.10 qui date du 18/03/2010. C'est cette version qui a été utilisée pour ce tutoriel. Le manuel de la bibliothèque est très clair et quasiment toutes les fonctions sont détaillées. Il se trouve en
ligne ou via man libzip pour la bibliothèque en général et man "nom de la commande".
Ce document présente comment :
- lister le contenu d'une archive zip ;
- effacer un fichier/dossier d'une archive zip ;
- renommer un fichier/dossier d'une archive zip ;
- remplacer un fichier d'une archive zip ;
- extraire un fichier/dossier d'une archive zip ;
- décompresser une archive zip ;
- créer une archive zip.
Tous les codes sont en C.
Les codes ci-dessous peuvent faire appel à des fonctions non présentes dans cette page mais le tout est disponible dans le code source C présent à la fin de la page. Le tutoriel n'est disponible que pour les systèmes UNIX/POSIX. Il ne devrait pas être difficile à adapter pour la plateforme Windows. Le code présente des appels particuliers POSIX et considère que les chemins sont de type UNIX '/' et non de type Windows '\'. Tout a été testé sur FreeBSD, si des modifications sont à apporter pour d'autres systèmes n'hésitez pas à me le faire savoir.
2. Exemple de Code
2-A. Lister le contenu d'une archive zip
2-A-1. Algorithme
Ouvrir l'archive (Fonction zip_open).
Compter le nombre d'éléments dans l'archive (Fonction zip_get_num_files).
Pour chaque élément, afficher son nom (Fonction zip_get_name).
Fermer l'archive (Fonction zip_close).
2-A-2. Code source
| Afficher le contenu d'une archive Zip |
\fn
\brief
\return
static int afficherFichierZip(const char* fichierZip)
{
if(fichierZip == NULL)
return ZIPZAP_FAILURE;
int err = 0;
struct zip *f_zip=NULL;
f_zip = zip_open(fichierZip, ZIP_CHECKCONS, &err);
if(err != ZIP_ER_OK)
{
zip_error_to_str(buf_erreur, sizeof buf_erreur, err, errno);
printf("Error %d : %s\n",err, buf_erreur);
return ZIPZAP_FAILURE;
}
if(f_zip==NULL)
{
printf("Erreur à l'ouverture du fichier %s\n", fichierZip);
return ZIPZAP_FAILURE;
}
int count = zip_get_num_files(f_zip);
if(count==-1)
{
printf("Erreur à la lecture du fichier %s\n", fichierZip);
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_FAILURE;
}
int i = 0;
printf("Nombre de fichiers dans l'archive : %d\n",count);
for(i=0; i<count; i++)
{
printf("%s\n", zip_get_name(f_zip, i, ZIP_FL_UNCHANGED));
}
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_SUCCESS;
}
|
2-B. Effacer un fichier/dossier d'une archive zip
2-B-1. Algorithme
Ouvrir l'archive (Fonction zip_open).
Rechercher le fichier/dossier dans l'archive (Fonction zip_name_locate).
Si c'est un dossier
pour chaque élément du dossier, le supprimer (Fonction zip_delete).
Sinon
le supprimer (Fonction zip_delete).
Fermer l'archive (Fonction zip_close).
2-B-2. Code source
| Effacer un fichier/dossier d'une archive zip |
\fn
\brief
\param
\param
\return
static int effacerFichierZip(const char* fichierZip, const char* fichier)
{
int visu = 0;
struct zip * f_zip=NULL;
int err = 0;
f_zip=zip_open(fichierZip,ZIP_CREATE,&err);
if(err != ZIP_ER_OK)
{
zip_error_to_str(buf_erreur, sizeof buf_erreur, err, errno);
printf("Error %d : %s\n",err, buf_erreur);
return ZIPZAP_FAILURE;
}
if(f_zip==NULL)
{
printf("Erreur à l'ouverture du fichier %s\n", fichierZip);
return ZIPZAP_FAILURE;
}
visu=zip_name_locate(f_zip,fichier,0);
if (visu==-1)
{
printf("Le fichier %s n'existe pas dans %s\n", fichier, fichierZip);
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_FAILURE;
}
if(fichier[strlen(fichier)-1]=='/')
{
char *ptr = NULL;
int i = 0;
int count = zip_get_num_files(f_zip);
if(count==-1)
{
printf("Erreur à l'ouverture du fichier %s\n", fichierZip);
zip_close(f_zip);
f_zip = NULL;
ptr = NULL;
return ZIPZAP_FAILURE;
}
for(i=0; i<count; i++)
{
if( (ptr=strstr(zip_get_name(f_zip, i, ZIP_FL_UNCHANGED), fichier)) != NULL)
{
if(zip_delete(f_zip,i) == -1)
{
printf("%s\n", zip_strerror(f_zip));
zip_close(f_zip);
f_zip = NULL;
ptr = NULL;
return ZIPZAP_FAILURE;
}
printf("Le fichier %s a été supprimé dans %s\n", zip_get_name(f_zip, i, ZIP_FL_UNCHANGED), fichierZip);
}
}
ptr = NULL;
}
else
{
if(zip_delete(f_zip,visu) == -1)
{
printf("%s\n", zip_strerror(f_zip));
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_FAILURE;
}
printf("Le fichier %s a été supprimé dans %s\n", fichier, fichierZip);
}
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_SUCCESS;
}
|
2-C. Renommer un fichier/dossier d'une archive zip
2-C-1. Algorithme
Ouvrir l'archive (Fonction zip_open).
Rechercher le fichier/dossier dans l'archive (Fonction zip_name_locate).
Si c'est un dossier
pour chaque élément du dossier, le renommer (Fonction zip_rename).
Sinon
le renommer (Fonction zip_rename).
Fermer l'archive (Fonction zip_close).
2-C-2. Code source
| Renommer un fichier/dossier d'une archive |
\fn
\brief
\param
\param
\param
\return
static int renommerFichierZip(const char* fichierZip, const char* fichierFrom, const char* fichierTo)
{
int visu = 0;
struct zip * f_zip=NULL;
int err = 0;
f_zip=zip_open(fichierZip,ZIP_CREATE,&err);
if(err != ZIP_ER_OK)
{
zip_error_to_str(buf_erreur, sizeof buf_erreur, err, errno);
printf("Error %d : %s\n",err, buf_erreur);
return ZIPZAP_FAILURE;
}
if(f_zip==NULL)
{
printf("Erreur à l'ouverture du fichier %s\n", fichierZip);
return ZIPZAP_FAILURE;
}
visu=zip_name_locate(f_zip,fichierFrom,0);
if (visu==-1)
{
printf("Le fichier %s n'existe pas dans %s\n", fichierFrom, fichierZip);
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_FAILURE;
}
if(fichierFrom[strlen(fichierFrom)-1]=='/')
{
char *ptr = NULL;
int i = 0;
int count = zip_get_num_files(f_zip);
if(count==-1)
{
printf("Erreur à l'ouverture du fichier %s\n", fichierZip);
return ZIPZAP_FAILURE;
}
for(i=0; i<count; i++)
{
if( (ptr=strstr(zip_get_name(f_zip, i, ZIP_FL_UNCHANGED), fichierFrom)) != NULL)
{
if(strlen(fichierFrom)==strlen(zip_get_name(f_zip, i, ZIP_FL_UNCHANGED)))
{
if(zip_rename(f_zip,i,fichierTo) == -1)
{
printf("%s\n", zip_strerror(f_zip));
zip_close(f_zip);
f_zip = NULL;
ptr = NULL;
return ZIPZAP_FAILURE;
}
printf("Le fichier %s a été renommé en %s dans %s\n", fichierFrom, fichierTo, fichierZip);
}
else
{
char *buf = NULL;
buf = malloc(FILENAME_MAX*sizeof(char));
if(buf==NULL)
{
printf("Erreur d'allocation mémoire.\n");
zip_close(f_zip);
f_zip = NULL;
FREE(buf);
ptr = NULL;
return ZIPZAP_FAILURE;
}
strcpy(buf,fichierTo);
strcat(buf,zip_get_name(f_zip, i, ZIP_FL_UNCHANGED)+strlen(fichierFrom));
printf("%s\n",buf);
if(zip_rename(f_zip,i,buf) == -1)
{
printf("%s\n", zip_strerror(f_zip));
zip_close(f_zip);
f_zip = NULL;
FREE(buf);
ptr = NULL;
return ZIPZAP_FAILURE;
}
printf("Le fichier %s a été renommé en %s dans %s\n", fichierFrom, fichierTo, fichierZip);
FREE(buf);
}
}
}
ptr = NULL;
}
else
{
if(zip_rename(f_zip,visu,fichierTo) == -1)
{
printf("%s\n", zip_strerror(f_zip));
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_FAILURE;
}
printf("Le fichier %s a été renommé en %s dans %s\n", fichierFrom, fichierTo, fichierZip);
}
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_SUCCESS;
}
|
2-D. Remplacer un fichier d'une archive zip
2-D-1. Algorithme
Ouvrir l'archive (Fonction zip_open).
Rechercher le fichier dans l'archive (Fonction zip_name_locate).
Si le fichier n'existe pas et si on a demandé de l'ajouter dans ce cas-là
ajouter le fichier (Fonction zip_add).
Sinon
le remplacer (Fonction zip_replace).
Fermer l'archive (Fonction zip_close).
2-D-2. Code source
| Remplacer le fichier d'une archive |
\fn
\brief
\param
\param
\param
\return
static int remplacerFichierZip(const char* fichierZip, const char* fichier, int ajout)
{
int visu = 0;
struct zip * f_zip=NULL;
struct zip_source * n_zip=NULL;
int err = 0;
f_zip=zip_open(fichierZip,ZIP_CREATE,&err);
if(err != ZIP_ER_OK)
{
zip_error_to_str(buf_erreur, sizeof buf_erreur, err, errno);
printf("Error %d : %s\n",err, buf_erreur);
return ZIPZAP_FAILURE;
}
if(f_zip==NULL)
{
printf("Erreur à l'ouverture du fichier %s\n", fichierZip);
return ZIPZAP_FAILURE;
}
if((n_zip=zip_source_file(f_zip,fichier, (off_t)0, (off_t)0)) == NULL)
{
printf("%s\n", zip_strerror(f_zip));
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_FAILURE;
}
visu=zip_name_locate(f_zip,fichier,0);
if (visu==-1)
{
printf("Le fichier %s n'existe pas dans %s\n", fichier, fichierZip);
if(ajout==REPLACE_ADD)
{
if(zip_add(f_zip,fichier,n_zip) == -1)
{
printf("%s\n", zip_strerror(f_zip));
zip_close(f_zip);
f_zip = NULL;
zip_source_free(n_zip);
n_zip = NULL;
return ZIPZAP_FAILURE;
}
printf("Le fichier %s a été ajouté dans %s\n", fichier, fichierZip);
}
else if(ajout==REPLACE_NOT_ADD)
{
printf("Le fichier %s n'a pas été ajouté ou remplacé dans %s\n", fichier, fichierZip);
}
else
{
printf("Erreur d'utilisation de la fonction %s\n", __FUNCTION__);
}
}
else
{
if(zip_replace(f_zip,visu,n_zip) == -1)
{
printf("%s\n", zip_strerror(f_zip));
zip_close(f_zip);
f_zip = NULL;
zip_source_free(n_zip);
n_zip = NULL;
return ZIPZAP_FAILURE;
}
printf("Le fichier %s a été remplacé dans %s\n", fichier, fichierZip);
}
zip_close(f_zip);
f_zip = NULL;
zip_source_free(n_zip);
n_zip = NULL;
return ZIPZAP_SUCCESS;
}
|
2-E. Extraire un fichier/dossier d'une archive zip
2-E-1. Algorithme
Ouvrir l'archive (Fonction zip_open).
Rechercher le fichier/dossier dans l'archive (Fonction zip_name_locate).
Si c'est un dossier
pour chaque élément du dossier, l'extraire (Fonction extraireFichier -> Fonctions zip_stat, zip_fopen, zip_fread, zip_fclose).
Sinon
l'extraire (Fonction extraireFichier -> Fonctions zip_stat, zip_fopen, zip_fread, zip_fclose).
Fermer l'archive (Fonction zip_close).
2-E-2. Code source
| Extraire un fichier/dossier d'une archive |
\fn
\brief
\param
\param
\param
\param
\return
static int extraireFichierZip(const char* fichierZip, const char* fichier, const char* repSortie, const char* motDePasse)
{
int visu = 0;
struct zip *f_zip=NULL;
int err=0;
f_zip=zip_open(fichierZip, ZIP_CHECKCONS, &err);
if(err != ZIP_ER_OK)
{
zip_error_to_str(buf_erreur, sizeof buf_erreur, err, errno);
printf("Error %d : %s\n",err, buf_erreur);
return ZIPZAP_FAILURE;
}
if(f_zip==NULL)
{
printf("Erreur à l'ouverture du fichier %s\n", fichierZip);
return ZIPZAP_FAILURE;
}
visu=zip_name_locate(f_zip,fichier,0);
if (visu==-1)
{
printf("Le fichier %s n'existe pas dans %s\n", fichier, fichierZip);
printf("Ajouter le caractère '/' à la fin du nom s'il s'agit d'un dossier\n");
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_FAILURE;
}
if(fichier[strlen(fichier)-1]=='/')
{
char *ptr = NULL;
int i = 0;
int count = zip_get_num_files(f_zip);
if(count==-1)
{
zip_close(f_zip);
f_zip = NULL;
printf("Erreur à l'ouverture du fichier %s\n", fichierZip);
return ZIPZAP_FAILURE;
}
for(i=0; i<count; i++)
{
if( (ptr=strstr(zip_get_name(f_zip, i, ZIP_FL_UNCHANGED), fichier)) != NULL)
{
if( (strlen(fichier) == strlen(ptr)) && (strcmp(ptr,fichier)==0))
{
printf("Extraction des fichiers du dossier %s\n",ptr);
}
else
{
if(extraireFichier(i, f_zip, repSortie, motDePasse)==ZIPZAP_FAILURE)
{
printf("Erreur à l'extraction du fichier %s\n", zip_get_name(f_zip, i, ZIP_FL_UNCHANGED));
zip_close(f_zip);
f_zip = NULL;
ptr = NULL;
return ZIPZAP_FAILURE;
}
}
}
}
ptr = NULL;
}
else
{
if(extraireFichier(visu, f_zip, repSortie, motDePasse)==ZIPZAP_FAILURE)
{
printf("Erreur à l'extraction du fichier %s\n", zip_get_name(f_zip, visu, ZIP_FL_UNCHANGED));
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_FAILURE;
}
}
zip_close(f_zip);
return ZIPZAP_SUCCESS;
}
|
| Fonction extraireFichier |
\fn
\brief
\param
\param
\param
\param
\return
static int extraireFichier(int id, struct zip *f_zip, const char *repSortie, const char* motDePasse)
{
struct zip_stat file_stat;
struct zip_file *file_zip=NULL;
zip_stat_index(f_zip, id, 0, &file_stat);
if(zip_stat(f_zip, file_stat.name, 0, &file_stat) == -1)
{
printf("%s\n", zip_strerror(f_zip));
return ZIPZAP_FAILURE;
}
printf("taille du fichier %s : %d \n", file_stat.name, (int)(file_stat.size*sizeof(char)+1));
if(motDePasse==NULL)
{
file_zip=zip_fopen(f_zip, file_stat.name, ZIP_FL_UNCHANGED);
}
else
{
file_zip=zip_fopen_encrypted(f_zip, file_stat.name, ZIP_FL_UNCHANGED, motDePasse);
}
if(!file_zip)
{
printf("%s\n", zip_strerror(f_zip));
return ZIPZAP_FAILURE;
}
char *str=NULL;
str = malloc((size_t)(file_stat.size+1));
memset(str, 0, (size_t)(file_stat.size+1));
if(str == NULL)
{
printf("Erreur d'allocation mémoire\n");
return ZIPZAP_FAILURE;
}
if(zip_fread(file_zip, str, (size_t)(file_stat.size)) != file_stat.size)
{
printf("%s\n", zip_strerror(f_zip));
FREE(str);
zip_fclose(file_zip);
file_zip = NULL;
return ZIPZAP_FAILURE;
}
FILE *fOut = NULL;
if(repSortie != NULL)
{
char *repOut= malloc(FILENAME_MAX * sizeof(char));
if(repOut == NULL)
{
printf("Erreur d'allocation mémoire\n");
FREE(str);
zip_fclose(file_zip);
file_zip = NULL;
return ZIPZAP_FAILURE;
}
memset(repOut, 0, FILENAME_MAX * sizeof(char));
if( (repSortie[strlen(repSortie)-1]=='/') && (file_stat.name[0]=='/'))
{
strncpy(repOut, repSortie, strlen(repSortie)-2);
strcat(repOut, file_stat.name);
}
else if( (repSortie[strlen(repSortie)-1]=='/') || (file_stat.name[0]=='/'))
sprintf(repOut, "%s%s", repSortie, file_stat.name);
else
sprintf(repOut, "%s/%s", repSortie, file_stat.name);
mkpath(repOut, 0777);
if(repOut[strlen(repOut)-1]!='/')
{
if((fOut = fopen(repOut, "wb"))==NULL)
{
printf("Erreur à la création du fichier %s\n", repOut);
FREE(str);
FREE(repOut);
zip_fclose(file_zip);
file_zip = NULL;
return ZIPZAP_FAILURE;
}
fwrite(str, sizeof(char), (size_t)file_stat.size, fOut);
fclose(fOut);
fOut = NULL;
}
zip_fclose(file_zip);
file_zip = NULL;
FREE(str);
FREE(repOut);
}
else
{
mkpath(file_stat.name, 0777);
if(file_stat.name[strlen(file_stat.name)-1] != '/' )
{
if((fOut = fopen(file_stat.name, "wb"))==NULL)
{
printf("Erreur à la création du fichier %s\n", file_stat.name);
zip_fclose(file_zip);
file_zip = NULL;
FREE(str);
return ZIPZAP_FAILURE;
}
fwrite(str, sizeof(char), (size_t)file_stat.size, fOut);
FREE(str);
fclose(fOut);
fOut = NULL;
zip_fclose(file_zip);
file_zip = NULL;
}
}
FREE(str);
file_zip = NULL;
return ZIPZAP_SUCCESS;
}
|
2-F. Décompresser une archive zip
2-F-1. Algorithme
Ouvrir l'archive (Fonction zip_open).
Compter le nombre d'éléments dans l'archive (Fonction zip_get_num_files).
Extraire chaque élément (Fonction extraireFichier -> Fonctions zip_stat, zip_fopen, zip_fread, zip_fclose).
Fermer l'archive (Fonction zip_close).
2-F-2. Code source
| Décompresser une archive |
static int decompresserFichierZip(const char* fichierZip, const char* repSortie, const char* motDePasse)
{
int err=0;
struct zip *f_zip=NULL;
f_zip = zip_open(fichierZip, ZIP_CHECKCONS, &err);
if(err != ZIP_ER_OK)
{
zip_error_to_str(buf_erreur, sizeof buf_erreur, err, errno);
printf("Error %d : %s\n",err, buf_erreur);
return ZIPZAP_FAILURE;
}
if(f_zip==NULL)
{
printf("Erreur à l'ouverture du fichier %s\n", fichierZip);
return ZIPZAP_FAILURE;
}
int count = zip_get_num_files(f_zip);
if(count==-1)
{
printf("Erreur à l'ouverture du fichier %s\n", fichierZip);
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_FAILURE;
}
printf("Nombre de fichiers dans l'archive : %d\n", count);
int i;
for(i=0; i<count; i++)
{
if(extraireFichier(i, f_zip, repSortie, motDePasse)==ZIPZAP_FAILURE)
{
printf("Erreur à l'extraction du fichier %s\n", zip_get_name(f_zip, i, ZIP_FL_UNCHANGED));
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_FAILURE;
}
}
zip_close(f_zip);
f_zip = NULL;
return ZIPZAP_SUCCESS;
}
|
2-G. Créer une archive zip
2-G-1. Algorithme
Créer l'archive suivant le mode choisi (Fonction zip_open).
Vérifier que le fichier/dossier n'est pas déjà présent dans l'archive (Fonction verfiPresenceFichier).
Si on ajoute un dossier
on l'ajoute à l'archive (Fonction zip_add_dir),
on ajoute tous ses éléments dans l'archive (Fonction ajouteDossier ->Fonctions zip_source_file, zip_add_dir, zip_add).
Sinon
on ajoute le fichier à l'archive (Fonctions zip_source_file, zip_add).
Fermer l'archive (Fonction zip_close).
2-G-2. Code source
| Créer une archive |
\fn
\brief
\param
\param
\param
\param
\return
static int creerFichierZip(const char* fichierZipEnSortie, int modeZip, int argc, char *arg[])
{
struct zip *f_zip=NULL;
struct zip_source *doc = NULL;
int err = 0;
if(modeZip==CREATE)
{
remove(fichierZipEnSortie);
f_zip=zip_open(fichierZipEnSortie, ZIP_CREATE, &err);
}
else if(modeZip==EXIST)
{
f_zip=zip_open(fichierZipEnSortie, ZIP_EXCL|ZIP_CREATE, &err);
}
else if(modeZip==ADD)
{
f_zip=zip_open(fichierZipEnSortie, ZIP_CREATE, &err);
}
else
{
printf("Erreur du choix du mode\n");
usage(arg[0]);
return ZIPZAP_FAILURE;
}
if(err != ZIP_ER_OK)
{
zip_error_to_str(buf_erreur, sizeof buf_erreur, err, errno);
printf("Error %d : %s\n",err, buf_erreur);
return ZIPZAP_FAILURE;
}
if(f_zip==NULL)
{
printf("Erreur à l'ouverture du fichier %s\n", fichierZipEnSortie);
return ZIPZAP_FAILURE;
}
int i = 3;
for(; i<argc; i++)
{
if(verifPresenceFichier(f_zip, arg[i])==ZIPZAP_FAILURE)
{
printf("Erreur lors de l'ajout du fichier/dossier \"%s\" à l'archive %s\n", arg[i], fichierZipEnSortie);
zip_close(f_zip);
f_zip = NULL;
zip_source_free(doc);
doc = NULL;
return ZIPZAP_FAILURE;
}
#if defined(__POSIX_VISIBLE) || defined(_POSIX_C_SOURCE)
struct stat f_stat;
if(lstat(arg[i], &f_stat) != -1)
{
if(S_ISDIR(f_stat.st_mode))
{
if(zip_add_dir(f_zip, arg[i]) == -1)
{
printf("%s\n", zip_strerror(f_zip));
zip_close(f_zip);
f_zip = NULL;
zip_source_free(doc);
doc = NULL;
return ZIPZAP_FAILURE;
}
if(ajouteDossier(arg[i], f_zip)==ZIPZAP_FAILURE)
{
printf("Erreur à l'ajout du dossier %s\n", arg[i]);
zip_close(f_zip);
f_zip = NULL;
zip_source_free(doc);
doc = NULL;
return ZIPZAP_FAILURE;
}
}
else
{
if((doc=zip_source_file(f_zip,arg[i],(off_t)0,(off_t)0))==NULL)
{
printf("%s\n", zip_strerror(f_zip));
zip_close(f_zip);
f_zip = NULL;
zip_source_free(doc);
doc = NULL;
return ZIPZAP_FAILURE;
}
if(zip_add(f_zip, arg[i], doc)==-1)
{
printf("%s\n", zip_strerror(f_zip));
zip_close(f_zip);
f_zip = NULL;
zip_source_free(doc);
doc = NULL;
return ZIPZAP_FAILURE;
}
}
}
else
{
printf("Le fichier %s n'existe pas\n", arg[i]);
zip_close(f_zip);
f_zip = NULL;
zip_source_free(doc);
doc = NULL;
return ZIPZAP_FAILURE;
}
#endif
}
zip_close(f_zip);
f_zip = NULL;
zip_source_free(doc);
doc = NULL;
return ZIPZAP_SUCCESS;
}
|
3. Conclusion
Les codes sources présentés ci-dessus montrent comment il est facile avec la LibZip de réaliser les opérations classiques sur des archives. Je vous recommande l'utilisation de cette bibliothèque très puissante et très simple d'utilisation. Elle est d'ailleurs utilisée par de nombreux gros projets et ce n'est sans doute pas pour rien.
Vous pouvez télécharger le code source complet et la Makefile dans cette archive zip créée avec les exemples du code.
Télécharger ZipZap(miroir).
4. Remerciements
Copyright © 2011 Loïc BARTOLETTI. Aucune reproduction, même partielle, ne peut être faite
de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur.
Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 €
de dommages et intérêts.
Cette page est déposée.
