Soutenez-nous
Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 2 sur 2
  1. #1
    Invité de passage
    Étudiant
    Inscrit en
    janvier 2009
    Messages
    3
    Détails du profil
    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2009
    Messages : 3
    Points : 1
    Points
    1

    Par défaut Récupérer un fichier dans une archive avec ZLIB

    Bonjour à tous !

    Voila je suis actuellement sur un projet en C dont l'objectif est de supprimer le lancement de macro des fichier Microsoft Office ou Libre Office.
    Pour ce faire il faut pour les fichiers Office supprimer une certain répertoire dans l'archive (.docm, .pptm...) et pour LibreOffice il suffit de supprimer une balise dans le fichier XML "content.xml".
    Pour lire et supprimer un fichier dans l'archive j'ai utilisé la librairie minizip qui est une addon de la librairie zlib, et ça fonctionne bien ! Voila mon code pour traiter les fichiers Office.
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
     
    #include <stdio.h>
    #include <windows.h>
    #include <tchar.h>
    #include "unzip.h"
    #include "zlib.h"
    #include "zip.h"
    #include "iowin32.h"
    #include <string.h>
    #include "ParseXML.h"
     
    #define TRUE 1
    #define FALSE 0
     
    BOOL some_was_del = FALSE;
     
    int DeleteFileFromZIP(const char* zip_name, const char* del_file)
    {
    	char* tmp_name;
    	zlib_filefunc_def ffunc;
    	zipFile szip;
    	zipFile dzip;
    	unz_global_info glob_info;
    	char* glob_comment = NULL;
    	int n_files = 0;
    	int rv;
    	char fn[MAX_PATH];
    	char* commentary;
    	int method;
    	int level;
    	int size_local_extra;
    	void* local_extra;
    	void* buf;
    	int sz;
    	zip_fileinfo zfi;
     
    	// change name for temp file
    	tmp_name = (char*)malloc((strlen(zip_name) + 5)*sizeof(char));
    	strcpy(tmp_name, zip_name);
    	strncat(tmp_name, ".tmp", 5);
     
    	// open source and destination file
    	szip = unzOpen(zip_name);
    	if (szip==NULL) 
    	{
    		free(tmp_name);
    		return -1; 
    	}
    	dzip = zipOpen(tmp_name, APPEND_STATUS_CREATE);
    	if (dzip==NULL) 
    	{
    		unzClose(szip); 
    		free(tmp_name);
    		return -1; 
    	}
     
    	printf("Opening OK\n");
     
    	// get global commentary
    	if (unzGetGlobalInfo(szip, &glob_info) != UNZ_OK) 
    	{
    		zipClose(dzip, NULL);
    		unzClose(szip); 
    		free(tmp_name);
    		return -1; 
    	}
     
    	if (glob_info.size_comment > 0)
    	{
    		glob_comment = (char*)malloc(glob_info.size_comment+1);
    		if ((glob_comment==NULL)&&(glob_info.size_comment!=0)) 
    		{
    			zipClose(dzip, NULL); 
    			unzClose(szip); 
    			free(tmp_name); 
    			return -1; 
    		}
     
    		if ((unsigned int)unzGetGlobalComment(szip, glob_comment, glob_info.size_comment+1) != glob_info.size_comment)  
    		{
    			zipClose(dzip, NULL); 
    			unzClose(szip); 
    			free(glob_comment);
    			free(tmp_name); 
    			return -1; 
    		}
    	}
     
    	printf("Preparation OK\n");
     
    	// copying files
    	rv = unzGoToFirstFile(szip);
    	while (rv == UNZ_OK)
    	{
    		// get zipped file info
    		unz_file_info unzfi;
    		char dos_fn[MAX_PATH];
    		if (unzGetCurrentFileInfo(szip, &unzfi, dos_fn, MAX_PATH, NULL, 0, NULL, 0) != UNZ_OK) break;
    		OemToCharA(dos_fn, fn);
     
    		// if not need delete this file
    		if (stricmp(fn, del_file)==0) // lowercase comparison
    			some_was_del = TRUE;
    		else
    		{
    			char* extrafield = (char*)malloc(unzfi.size_file_extra);
    			if ((extrafield==NULL)&&(unzfi.size_file_extra!=0)) break;
    			commentary = (char*)malloc(unzfi.size_file_comment);
    			if ((commentary==NULL)&&(unzfi.size_file_comment!=0)) 
    			{
    				free(extrafield); 
    				break;
    			}
     
    			if (unzGetCurrentFileInfo(szip, &unzfi, dos_fn, MAX_PATH, extrafield, unzfi.size_file_extra, commentary, unzfi.size_file_comment) != UNZ_OK) 
    			{
    				free(extrafield); 
    				free(commentary);
    				break;
    			}
     
    			// open file for RAW reading
    			if (unzOpenCurrentFile2(szip, &method, &level, 1)!=UNZ_OK)
    			{
    				free(extrafield); 
    				free(commentary); 
    				break;
    			}
     
    			size_local_extra = unzGetLocalExtrafield(szip, NULL, 0);
    			if (size_local_extra<0) 
    			{
    				free(extrafield);
    				free(commentary);
    				break;
    			}
    			local_extra = malloc(size_local_extra);
    			if ((local_extra==NULL)&&(size_local_extra!=0)) 
    			{
    				free(extrafield);
    				free(commentary);
    				break;
    			}
    			if (unzGetLocalExtrafield(szip, local_extra, size_local_extra)<0) 
    			{
    				free(extrafield); 
    				free(commentary); 
    				free(local_extra); 
    				break;
    			}
     
    			// this malloc may fail if file very large
    			buf = malloc(unzfi.compressed_size);
    			if ((buf==NULL)&&(unzfi.compressed_size!=0)) 
    			{
    				free(extrafield);
    				free(commentary); 
    				free(local_extra);
    				break;
    			}
     
    			// read file
    			sz = unzReadCurrentFile(szip, buf, unzfi.compressed_size);
    			if ((unsigned int)sz != unzfi.compressed_size) 
    			{
    				free(extrafield); 
    				free(commentary); 
    				free(local_extra); 
    				free(buf); 
    				break;
    			}
     
    			//main2(buf,sz);
     
    			// open destination file
    			memcpy (&zfi.tmz_date, &unzfi.tmu_date, sizeof(tm_unz));
    			zfi.dosDate = unzfi.dosDate;
    			zfi.internal_fa = unzfi.internal_fa;
    			zfi.external_fa = unzfi.external_fa;
     
    			if (zipOpenNewFileInZip2(dzip, dos_fn, &zfi, local_extra, size_local_extra, extrafield, unzfi.size_file_extra, commentary, method, level, 1)!=UNZ_OK) 
    			{
    				free(extrafield); 
    				free(commentary); 
    				free(local_extra); 
    				free(buf); 
    				break;
    			}
     
    			// write file
    			if (zipWriteInFileInZip(dzip, buf, unzfi.compressed_size)!=UNZ_OK) 
    			{
    				free(extrafield);
    				free(commentary); 
    				free(local_extra); 
    				free(buf); 
    				break;
    			}
     
    			if (zipCloseFileInZipRaw(dzip, unzfi.uncompressed_size, unzfi.crc)!=UNZ_OK) 
    			{
    				free(extrafield); 
    				free(commentary); 
    				free(local_extra); 
    				free(buf); break;
    			}
     
    			if (unzCloseCurrentFile(szip)==UNZ_CRCERROR) 
    			{
    				free(extrafield); 
    				free(commentary); 
    				free(local_extra); 
    				free(buf); break;
    			}
    			free(commentary);
    			free(buf);
    			free(extrafield);
    			free(local_extra);
     
    			n_files ++;
    		}
     
    		rv = unzGoToNextFile(szip);
    	}
     
    	zipClose(dzip, glob_comment);
    	unzClose(szip);
     
    	free(glob_comment);
     
    	printf("Avant\n");
     
    	// if fail
    	if ( (!some_was_del) || (rv!=UNZ_END_OF_LIST_OF_FILE) )
    	{
    		remove(tmp_name);		
    		free(tmp_name);
    		return -1;
    	}
    	printf("Après\n");
     
    	remove(zip_name);
    	if (rename(tmp_name, zip_name) != 0)
    	{
    		free(tmp_name);
    		return -1;
    	}
     
    	// if all files were deleted
    	if (n_files==0) remove(zip_name);
     
    	free(tmp_name);
    	return 0;
    }
     
     
    int main(int argc, TCHAR *argv[])
    {
    	char* ext = NULL;
    	char* str = "../toto.docm";
    	ext = strrchr(str, '.');
    	if (!ext) {
    		printf("Pas d'extension connue");
    	} 
    	else {
    		printf("extension is %s\n", ext + 1);
    	}
    	if(strcmp(ext,".docm")==0){
    		if(DeleteFileFromZIP(str, "word/vbaProject.bin")==0) printf("Suppression de la macro un fichier de type %s\n",str);
    	}
    	if(strcmp(ext,".pptm")==0){
    		if(DeleteFileFromZIP(str, "ppt/vbaProject.bin")==0) printf("Suppression de la macro un fichier de type %s\n",str);
    	}
    	if(strcmp(ext,".xlsm" )==0){
    		if(DeleteFileFromZIP(str, "xl/vbaProject.bin")==0) printf("Suppression de la macro un fichier de type %s\n",str);
    	}		
     
    	getchar();
    	return 0;
    }
    Comme je vous l'ai dit pour les fichiers LibreOffice il me suffit (théoriquement) de supprimer une balise dans le fichier content.xml contenu dans chaque fichier LibreOffice. Pour parser le xml j'ai utilisé la librairie libxml, ça fonctionne parfaitement le souci c'est que je suis obligé de parser un fichier xml présent en dehors de toute archive... voila mon code :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
     
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <libxml\xpath.h>
    #include <libxml\parser.h>
    #include <unzip.h>
     
    int ParseXML(void){
     
    		xmlDocPtr doc;
    		xmlNodePtr cur;
     
    		doc = xmlParseFile("content.xml");
     
    		if (doc == NULL ) {
    			fprintf(stderr,"Document not parsed successfully. \n");
    			return;
    		}
     
    		cur = xmlDocGetRootElement(doc);
     
    		if (cur == NULL) {
    			fprintf(stderr,"empty document\n");
    			xmlFreeDoc(doc);
    			return;
    		}
     
    		if (xmlStrcmp(cur->name, (const xmlChar *) "document-content")) {
    			fprintf(stderr,"document of the wrong type, root node != catalogue");
    			xmlFreeDoc(doc);
    			return;
    		}
     
    		cur = cur->xmlChildrenNode;
    		while (cur != NULL) {
    			if ((!xmlStrcmp(cur->name, (const xmlChar *)"scripts"))){
    				//parseStory(doc, cur);
    				xmlUnlinkNode(cur);
    				xmlFreeNode(cur);
    				xmlSaveFileEnc("content.xml", doc, "UTF-8");
    				return;
    			}
     
    			cur = cur->next;
    		}
     
    		getchar();
    		return 0;
    }
    Mon problème c'est que je souhaiterai pouvoir parser un fichier xml contenu dans l'archive parcourue par zlib. Or j'ai épluché la doc de libxml dans tous les sens et à toutes les fonctions proposée prennent soit un "file descriptor" soit un "char *", or dans mon cas zlib charge juste chaque fichier en mémoire dans un buffer de type "void*"

    Voila je ne sais pas si j'ai été clair, n'hésité pas a demander si ce ne'est pas le cas...

    Merci d'avance

  2. #2
    Invité de passage
    Étudiant
    Inscrit en
    janvier 2009
    Messages
    3
    Détails du profil
    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2009
    Messages : 3
    Points : 1
    Points
    1

    Par défaut

    Autant pour moi j'ai finalement trouvé d'où venait l'erreur... C'était (une fois de plus) juste une erreur d'étourderie lors de la l'ouverture des fichiers avec unzOpenFile il fallait juste mettre l'option RAW à 0 et non 1 ! Ce qui correspond à la compression ou ou non du fichier...

+ Répondre à la discussion
Cette discussion est résolue.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •