コード例 #1
1
ファイル: ZipArchive.php プロジェクト: nnnnathann/piwik
 /**
  * Extract files from archive to target directory
  *
  * @param string  $pathExtracted  Absolute path of target directory
  * @return mixed  Array of filenames if successful; or 0 if an error occurred
  */
 public function extract($pathExtracted)
 {
     if (substr_compare($pathExtracted, '/', -1)) {
         $pathExtracted .= '/';
     }
     $fileselector = array();
     $list = array();
     $count = $this->ziparchive->numFiles;
     if ($count === 0) {
         return 0;
     }
     for ($i = 0; $i < $count; $i++) {
         $entry = $this->ziparchive->statIndex($i);
         $filename = str_replace('\\', '/', $entry['name']);
         $parts = explode('/', $filename);
         if (!strncmp($filename, '/', 1) || array_search('..', $parts) !== false || strpos($filename, ':') !== false) {
             return 0;
         }
         $fileselector[] = $entry['name'];
         $list[] = array('filename' => $pathExtracted . $entry['name'], 'stored_filename' => $entry['name'], 'size' => $entry['size'], 'compressed_size' => $entry['comp_size'], 'mtime' => $entry['mtime'], 'index' => $i, 'crc' => $entry['crc']);
     }
     $res = $this->ziparchive->extractTo($pathExtracted, $fileselector);
     if ($res === false) {
         return 0;
     }
     return $list;
 }
コード例 #2
1
 /**
  * Upload component
  *
  * @requires component package file,
  *
  * @return bool;
  */
 public function upload()
 {
     $archive = new ZipArchive();
     $data_dir = ossn_get_userdata('tmp/components');
     if (!is_dir($data_dir)) {
         mkdir($data_dir, 0755, true);
     }
     $zip = $_FILES['com_file'];
     $newfile = "{$data_dir}/{$zip['name']}";
     if (move_uploaded_file($zip['tmp_name'], $newfile)) {
         if ($archive->open($newfile) === TRUE) {
             $archive->extractTo($data_dir);
             //make community components works on installer #394
             $validate = $archive->statIndex(0);
             $validate = str_replace('/', '', $validate['name']);
             $archive->close();
             if (is_dir("{$data_dir}/{$validate}") && is_file("{$data_dir}/{$validate}/ossn_com.php") && is_file("{$data_dir}/{$validate}/ossn_com.xml")) {
                 $archive->open($newfile);
                 $archive->extractTo(ossn_route()->com);
                 $archive->close();
                 $this->newCom($validate);
                 OssnFile::DeleteDir($data_dir);
                 return true;
             }
         }
     }
     return false;
 }
コード例 #3
0
 public function action($parent)
 {
     $c = $parent->config;
     $util = new Utility();
     if (strpos($_POST['path'], '/') === 0 || strpos($_POST['path'], '../') !== false || strpos($_POST['path'], './') === 0) {
         $this->r = array('wrong path', 400);
         return;
     }
     $path = $c['current_path'] . $_POST['path'];
     $info = pathinfo($path);
     $base_folder = $c['current_path'] . $util->fix_dirname($_POST['path']) . "/";
     switch ($info['extension']) {
         case "zip":
             $zip = new \ZipArchive();
             if ($zip->open($path) === true) {
                 //make all the folders
                 for ($i = 0; $i < $zip->numFiles; $i++) {
                     $OnlyFileName = $zip->getNameIndex($i);
                     $FullFileName = $zip->statIndex($i);
                     if (substr($FullFileName['name'], -1, 1) == "/") {
                         $util->create_folder($base_folder . $FullFileName['name']);
                     }
                 }
                 //unzip into the folders
                 for ($i = 0; $i < $zip->numFiles; $i++) {
                     $OnlyFileName = $zip->getNameIndex($i);
                     $FullFileName = $zip->statIndex($i);
                     if (!(substr($FullFileName['name'], -1, 1) == "/")) {
                         $fileinfo = pathinfo($OnlyFileName);
                         if (in_array(strtolower($fileinfo['extension']), $ext)) {
                             copy('zip://' . $path . '#' . $OnlyFileName, $base_folder . $FullFileName['name']);
                         }
                     }
                 }
                 $zip->close();
             } else {
                 $this->r = array('Could not extract. File might be corrupt.', 500);
                 return;
             }
             break;
         case "gz":
             $p = new \PharData($path);
             $p->decompress();
             // creates files.tar
             break;
         case "tar":
             // unarchive from the tar
             $phar = new \PharData($path);
             $phar->decompressFiles();
             $files = array();
             $util->check_files_extensions_on_phar($phar, $files, '', $ext);
             $phar->extractTo($current_path . fix_dirname($_POST['path']) . "/", $files, true);
             break;
         default:
             $this->r = array('This extension is not supported. Valid: zip, gz, tar.', 400);
             return;
             break;
     }
 }
コード例 #4
0
 /**
  * @param \ZipArchive $stream
  * @return string
  */
 private function getPluginNamespace(\ZipArchive $stream)
 {
     $segments = $stream->statIndex(0);
     $segments = array_filter(explode('/', $segments['name']));
     if (count($segments) <= 1) {
         $segments = $stream->statIndex(1);
         $segments = array_filter(explode('/', $segments['name']));
     }
     if (!in_array($segments[0], ['Frontend', 'Backend', 'Core'])) {
         throw new \RuntimeException(sprintf('Uploaded zip archive contains no plugin namespace directory: %s', $segments[1]));
     }
     return implode('/', $segments);
 }
コード例 #5
0
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->georgiaVoterService->setConnectionName($input->getArgument('dbname'));
     if ($input->getOption('config')) {
         $this->georgiaVoterService->setConfigFolder($input->getOption('config'));
     }
     // setConfigFolder
     $zip = new \ZipArchive();
     $res = $zip->open($input->getArgument('zipFile'));
     if ($res === TRUE) {
         $this->georgiaVoterService->initializeGeorgiaVoterTable();
         $compressedfiles = [];
         for ($i = 0; $i < $zip->numFiles; $i++) {
             $compressedfiles[] = $zip->statIndex($i);
         }
         usort($compressedfiles, function ($a, $b) {
             if ($a['size'] == $b['size']) {
                 return 0;
             }
             return $a['size'] < $b['size'] ? -1 : 1;
         });
         $maxentry = array_pop($compressedfiles);
         $exportDate = \date("Y-m-d", $maxentry['mtime']);
         $fp = $zip->getStream($maxentry['name']);
         while (($buffer = fgets($fp, 4096)) !== false) {
             $output->writeln($buffer);
         }
     } else {
         $output->writeln("Zip File Problem");
     }
 }
コード例 #6
0
 public function testCompressFolder()
 {
     $files = array('releases-noNewPatch.xml', 'releases-patchsOnly.xml', 'releases.xml', 'folder/', 'folder/emptyFile', 'emptyFolder/');
     $dest = dirname(__FILE__) . '/backup/test.zip';
     $src = dirname(__FILE__) . '/sample';
     taoUpdate_helpers_Zip::compressFolder($src, $dest);
     $this->assertTrue(is_file($dest));
     $zip = new ZipArchive();
     $zip->open($dest);
     foreach ($files as $file) {
         $this->assertFalse($zip->locateName($file) === false, $file . ' not found');
     }
     $this->assertFalse($zip->locateName('.svn'));
     helpers_File::remove($dest);
     $dest = dirname(__FILE__) . '/backup/test2.zip';
     taoUpdate_helpers_Zip::compressFolder($src, $dest, true);
     $files = array('sample/releases-noNewPatch.xml', 'sample/releases-patchsOnly.xml', 'sample/releases.xml', 'sample/folder/', 'sample/folder/emptyFile', 'sample/emptyFolder/');
     $this->assertTrue(is_file($dest));
     $zip = new ZipArchive();
     $zip->open($dest);
     for ($i = 0; $i < $zip->numFiles; $i++) {
         $stat = $zip->statIndex($i);
         //cehck no .svn added in zip
         $this->assertFalse(strpos($stat['name'], '.svn') > 0);
     }
     foreach ($files as $file) {
         $this->assertFalse($zip->locateName($file) === false);
     }
     helpers_File::remove($dest);
 }
コード例 #7
0
 function import($inputFile, $targetDirectory = null)
 {
     if (!$targetDirectory) {
         $targetDirectory = '';
     }
     $finfo = finfo_open(FILEINFO_MIME_TYPE);
     $type = finfo_file($finfo, $inputFile);
     finfo_close($finfo);
     switch ($type) {
         case 'application/zip':
             $zip = new ZipArchive();
             $zip->open($inputFile);
             $i = 0;
             while ($i < $zip->numFiles) {
                 $file = $zip->statIndex($i);
                 $contents = '';
                 $fp = $zip->getStream($file['name']);
                 while (!feof($fp)) {
                     $contents .= fread($fp, 2);
                 }
                 SiteCollection::createFile($targetDirectory . $file['name'], $contents);
                 fclose($fp);
                 $i++;
             }
             break;
         default:
             throw new Exception('MIME type ' . $type . ' unsupported.');
     }
 }
コード例 #8
0
ファイル: ZipCommand.php プロジェクト: guitarpoet/clips-tool
 public function execute($args)
 {
     if ($args) {
         $file = $args[0];
         if (file_exists($file) && \Clips\is_zip($file)) {
             switch (count($args)) {
                 case 1:
                     $p = new \ZipArchive();
                     $p->open($file);
                     for ($i = 0; $i < $p->numFiles; $i++) {
                         $stat = $p->statIndex($i);
                         echo $stat['name'] . PHP_EOL;
                         print_r($stat);
                     }
                     break;
                 default:
                     echo \Clips\zip_contents($file, $args[1]);
             }
         } else {
             $this->error("The file {$file} is not exists or is not a phar file!");
         }
     } else {
         $this->error('No phar file input!');
     }
 }
コード例 #9
0
ファイル: DBImport.php プロジェクト: serega011/izumrud
  public function importtables($thisfolder) {                            // the main sub in our application
   $PHP_EOL = "\r\n";
//  if (file_exists($filename)) unlink ($filename);
   
   $za = new ZipArchive(); 
   $za->open($thisfolder.'/update.zip');
   
//   if ($txt=="update") {
    echo "Files in zip archive: ".$za->numFiles.$PHP_EOL;
    echo "Extracting to ".$thisfolder."".$PHP_EOL;
    $za->extractTo($thisfolder."");
//   } else {
//    echo "Single table mode".$PHP_EOL;
//   }
   
   $tablenames = array(
    'Money'
   );
//    'Projects'
   
   $filenames = array(
    'Money.dbu'
   );
//    'Projects.dbu'
   
   echo "------\r";
   for($i = 0; $i < $za->numFiles; $i++) {
    $stat = $za->statIndex($i);
    if (in_array($stat['name'],$filenames)) {
     $filename=$thisfolder."/".$stat['name'];
     if (file_exists($filename)) echo $filename." extracted successfully".$PHP_EOL;
    }
   }
   
   echo "------\r";
   for($i = 0; $i < sizeof($filenames); $i++) {
    $filename=$thisfolder."/".$filenames[$i];
    if (file_exists($filename)) {
     echo "Reading data from ".$filenames[$i].$PHP_EOL;
     $file = conv(file_get_contents($filename));
     $json = json_decode($file);
     if (sizeof($json)) {
      echo "Importing data (".strlen($file)." Kb)".$PHP_EOL;
      $this->importtable($json, $txt);
     } else {
      echo "JSON decode error ".echo_jerror(json_last_error()).$PHP_EOL;
     }
     echo "------\r";
    } else {
     echo "File not found".$PHP_EOL;
    }
   }
   
 //    ajax_echo_r(json_last_error());
 //    echo_r($json);
   
   if ($za->numFiles) {
    $za->close();
   }
  }
コード例 #10
0
ファイル: ArtifactRepository.php プロジェクト: VicDeo/poc
 private function locateFile(\ZipArchive $zip, $filename)
 {
     $indexOfShortestMatch = false;
     $lengthOfShortestMatch = -1;
     for ($i = 0; $i < $zip->numFiles; $i++) {
         $stat = $zip->statIndex($i);
         if (strcmp(basename($stat['name']), $filename) === 0) {
             $directoryName = dirname($stat['name']);
             if ($directoryName == '.') {
                 return $i;
             }
             if (strpos($directoryName, '\\') !== false || strpos($directoryName, '/') !== false) {
                 continue;
             }
             $length = strlen($stat['name']);
             if ($indexOfShortestMatch == false || $length < $lengthOfShortestMatch) {
                 $contents = $zip->getFromIndex($i);
                 if ($contents !== false) {
                     $indexOfShortestMatch = $i;
                     $lengthOfShortestMatch = $length;
                 }
             }
         }
     }
     return $indexOfShortestMatch;
 }
コード例 #11
0
 /**
  * test export data
  */
 public function testExportData() {
     $dao = new BackupMySQLDAO();
     $export_file = $dao->export();
     $this->assertTrue( file_exists($export_file) );
     $zip_stats = stat($export_file);
     $this->assertTrue($zip_stats['size'] > 0);
     $za = new ZipArchive();
     $za->open($export_file);
     $zip_files = array();
     for ($i=0; $i<$za->numFiles;$i++) {
         $zfile = $za->statIndex($i);
         $zip_files[$zfile['name']] = $zfile['name'];
     }
     //verify we have create table file
     $this->assertTrue($zip_files["create_tables.sql"]);
     $za->close();
     $q = "show tables";
     $q2 = "show create table ";
     $stmt = $this->pdo->query($q);
     // verify we have all table files
     while($data = $stmt->fetch(PDO::FETCH_ASSOC)) {
         foreach($data as $key => $value) {
             $zfile = '/' . $value .'.txt';
             $this->assertTrue($zip_files[$zfile]);
         }
     }
 }
コード例 #12
0
 public function url_stat($path, $flags)
 {
     $ret = [];
     $zippath = preg_replace('/^myzip:\\/\\//', "", $path);
     $parts = explode('#', $zippath, 2);
     if (count($parts) != 2) {
         return false;
     }
     list($zippath, $subfile) = $parts;
     $za = new \ZipArchive();
     if ($za->open($zippath) !== true) {
         return false;
     }
     $i = $za->locateName($subfile);
     if ($i === false) {
         return false;
     }
     $zst = $za->statIndex($i);
     $za->close();
     unset($za);
     foreach ([7 => 'size', 8 => 'mtime', 9 => 'mtime', 10 => 'mtime'] as $a => $b) {
         if (!isset($zst[$b])) {
             continue;
         }
         $ret[$a] = $zst[$b];
     }
     return $ret;
 }
コード例 #13
0
ファイル: repo.php プロジェクト: palpandi111/mbeddr.core
function processPluginsFolder($folder, $requiredMpsVersion, $pluginsVersion)
{
    $files = scandir($folder);
    foreach ($files as $zipfile) {
        if (pathinfo($zipfile, PATHINFO_EXTENSION) == 'zip') {
            $za = new ZipArchive();
            $za->open($folder . $zipfile);
            for ($i = 0; $i < $za->numFiles; $i++) {
                $stat = $za->statIndex($i);
                $pluginXmlFile = $stat['name'];
                if (endsWith($pluginXmlFile, "META-INF/plugin.xml")) {
                    $stream = $za->getStream($pluginXmlFile);
                    $content = stream_get_contents($stream);
                    $xml = simplexml_load_string($content);
                    if (fixPluginXml($xml, $requiredMpsVersion, $pluginsVersion)) {
                        $za->deleteName($pluginXmlFile);
                        $za->addFromString($pluginXmlFile, $xml->asXML());
                    }
                    printPluginXml($xml, $zipfile, $requiredMpsVersion, $pluginsVersion);
                    break;
                }
            }
        }
    }
}
コード例 #14
0
	private static function getZippedFile($filename) {
		
		if(!self::zipModuleLoaded()) {
			throw new WURFL_WURFLException("The Zip extension is not loaded. Load the extension or use the flat wurfl.xml file");
		}
		
		
		$tmpDir = sys_get_temp_dir();
		
		$zip = new ZipArchive();

		if ($zip->open($filename)!==TRUE) {
			exit("cannot open <$filename>\n");
		}
		$zippedFile = $zip->statIndex(0);
		$wurflFile = $zippedFile['name'];
		
		//$wurflFile = md5(uniqid(rand(), true)); 
		
		//$zip->extractTo($tmpDir, $wurflFile);
		$zip->extractTo($tmpDir);

		$zip->close();
		
		return $tmpDir . '/' .$wurflFile;
	}
コード例 #15
0
 public function import($zipfile)
 {
     if (file_exists($zipfile)) {
         $zip = new ZipArchive();
         if ($zip->open($zipfile) !== TRUE) {
             throw new Exception("Unable to open import file, corrupted zip file?: " . $zipfile);
         } else {
             // validate zip file
             $num_files = $zip->numFiles;
             if ($num_files < 1) {
                 throw new Exception("Unable to open import file, corrupted zip file?: " . $zipfile);
             }
             $num_files--;
             $last_file = $zip->statIndex($num_files);
             if ($last_file['name'] != 'create_tables.sql') {
                 throw new Exception("Unable to open import file, corrupted zip file?: " . $zipfile);
             }
             // extract zipfile
             // create backip dir
             $bkdir = THINKUP_WEBAPP_PATH . self::CACHE_DIR . '/backup';
             if (!file_exists($bkdir)) {
                 mkdir($bkdir);
             }
             $zip->extractTo($bkdir);
             $create_table = $bkdir . '/create_tables.sql';
             $infiles = glob($bkdir . '/*.txt');
             // rebuild db
             $sql = file_get_contents($create_table);
             if (getenv('BACKUP_VERBOSE') !== false) {
                 print "  Creating tables...\n\n";
             }
             $stmt = $this->execute($sql);
             $stmt->closeCursor();
             unlink($create_table);
             // import data
             //var_dump($infiles);
             foreach ($infiles as $infile) {
                 $table = $infile;
                 $matches = array();
                 if (preg_match('#.*/(\\w+).txt$#', $table, $matches)) {
                     $table = $matches[1];
                     if (getenv('BACKUP_VERBOSE') !== false) {
                         print "  Restoring data for table: {$table}\n";
                     }
                     $q = "LOAD DATA INFILE '{$infile}' INTO TABLE {$table}";
                     $stmt = $this->execute($q);
                     if (!$stmt) {
                         throw new Exception("unbale to load data file: " . $infile);
                     }
                     $stmt->closeCursor();
                     unlink($infile);
                 }
             }
             rmdir($bkdir);
             return true;
         }
     } else {
         throw new Exception("Unable to open import file: " . $zipfile);
     }
 }
コード例 #16
0
 /**
  * Find a file by name, returning the one that has the shortest path.
  *
  * @param \ZipArchive $zip
  * @param $filename
  * @return bool|int
  */
 private function locateFile(\ZipArchive $zip, $filename)
 {
     $indexOfShortestMatch = false;
     $lengthOfShortestMatch = -1;
     for ($i = 0; $i < $zip->numFiles; $i++) {
         $stat = $zip->statIndex($i);
         if (strcmp(basename($stat['name']), $filename) === 0) {
             $directoryName = dirname($stat['name']);
             if ($directoryName == '.') {
                 //if composer.json is in root directory
                 //it has to be the one to use.
                 return $i;
             }
             if (strpos($directoryName, '\\') !== false || strpos($directoryName, '/') !== false) {
                 //composer.json files below first directory are rejected
                 continue;
             }
             $length = strlen($stat['name']);
             if ($indexOfShortestMatch == false || $length < $lengthOfShortestMatch) {
                 //Check it's not a directory.
                 $contents = $zip->getFromIndex($i);
                 if ($contents !== false) {
                     $indexOfShortestMatch = $i;
                     $lengthOfShortestMatch = $length;
                 }
             }
         }
     }
     return $indexOfShortestMatch;
 }
コード例 #17
0
ファイル: clsPicture.php プロジェクト: shifter/ospap2
 /** Returns an array of strings (for error messages) and image objects (for successful). */
 public static function createFromArchive($filename, $objAlbum)
 {
     if (!class_exists('ZipArchive')) {
         return "image_nozip";
     }
     $arrRet = array();
     $zipArchive = new ZipArchive();
     $zipArchive->open($filename);
     for ($i = 0; $i < $zipArchive->numFiles; $i++) {
         /* We stat the file, to get its name. */
         $stat = $zipArchive->statIndex($i);
         $strInName = $stat['name'];
         /* Open the temp output file. This is vulnerable to a race condition. TODO. */
         $filename = tempnam("/tmp", "OSPAP2");
         $out = fopen($filename, 'w');
         /* Get the file stream from the archive. */
         $in = $zipArchive->getStream($stat['name']);
         /* Read the file from the zip. It takes several iterations to get to the end, so we loop. */
         while (!feof($in)) {
             fputs($out, fgets($in));
         }
         /* Close the input and output files. */
         fclose($out);
         fclose($in);
         /* Determine the mimetype from the filename. None of php's built-in functions seem to work.. */
         if (preg_match("/\\.png\$/", $stat['name'])) {
             $mimetype = "image/png";
         } elseif (preg_match("/\\.gif\$/", $stat['name'])) {
             $mimetype = "image/gif";
         } elseif (preg_match("/\\.jpg\$/", $stat['name'])) {
             $mimetype = "image/jpeg";
         } elseif (preg_match("/\\.jpeg\$/", $stat['name'])) {
             $mimetype = "image/jpeg";
         } else {
             $mimetype = "unknown";
         }
         /* Create the new file. */
         $new = clsPicture::createFromFile($filename, $mimetype, $objAlbum);
         /* Delete the file. */
         unlink($filename);
         if (is_string($new)) {
             $strError = $new;
             $new = new clsDB('image');
             $new->set('error', $strError);
             $new->set('name', $stat['name']);
         } else {
             $new->set('original_name', $stat['name']);
             $new->set('original_mime', $mimetype);
             $new->set('original_size', $stat['size']);
         }
         /* Add it to the array (note that it can be a string (for an error) or an image object. */
         $arrRet[] = $new;
     }
     if (sizeof($arrRet) == 0) {
         return 'image_nofiles';
     }
     return $arrRet;
 }
コード例 #18
0
 /**
  * Extract headers and readme.txt data from a ZIP archive that contains a plugin or theme.
  *
  * Returns an associative array with these keys:
  *  'type'   - Detected package type. This can be either "plugin" or "theme".
  * 	'header' - An array of plugin or theme headers. See get_plugin_data() or WP_Theme for details.
  *  'readme' - An array of metadata extracted from readme.txt. @see self::parseReadme()
  * 	'pluginFile' - The name of the PHP file where the plugin headers were found relative to the root directory of the ZIP archive.
  * 	'stylesheet' - The relative path to the style.css file that contains theme headers, if any.
  *
  * The 'readme' key will only be present if the input archive contains a readme.txt file
  * formatted according to WordPress.org readme standards. Similarly, 'pluginFile' and
  * 'stylesheet' will only be present if the archive contains a plugin or a theme, respectively.
  *
  * @param string $packageFilename The path to the ZIP package.
  * @param bool $applyMarkdown Whether to transform markup used in readme.txt to HTML. Defaults to false.
  * @return array Either an associative array or FALSE if the input file is not a valid ZIP archive or doesn't contain a WP plugin or theme.
  */
 public static function parsePackage($packageFilename, $applyMarkdown = false)
 {
     if (!file_exists($packageFilename) || !is_readable($packageFilename)) {
         return false;
     }
     //Open the .zip
     $zip = new ZipArchive();
     if ($zip->open($packageFilename) !== true) {
         return false;
     }
     //Find and parse the plugin or theme file and (optionally) readme.txt.
     $header = null;
     $readme = null;
     $pluginFile = null;
     $stylesheet = null;
     $type = null;
     for ($fileIndex = 0; $fileIndex < $zip->numFiles && (empty($readme) || empty($header)); $fileIndex++) {
         $info = $zip->statIndex($fileIndex);
         //Normalize filename: convert backslashes to slashes, remove leading slashes.
         $fileName = trim(str_replace('\\', '/', $info['name']), '/');
         $fileName = ltrim($fileName, '/');
         $fileNameParts = explode('.', $fileName);
         $extension = strtolower(end($fileNameParts));
         $depth = substr_count($fileName, '/');
         //Skip empty files, directories and everything that's more than 1 sub-directory deep.
         if ($depth > 1 || $info['size'] == 0) {
             continue;
         }
         //readme.txt (for plugins)?
         if (empty($readme) && strtolower(basename($fileName)) == 'readme.txt') {
             //Try to parse the readme.
             $readme = self::parseReadme($zip->getFromIndex($fileIndex), $applyMarkdown);
         }
         //Theme stylesheet?
         if (empty($header) && strtolower(basename($fileName)) == 'style.css') {
             $fileContents = substr($zip->getFromIndex($fileIndex), 0, 8 * 1024);
             $header = self::getThemeHeaders($fileContents);
             if (!empty($header)) {
                 $stylesheet = $fileName;
                 $type = 'theme';
             }
         }
         //Main plugin file?
         if (empty($header) && $extension === 'php') {
             $fileContents = substr($zip->getFromIndex($fileIndex), 0, 8 * 1024);
             $header = self::getPluginHeaders($fileContents);
             if (!empty($header)) {
                 $pluginFile = $fileName;
                 $type = 'plugin';
             }
         }
     }
     if (empty($type)) {
         return false;
     } else {
         return compact('header', 'readme', 'pluginFile', 'stylesheet', 'type');
     }
 }
コード例 #19
0
ファイル: Volume.php プロジェクト: askzap/ultimate
 protected function getArchivers($use_cache = true)
 {
     $arcs = array('create' => array(), 'extract' => array());
     $obj = $this;
     // php 5.3 compatibility
     if (class_exists('ZipArchive')) {
         $arcs['extract']['application/zip'] = array('cmd' => function ($archive, $path) use($obj) {
             $zip = new \ZipArchive();
             if ($zip->open($archive)) {
                 for ($i = 0; $i < $zip->numFiles; $i++) {
                     $stat = $zip->statIndex($i);
                     if (empty($stat['size'])) {
                         // directory
                         continue;
                     }
                     $filename = $stat['name'];
                     if (!$obj->tyghIsUTF8($filename) && function_exists('iconv')) {
                         $newfile = iconv('cp866', 'utf-8', $filename);
                     } else {
                         $newfile = $filename;
                     }
                     $obj->tyghMkdir(dirname($path . '/' . $newfile));
                     copy('zip://' . $archive . '#' . $filename, $path . '/' . $newfile);
                 }
                 $zip->close();
                 return true;
             }
             return false;
         }, 'ext' => 'zip');
         $arcs['create']['application/zip'] = array('cmd' => function ($archive, $files) use($obj) {
             $zip = new \ZipArchive();
             if ($zip->open($archive, \ZipArchive::CREATE) === true) {
                 $base_path = dirname($archive);
                 foreach ($files as $file) {
                     $path = $base_path . DIRECTORY_SEPARATOR . $file;
                     if (is_file($path)) {
                         $zip->addFile($path, $file);
                     } elseif (is_dir($path)) {
                         foreach ($obj->tyghGetFiles($path) as $_file) {
                             $zip->addFile($path . DIRECTORY_SEPARATOR . $_file, $_file);
                         }
                     }
                 }
                 $zip->close();
                 return true;
             }
             return false;
         }, 'ext' => 'zip');
     }
     if (class_exists('PharData')) {
         $arcs['extract']['application/x-gzip'] = array('cmd' => function ($archive, $path) {
             $phar = new \PharData($archive);
             $phar->extractTo($path, null, true);
         }, 'ext' => 'tgz');
     }
     return $arcs;
 }
コード例 #20
0
function getZipContentsAsQueryable($zipFilePath)
{
    $zip = new ZipArchive();
    $zip->open($zipFilePath);
    $zipContents = [];
    for ($i = 0; $i < $zip->numFiles; $i++) {
        $zipContents[] = $zip->statIndex($i);
    }
    return from($zipContents);
}
コード例 #21
0
/**
 * Tim Hodson: renamed functions to avoid collisions.
 * 
 * Extract plugin headers and readme.txt data from a plugin's ZIP archive.
 * 
 * Returns an associative array with these keys:
 * 	'headers' - An array of plugin headers. See get_plugin_data() for details.
 *  'readme' - An array of metadata extracted from readme.txt. See parsePluginReadme() for details.
 * 	'pluginFile' - The name of the PHP file where the plugin headers were found; relative to the root directory of the ZIP archive.
 * 
 * The 'readme' key will only be present if the input archive contains a readme.txt file
 * formatted according to WordPress.org readme standards.
 * 
 * @uses parsePluginReadme()
 * @uses get_plugin_data()
 * 
 * @param string $packageFilename The path to the plugin's ZIP package.
 * @param bool $applyMarkdown Whether to transform markup used in readme.txt to HTML. Defaults to false.
 * @return array Associative array containing 'headers', 'readme' and 'pluginFile'. Returns FALSE if the input file is not a valid ZIP archive or doesn't contain a WP plugin.
 */
function pm_analysePluginPackage($packageFilename, $applyMarkdown = false)
{
    if (!file_exists($packageFilename) || !is_readable($packageFilename)) {
        return false;
    }
    //Open the .zip
    $zip = new ZipArchive();
    if ($zip->open($packageFilename) !== true) {
        return false;
    }
    //Find and parse the plugin file and readme.txt
    $header = null;
    $readme = null;
    $pluginFile = null;
    for ($fileIndex = 0; $fileIndex < $zip->numFiles && (empty($readme) || empty($header)); $fileIndex++) {
        $info = $zip->statIndex($fileIndex);
        $fileName = trim(str_replace('\\', '/', $info['name']), '/');
        //Backslashes to slashes, kill leading slashes.
        //readme.txt?
        if (empty($readme) && strtolower(basename($fileName)) == 'readme.txt') {
            //Try to parse the readme
            $readme = pm_parsePluginReadme($zip->getFromIndex($fileIndex), $applyMarkdown);
            continue;
            //Skip the rest of the checks.
        }
        //Plugin header?
        if (empty($header)) {
            //Skip directories and empty files
            if ($info['size'] == 0) {
                continue;
            }
            //We're only interested in PHP files
            $extension = end(explode('.', $fileName));
            if (strtolower($extension) != 'php') {
                continue;
            }
            //WordPress only looks for plugin files in the top or second level
            //of the directory tree, so we do the same.
            if (substr_count($fileName, '/') > 1) {
                continue;
            }
            //Try to read the header. WP only scans the first 8kiB, so we do the same.
            $fileContents = substr($zip->getFromIndex($fileIndex), 0, 8 * 1024);
            $header = pm_getPluginHeader($fileContents);
            if (!empty($header)) {
                $pluginFile = $fileName;
            }
        }
    }
    if (empty($pluginFile)) {
        return false;
    } else {
        return compact('header', 'readme', 'pluginFile');
    }
}
コード例 #22
0
function loadIndexesFromDir($output, $outputIndexes, $dir, $elementName, $mapNodes)
{
    $local_file = basename($_SERVER['PHP_SELF']) == basename(__FILE__);
    if (is_dir($dir)) {
        if ($dh = opendir($dir)) {
            $zip = new ZipArchive();
            while (($file = readdir($dh)) !== false) {
                $filename = $dir . $file;
                //"./test112.zip";
                //print("processing file:" . $filename . "\n");
                if ($zip->open($filename, ZIPARCHIVE::CHECKCONS) !== TRUE) {
                    // echo exit("cannot open <$filename>\n");
                    // print($filename . " cannot open as zip\n");
                    continue;
                }
                $indexName = $file;
                $description = $zip->getCommentIndex(0);
                $stat = $zip->statIndex(0);
                $date = date('d.m.Y', $stat['mtime']);
                $size = number_format(filesize($filename) / (1024.0 * 1024.0), 1, '.', '');
                $zip->close();
                if ($local_file) {
                    echo 'Local : ' . $indexName . ' ' . $date . ' ' . $size . '<br>';
                }
                if (isset($mapNodes[$indexName])) {
                    $exdate = DateTime::createFromFormat('d.m.Y', $mapNodes[$indexName]->getAttribute("date"));
                    $localdate = DateTime::createFromFormat('d.m.Y', $date);
                    if ($localdate->getTimestamp() <= $exdate->getTimestamp()) {
                        continue;
                    }
                    $out = $mapNodes[$indexName];
                    //if($out -> getAttribute("parts")) {
                    $outputIndexes->removeChild($out);
                    $out = $output->createElement($elementName);
                    $outputIndexes->appendChild($out);
                    //}
                } else {
                    $out = $output->createElement($elementName);
                    $outputIndexes->appendChild($out);
                }
                $out->setAttribute("date", $date);
                $out->setAttribute("local", "true");
                $out->setAttribute("size", $size);
                $out->setAttribute("name", $indexName);
                $out->setAttribute("description", $description);
                //$mapNodes[$indexName] = $out;
            }
            closedir($dh);
        }
    } else {
        print $dir . " not a directory!\n";
    }
}
コード例 #23
0
 /**
  * @param string $zipFilePath
  *
  * @return array
  */
 protected function getTemplateSnippetIdsFromExportFile($zipFilePath)
 {
     $exportedSnippetIds = array();
     $exportZip = new \ZipArchive();
     $exportZip->open($zipFilePath);
     for ($i = 0; $i < $exportZip->numFiles; $i++) {
         $stat = $exportZip->statIndex($i);
         if (preg_match('/([^\\/]+?)\\/templateSnippet.json/', $stat['name'], $matches)) {
             $exportedSnippetIds[] = $matches[1];
         }
     }
     return array_unique($exportedSnippetIds);
 }
コード例 #24
0
 function extractImages()
 {
     $ZipArchive = new ZipArchive();
     if (true === $ZipArchive->open($this->file)) {
         for ($i = 0; $i < $ZipArchive->numFiles; $i++) {
             $zip_element = $ZipArchive->statIndex($i);
             if (preg_match("([^\\s]+(\\.(?i)(jpg|jpeg|png|gif|bmp))\$)", $zip_element['name'])) {
                 $imagename = explode('/', $zip_element['name']);
                 $imagename = end($imagename);
                 $this->indexes[$imagename] = $i;
             }
         }
     }
 }
コード例 #25
0
ファイル: fileZipper.php プロジェクト: scirelli/garminparser
function list_zip_files($fileName, $bBaseNameOnly = false)
{
    $za = new ZipArchive();
    $aFiles = array();
    $za->open($fileName);
    for ($i = 0; $i < $za->numFiles; $i++) {
        $stat = $za->statIndex($i);
        if ($bBaseNameOnly) {
            array_push($aFiles, basename($stat['name']));
        } else {
            array_push($aFiles, $stat['name']);
        }
    }
    return $aFiles;
}
コード例 #26
0
 protected function unzip($file)
 {
     $zippedFiles = [];
     $zip = new \ZipArchive();
     $zip->open($file);
     for ($i = 0; $i < $zip->numFiles; $i++) {
         $f = $zip->statIndex($i);
         if (isset($f['name'])) {
             $zippedFiles[] = $f['name'];
         }
     }
     $zip->close();
     sort($zippedFiles);
     return $zippedFiles;
 }
コード例 #27
0
 public function upload()
 {
     if (!$this->BuilderEngine->is_public_version()) {
         die("Not supported for cloud users");
     }
     $path = $this->do_upload("module_zip");
     $zip = new ZipArchive();
     if ($zip->open($path) === TRUE) {
         $stat = $zip->statIndex(0);
         $folder = basename($stat['name']);
         $zip->extractTo(APPPATH . '../modules');
         $zip->close();
         unlink($path);
     }
     $this->install($folder);
 }
コード例 #28
0
ファイル: Utils.php プロジェクト: mimmi20/wurfl
 /**
  * Returns a XML Resource filename for the uncompressed contents of the provided zipped $filename
  *
  * @param string $filename of zipped XML data
  *
  * @throws Exception ZipArchive extension is not loaded or the ZIP file is corrupt
  *
  * @return string Full filename and path of extracted XML file
  */
 private static function getZippedFile($filename)
 {
     if (!self::zipModuleLoaded()) {
         throw new Exception('The ZipArchive extension is not loaded. Load the extension or use the flat wurfl.xml file');
     }
     $tmpDir = FileUtils::getTempDir();
     $zip = new \ZipArchive();
     if ($zip->open($filename) !== true) {
         throw new Exception('The Zip file <$filename> could not be opened');
     }
     $zippedFile = $zip->statIndex(0);
     $wurflFile = $zippedFile['name'];
     $zip->extractTo($tmpDir);
     $zip->close();
     return FileUtils::cleanFilename($tmpDir . DIRECTORY_SEPARATOR . $wurflFile);
 }
コード例 #29
0
 public function zfAction()
 {
     if (!extension_loaded('zip')) {
         return $this->sendError('You need to install the ZIP extension of PHP');
     }
     $console = $this->getServiceLocator()->get('console');
     $tmpDir = sys_get_temp_dir();
     $request = $this->getRequest();
     $version = $request->getParam('version');
     $path = rtrim($request->getParam('path'), '/');
     if (file_exists($path)) {
         return $this->sendError("The directory {$path} already exists. You cannot install the ZF2 library here.");
     }
     if (empty($version)) {
         $version = Zf::getLastVersion();
         if (false === $version) {
             return $this->sendError("I cannot connect to the Zend Framework website.");
         }
     } else {
         if (!Zf::checkVersion($version)) {
             return $this->sendError("The specified ZF version, {$version}, doesn't exist.");
         }
     }
     $tmpFile = ZF::getTmpFileName($tmpDir, $version);
     if (!file_exists($tmpFile)) {
         if (!Zf::downloadZip($tmpFile, $version)) {
             return $this->sendError("I cannot download the ZF2 library from github.");
         }
     }
     $zip = new \ZipArchive();
     if ($zip->open($tmpFile)) {
         $zipFolders = $zip->statIndex(0);
         $zipFolder = $tmpDir . '/' . rtrim($zipFolders['name'], "/");
         if (!$zip->extractTo($tmpDir)) {
             return $this->sendError("Error during the unzip of {$tmpFile}.");
         }
         $result = Utility::copyFiles($zipFolder, $path);
         if (file_exists($zipFolder)) {
             Utility::deleteFolder($zipFolder);
         }
         $zip->close();
         if (false === $result) {
             return $this->sendError("Error during the copy of the files in {$path}.");
         }
     }
     $console->writeLine("The ZF library {$version} has been installed in {$path}.", Color::GREEN);
 }
コード例 #30
0
ファイル: filesystem.php プロジェクト: ZerGabriel/cms-1
 /**
  * 
  * @param string $file
  * @return string
  * @throws Exception
  */
 public function view($file = NULL)
 {
     if ($file === NULL) {
         $file = $this->file;
     }
     if (!file_exists($file)) {
         throw new Exception('File ' . $file . ' not exists');
     }
     $za = new ZipArchive();
     $files = '';
     $za->open($file);
     for ($i = 0; $i < $za->numFiles; $i++) {
         $stat = $za->statIndex($i);
         $files .= $stat['name'] . "\n";
     }
     return $files;
 }