Manuel de Lzip


Next: , Up: (dir)

Manuel de Lzip

Ce manuel documente Lzip (version 1.11, 16 Septembre 2010).


Ce manuel a été traduit en français par Gilsan Lpuser le 03 décembre 2010.

Copyright © 2008, 2009, 2010 Antonio Diaz Diaz.

Ce manuel est une documentation libre : vous avez la permission de le copier, le distribuer et le modifier sans aucune restriction.



Next: , Previous: Top, Up: Top

1 Présentation et caractèristiques de lzip

Lzip est un compresseur de données sans pertes basé sur l'algorithme LZMA. Il possède un contrôle d'intégrité très fiable, ainsi qu'une interface utilisateur similaire à celles de gzip ou bzip2. La vitesse de décompression de lzip est proche de celle de gzip, et son taux de compression est meilleur que celui de bzip2, ce qui le destine, tout particulièrement, à l'archivage de données, ainsi qu'aux distributions de logiciels.

Lzip remplace chaque fichier donné comme paramètre dans la ligne de commande par une version compressée de ce même fichier, à laquelle il ajoute le suffixe '.lz'. Le nom du fichier compressé devient donc 'fichier_original.lz'. Chaque fichier compressé conserve sa date de modification et ses permissions antèrieures, et, lorsque cela est possible, le propriétaire correspondant au fichier original. Cela permet la restauration correcte de ces propriétés lors de la décompression. Si l'option `--stdout' est spécifiée, lzip est capable de lire les données à partir de certains types de fichiers non réguliers (fichiers de périphériques etc...) comme par exemple `/dev/fd0'.

Si aucun nom de fichier n'est spécifié comme paramètre, lzip compresse (ou décompresse selon l'option) le flux entrant dans l'entrée standart 'stdin' et le renvoie, après traitement, vers la sortie standart 'stdout'. Dans le cas précis de la compression, lzip refusera d'écrire les données compressées vers un terminal, car cela serait illisible et sans intérêt.

Lzip décompressera correctement un fichier résultant de la concaténation de deux ou plusieurs fichiers compressés. Le résutat sera la concaténation des fichiers correspondants, mais décompressée. Le test de fichiers concaténés puis compressés est aussi supporté.

Lzip sait créer des fichiers multimembres, et, en cas d'altération de fichier, restaurer de manière sûre et fiable les membres nons endommagés d'un fichier corrompu à l'aide de la commande lziprecover. Lzip permet, aussi, de fractionner les données sortantes compressées en volumes dont on peut prédéfinir la taille, et cela, même lorsque la lecture s'effectue depuis l'entrée standart 'stdin'. Cela permet de créer directement des archives 'tar' compressées multivolumes.

La quantité de mémoire nécessaire pour la compression est d'environ 5 MiB, plus 1 ou 2 fois la taille maximale du dictionnaire (1 fois si le fichier d'entrée est inférieur à la taille maximale du dictionnaire, 2 fois dans le cas contraire), plus 8 fois la taille du dictionnaire réellement utilisé. L'option `-0' est spécifique, du fait qu'elle ne nécessite que 1,5 MiB de mémoire, tous au plus. Pour la décompression, l'empreinte mémoire est légèrement supérieure à la taille du dictionnaire réellement utilisé.

Lzip utilisera, de façon automatique, à la compression, la plus petite taille de dictionnaire possible dans une limite préétablie. Il est important de noter que la taille mémoire nécessaire pour la décompression est directement dépendante de la taille maximale du dictionnaire choisie lors de la compression.

Lors de la décompression, lzip reconstitue le nom du fichier décompressé à partir du fichier compressé de la façon suivante :

nomdefichier.lz devient nomdefichier
nomdefichier.tlz devient nomdefichier.tar
unautrenom devient unautrenom.out

Par mesure de sécurité, lzip stocke, à la fin de chaque membre, le CRC 32 bits ainsi que la taille des données originales non compressées. Cela permet de vérifier que les données décompressées sont identiques à l'original, et donc, d'en contrôler l'intègrité.Cela vous prémunit contre la non détection de corruption des données compressées et contre un éventuel bug indétecté dans lzip (peu vraisemblable, heureusement!). Le risque d'une corruption de données indécelable est microscopique, et représente un risque de 1 sur 4000 millions pour chaque membre traité. Il est à noter, par ailleurs, que le contrôle d'intègrité s'effectue lors de la décompression, de sorte qu'il vous informera qu'il y a une erreur, mais ne pourra pas vous aider à réparer les données originales décompressées. Valeur de retour : 0 pour une terminaison normale sans erreur, 1 indique un problème d'environnement (fichier non trouvé, flags invalides, erreurs d'entrées/sorties, etc...), 2 signifie qu'un fichier d'entrée est corrompu ou invalide, 3 indique une erreur interne (eg, bug) qui provoque la panique de lzip.


Next: , Previous: Introduction, Up: Top

2 Comment lzip compresse les données

Lzip met en oeuvre une version simplifié de l'algorithme LZMA (Lempel-Ziv-Markov chain-Algorithm). Le fort taux de compression de LZMA provient de la combinaison de deux concepts de compressions éprouvés et bien connus : les dictionnaires glissants (LZ77/78) et les modèles de Markov (la technique utilisée par tout les algoritmes de compressions qui utilisent l'encodage par plages, ou un codage similaire, d'ordre entropique 0 à leur dernière étape) avec ségrégation de contexte selon l'utilisation des bits.

Lzip est un compresseur en deux étapes. La première est un codage Lempel-Ziv qui permet de réduire les redondances par translation des blocs de données identiques en leurs équivalences distances-longueurs. La seconde est un encodage qui utilise diffèrents modèles de probabilités suivant le type de donnée; distances, longueurs, octets littéraux etc...

La 'détection de correspondances', partie intègrante du codeur LZ, est la fonction la plus importante de l'algorithme LZMA, comme c'est le cas, d'ailleurs, dans beaucoups d'algorithmes basés sur Lempel-Ziv. La plus grande partie du temps d'exécution de lzip est consacrée à cette 'détection de correspondances', qui, de plus, a une influence considèrable sur le taux de compression.

Voici, étape par étape, comment cela fonctionne :

1) L'en-tête du membre est écrite vers le flux de sortie.

2) Le premier octet est codé littéralement, étant donné qu'il n'y a pas de prédécesseur auquel la 'détection de correspondances' ne puisse se référer.

3) L'encodeur lit ensuite l'octet suivant dans le flux d'entrée, puis lance une 'détection de correspondances'.

4) La 'détection de correspondances' remplit ensuite un tableau, dans lequel elle inscrit les distances mimimums avant l'octet courant, où une correspondance de longueur donnée peut être trouvée.

5) Retour à l'étape 3 jusqu'à ce qu'une séquence (formée de paires, répétitions de distances et octets littéraux) ai pu être formée au coût le plus faible. Le coût représente, ici, le nombre de bits produits en sortie.

6) L'encodeur par plage encode la séquence produite par l'encodeur principal et envoie les octets résultants vers le flux de sortie.

7) Retour à l'étape 3 jusqu'à ce qu'il n'y ai plus de données d'entrée à traiter, ou, que la taille maximale du membre ou du volume soit atteinte.

8) L'encodeur par plage est purgé.

9) Le marqueur de fin de membre est envoyé vers le flux de sortie.

10) Si il reste encore des données à compresser, retour à l'étape 1.


Les idées et concepts qui ont permis la conception de lzip sont en grandes parties dûs aux personnes suivantes: Abraham Lempel et Jacob Ziv (pour l'algorithme LZ), Andrey Markov (pour la définition des chaînes de Markov), G.N.N. Martin (pour la définition de l'encodage par plage), Igor Pavlov (pour avoir réuni les concepts précédents au sein de l'algorithme LZMA), et Julian Seward (pour le CLI de bzip2 et l'idée de unzcrash).


Next: , Previous: Algorithme, Up: Top

3 Utiliser lzip et ses options en ligne de commande

Le format générique de la commande lzip est :

     lzip [options] [fichiers]

Lzip supporte les options suivantes :

`--help'
`-h'
Affiche l'aide décrivant les diffèrentes options puis quitte.
`--version'
`-V'
Affiche le numéro de version de lzip puis quitte.
`--member-size=taille'
`-b taille'
Créer un fichier multimembre et fixer la taille maximum d'un membre à 'taille' en octets. La taille limite mininimum d'un membre est de 100KB. Un membre de petite taille dégradant fortement le taux de compression, il est, de ce fait, recommandé de n'utiliser cette option qu'en cas de stricte nécessité et en toute connaissance de cause. La valeur par défaut de lzip est de produire un seul membre dont la taille est égale à celle du fichier à compresser.
`--stdout'
`-c'
Compresse ou décompresse vers la sortie standart 'stdout'. Obligatoire lors de la lecture d'un tube nommé (pipe,fifo) ou d'un fichier de périphérique comme, par exemple, `/dev/fd0'. A utiliser, aussi, pour récupérer le maximum de données non compressées possible lors de la décompression d'un fichier corrompu.
`--decompress'
`-d'
Décompresse.
`--force'
`-f'
Force la surécriture du fichier de sortie, lors de la compression ou de la décompression, si ce dernier existe déjà. Cela signifie l'effacement du fichier existant, et le remplacement de son contenu par le flux de sortie de lzip, si le fichier existant porte le même nom que celui affecté automatiquement par défaut par lzip ou par lzip avec l'option `-o fichier'.
`--keep'
`-k'
Préserve de l'effacement le(s) fichier(s) donné(s) comme paramètre(s) d'entrée lors de la compression ou de la décompression.
`--match-length=longueur'
`-m longueur'
Fixe la longueur maximale de correspondance en octets. Après qu'une correspondance de cette longueur soit trouvée, la recherche se termine. La plage des valeurs valides va de 5 à 273. Plus cette valeur augmente, meilleur sera le taux de compression, mais, corrèlativement, plus long sera le temps de compression.
`--output=fichier'
`-o fichier'
Lors de la lecture à partir de l'entrée standart `stdin', et que l'option `--stdout' n'a pas été spécifiée, utilise `fichier' comme nom virtuel pour le fichier de données décompressées. Cela produit un fichier nommé `fichier' lors de la décompression, un fichier nommé `fichier.lz' lors de la compression, et plusieurs fichiers nommés `fichier00001.lz' `fichier00002.lz' etc..., lors de la compression multivolume.
`--quiet'
`-q'
opération tranquilité. Supprime tous les messages d'informations et/ou d'avertissements.
`--dictionary-size=taille'
`-s taille'
Fixe la taille maximale du dictionnaire en octets. Les valeurs valides vont 4KiB à 512MiB. Pour chaque membre, lzip utilisera la plus petite taille de dictionnaire possible, dans une certaine limite, préétablie. Il est, à noter, que les tailles de dictionnaires sont quantifiées. Ainsi, si la taille donnée ne correspond pas à une valeur valide, elle est arrondie à la valeur valide immédiatement supérieure.

Pour obtenir une compression maximale, vous pourrriez utiliser une taille de dictionnaire la plus grande possible. Mais, n'oubliez surtout pas, que la taille de la mémoire nécessaire pour la décompression sera directement dépendante de la taille maximale du dictionnaire choisie lors de la compression.

`--volume-size=taille'
`-S taille'
Fractionne la sortie compressée en plusieurs volumes, dont les noms de fichiers sont `nom_original00001.lz' `nom_original00002.lz' etc, et, fixe la taille maximale de chaque volume à taille en octets. Chaque volume est un fichier lzip complet, qui peut être multimembre. La taille minimum d'un volume est fixée à 100KB. Une faible taille de volume pouvant dégrader fortement le taux de compression, il est recommandé de n'utiliser des petites tailles de volumes qu'en cas de stricte nécessité.
`--test'
`-t'
Vérifie l'intégrité du/des fichier(s) compressé(s) sans le/les décompresser. Cette option effectue, en réalité, un essai de décompression, puis en analyse le résultat. Utiliser `-tvv' ou `-tvvv' pour obtenir encore plus d'informations sur un ou des fichiers compressés.
`--verbose'
`-v'
Mode verbeux. Affiche le taux de compression pour chaque fichier fourni comme paramètre dans la ligne de commande. Si on ajoute un ou deux 'v' supplémentaires, le niveau de verbosité augmente.
`-0 .. -9'
Fixe les paramètres de compressions (taille du dictionnaire et longueur maximale de correspondance), comme indiqué dans le tableau ci-dessous. Notez que l'option `-9' peut être énormément plus lente que `-O', mais cela n'a aucune influence sur le temps de décompression.

L'espace bidimensionnel des paramètres de LZMA, peut difficilement être converti en une échelle linéaire qui serait optimale pout tous les types de fichiers. Selon le type de fichier (fichiers de grande taille, très répétitifs, etc...), il se peut que vous ayez à utiliser les options `--match-length' et `--dictionary-size' directement si vous souhaitez obtenir des performances optimales.

Niveau Taille dictionnaire Longueur maximale de correspondance
-0 64KiB 16 octets
-1 1MiB 5 octets
-2 1,5MiB 6 octets
-3 2MiB 8 octets
-4 3MiB 12 octets
-5 4MiB 20 octets
-6 8MiB 36 octets
-7 16MiB 68 octets
-8 24MiB 132 octets
-9 32MiB 273 octets

`--fast'
`--best'
Alias pour maintenir la compatibilité avec GNU gzip

Les nombres fournis comme arguments des options peuvent être suivis d'un coefficient multiplicateur et optionnellement de `B' qui signifie `octet'.

Tableau des préfixes binaires et SI (multiplicateurs d'unité) :

Préfixe Valeur | Préfixe Valeur
K kilooctet (10^3 = 1000) | Ki kibioctet (2^10 = 1024)
M megaoctet (10^6) | Mi mebioctet (2^20)
G gigaoctet (10^9) | Gi gibioctet (2^30)
T teraoctet (10^12) | Ti tebioctet (2^40)
P petaoctet (10^15) | Pi pebioctet (2^50)
E exaoctet (10^18) | Ei exbioctet (2^60)
Z zettaoctet (10^21) | Zi zebioctet (2^70)
Y yottaoctet (10^24) | Yi yobioctet (2^80)


Next: , Previous: Invoquer Lzip, Up: Top

4 Format détaillé d'un fichier compressé

Dans le diagramme ci-dessous, une boîte comme celle-ci :

+---+
|   | <-- les barres verticales peuvent manquer.
+---+

représente un octet;

Une boîte comme celle-là :

+==============+
|              |
+==============+

représente un nombre variable d'octets.


Un fichier lzip consiste en un série de "membres" (blocs de données compressées). Les membres apparaissent simplement l'un après l'autre dans le fichier, sans aucune information additionnelle, que ce soit avant, entre ou après eux.

Chaque membre a la structure suivante :

+--+--+--+--+----+----+=============+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|Marqueur ID| VN | DS | Flux Lzma   | CRC32 | Taille Data   | Taille Membre |
+--+--+--+--+----+----+=============+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Toutes les valeurs multioctets sont stockées dans l'ordre 'little endian' (poids faibles en tête).

`Marqueur ID'
Une chaîne de 4 octets, identifiant le type du membre, et qui contient la valeur "LZIP".
`VN (Numéro de Version, 1 octet)'
Octet réservé, au cas où d'éventuelles modifications seraient requises dans le futur. Les valeurs valides sont 0 et 1. Les fichiers version 0 contiennent uniquement un seul membre et ne contiennent pas le champ `Taille Membre'.
`DS (Taille codée du dictionnaire, 1 octet)'
Les bits 4-0 contiennent le logarithme base 2 de la taille de base du dictionnaire.
Les bits 7-5 contiennent le nombre de "parties" à soustraire de la taille de base du dictionnaire, pour obtenir la taille réelle du dictionnaire utilisé. La taille d'une "partie" est (taille de base du dictionnaire / 16).
Les valeurs valides pour la taille du dictionnaire vont de 4KiB à 512MiB.
`Flux Lzma'
Le flux lzma, terminé par un marqueur de fin de flux. Lors de l'encodage, les valeurs par défauts sont utilisées par l'encodeur.
`CRC32 (4 octets)'
CRC des données originales non compressées.
`Taille Data (8 octets)'
Taille des données originales non compressées.
`Taille Membre (8 octets)'
Taille totale du membre, marqueurs d'en-tête et de fin inclus. Cela facilite, de façon plus sûre, la récupération des membres non endommagés issus de fichiers multimembres.


Next: , Previous: Format de fichier, Up: Top

5 Mini tutoriel avec exemples

AVERTISSEMENT! Même si lzip est exempt de bugs, d'autres facteurs peuvent provoquer la corruption de fichiers compressés (bugs dans les librairies système, erreurs mémoire, etc...). En conséquence, si les données que vous compressez sont importantes, utilisez lzip avec l'option `--keep' et ne supprimez pas le fichier original avant d'avoir vérifié le fichier compressé à l'aide d'une commande comme `lzip -cd fichier.lz | cmp fichier -'.


Exemple 1 : Remplace un fichier régulier par sa version compressée fichier.lz et affiche le taux de compression.
     lzip -v fichier

Exemple 2 : Comme dans 1, mais ici le fichier fichier.lz est multimembre avec une taille de chaque membre fixée à 1MiB. Le taux de compression n'est pas affiché.
     lzip -b 1MiB fichier

Exemples 3 : Restaure un fichier régulier à partir de sa version compressée `fichier.lz'. Si l'opération réussit, `fichier.lz' est suprimé et remplacé par sa version décompressée `fichier'.
     lzip -d fichier.lz

Exemple 4 : Vérifie l'intègrité du fichier compressé `fichier.lz' et affiche son status.
     lzip -tv fichier.lz

Exemple 5 : Compresse une disquette présente dans '/dev/fd0' (en général le lecteur A: sous d'autres OS comme FreeDos etc...) et envoie le flux sortant 'stdout' vers le fichier 'fichier.lz'.
     lzip -c /dev/fd0 > fichier.lz

Exemple 6 : Décompresse partiellement le fichier `fichier.lz' jusqu'à l'obtention des premiers 10KiB de données décompressées.
     lzip -cd fichier.lz | dd bs=1024 count=10

Exemples 7 : Créer une archive tar compressée multivolume avec une taille de volume de 1440KiB.
     tar -c un_répertoire | lzip -S 1440KiB -o nom_de_volume

Exemple 8 : Extraction d'une archive tar compressée multivolume.
     lzip -cd nom_de_volume*.lz | tar -xf -

Exemple 9 : Création d'une sauvegarde (un backup) compressée multivolume, d'un fichier contenant une énorme base de données, en spécifiant une taille de volume de 650MB, et en fixant, pour chaque volume, la taille d'un membre à 32MiB.
     lzip -b 32MiB -S 650MB une_ebd

note: `une_ebd' signifie `une_énorme_base_de_données'


Exemple 10 : Réparer une sauvegarde compressé (un backup) à partir de deux copies gravées sur CD-ROM (consultez le manuel GNU de ddrescue pour de plus amples détails sur l'utilisation de ddrescue).
     ddrescue -b2048 /dev/cdrom imagecd1 fichier1og1
     mount -t iso9660 -o loop,ro imagecd1 /mnt/imagecd
     cp /mnt/imagecd/backup.tar.lz rescued1.tar.lz
     umount /mnt/imagecd
       (Insèrer la seconde copie dans le lecteur CD)
     ddrescue -b2048 /dev/cdrom imagecd2 fichierlog2
     mount -t iso9660 -o loop,ro imagecd2 /mnt/imagecd
     cp /mnt/imagecd/backup.tar.lz rescued2.tar.lz
     umount /mnt/imagecd
     lziprecover -m -o rescued.tar.lz rescued1.tar.lz rescued2.tar.lz

Exemple 11 : Réparer le premier volume de la sauvegarde (du backup) créée dans l'exemple 9 à partir de deux copies, `une_ebd1_00001.lz' et `une_ebd2_00001.lz', dont le membre 00007 dans la première copie est endommagé, le membre 00018 dans la seconde copie est endommagé, et le membre 00012 est endommagé dans les deux copies. (les lignes décalées à droite correspondent aux messages d'erreurs de lzip). Le résultat de la manipulation, montrée en exemple ci-après, est l'obtention de deux copies correctes, à partir de deux copies endommagées.
     lziprecover -s une_ebd1_00001.lz
     lziprecover -s une_ebd2_00001.lz
     lzip -t rec*une_ebd1_00001.lz
       rec00007une_ebd1_00001.lz: crc mismatch (erreur crc)
       rec00012une_ebd1_00001.lz: crc mismatch (erreur crc)
     lzip -t rec*une_ebd2_00001.lz
       rec00012une_ebd2_00001.lz: crc mismatch (erreur crc)
       rec00018une_ebd2_00001.lz: crc mismatch (erreur crc)
     lziprecover -m rec00012une_ebd1_00001.lz rec00012une_ebd2_00001.lz
       Input files merged successfully
     cp rec00007une_ebd2_00001.lz rec00007une_ebd1_00001.lz
     cp rec00012une_ebd1_00001_fixed.lz rec00012une_ebd1_00001.lz
     cp rec00012une_ebd1_00001_fixed.lz rec00012une_ebd2_00001.lz
     cp rec00018une_ebd1_00001.lz rec00018une_ebd2_00001.lz
     cat rec*une_ebd1_00001.lz > une_ebd3_00001.lz
     cat rec*une_ebd2_00001.lz > une_ebd4_00001.lz
     zcmp une_ebd3_00001.lz une_ebd4_00001.lz


Next: , Previous: Exemples, Up: Top

6 Restaurer des données d'un fichier compressé endommagé

Lziprecover est un outil de récupération de données, pour les fichiers compressés avec lzip, qui est capable de réparer les fichiers légèrement endommagés, de réparer des fichiers gravement endommagés à partir de deux ou plusieurs copies, et d'extraire les membres non endommagés de fichiers multimembres.

Lziprecover prend comme arguments les noms des fichiers endommagés, puis écrit soit aucun ou plusieurs fichiers de récupération selon l'opération sélectionnée, et la réussite ou échec de la récupération.

Si les fichiers sont, vraiment, trops endommagés pour que lziprecover puisse les réparer, les données des membres endommagés peuvent être partiellement récupérées, en les écrivant vers le flux de sortie standart `stdout' comme indiqué dans l'exemple qui suit (il est possible que le fichier résultant contienne des données incohèrentes vers la fin) :

     lzip -cd rec00001fichier.lz > rec00001fichier

Si la cause de la corruption de fichier provient d'un média endommagé, la combinaison GNU ddrescue + lziprecover est la meilleure option pour la récupération de données à partir de copies multiples endommagées. Voir See ddrescue-example, pour un exemple.


Next: , Previous: Lziprecover, Up: Top

7 Invoquer Lziprecover

Le format générique de la commande lziprecover est :

     lziprecover [options] [fichiers]

Lziprecover supporte les options suivantes :

`--help'
`-h'
Affiche l'aide décrivant les diffèrentes options, puis quitte.
`--version'
`-V'
Affiche le numéro de version de lziprecover, puis quitte.
`--force'
`-f'
Force la surécriture du fichier de sortie, si ce dernier existe déjà. Cela signifie l'effacement du fichier existant, et le remplacement de son contenu par le flux de sortie de lziprcover, si le fichier existant porte le même nom que celui affecté automatiquement par défaut par lziprecover ou par lziprecover avec l'option `-o fichier'.
`--merge'
Tente de produire un fichier correct en mixant les parties non endommagées de deux (ou plus) copies endommagées. Les copies doivent être des fichiers contenant un seul membre. L'opération peut échouer si les copies ont trops de zones endommagées ou si le même octet est endommagé dans l'ensemble des copies. En cas de réussite, une copie réparée sera écrite dans le fichier `fichier_fixed.lz'.

Pour vous faire une idée, lors d'un mixage de deux copies avec chacune une zone endommagée d'approximativement 1 pour cent, la probabilité de réussir à obtenir un fichier correct est d'environ 98 pour cent. Avec trois copies la probalité passe à 99,97 pour cent. Pour de grands fichiers contenant de très petites erreurs, la probabilité approche les 100 pour cent, et ce, même avec deux copies.

`--output=fichier'
`-o fichier'
Envoie le flux de sortie dans le fichier `fichier' plutôt que dans le fichier par défaut `fichier_fixed.lz'.

En cas de fractionnement (option `--split'), les noms des fichiers produits sont de la forme `rec00001fichier' `rec00002fichier', etc.

`--quiet'
`-q'
Opération tranquilité. Supprime tous les messages d'informations et/ou d'avertissements.
`--repair'
`-R'
Tente de réparer une erreur minime, affectant uniquement un octet, dans un fichier `fichier' contenant un seul membre. En cas de réussite, une copie réparée est écrite dans le fichier `fichier_fixed.lz'. Le fichier `fichier' ne subit strictement aucune modification.
`--split'
`-s'
Fractionner un fichier. Recherche les membres dans le fichier `fichier' et écrit chaque membre dans son propre fichier `.lz'. Vous pouvez, ensuite, utiliser la commande `lzip -t' pour tester l'intègrité des fichiers résultants, décompresser ceux qui ne sont pas endommagés, et tenter de réparer ou de décompresser partiellement ceux qui sont endommagés.

Les noms des fichiers produits sont de la forme `rec00001fichier.lz' `rec00002fichier.lz' etc, et sont conçus pour que lors de l'utilisation de jockers dans les opérations ultèrieures, par exemple `lzip -cd rec*fichier.lz > données_récupérées', les fichiers soient traités dans bon l'ordre.

`--verbose'
`-v'
Mode verbeux. Si on ajoute un ou deux 'v' supplémentaires, le niveau de verbosité augmente.


Next: , Previous: Invoquer Lziprecover, Up: Top

8 Rapporter des Bugs

Il y a probablement des bugs dans lzip. Il y a certainement des erreurs ou omissions dans le présent manuel. Si vous m'en informez, cela sera corrigé. Dans le cas contraire, personne n'en aura connaissance, et, ses erreurs demeuront indéfiniment non corrigées.

Si vous découvrez un bug dans lzip, envoyez moi, s'il vous plaît un mail à lzip-bug@nongnu.org. Mentionnez le numéro de version de lzip, qui peut être obtenu en lançant la commande `lzip --version'.


Previous: Disfonctionnements, Up: Top

Index Conceptuel