/**
  * Adds a folder to the archive
  * @param 	string   	$path 	    The folder which will be copied into the archive
  * @param 	string 		$name 		The entry name
  * @return	$this
  * @throws
  */
 public function addFolder($path, $name = null)
 {
     $fs = new Filesystem();
     //check the folder exists
     if (!is_dir($path)) {
         throw new \InvalidArgumentException("Folder \"{$path}\" not found.");
     }
     $path = rtrim($path, '\\//');
     //set the default name
     if (is_null($name)) {
         $name = basename($path);
         if ($name == '.') {
             $name = basename(dirname($path));
         }
     }
     // @see http://us.php.net/manual/en/ziparchive.addfile.php#89813
     // @see http://stackoverflow.com/questions/4620205/php-ziparchive-corrupt-in-windows
     $name = str_replace('\\', '/', ltrim($name, '\\/'));
     if (!empty($name) && $this->archive->statName($name) === false) {
         if ($this->archive->addEmptyDir($name) === false) {
             throw new \RuntimeException("Unable to add folder \"{$path}\" to ZIP archive as \"{$name}\".");
         }
     }
     //** I had to use \DirectoryIterator instead of \deit\filesystem\Finder because I kept hitting the directory not empty when trying to remove files after this method
     $it = new \FilesystemIterator($path);
     foreach ($it as $p) {
         if (empty($name)) {
             $n = $fs->getRelativePath($p->getPathname(), $path);
         } else {
             $n = $name . '/' . $fs->getRelativePath($p->getPathname(), $path);
         }
         $this->add($p->getPathname(), $n);
     }
     return $this;
 }
Beispiel #2
0
 public function remplace_image($search, $urlImage)
 {
     /* recherche des images dans le document 
      *  /word/media
      */
     if (!file_exists($urlImage)) {
         return "RI : pb urlImage.";
     }
     $name = 'word/media/' . $search;
     $info = $this->_objZip->statName($name);
     // l'image n'est pas trouvé
     if ($info === FALSE) {
         return "RI : L'image n'est pas présente dans le docx. (" . $name . ")";
     }
     // image est trouvé, il reste à la remplacer
     $ret = $this->_objZip->deleteName($name);
     if (!$ret) {
         return 'RI pb delete image';
     }
     $ret = $this->_objZip->addFile($urlImage, $name);
     if (!$ret) {
         return 'RI addFile';
     }
     return TRUE;
 }
Beispiel #3
0
function pleiofile_add_folder_to_zip(ZipArchive &$zip_archive, ElggObject $folder, $folder_path = "")
{
    if (!empty($zip_archive) && !empty($folder) && elgg_instanceof($folder, "object", "folder")) {
        $folder_title = elgg_get_friendly_title($folder->title);
        $zip_archive->addEmptyDir($folder_path . $folder_title);
        $folder_path .= $folder_title . DIRECTORY_SEPARATOR;
        $file_options = array("type" => "object", "subtype" => "file", "limit" => false, "relationship" => "folder_of", "relationship_guid" => $folder->getGUID());
        // add files from this folder to the zip
        if ($files = elgg_get_entities_from_relationship($file_options)) {
            foreach ($files as $file) {
                // check if the file exists
                if ($zip_archive->statName($folder_path . $file->originalfilename) === false) {
                    // doesn't exist, so add
                    $zip_archive->addFile($file->getFilenameOnFilestore(), $folder_path . sanitize_file_name($file->originalfilename));
                } else {
                    // file name exists, so create a new one
                    $ext_pos = strrpos($file->originalfilename, ".");
                    $file_name = substr($file->originalfilename, 0, $ext_pos) . "_" . $file->getGUID() . substr($file->originalfilename, $ext_pos);
                    $zip_archive->addFile($file->getFilenameOnFilestore(), $folder_path . sanitize_file_name($file_name));
                }
            }
        }
        // check if there are subfolders
        $folder_options = array("type" => "object", "subtype" => "folder", "limit" => false, "metadata_name_value_pairs" => array("parent_guid" => $folder->getGUID()));
        if ($sub_folders = elgg_get_entities_from_metadata($folder_options)) {
            foreach ($sub_folders as $sub_folder) {
                pleiofile_add_folder_to_zip($zip_archive, $sub_folder, $folder_path);
            }
        }
    }
}
Beispiel #4
0
function zipfile_crc32($filename)
{
    $zip = new ZipArchive();
    $res = $zip->open($filename);
    $filename = basename($filename, ".zip");
    $stats = $zip->statName($filename, ZipArchive::FL_NOCASE | ZipArchive::FL_NODIR);
    $result = dechex($stats["crc"]);
    $zip->close();
    return $result;
}
 public static function assertFileExists($fileZip, $path)
 {
     $oZip = new \ZipArchive();
     if ($oZip->open($fileZip) !== true) {
         return false;
     }
     if ($oZip->statName($path) === false) {
         return false;
     }
     return true;
 }
Beispiel #6
0
 /**
  * Can the current PHPExcel_Reader_IReader read the file?
  *
  * @param 	string 		$pFilename
  * @return 	boolean
  * @throws PHPExcel_Reader_Exception
  */
 public function canRead($pFilename)
 {
     // Check if file exists
     if (!file_exists($pFilename)) {
         throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
     }
     // Check if zip class exists
     if (!class_exists('ZipArchive', FALSE)) {
         throw new PHPExcel_Reader_Exception("ZipArchive library is not enabled");
     }
     $mimeType = 'UNKNOWN';
     // Load file
     $zip = new ZipArchive();
     if ($zip->open($pFilename) === true) {
         // check if it is an OOXML archive
         $stat = $zip->statName('mimetype');
         if ($stat && $stat['size'] <= 255) {
             $mimeType = $zip->getFromName($stat['name']);
         } elseif ($stat = $zip->statName('META-INF/manifest.xml')) {
             $xml = simplexml_load_string($zip->getFromName('META-INF/manifest.xml'));
             $namespacesContent = $xml->getNamespaces(true);
             if (isset($namespacesContent['manifest'])) {
                 $manifest = $xml->children($namespacesContent['manifest']);
                 foreach ($manifest as $manifestDataSet) {
                     $manifestAttributes = $manifestDataSet->attributes($namespacesContent['manifest']);
                     if ($manifestAttributes->{'full-path'} == '/') {
                         $mimeType = (string) $manifestAttributes->{'media-type'};
                         break;
                     }
                 }
             }
         }
         $zip->close();
         return $mimeType === 'application/vnd.oasis.opendocument.spreadsheet';
     }
     return FALSE;
 }
function serveFileFromZIP($baseDir, $zipName, $fileName)
{
    $zip = new ZipArchive();
    if ($zip->open($baseDir . $zipName) !== TRUE) {
        handleError("Could not open ZIP file '{$zipName}'");
    }
    $contents = $zip->getStream($fileName);
    if ($contents === FALSE) {
        $zip->close();
        handleError("Could not find file '{$fileName}' in ZIP file '{$zipName}'");
    }
    $fileSize = $zip->statName($fileName)['size'];
    header('Content-Length: ' . $fileSize);
    header('Content-Type: text/plain');
    fpassthru($contents);
    fclose($contents);
    $zip->close();
    exit;
}
Beispiel #8
0
 /**
  * @param string $file_name
  */
 public function __construct($file_name)
 {
     parent::__construct($file_name);
     $archive = strstr($file_name, '#', true);
     if (strpos($archive, 'zip://') === 0) {
         $this->_zip_name = substr($archive, strlen('zip://'));
     } else {
         $this->_zip_name = $archive;
     }
     $filename = substr(strstr($file_name, '#'), 1);
     $zip = new \ZipArchive();
     $ret = $zip->open($this->_zip_name);
     if (true !== $ret) {
         $message = sprintf('zip error', $ret);
         throw new \RuntimeException($message);
     }
     $this->_stat = $zip->statName($filename);
     $this->_zip = $zip;
     $this->_file_name = $filename;
 }
 public function inspect_zip(ZipArchive $zip)
 {
     $content = array('db' => false, 'fs' => false, 'auto-install' => false);
     if (count(array_filter(array('index.php', 'wp-config.php'), array($zip, 'statName'))) > 0) {
         $content['fs'] = true;
     }
     if ($zip->statName('database.txt') !== false) {
         $content['db'] = true;
     }
     if ($content['db'] || $content['fs']) {
         return $content;
     }
     $s = '/auto-install/database.txt';
     for ($index = 0; $index < $zip->numFiles; ++$index) {
         $name = $zip->getNameIndex($index);
         if (substr($name, -strlen($s)) === $s) {
             $content['auto-install'] = true;
             break;
         }
     }
     return $content;
 }
Beispiel #10
0
 protected function getFromStream()
 {
     try {
         $za = new ZipArchive();
         if ($za->open($this->mwb)) {
             if (0 < $za->numFiles) {
                 $stat = $za->statIndex(0);
                 $filename = $stat["name"];
                 if (basename($filename) == "document.mwb.xml") {
                     $fp = $za->getStream($filename);
                     if (!$fp) {
                         throw new Exception("Error: can't get stream to zipped file");
                     } else {
                         $stat = $za->statName($stat["name"]);
                         $buf = "";
                         ob_start();
                         while (!feof($fp)) {
                             $buf .= fread($fp, 2048);
                         }
                         $xmlstream = ob_get_contents();
                         ob_end_clean();
                         if (stripos($xmlstream, "CRC error") != FALSE) {
                             $errBuff = '';
                             ob_start();
                             echo 'CRC32 mismatch, current ';
                             printf("%08X", crc32($buf));
                             //current CRC
                             echo ', expected ';
                             printf("%08X", $stat['crc']);
                             //expected CRC
                             $error = ob_get_contents();
                             ob_end_clean();
                             fclose($fp);
                             throw new Exception($error);
                         }
                         fclose($fp);
                         $this->xmlstream = $buf;
                     }
                 } else {
                     throw new Exception("archive has to contain document.mwb.xml as first entry document.");
                 }
             } else {
                 $za->close();
                 throw new Exception("zip archive is empty");
             }
         } else {
             throw new Exception("could not open archive " . $this->mwb);
         }
     } catch (Exception $e) {
         $this->error = $e->getMessage();
     }
 }
Beispiel #11
0
 private function addRunnerToArchive($archive, $worker_file_name, $options = array())
 {
     $zip = new \ZipArchive();
     if (!$zip->open($archive, \ZIPARCHIVE::CREATE) === true) {
         $zip->close();
         throw new IronWorkerException("Archive {$archive} was not found!");
     }
     if ($zip->statName($worker_file_name) === false) {
         $zip->close();
         throw new IronWorkerException("File {$worker_file_name} in archive {$archive} was not found!");
     }
     if (!empty($options['set_env']) && is_array($options['set_env'])) {
         $envs = $options['set_env'];
     } else {
         $envs = array();
     }
     if (!$zip->addFromString('runner.php', $this->workerHeader($worker_file_name, $envs))) {
         throw new IronWorkerException("Adding Runner to the worker failed");
     }
     $zip->close();
     return true;
 }
 private function addRunnerToArchive($archive, $worker_file_name)
 {
     $zip = new ZipArchive();
     if (!$zip->open($archive, ZIPARCHIVE::CREATE) === true) {
         $zip->close();
         throw new IronWorker_Exception("Archive {$archive} was not found!");
     }
     if ($zip->statName($worker_file_name) === false) {
         $zip->close();
         throw new IronWorker_Exception("File {$worker_file_name} in archive {$archive} was not found!");
     }
     if (!$zip->addFromString('runner.php', $this->workerHeader($worker_file_name))) {
         throw new IronWorker_Exception("Adding Runner to the worker failed");
     }
     $zip->close();
     return true;
 }
Beispiel #13
0
/**
 * @author Jack
 * @date Sun Sep 20 21:57:13 2015
 * @version 1.1
 */
function zip_contents($file, $path)
{
    $file = safe_add_extension($file, 'zip');
    if (file_exists($file)) {
        if (filesize($file) >= 4294967296) {
            // If the file is bigger than 4G, we can't use PHP's zip for now
            $p7zip = config('p7zip', '/opt/local/bin/7z');
            if (!file_exists($p7zip)) {
                $p7zip = '/usr/bin/7za';
            }
            $spec = array(array("pipe", "r"), array("pipe", "w"), array("pipe", "w"));
            $p = proc_open("{$p7zip} x -so {$file} '{$path}'", $spec, $pipes);
            if (is_resource($p)) {
                $data = stream_get_contents($pipes[1]);
                fclose($pipes[1]);
                proc_close($p);
                return $data;
            }
        } else {
            $zip = new \ZipArchive();
            if ($zip->open($file)) {
                if ($zip->statName($path)) {
                    return file_get_contents('zip://' . $file . '#' . $path);
                }
            }
        }
    }
    return null;
}
Beispiel #14
0
 public function zipCheck($extendtype, $pluginurl, $pluginfile, $pluginfilename)
 {
     //Save extend zip file to server
     $data = file_get_contents($pluginurl);
     $fp = fopen($pluginfile, "wb");
     fwrite($fp, $data);
     fclose($fp);
     if ($extendtype == "languages" || $extendtype == "themes") {
         return true;
     } elseif ($extendtype == "plugins") {
         $zip = new ZipArchive();
         if ($zip->open(GSADMINPATH . $pluginfile) === TRUE) {
             if ($zip->statName($pluginfilename) != "") {
                 return true;
             } else {
                 return false;
             }
             $zip->close();
         }
     }
 }
Beispiel #15
0
/**
 * Add a folder to a zip file
 *
 * @param ZipArchive &$zip_archive the zip file to add files/folder to
 * @param ElggObject $folder       the folder to add
 * @param string     $folder_path  the path of the current folder
 *
 * @return void
 */
function file_tools_add_folder_to_zip(ZipArchive &$zip_archive, ElggObject $folder, $folder_path = '')
{
    if (!$zip_archive instanceof ZipArchive || !elgg_instanceof($folder, 'object', FILE_TOOLS_SUBTYPE)) {
        return;
    }
    $folder_title = elgg_get_friendly_title($folder->title);
    $zip_archive->addEmptyDir($folder_path . $folder_title);
    $folder_path .= $folder_title . DIRECTORY_SEPARATOR;
    $file_options = ['type' => 'object', 'subtype' => 'file', 'limit' => false, 'relationship' => FILE_TOOLS_RELATIONSHIP, 'relationship_guid' => $folder->getGUID()];
    // add files from this folder to the zip
    $files = new ElggBatch('elgg_get_entities_from_relationship', $file_options);
    foreach ($files as $file) {
        // check if the file exists
        if ($zip_archive->statName($folder_path . $file->originalfilename) === false) {
            // doesn't exist, so add
            $zip_archive->addFile($file->getFilenameOnFilestore(), $folder_path . $file->originalfilename);
        } else {
            // file name exists, so create a new one
            $ext_pos = strrpos($file->originalfilename, '.');
            $file_name = substr($file->originalfilename, 0, $ext_pos) . '_' . $file->getGUID() . substr($file->originalfilename, $ext_pos);
            $zip_archive->addFile($file->getFilenameOnFilestore(), $folder_path . $file_name);
        }
    }
    // check if there are subfolders
    $folder_options = ['type' => 'object', 'subtype' => FILE_TOOLS_SUBTYPE, 'limit' => false, 'metadata_name_value_pairs' => ['parent_guid' => $folder->getGUID()]];
    $sub_folders = new ElggBatch('elgg_get_entities_from_metadata', $folder_options);
    foreach ($sub_folders as $sub_folder) {
        file_tools_add_folder_to_zip($zip_archive, $sub_folder, $folder_path);
    }
}
Beispiel #16
0
 public static function getFileContents($archivefilename, $filename, &$buf = null)
 {
     $zip = new \ZipArchive();
     if (!$zip->open($archivefilename)) {
         return array('ok' => false, 'error' => self::ZipStatusString(\ZipArchive::ER_OPEN));
     }
     $fp = $zip->getStream($filename);
     //file inside archive
     if (!$fp) {
         return array('ok' => false, 'error' => self::ZipStatusString(\ZipArchive::ER_OPEN));
     }
     $stat = $zip->statName($filename);
     $buf = "";
     //file buffer
     ob_start();
     //to capture CRC error message
     while (!feof($fp)) {
         $buf .= fread($fp, 2048);
         //reading more than 2156 bytes seems to disable internal CRC32 verification (bug?)
     }
     $s = ob_get_contents();
     ob_end_clean();
     if (stripos($s, "CRC error") != FALSE) {
         //  echo 'CRC32 mismatch, current ';    //\ZipArchive::ER_CRC
         $buf = null;
         fclose($fp);
         $zip->close();
         return array('ok' => false, 'error' => self::ZipStatusString(\ZipArchive::ER_CRC), 'crc32' => sprintf("%08X", crc32($buf)), 'expected' => sprintf("%08X", $stat['crc']));
     }
     fclose($fp);
     $zip->close();
     //Done, unpacked file is stored in $buf
     return array('ok' => true, 'crc32' => sprintf("%08X", crc32($buf)), 'expected' => sprintf("%08X", $stat['crc']), 'byte' => strlen($buf), 'sha1' => sha1($buf));
 }
Beispiel #17
0
                $files[] = $matches[1];
            }
        }
    }
    if (count($files) > 0) {
        $ok = $zip->extractTo($bdir, $files);
    } else {
        $ok = false;
    }
    return $ok;
}
unset($_SESSION["magmi_install_error"]);
$zip = new ZipArchive();
$res = $zip->open($_FILES["magmi_package"]["tmp_name"]);
try {
    $info = $zip->statName('magmi/conf/magmi.ini.default');
    if ($res === TRUE && $info !== FALSE) {
        $ok = extractZipDir($zip, dirname(dirname(__FILE__)), "magmi");
        $zip->close();
        $_SESSION["magmi_install"] = array("info", "Magmi updated");
    } else {
        $zip->close();
        $_SESSION["magmi_install"] = array("error", "Invalid Magmi Archive");
    }
    if (!$ok) {
        $_SESSION["magmi_install"] = array("error", "Cannot unzip Magmi Archive");
    }
    session_write_close();
} catch (Exception $e) {
    session_write_close();
    die($e->getMessage());
Beispiel #18
0
<?php

$fname = dirname(__FILE__) . "/test53885.zip";
if (file_exists($fname)) {
    unlink($fname);
}
touch($fname);
$nx = new ZipArchive();
$nx->open($fname);
$nx->locateName("a", ZIPARCHIVE::FL_UNCHANGED);
$nx->statName("a", ZIPARCHIVE::FL_UNCHANGED);
?>
==DONE==
<?php 
error_reporting(0);
$fname = dirname(__FILE__) . "/test53885.zip";
unlink($fname);
 /**
  * check if a file exists allready
  * @param $NAME name of the file in the zip
  */
 function fileExistsInZip($NAME)
 {
     $zip = new ZipArchive();
     $code = $zip->open($this->functions->settings->zipFile, ZipArchive::CREATE);
     if ($code === TRUE) {
         return !($zip->statName($NAME) === FALSE);
     }
     return false;
 }
Beispiel #20
0
 /**
  * Can the current PHPExcel_Reader_IReader read the file?
  *
  * @param 	string 		$pFileName
  * @return 	boolean
  * @throws Exception
  */
 public function canRead($pFilename)
 {
     // Check if file exists
     if (!file_exists($pFilename)) {
         throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");
     }
     // Check if zip class exists
     if (!class_exists('ZipArchive', FALSE)) {
         throw new Exception("ZipArchive library is not enabled");
     }
     // Load file
     $zip = new ZipArchive();
     if ($zip->open($pFilename) === true) {
         // check if it is an OOXML archive
         $stat = $zip->statName('mimetype');
         if ($stat && $stat['size'] <= 255) {
             $mimeType = $zip->getFromName($stat['name']);
         } else {
             $zip->close();
             return FALSE;
         }
         $zip->close();
         return $mimeType === 'application/vnd.oasis.opendocument.spreadsheet';
     }
     return FALSE;
 }
Beispiel #21
0
 function updateSoftwareArchive($path)
 {
     $statusCode = 0;
     $zip = new ZipArchive();
     if ($zip->open($path) === true) {
         $fileNameInformation = $this->yellow->config->get("updateInformationFile");
         for ($i = 0; $i < $zip->numFiles; ++$i) {
             $fileName = $zip->getNameIndex($i);
             if (empty($pathBase)) {
                 preg_match("#^(.*\\/).*?\$#", $fileName, $matches);
                 $pathBase = $matches[1];
             }
             if ($fileName == $pathBase . $fileNameInformation) {
                 $fileData = $zip->getFromIndex($i);
                 break;
             }
         }
         foreach ($this->yellow->toolbox->getTextLines($fileData) as $line) {
             if (preg_match("/^\\#/", $line)) {
                 continue;
             }
             preg_match("/^\\s*(.*?)\\s*:\\s*(.*?)\\s*\$/", $line, $matches);
             if (lcfirst($matches[1]) == "plugin" || lcfirst($matches[1]) == "theme") {
                 $software = $matches[2];
             }
             if (!empty($software) && !empty($matches[1]) && !empty($matches[2])) {
                 list($fileName, $flags) = explode(',', $matches[2], 2);
                 $fileData = $zip->getFromName($pathBase . $fileName);
                 $metaData = $zip->statName($pathBase . $fileName);
                 $modified = $metaData ? $metaData["mtime"] : 0;
                 $statusCode = $this->updateSoftwareFile($matches[1], $fileData, $modified, $flags, $software);
                 if ($statusCode != 200) {
                     break;
                 }
             }
         }
         $zip->close();
         if ($statusCode == 200 && !$this->yellow->toolbox->deleteFile($path)) {
             $statusCode = 500;
             $this->yellow->page->error($statusCode, "Can't delete file '{$path}'!");
         }
     }
     return $statusCode;
 }
 public function restore(FW_Backup_Interface_Storage $storage, FW_Backup_Interface_File $backup_file)
 {
     /**
      * @var WP_Filesystem_Base $wp_filesystem
      */
     global $wp_filesystem;
     if ($wp_filesystem->abspath() == '/') {
         throw new FW_Backup_Exception('WordPress was located at root directory (/). Restoration for this scenario was not implemented.');
     }
     $wp = rtrim($wp_filesystem->abspath(), '/');
     $wp_new = rtrim(dirname($wp), '/') . '/' . uniqid();
     $wp_backup = $wp . '-' . date('Y-m-d_H-i_s');
     $backup_rel = str_replace(DIRECTORY_SEPARATOR, '/', $this->backup_rel);
     $tmp = array();
     $func = array();
     try {
         // Fetch archive
         $tmp[] = $tmp_zip = $storage->fetch($backup_file);
         $zip = new ZipArchive();
         if (($errno = $zip->open($tmp_zip)) !== true) {
             throw new FW_Backup_Exception(sprintf(__('$zip->open() failed: %d'), $errno));
         }
         $func[] = array($zip, 'close');
         // Restore files (should come before database: rename wordpress dir can fail)
         if (count(array_filter(array('index.php', 'wp-config.php'), array($zip, 'statName'))) > 0) {
             // Extract archive into temporary location
             unzip_file($tmp_zip, $wp_new);
             // Get rid of database.sql file, if any
             if ($wp_filesystem->exists("{$wp_new}/database.sql")) {
                 $wp_filesystem->delete("{$wp_new}/database.sql");
             }
             // Replace wordpress dir by version from backup
             $move = true && $wp_filesystem->move($wp, $wp_backup) && $wp_filesystem->move($wp_new, $wp) && $wp_filesystem->move("{$wp_backup}/{$backup_rel}", "{$wp}/{$backup_rel}");
             if (!$move) {
                 throw new FW_Backup_Exception('Replacing wordpress dir by version from backup failed');
             }
         }
         // Restore database
         if ($zip->statName('database.sql') !== false) {
             $fp = array($fp_settings = tmpfile(), $fp_history = tmpfile());
             // Preserve Backup History and Backup Settings across restore
             $this->ie_history->export($fp_history);
             $this->ie_settings->export($fp_settings);
             // .zip streams does not support seeking
             array_map('rewind', $fp);
             $fp[] = $fp_db = $zip->getStream('database.sql');
             $this->ie_db->import($fp_db);
             $this->ie_history->import($fp_history);
             $this->ie_settings->import($fp_settings);
             array_map('fclose', $fp);
         }
     } catch (Exception $exception) {
         // Delete directory .zip was extracted into
         if ($wp_filesystem->exists($wp_new)) {
             $wp_filesystem->delete($wp_new, true);
         }
         // If backup copy was made
         if ($wp_filesystem->exists($wp_backup)) {
             // 3. Move backup_dir back
             if ($wp_filesystem->exists("{$wp}/{$backup_rel}")) {
                 $wp_filesystem->move("{$wp}/{$backup_rel}", "{$wp_backup}/{$backup_rel}");
             }
             // 2. Delete extracted version
             if ($wp_filesystem->exists($wp)) {
                 $wp_filesystem->delete($wp, true);
             }
             // 1. Move backup'ed directory backup
             $wp_filesystem->move($wp_backup, $wp);
         }
     }
     // on WAMP 2.5 with PHP 5.5.12 and Apache 2.4.9 this makes php crash
     // array_map('call_user_func', $func);
     foreach ($func as $callable) {
         call_user_func($callable);
     }
     array_map('unlink', array_filter($tmp, 'file_exists'));
     if (isset($exception)) {
         throw $exception;
     }
 }
Beispiel #23
0
<?php

$debug = true;
include 'common.inc';
if (!$admin) {
    header('HTTP/1.0 403 Forbidden');
    exit;
}
if (isset($_REQUEST['name']) && isset($_FILES['apk']['tmp_name']) && isset($_FILES['apk']['name'])) {
    $lock = Lock('BrowserUpload', true, 30);
    if ($lock) {
        $valid = false;
        $uploadResult = 'Error processing ' . htmlspecialchars($_FILES['apk']['name']);
        $zip = new ZipArchive();
        if ($zip->open($_FILES['apk']['tmp_name'])) {
            if ($zip->statName('assets/content_shell.pak') !== false) {
                $name = $_REQUEST['name'];
                if (preg_match('/[a-zA-Z0-9_\\-]+/', $name)) {
                    if (!is_file("./browsers/{$name}.apk")) {
                        $valid = true;
                    } else {
                        $uploadResult = "ERROR: A browser named {$name} already exists";
                    }
                } else {
                    $uploadResult = 'ERROR: Invalid browser name: ' . htmlspecialchars($name);
                }
            }
            $zip->close();
        }
        if ($valid) {
            if (move_uploaded_file($_FILES['apk']['tmp_name'], "./browsers/{$name}.apk")) {
 }
 // stores ['fullFileName' => num of occurances]
 // reason for 'fullFileName' as key is file1.JPG and file2.GIF are not the same
 $preExistingFiles = array();
 foreach ($idArr as $fileid) {
     // for each given file ID
     // get data from database
     $query = "SELECT * FROM filestores WHERE id='{$fileid}'";
     $result = mysql_query($query);
     $row = mysql_fetch_array($result);
     $fileData = $row['file'];
     $fileName = $row['filename'];
     $fileExtension = $row['extension'];
     // attempt add to the .ZIP, first check if file already exists
     $fullFileName = $fileName . '.' . $fileExtension;
     if ($zippy->statName($fullFileName) !== false) {
         if (!array_key_exists($fullFileName, $preExistingFiles)) {
             // 1st re-occurance of file in .ZIP, append (1) index
             $preExistingFiles[$fullFileName] = 1;
             $fileName .= "(copy 1)";
         } else {
             // at least 2nd re-occurance of file in .ZIP, append (i) index
             $preExistingFiles[$fullFileName] += 1;
             $fileName .= '(copy ' . $preExistingFiles[$fullFileName] . ')';
         }
     }
     $zippy->addFromString($fileName . '.' . $fileExtension, $fileData);
 }
 $zippy->close();
 // close zippy, saving changes
 // send zip file to web browser with all information
Beispiel #25
0
 /**
  * Adds a file to Archive
  *
  * @param $file_name       string
  * @param $name_in_archive string
  * @return bool Add worked or not
  */
 public function add_file($file_name, $name_in_archive = '')
 {
     $file_name = trim($file_name);
     //check param
     if (empty($file_name)) {
         trigger_error(__('File name cannot be empty', 'backwpup'), E_USER_WARNING);
         return FALSE;
     }
     if (version_compare(PHP_VERSION, '5.3', '>=')) {
         clearstatcache(TRUE, $file_name);
     }
     if (!is_readable($file_name)) {
         trigger_error(sprintf(_x('File %s does not exist or is not readable', 'File to add to archive', 'backwpup'), $file_name), E_USER_WARNING);
         return TRUE;
     }
     if (empty($name_in_archive)) {
         $name_in_archive = $file_name;
     }
     //remove reserved chars
     $name_in_archive = str_replace(array("?", "<", ">", ":", "%", "\"", "*", "|", chr(0)), '', $name_in_archive);
     switch ($this->get_method()) {
         case 'gz':
             if ($this->file_count > 0) {
                 trigger_error(__('This archive method can only add one file', 'backwpup'), E_USER_WARNING);
                 return FALSE;
             }
             //add file to archive
             if (!($fd = fopen($file_name, 'rb'))) {
                 trigger_error(sprintf(__('Cannot open source file %s to archive', 'backwpup'), $file_name), E_USER_WARNING);
                 return FALSE;
             }
             while (!feof($fd)) {
                 fwrite($this->filehandel, fread($fd, 8192));
             }
             fclose($fd);
             $this->file_count++;
             break;
         case 'bz':
             if ($this->file_count > 0) {
                 trigger_error(__('This archive method can only add one file', 'backwpup'), E_USER_WARNING);
                 return FALSE;
             }
             //add file to archive
             if (!($fd = fopen($file_name, 'rb'))) {
                 trigger_error(sprintf(__('Cannot open source file %s to archive', 'backwpup'), $file_name), E_USER_WARNING);
                 return FALSE;
             }
             while (!feof($fd)) {
                 fwrite($this->filehandel, bzcompress(fread($fd, 8192)));
             }
             fclose($fd);
             $this->file_count++;
             break;
         case 'Tar':
         case 'TarGz':
         case 'TarBz2':
             //convert chars for archives file names
             if (function_exists('iconv') && stristr(PHP_OS, 'win') !== false) {
                 $test = @iconv('ISO-8859-1', 'UTF-8', $name_in_archive);
                 if ($test) {
                     $name_in_archive = $test;
                 }
             }
             return $this->tar_file($file_name, $name_in_archive);
             break;
         case 'ZipArchive':
             //convert chars for archives file names
             if (function_exists('iconv') && stristr(PHP_OS, 'win') === false) {
                 $test = @iconv('UTF-8', 'CP437', $name_in_archive);
                 if ($test) {
                     $name_in_archive = $test;
                 }
             }
             $file_size = filesize($file_name);
             if ($file_size === FALSE) {
                 return FALSE;
             }
             //check if entry already in archive and delete it if it not in full size
             if ($zip_file_stat = $this->ziparchive->statName($name_in_archive)) {
                 if ($zip_file_stat['size'] != $file_size) {
                     $this->ziparchive->deleteName($name_in_archive);
                     //reopen on deletion
                     $this->file_count = 21;
                 } else {
                     //file already complete in archive
                     return TRUE;
                 }
             }
             //close and reopen, all added files are open on fs
             if ($this->file_count > 20) {
                 //35 works with PHP 5.2.4 on win
                 if (!$this->ziparchive->close()) {
                     $this->ziparchive_status();
                     trigger_error(__('ZIP archive cannot be closed correctly', 'backwpup'), E_USER_ERROR);
                     sleep(1);
                 }
                 $this->ziparchive = NULL;
                 if (!$this->check_archive_filesize()) {
                     return FALSE;
                 }
                 $this->ziparchive = new ZipArchive();
                 $ziparchive_open = $this->ziparchive->open($this->file, ZipArchive::CREATE);
                 if ($ziparchive_open !== TRUE) {
                     $this->ziparchive_status();
                     return FALSE;
                 }
                 $this->file_count = 0;
             }
             if ($file_size < 1024 * 1024 * 2) {
                 if (!$this->ziparchive->addFromString($name_in_archive, file_get_contents($file_name))) {
                     $this->ziparchive_status();
                     trigger_error(sprintf(__('Cannot add "%s" to zip archive!', 'backwpup'), $name_in_archive), E_USER_ERROR);
                     return FALSE;
                 } else {
                     $file_factor = round($file_size / (1024 * 1024), 4) * 2;
                     $this->file_count = $this->file_count + $file_factor;
                 }
             } else {
                 if (!$this->ziparchive->addFile($file_name, $name_in_archive)) {
                     $this->ziparchive_status();
                     trigger_error(sprintf(__('Cannot add "%s" to zip archive!', 'backwpup'), $name_in_archive), E_USER_ERROR);
                     return FALSE;
                 } else {
                     $this->file_count++;
                 }
             }
             break;
         case 'PclZip':
             $this->pclzip_file_list[] = array(PCLZIP_ATT_FILE_NAME => $file_name, PCLZIP_ATT_FILE_NEW_FULL_NAME => $name_in_archive);
             if (count($this->pclzip_file_list) >= 100) {
                 if (0 == $this->pclzip->add($this->pclzip_file_list)) {
                     trigger_error(sprintf(__('PclZip archive add error: %s', 'backwpup'), $this->pclzip->errorInfo(TRUE)), E_USER_ERROR);
                     return FALSE;
                 }
                 $this->pclzip_file_list = array();
             }
             break;
     }
     return TRUE;
 }
Beispiel #26
0
<?php

$filename = 'MYLOGOV2.GFX';
$zipname = dirname(__FILE__) . "/pecl12414.zip";
$za = new ZipArchive();
$res = $za->open($zipname);
if ($res === TRUE) {
    $finfo = $za->statName($filename);
    $file_size = $finfo['size'];
    if ($file_size > 0) {
        $contents = $za->getFromName($filename);
        echo "ZIP contents size: " . strlen($contents) . "\n";
        if (strlen($contents) != $file_size) {
            echo "zip_readfile recorded data does not match unpacked size: " . $zipname . " : " . $filename;
        }
    } else {
        $contents = false;
        echo "zip_readfile could not open stream from zero length file " . $zipname . " : " . $filename;
    }
    $za->close();
} else {
    echo "zip_readfile could not read from " . $zipname . " : " . $filename;
}
 /**
  * Warning: This test asserts multiple things at once to keep the setup short.
  *
  * @test
  */
 public function createZipFileFromExtensionGeneratesCorrectArchive()
 {
     // 42 second of first day in 1970 - used to have achieve stable file names
     $GLOBALS['EXEC_TIME'] = 42;
     // Create extension for testing:
     $extKey = $this->createFakeExtension();
     $extensionRoot = $this->fakedExtensions[$extKey]['siteAbsPath'];
     // Build mocked fileHandlingUtility:
     $fileHandlerMock = $this->getAccessibleMock(\TYPO3\CMS\Extensionmanager\Utility\FileHandlingUtility::class, array('getAbsoluteExtensionPath', 'getExtensionVersion'));
     $fileHandlerMock->expects($this->any())->method('getAbsoluteExtensionPath')->will($this->returnValue($extensionRoot));
     $fileHandlerMock->expects($this->any())->method('getExtensionVersion')->will($this->returnValue('0.0.0'));
     // Add files and directories to extension:
     touch($extensionRoot . 'emptyFile.txt');
     file_put_contents($extensionRoot . 'notEmptyFile.txt', 'content');
     touch($extensionRoot . '.hiddenFile');
     mkdir($extensionRoot . 'emptyDir');
     mkdir($extensionRoot . 'notEmptyDir');
     touch($extensionRoot . 'notEmptyDir/file.txt');
     // Create zip-file from extension
     $filename = $fileHandlerMock->_call('createZipFileFromExtension', $extKey);
     $expectedFilename = PATH_site . 'typo3temp/ExtensionManager/' . $extKey . '_0.0.0_' . date('YmdHi', 42) . '.zip';
     $this->testFilesToDelete[] = $filename;
     $this->assertEquals($expectedFilename, $filename, 'Archive file name differs from expectation');
     // File was created
     $this->assertTrue(file_exists($filename), 'Zip file not created');
     // Read archive and check its contents
     $archive = new \ZipArchive();
     $this->assertTrue($archive->open($filename), 'Unable to open archive');
     $this->assertEquals($archive->statName('emptyFile.txt')->size, 0, 'Empty file not in archive');
     $this->assertEquals($archive->getFromName('notEmptyFile.txt'), 'content', 'Expected content not found');
     $this->assertFalse($archive->statName('.hiddenFile'), 'Hidden file not in archive');
     $this->assertTrue(is_array($archive->statName('emptyDir/')), 'Empty directory not in archive');
     $this->assertTrue(is_array($archive->statName('notEmptyDir/')), 'Not empty directory not in archive');
     $this->assertTrue(is_array($archive->statName('notEmptyDir/file.txt')), 'File within directory not in archive');
     // Check that the archive has no additional content
     $this->assertEquals($archive->numFiles, 5, 'Too many or too less files in archive');
 }
 /**
  * Implements support for fstat().
  *
  * @return  boolean
  */
 public function stream_stat()
 {
     return $this->archive->statName($this->fileNameInArchive);
 }
Beispiel #29
0
$folder_guids = get_input("folder_guids");
if (empty($file_guids) && empty($folder_guids)) {
    register_error(elgg_echo("InvalidParameterException:MissingParameter"));
    forward(REFERER);
}
$zip = new ZipArchive();
if ($zip->open($zip_filename, ZIPARCHIVE::CREATE) !== true) {
    register_error(elgg_echo("file:downloadfailed"));
    forward(REFERER);
}
// add files to the zip
if (!empty($file_guids)) {
    foreach ($file_guids as $file_guid) {
        if ($file = get_entity($file_guid)) {
            // check if the name exists in the zip
            if ($zip->statName($file->originalfilename) === false) {
                // doesn't exist, so add
                $zip->addFile($file->getFilenameOnFilestore(), $file->originalfilename);
            } else {
                // file name exists, so create a new one
                $ext_pos = strrpos($file->originalfilename, ".");
                $file_name = substr($file->originalfilename, 0, $ext_pos) . "_" . $file->getGUID() . substr($file->originalfilename, $ext_pos);
                $zip->addFile($file->getFilenameOnFilestore(), $file_name);
            }
        }
    }
}
// add folder (and their content) to the zip
if (!empty($folder_guids)) {
    foreach ($folder_guids as $folder_guid) {
        if ($folder = get_entity($folder_guid)) {
 /**
  * Create restore files list
  */
 public function restore_files_list()
 {
     if (is_readable(BACKUPFOLDER)) {
         $dh = opendir(BACKUPFOLDER);
         while ($filename = readdir($dh)) {
             if (filetype($filename) != 'dir') {
                 $file_type = '';
                 preg_match('/\\.[a-z]{2,3}/', $filename, $file_type);
                 if ($file_type[0] == '.zip') {
                     $zip = new ZipArchive();
                     $zip->open(BACKUPFOLDER . $filename);
                     if ($zip->statName('backup.sql')) {
                         $this->restore_files[] = array('name' => $filename, 'size' => round(filesize(BACKUPFOLDER . $filename) / 1024 / 1024, 2), 'create_date' => filemtime(BACKUPFOLDER . $filename));
                     }
                     $zip->close();
                 }
             }
         }
         return $this->restore_files;
     } else {
         return FALSE;
     }
 }