1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen

Mehrere Dateien mit zip.lib.php packen

Dieses Thema im Forum "PHP" wurde erstellt von kuhlmaehn, 22. November 2005.

  1. kuhlmaehn

    kuhlmaehn Erfahrenes Mitglied

    Hi!
    Ich hab folgenden Code im Netz gefunden:

    Code (Text):
    1. <?php
    2. /* $Id: zip.lib.php,v 1.6 2002/03/30 08:24:04 loic1 Exp $ */
    3.  
    4.  
    5. /**
    6.  * Zip file creation class.
    7.  * Makes zip files.
    8.  *
    9.  * Based on :
    10.  *
    11.  *  http://www.zend.com/codex.php?id=535&single=1
    12.  *  By Eric Mueller <eric@themepark.com>
    13.  *
    14.  *  http://www.zend.com/codex.php?id=470&single=1
    15.  *  by Denis125 <webmaster@atlant.ru>
    16.  *
    17.  *  a patch from Peter Listiak <mlady@users.sourceforge.net> for last modified
    18.  *  date and time of the compressed file
    19.  *
    20.  * Official ZIP file format: http://www.pkware.com/appnote.txt
    21.  *
    22.  * @access  public
    23.  */
    24. class zipfile
    25. {
    26.     /**
    27.      * Array to store compressed data
    28.      *
    29.      * @var  array    $datasec
    30.      */
    31.     var $datasec      = array();
    32.  
    33.     /**
    34.      * Central directory
    35.      *
    36.      * @var  array    $ctrl_dir
    37.      */
    38.     var $ctrl_dir     = array();
    39.  
    40.     /**
    41.      * End of central directory record
    42.      *
    43.      * @var  string   $eof_ctrl_dir
    44.      */
    45.     var $eof_ctrl_dir = "\x50\x4b\x05\x06\x00\x00\x00\x00";
    46.  
    47.     /**
    48.      * Last offset position
    49.      *
    50.      * @var  integer  $old_offset
    51.      */
    52.     var $old_offset   = 0;
    53.  
    54.  
    55.     /**
    56.      * Converts an Unix timestamp to a four byte DOS date and time format (date
    57.      * in high two bytes, time in low two bytes allowing magnitude comparison).
    58.      *
    59.      * @param  integer  the current Unix timestamp
    60.      *
    61.      * @return integer  the current date in a four byte DOS format
    62.      *
    63.      * @access private
    64.      */
    65.     function unix2DosTime($unixtime = 0) {
    66.         $timearray = ($unixtime == 0) ? getdate() : getdate($unixtime);
    67.  
    68.         if ($timearray['year'] < 1980) {
    69.             $timearray['year']    = 1980;
    70.             $timearray['mon']     = 1;
    71.             $timearray['mday']    = 1;
    72.             $timearray['hours']   = 0;
    73.             $timearray['minutes'] = 0;
    74.             $timearray['seconds'] = 0;
    75.         } // end if
    76.  
    77.         return (($timearray['year'] - 1980) << 25) | ($timearray['mon'] << 21) | ($timearray['mday'] << 16) |
    78.                 ($timearray['hours'] << 11) | ($timearray['minutes'] << 5) | ($timearray['seconds'] >> 1);
    79.     } // end of the 'unix2DosTime()' method
    80.  
    81.  
    82.     /**
    83.      * Adds "file" to archive
    84.      *
    85.      * @param  string   file contents
    86.      * @param  string   name of the file in the archive (may contains the path)
    87.      * @param  integer  the current timestamp
    88.      *
    89.      * @access public
    90.      */
    91.     function addFile($data, $name, $time = 0)
    92.     {
    93.         $name     = str_replace('\\', '/', $name);
    94.  
    95.         $dtime    = dechex($this->unix2DosTime($time));
    96.         $hexdtime = '\x' . $dtime[6] . $dtime[7]
    97.                   . '\x' . $dtime[4] . $dtime[5]
    98.                   . '\x' . $dtime[2] . $dtime[3]
    99.                   . '\x' . $dtime[0] . $dtime[1];
    100.         eval('$hexdtime = "' . $hexdtime . '";');
    101.  
    102.         $fr   = "\x50\x4b\x03\x04";
    103.         $fr   .= "\x14\x00";            // ver needed to extract
    104.         $fr   .= "\x00\x00";            // gen purpose bit flag
    105.         $fr   .= "\x08\x00";            // compression method
    106.         $fr   .= $hexdtime;             // last mod time and date
    107.  
    108.         // "local file header" segment
    109.         $unc_len = strlen($data);
    110.         $crc     = crc32($data);
    111.         $zdata   = gzcompress($data);
    112.         $zdata   = substr(substr($zdata, 0, strlen($zdata) - 4), 2); // fix crc bug
    113.         $c_len   = strlen($zdata);
    114.         $fr      .= pack('V', $crc);             // crc32
    115.         $fr      .= pack('V', $c_len);           // compressed filesize
    116.         $fr      .= pack('V', $unc_len);         // uncompressed filesize
    117.         $fr      .= pack('v', strlen($name));    // length of filename
    118.         $fr      .= pack('v', 0);                // extra field length
    119.         $fr      .= $name;
    120.  
    121.         // "file data" segment
    122.         $fr .= $zdata;
    123.  
    124.         // "data descriptor" segment (optional but necessary if archive is not
    125.         // served as file)
    126.         $fr .= pack('V', $crc);                 // crc32
    127.         $fr .= pack('V', $c_len);               // compressed filesize
    128.         $fr .= pack('V', $unc_len);             // uncompressed filesize
    129.  
    130.         // add this entry to array
    131.         $this -> datasec[] = $fr;
    132.         $new_offset        = strlen(implode('', $this->datasec));
    133.  
    134.         // now add to central directory record
    135.         $cdrec = "\x50\x4b\x01\x02";
    136.         $cdrec .= "\x00\x00";                // version made by
    137.         $cdrec .= "\x14\x00";                // version needed to extract
    138.         $cdrec .= "\x00\x00";                // gen purpose bit flag
    139.         $cdrec .= "\x08\x00";                // compression method
    140.         $cdrec .= $hexdtime;                 // last mod time & date
    141.         $cdrec .= pack('V', $crc);           // crc32
    142.         $cdrec .= pack('V', $c_len);         // compressed filesize
    143.         $cdrec .= pack('V', $unc_len);       // uncompressed filesize
    144.         $cdrec .= pack('v', strlen($name) ); // length of filename
    145.         $cdrec .= pack('v', 0 );             // extra field length
    146.         $cdrec .= pack('v', 0 );             // file comment length
    147.         $cdrec .= pack('v', 0 );             // disk number start
    148.         $cdrec .= pack('v', 0 );             // internal file attributes
    149.         $cdrec .= pack('V', 32 );            // external file attributes - 'archive' bit set
    150.  
    151.         $cdrec .= pack('V', $this -> old_offset ); // relative offset of local header
    152.         $this -> old_offset = $new_offset;
    153.  
    154.         $cdrec .= $name;
    155.  
    156.         // optional extra field, file comment goes here
    157.         // save to central directory
    158.         $this -> ctrl_dir[] = $cdrec;
    159.     } // end of the 'addFile()' method
    160.  
    161.  
    162.     /**
    163.      * Dumps out file
    164.      *
    165.      * @return  string  the zipped file
    166.      *
    167.      * @access public
    168.      */
    169.     function file()
    170.     {
    171.         $data    = implode('', $this -> datasec);
    172.         $ctrldir = implode('', $this -> ctrl_dir);
    173.  
    174.         return
    175.             $data .
    176.             $ctrldir .
    177.             $this -> eof_ctrl_dir .
    178.             pack('v', sizeof($this -> ctrl_dir)) .  // total # of entries "on this disk"
    179.             pack('v', sizeof($this -> ctrl_dir)) .  // total # of entries overall
    180.             pack('V', strlen($ctrldir)) .           // size of central dir
    181.             pack('V', strlen($data)) .              // offset to start of central dir
    182.             "\x00\x00";                             // .zip file comment length
    183.     } // end of the 'file()' method
    184.  
    185. } // end of the 'zipfile' class
    186. ?>
    Und mit folgendem Code wird ein Zip aus der Datei test.txt erstellt, die im selben Ordner ist:

    Code (Text):
    1. <?php
    2.     // appel de la classe
    3.     require_once('zip.lib.php');
    4.     // nom du fichier à ajouter dans l'archive
    5.     $filename = 'test.txt';
    6.    
    7.     // contenu du fichier
    8.     $fp = fopen ($filename, 'r');
    9.     $content = fread($fp, filesize($filename));
    10.     fclose ($fp);
    11.    
    12.     // création d'un objet 'zipfile'
    13.     $zip = new zipfile();
    14.     // ajout du fichier dans cet objet
    15.     $zip->addfile($content, $filename);
    16.    
    17.     // production de l'archive' Zip
    18.     $archive = $zip->file();
    19.  
    20.     // entêtes HTTP
    21.     header('Content-Type: application/x-zip');
    22.     // force le téléchargement
    23.     header('Content-Disposition: inline; filename=archive.zip');
    24.    
    25.     // envoi du fichier au navigateur
    26.     echo $archive;
    27. ?>

    Mein Problem ist jetzt mehrere Dateien zu packen. Also z.B. test1.txt und test2.txt.
    Ich hab schon alles Mögliche probiert aber es haut nicht hin.
    Ich hoffe ihr könnt mir helfen.
    Vielen Dank schonmal,
    kuhlmaehn
     
  2. Blaschki

    Blaschki Erfahrenes Mitglied

    so:
    PHP:
    1. <?
    2. require('zip.lib.php');
    3.  
    4. $zipfile = new zipfile('test.zip');
    5.  
    6. $zipfile->addFileAndRead('test1.txt');  
    7. $zipfile->addFileAndRead('test2.txt');
    8. $zipfile->addFileAndRead('test3.txt');
    9. $zipfile->addFileAndRead('test4.txt');
    10.  
    11. echo $zipfile->file();
    12. ?>
    getestet aber nur mit der "zip.lip"

    PHP:
    1. <?php
    2.  
    3. class zipfile {
    4.  
    5.   var $datasec       = array();
    6.   var $ctrl_dir      = array();
    7.   var $eof_ctrl_dir  = "\x50\x4b\x05\x06\x00\x00\x00\x00";
    8.   var $old_offset    = 0;
    9.   var $pathToFPDF    = NULL;
    10.   var $pathToDeepDir = NULL;
    11.  
    12.   function zipfile ($output_filename = 'archive.zip', $DeepDir = './DeepDir.php', $FPDF = './fpdf.php') {
    13.  
    14.     //header("Content-type: application/octet-stream");
    15.     header('Content-Type: application/zip');
    16.     header('Content-disposition: attachment; filename="' . $output_filename . '"');
    17.     header('Expires: 0');
    18.     header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
    19.     header('Pragma: public');
    20.  
    21.     $this->pathToFPDF    = $FPDF;
    22.     $this->pathToDeepDir = $DeepDir;
    23.  
    24.   }
    25.  
    26.   function read_File ($file) {
    27.  
    28.     if (is_file($file)) {
    29.  
    30.       $fp = fopen ($file, 'rb');
    31.       $content = fread ($fp, filesize($file));
    32.       fclose ($fp);
    33.  
    34.       return $content;
    35.  
    36.     }
    37.  
    38.   }
    39.  
    40.   function replaceSuffix ($file, $suffix = 'pdf') {
    41.  
    42.     $arr = explode('.', $file);
    43.     unset($arr[count($arr) - 1]);
    44.     $file = NULL;
    45.     foreach($arr as $v) $file .= $v . '.';
    46.     $file .= $suffix;
    47.  
    48.     return $file;
    49.  
    50.   }
    51.  
    52.   function getDirContent ($dirName = './') {
    53.  
    54.     if (is_dir($dirName)) {
    55.  
    56.       if (include($this->pathToDeepDir)) {
    57.  
    58.         $dir = new DeepDir();
    59.         $dir->setDir($dirName);
    60.         $dir->load();
    61.  
    62.         return $dir->files;
    63.  
    64.       } else {
    65.  
    66.         if ($handle = opendir($dirName)) {
    67.  
    68.           while (false !== ($file = readdir($handle))) {
    69.  
    70.             if (($file != '.') && ($file != '..') && (is_file($file))) {
    71.  
    72.               $content[] = $file;
    73.  
    74.             }
    75.  
    76.           }
    77.  
    78.           closedir($handle);
    79.  
    80.           return $content;
    81.  
    82.         }
    83.  
    84.       }
    85.  
    86.     }
    87.  
    88.   }
    89.  
    90.   function addDirContent ($dir = './') {
    91.  
    92.     foreach ($this->getDirContent($dir) as $input) {
    93.       $this->addFileAndRead(str_replace('.//', NULL, $input));
    94.     }
    95.  
    96.   }
    97.  
    98.   function addFileAndRead ($file) {
    99.  
    100.     if (is_file($file))
    101.       $this->addFile($this->read_File($file), $file);
    102.  
    103.   }
    104.  
    105.   function addFileAsPDF ($file, $title = 'PDF File', $author = 'Anonymous') {
    106.     //You need FPDF to use this function!
    107.     //get it at http://www.fpdf.org/
    108.  
    109.     if (include($this->pathToFPDF)) {
    110.  
    111.       $pdf = new PDF();
    112.       $pdf->Open();
    113.  
    114.       //edit this as you need it
    115.  
    116.       $pdf->SetTitle($title);
    117.       $pdf->SetAuthor($author);
    118.       $pdf->PrintChapter(1, $author, $file);
    119.  
    120.       //nothing to edit below!
    121.  
    122.       $this->addFile($pdf->getBuffer(), $this->replaceSuffix($file));
    123.  
    124.     } else {
    125.  
    126.       $filecontent = implode(NULL, file($file));
    127.  
    128.       $content    .= '********************************************' . "\n";
    129.       $content    .= '*                                          *' . "\n";
    130.       $content    .= '*   Couldn\'t find FPDF!                   *' . "\n";
    131.       $content    .= '*   Adding this File as plain text file.   *' . "\n";
    132.       $content    .= '*                                          *' . "\n";
    133.       $content    .= '*   Below this box is the sourcefile.      *' . "\n";
    134.       $content    .= '*                                          *' . "\n";
    135.       $content    .= '********************************************' . "\n";
    136.  
    137.       $content    .= ' ' . "\n";
    138.       $content    .= ' ' . "\n";
    139.       $content    .= ' ' . "\n";
    140.  
    141.       $content    .= $filecontent;
    142.  
    143.       $this->addFile($content, $file);
    144.  
    145.     }
    146.  
    147.   }
    148.  
    149.   function unix2DosTime($unixtime = 0) {
    150.  
    151.     $timearray = ($unixtime == 0) ? getdate() : getdate($unixtime);
    152.  
    153.     if ($timearray['year'] < 1980) {
    154.  
    155.       $timearray['year']    = 1980;
    156.       $timearray['mon']     = 1;
    157.       $timearray['mday']    = 1;
    158.       $timearray['hours']   = 0;
    159.       $timearray['minutes'] = 0;
    160.       $timearray['seconds'] = 0;
    161.  
    162.     }
    163.  
    164.     return (($timearray['year'] - 1980) << 25) | ($timearray['mon'] << 21) | ($timearray['mday'] << 16) |
    165.       ($timearray['hours'] << 11) | ($timearray['minutes'] << 5) | ($timearray['seconds'] >> 1);
    166.  
    167.   }
    168.  
    169.   function addFile($data, $name, $time = 0) {
    170.  
    171.     $name     = str_replace('\\', '/', $name);
    172.  
    173.     $dtime    = dechex($this->unix2DosTime($time));
    174.     $hexdtime = '\x' . $dtime[6] . $dtime[7]
    175.               . '\x' . $dtime[4] . $dtime[5]
    176.               . '\x' . $dtime[2] . $dtime[3]
    177.               . '\x' . $dtime[0] . $dtime[1];
    178.  
    179.     eval('$hexdtime = "' . $hexdtime . '";');
    180.  
    181.     $fr   = "\x50\x4b\x03\x04";
    182.     $fr   .= "\x14\x00";            // ver needed to extract
    183.     $fr   .= "\x00\x00";            // gen purpose bit flag
    184.     $fr   .= "\x08\x00";            // compression method
    185.     $fr   .= $hexdtime;             // last mod time and date
    186.  
    187.     // "local file header" segment
    188.     $unc_len = strlen($data);
    189.     $crc     = crc32($data);
    190.     $zdata   = gzcompress($data);
    191.     $zdata   = substr(substr($zdata, 0, strlen($zdata) - 4), 2); // fix crc bug
    192.     $c_len   = strlen($zdata);
    193.     $fr      .= pack('V', $crc);             // crc32
    194.     $fr      .= pack('V', $c_len);           // compressed filesize
    195.     $fr      .= pack('V', $unc_len);         // uncompressed filesize
    196.     $fr      .= pack('v', strlen($name));    // length of filename
    197.     $fr      .= pack('v', 0);                // extra field length
    198.     $fr      .= $name;
    199.  
    200.     // "file data" segment
    201.     $fr .= $zdata;
    202.  
    203.     // "data descriptor" segment (optional but necessary if archive is not
    204.     // served as file)
    205.     $fr .= pack('V', $crc);                 // crc32
    206.     $fr .= pack('V', $c_len);               // compressed filesize
    207.     $fr .= pack('V', $unc_len);             // uncompressed filesize
    208.  
    209.     // add this entry to array
    210.     $this -> datasec[] = $fr;
    211.     $new_offset        = strlen(implode('', $this->datasec));
    212.  
    213.     // now add to central directory record
    214.     $cdrec  = "\x50\x4b\x01\x02";
    215.     $cdrec .= "\x00\x00";                // version made by
    216.     $cdrec .= "\x14\x00";                // version needed to extract
    217.     $cdrec .= "\x00\x00";                // gen purpose bit flag
    218.     $cdrec .= "\x08\x00";                // compression method
    219.     $cdrec .= $hexdtime;                 // last mod time & date
    220.     $cdrec .= pack('V', $crc);           // crc32
    221.     $cdrec .= pack('V', $c_len);         // compressed filesize
    222.     $cdrec .= pack('V', $unc_len);       // uncompressed filesize
    223.     $cdrec .= pack('v', strlen($name) ); // length of filename
    224.     $cdrec .= pack('v', 0 );             // extra field length
    225.     $cdrec .= pack('v', 0 );             // file comment length
    226.     $cdrec .= pack('v', 0 );             // disk number start
    227.     $cdrec .= pack('v', 0 );             // internal file attributes
    228.     $cdrec .= pack('V', 32 );            // external file attributes - 'archive' bit set
    229.  
    230.     $cdrec .= pack('V', $this -> old_offset ); // relative offset of local header
    231.     $this -> old_offset = $new_offset;
    232.  
    233.     $cdrec .= $name;
    234.  
    235.     // optional extra field, file comment goes here
    236.     // save to central directory
    237.     $this -> ctrl_dir[] = $cdrec;
    238.  
    239.   }
    240.  
    241.   function file() {
    242.  
    243.     $data    = implode(NULL, $this -> datasec);
    244.     $ctrldir = implode(NULL, $this -> ctrl_dir);
    245.  
    246.     return $data .
    247.            $ctrldir .
    248.            $this -> eof_ctrl_dir .
    249.            pack('v', sizeof($this -> ctrl_dir)) .  // total # of entries "on this disk"
    250.            pack('v', sizeof($this -> ctrl_dir)) .  // total # of entries overall
    251.            pack('V', strlen($ctrldir)) .           // size of central dir
    252.            pack('V', strlen($data)) .              // offset to start of central dir
    253.            "\x00\x00";                             // .zip file comment length
    254.   }
    255.  
    256. }
    257.  
    258. ?>
     
    Zuletzt bearbeitet: 23. November 2005
  3. kuhlmaehn

    kuhlmaehn Erfahrenes Mitglied

    Super vielen Dank!
    Hatte schon fast aufgegeben :)
     
  4. andreas_ei

    andreas_ei Grünschnabel

    Ich weiss ist schon sehr alt der Beitrag,
    aber wie kann ich es verhindern das das Pfad im zip mit gespeichert wird ?


    Gruss Andreas
     
Die Seite wird geladen...