Créer un fichier zippé

                    

                    

                    
<?php
/*------------------------------*/
/*
 Titre : Créer un fichier zippé                                                                                     
                                                                                                                          
 Auteur           : artemis                                                                                               
 Date édition     : 22 Juil 2010                                                                                       
 Date mise a jour : 17 Oct 2019
                                                                                          
 Rapport de la maj:                                                                                                       
  - fonctionnement du code vérifié                                                                                  
  - amélioration du code                                                                                               
 Date mise a jour : 16 Fev 2026
                                                                                          
 Rapport de la maj:                                                                                                       
  - amélioration du code                                                                                               
  - fonctionnement du code vérifié                                                                                  
  - refactoring du code en PHP 8                                                                                          
  - modification de la description                                                                                        
*/
/*------------------------------*/

declare(strict_types=1);

class ZipFile
{
    /**
     * Tableau pour stocker les données compressées
     */
    private array $datasec = [];

    /**
     * Répertoire central
     */
    private array $ctrl_dir = [];

    /**
     * Fin de l'enregistrement du répertoire central
     */
    private readonly string $eof_ctrl_dir;

    /**
     * Dernière position offset
     */
    private int $old_offset = 0;

    /**
     * Constructeur
     */
    public function __construct()
    {
        $this->eof_ctrl_dir = "\x50\x4b\x05\x06\x00\x00\x00\x00";
    }

    /**
     * Convertit un timestamp Unix en format date et heure DOS (4 octets)
     * 
     * @param int $unixtime Timestamp Unix (0 = maintenant)
     * @return int Date au format DOS
     */
    private function unix2DosTime(int $unixtime = 0): int
    {
        $timearray = ($unixtime === 0) ? getdate() : getdate($unixtime);

        // Les dates avant 1980 ne sont pas supportées par le format DOS
        if ($timearray['year'] < 1980) {
            $timearray['year'] = 1980;
            $timearray['mon'] = 1;
            $timearray['mday'] = 1;
            $timearray['hours'] = 0;
            $timearray['minutes'] = 0;
            $timearray['seconds'] = 0;
        }

        return (($timearray['year'] - 1980) << 25) | 
               ($timearray['mon'] << 21) |
               ($timearray['mday'] << 16) |
               ($timearray['hours'] << 11) | 
               ($timearray['minutes'] << 5) | 
               ($timearray['seconds'] >> 1);
    }

    /**
     * Convertit un timestamp DOS en chaîne hexadécimale formatée
     * 
     * @param int $dostime Timestamp au format DOS
     * @return string Chaîne de 4 octets
     */
    private function dosTimeToBytes(int $dostime): string
    {
        return pack('V', $dostime);
    }

    /**
     * Ajoute un fichier à l'archive
     * 
     * @param string $data Contenu du fichier

     * @param string $name Nom du fichier dans l'archive (peut contenir un chemin)
     * @param int $time Timestamp Unix (0 = maintenant)
     */
    public function addFile(string $data, string $name, int $time = 0): void
    {
        // Normalise les séparateurs de chemin
        $name = str_replace('\\', '/', $name);

        // Obtient le timestamp DOS formaté
        $dostime = $this->unix2DosTime($time);
        $hexdtime = $this->dosTimeToBytes($dostime);

        // En-tête du fichier local
        $fr = "\x50\x4b\x03\x04";           // Signature du fichier local
        $fr .= "\x14\x00";                  // Version nécessaire pour extraire
        $fr .= "\x00\x00";                  // Drapeau de bit général
        $fr .= "\x08\x00";                  // Méthode de compression (deflate)
        $fr .= $hexdtime;                   
// Date et heure de dernière modification

        // Données du fichier
        $unc_len = strlen($data);
        $crc = crc32($data);
        $zdata = gzcompress($data);
        // Retire les en-têtes gzip (2 octets) et le CRC (4 octets)
        $zdata = substr($zdata, 2, -4);
        $c_len = strlen($zdata);

        $fr .= pack('V', $crc);              // CRC32
        $fr .= pack('V', $c_len);            // Taille compressée
        $fr .= pack('V', $unc_len);          // Taille non compressée
        $fr .= pack('v', strlen($name));     // Longueur du nom de fichier
        $fr .= pack('v', 0);                 // Longueur du champ extra
        $fr .= $name;                        // Nom du fichier

        // Données du fichier compressé
        $fr .= $zdata;

        // Descripteur de données (optionnel mais nécessaire pour streaming)
        $fr .= pack('V', $crc);              // CRC32
        $fr .= pack('V', $c_len);            // Taille compressée
        $fr .= pack('V', $unc_len);          // Taille non compressée

        // Ajoute cette entrée au tableau
        $this->datasec[] = $fr;
        $new_offset = strlen(implode('', $this->datasec));

        // Ajoute au répertoire central
        $cdrec = "\x50\x4b\x01\x02";         // Signature du répertoire central
        $cdrec .= "\x00\x00";                // Version de création
        $cdrec .= "\x14\x00";                
// Version nécessaire pour extraire
        $cdrec .= "\x00\x00";                // Drapeau de bit général
        $cdrec .= "\x08\x00";                // Méthode de compression
        $cdrec .= $hexdtime;                 // Date et heure
        $cdrec .= pack('V', $crc);           // CRC32
        $cdrec .= pack('V', $c_len);         // Taille compressée
        $cdrec .= pack('V', $unc_len);       // Taille non compressée
        $cdrec .= pack('v', strlen($name));  // Longueur du nom de fichier
        $cdrec .= pack('v', 0);              // Longueur du champ extra
        $cdrec .= pack('v', 0);              // Longueur du commentaire
        $cdrec .= pack('v', 0);              // Numéro de disque de départ
        $cdrec .= pack('v', 0);              // Attributs internes
        $cdrec .= pack('V', 32);             
// Attributs externes (bit 'archive')
        $cdrec .= pack('V', $this->old_offset); 
// Offset relatif de l'en-tête local
        
        $this->old_offset = $new_offset;
        $cdrec .= $name;                     // Nom du fichier

        // Sauvegarde dans le répertoire central
        $this->ctrl_dir[] = $cdrec;
    }

    /**
     * Ajoute un fichier depuis le système de fichiers
     * 
     * @param string $filepath Chemin du fichier à ajouter

     * @param string|null $archiveName Nom dans l'archive (null = utilise le nom du fichier)
     * @return bool Succès de l'opération
     */
    public function addFileFromPath(string $filepath, ?string $archiveName = 
null): bool
    {
        if (!is_file($filepath) || !is_readable($filepath)) {
            return false;
        }

        $content = file_get_contents($filepath);
        if ($content === false) {
            return false;
        }

        $name = $archiveName ?? basename($filepath);
        $time = filemtime($filepath) ?: time();

        $this->addFile($content, $name, $time);
        return true;
    }

    /**
     * Ajoute tous les fichiers d'un répertoire
     * 
     * @param string $directory Chemin du répertoire
     * @param string $prefix Préfixe pour les chemins dans l'archive
     * @param bool $recursive Inclure les sous-répertoires
     * @return int Nombre de fichiers ajoutés
     */
    public function addDirectory(string $directory, string $prefix = '', bool 
$recursive = true): int
    {
        if (!is_dir($directory)) {
            return 0;
        }

        $count = 0;
        $directory = rtrim($directory, '/\\');
        
        $iterator = $recursive 
            ? new RecursiveIteratorIterator(
                new RecursiveDirectoryIterator($directory, 
RecursiveDirectoryIterator::SKIP_DOTS)
              )
            : new FilesystemIterator($directory, FilesystemIterator::SKIP_DOTS);

        foreach ($iterator as $file) {
            if ($file->isFile()) {
                $filepath = $file->getPathname();
                $relativePath = $prefix . substr($filepath, strlen($directory) +
 1);
                
                if ($this->addFileFromPath($filepath, $relativePath)) {
                    $count++;
                }
            }
        }

        return $count;
    }

    /**
     * Génère le fichier ZIP
     * 
     * @return string Contenu du fichier ZIP
     */
    public function getZipData(): string
    {
        $data = implode('', $this->datasec);
        $ctrldir = implode('', $this->ctrl_dir);

        return $data .
               $ctrldir .
               $this->eof_ctrl_dir .
               pack('v', count($this->ctrl_dir)) .  
// Nombre total d'entrées sur ce disque
               pack('v', count($this->ctrl_dir)) .  // Nombre total d'entrées
               pack('V', strlen($ctrldir)) .        
// Taille du répertoire central
               pack('V', strlen($data)) .           
// Offset du répertoire central
               "\x00\x00";                          // Longueur du commentaire
    }

    /**
     * Alias de getZipData() pour compatibilité avec l'ancienne classe
     */
    public function file(): string
    {
        return $this->getZipData();
    }

    /**
     * Sauvegarde le ZIP dans un fichier
     * 
     * @param string $filename Chemin du fichier de destination
     * @return bool Succès de l'opération
     */
    public function saveToFile(string $filename): bool
    {
        $data = $this->getZipData();
        return file_put_contents($filename, $data) !== false;
    }

    /**
     * Envoie le ZIP au navigateur pour téléchargement
     * 
     * @param string $filename Nom du fichier pour le téléchargement
     */
    public function download(string $filename = 'archive.zip'): void
    {
        $data = $this->getZipData();

        header('Content-Type: application/zip');
        header('Content-Disposition: attachment; filename="' . $filename . '"');
        header('Content-Length: ' . strlen($data));
        header('Pragma: no-cache');
        header('Expires: 0');

        echo $data;
    }

    /**
     * Obtient le nombre de fichiers dans l'archive
     */
    public function getFileCount(): int
    {
        return count($this->ctrl_dir);
    }

    /**
     * Réinitialise l'archive
     */
    public function reset(): void
    {
        $this->datasec = [];
        $this->ctrl_dir = [];
        $this->old_offset = 0;
    }
}

?>