Discussion :

[kij]

Bonjour,

Tout est dans le titre, dans l'une de mes applications je zip des fichiers dans des archives (une archive par fichier, soit un fichier pour une archive). Or depuis un petit moment je constate que les fichiers produit par mon application donne des erreurs lors du dézippage de ces archives par le client :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Erreur CRC

Je voulais donc savoir s'il est possible en Java de faire un CRC afin de controler l'intégrité de l'archive ?

[tchize_]

je proposerais assez naivement d'utiliser l'api zip de java pour décompresser ce que tu viens de compresser, histoire de voir si t'as pas d'erreur.

[kij]

Effectivement c'est la première chose que j'ai fait pour voir, malheureusement la décompression fonctionne bien alors que le fichier est corrompu. En gros, alors que les logiciels comme winZip, Unrar, etc affiche bien un message d'erreur CRC et demande s'il faut réellement décompresser l'archive en question.

J'ai ensuite voulu afficher le CRC de l'archive (fonction getCrc() de l'API), et j'obtiens un -1. Je pense que ce CRC est à mettre soi-même lors de la compression suite à un contrôle CRC.

Mon but est donc désormais de trouver une manière de faire pour reconnaitre cette erreur, et si elle a lieu, faire un petit algo pour supprimer mon archive et la compresser à nouveau.

Pourquoi cela ? Parce que j'ai remarqué qu'en utilisant l'API Zip, j'ai aléatoirement cette erreur CRC qui apparait sur des archives, et donc je voudrais corrigé ce petit bug par une nouvelle compression de mes fichiers (pour le moment).

[tchize_]

tu peux toujours comparer ce que tu décompresse, au fur et à mesure, avec les données de départ.

[millie]

tu peux toujours comparer ce que tu décompresse, au fur et à mesure, avec les données de départ.

Oui, mais comment faire s'il n'y a que le fichier zip et non les fichiers de départs (par exemple si l'on ne fait que décompresser) ? (enfin, même si dans ce cas ci, c'est de la compression)

[tchize_]

tu as getCrc() et setCrc() sur ZipEntry, qui peux servir à consulter l'information. Tu as la classe crc32 du package zip qui permet de calculer un crc. Il n'y a plus qu'à comparer.

[kij]

Re,

Merci à tout deux pour vos participations
Je n'avais pas vu vos deux post, mais effectivement je suis tombé sur la classe CRC32 du même package Zip.

Pour éclaircir la situation :
- c'est mon programme qui fait la compression des fichiers en archive, sans calculer de CRC pour le moment.
- le problème de fichier corrompu arrive lorsque le client (ou nous même) décompressons les archives en question.

Conclusion, ce que je vais faire :
Lorsque je compresse mes fichiers, je vais calculer un CRC, puis tout de suite derrière je vais lire les fichiers de l'archive (sans pour antant les décompresser) juste afin de recalculer un CRC et pouvoir faire une comparaison avec celui généré lors de la compression.

Je suis en train de le faire, ça me semble une méthode correcte mais je n'en suis pas certain, peut-être avez vous une idée ?

Je vous remercie bien de votre aide en tout cas

[kij]

Suite à ces indications, voici ce que j'ai fait.

Deux méthodes, l'une pour compresser, l'autre pour décompresser, toute deux retournant un CRC (ces deux méthodes se trouvent dans une classe nommée 'TestZip' :
compressSimpleFile(String,String)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
	public CRC32 compressSimpleFile ( String theFile, String thePath ) throws DocdbException {
 
		final int BUF_SIZE	= 2048;
		byte[] data = new byte[BUF_SIZE];
		CRC32 myCrc = new CRC32();
		String myArcName = thePath.concat("archive.zip");
 
		try{
			FileOutputStream dest = new FileOutputStream(myArcName);
			BufferedOutputStream buff = new BufferedOutputStream(dest);
			ZipOutputStream out = new ZipOutputStream(buff);
			out.setLevel(1);
 
 
			FileInputStream fi = new FileInputStream(theFile);
			BufferedInputStream buffi = new BufferedInputStream(fi);
			ZipEntry entry = new ZipEntry(new File(theFile).getName());
			out.putNextEntry(entry);
			int count = 0;
			while ( (count = buffi.read(data,0,BUF_SIZE)) != -1 ){
				myCrc.update(data,0,count);
				out.write(data,0,count);
			}
			entry.setCrc(myCrc.getValue());
			out.closeEntry();
			buffi.close();
			out.close();
		}catch(Exception e){
			throw new DocdbException(e.getMessage());
		}
 
		return myCrc;
 
	}

unzipAndControlLastEntry(String)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
	public CRC32 unzipAndControlLastEntry ( String theFile ) throws DocdbException {
 
		final int BUF_SIZE	= 2048;
		byte[] data = new byte[BUF_SIZE];
		CRC32 myCrc = new CRC32();
 
		try{
			BufferedOutputStream dest = null;
			FileInputStream fis = new FileInputStream(theFile);
			BufferedInputStream buffi = new BufferedInputStream(fis);
			ZipInputStream zis = new ZipInputStream(buffi);
 
			ZipEntry entry;
			FileOutputStream fos;
			int count;
 
			String outDir = theFile.substring(0,theFile.lastIndexOf(File.separator)+1);
 
			while ( (entry = zis.getNextEntry()) != null ){
				myCrc.reset();
				fos = new FileOutputStream(outDir.concat(entry.getName()));
				dest = new BufferedOutputStream(fos,BUF_SIZE);
				while( (count = zis.read(data,0,BUF_SIZE)) != -1 ){
					// --- Update the crc with data
					myCrc.update(data);
					dest.write(data,0,count);
				}
				dest.flush();
				dest.close();
			}
 
			zis.close();
 
		}catch(FileNotFoundException e){
			System.err.println("FNFE");
			throw new DocdbException(e.getMessage());
		}catch(IOException e){
			System.err.println("IOE");
			throw new DocdbException(e.getMessage());
		}
 
		return myCrc;
 
	}

Voici un petit main pour les utiliser sur un fichier XML à compresser puis decompresser afin de comparer les valeurs des CRC à la fin :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
public static void main (String[] args){
 
 
		String thePath = "*****";
		String theArchiveName = "archive.zip";
		String theXmlFile = "*****.xml";
 
		TestZip myZipManager = null;
		CRC32 myCrcZip, myCrcRead;
		try{
 
			myZipManager = new TestZip();
			myCrcZip = myZipManager.compressSimpleFile(theXmlFile,thePath);
			myCrcRead = myZipManager.unzipAndControlLastEntry(thePath.concat(theArchiveName));
			System.out.println("Comparison between two CRC :");
			System.out.println("\tFist : "+myCrcZip.getValue());
			System.out.println("\tSecd : "+myCrcRead.getValue());
 
		}catch(DocdbException e){
			System.err.println("ERROR : "+e.getMessage());
		}
 
	}

Lorsque j'exécute ce programme plusieurs fois sur le même fichier XML en entrée, voici ce que ça donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Comparison between two CRC :
	Fist : 3207811235
	Secd : 2013059193

On peut voir que les CRC ne sont pas les mêmes. On constate aussi que quelque soit le nombre de fois que l'on exécute le programme, les CRC sont toujours identiques.

Ma question est donc : pourquoi les CRC ne sont pas égaux suite à la compression et la décompression de mon archive alors que la valeur d'initialisation est toujours la même (0) ?

Remarque : si je l'exécute sur un autre fichier XML (pas les mêmes données donc), le résultat est similaire avec d'autres CRC :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Comparison between two CRC :
	Fist : 394654411
	Secd : 3549617088

Je pense que ce n'est pas la bonne méthode à faire puisque ça ne fonctionne pas, dans ce cas quelle est la bonne méthode ^^ ?

[adiGuba]

Salut,


Ton CRC est différent car lors de la décompression tu le calcule mal car tu ne précise pas le nombre de caractère lu :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

myCrc.update(data);

Au lieu de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

myCrc.update(data,0,count);

Une question : les archives problématiques sont-elles générées sur le poste du client, ou est-ce qu'elles lui sont transmises par un moyen quelconque ?
Il est possible que le zip soit corrompu pendant le "transport"...


Sinon quelques remarques :

• Utilises des try/finally pour fermer tes flux
• Lorsque tu catch une exception pour en remonter une autre, c'est bien d'englober l'exception source (cela donne plus d'info lorsqu'on a un problème)

a++

[kij]

Effectivement il y a un transport via FTP derrière, mais j'ai déjà vérifié et les archives sont corrompues avant.
Comment le savoir : suite à la compression j'ai une étape de validation des fichiers XML archivés, qui ouvre l'archive et valide une à une les entrées. Une erreur est parfois générée lors de cette étape à cause du CRC. Donc j'en déduis que c'est lors de la compression.

Effectivement petite erreur d'inattention qui coûte cher :/ je vais modifier ça je te remercie.

Pour ce qui est des try,catch et fermeture des flux, effectivement je vais modifier mon code également, le but étant juste de faire des tests ici.
Je mettrais mon code plus propre lorsque j'aurai résolu ce problème.

Pour ce qui est la gestion de la remontée de l'erreur, englober l'erreur source dans la seconde je ne vois pas trop ce que tu veux dire par là, j'avoue que niveau gestion des exceptions mes connaissances sont assez sommaire. Je vais voir un tutoriel la dessus.

Merci encore pour ces bon(ne)s conseils/remarques