PHP File_Archive类代码示例

 /**
  * Creates a .zip file of the theme in themes/ directory
  *
  * @access  public
  * @param   string  $theme      Name of the theme
  * @param   string  $srcDir     Source directory
  * @param   string  $destDir    Target directory
  * @param   bool    $copy_example_to_repository  If copy example.png too or not
  * @return  bool    Returns true if:
  *                    - Theme exists
  *                    - Theme exists and could be packed
  *                  Returns false if:
  *                    - Theme doesn't exist
  *                    - Theme doesn't exists and couldn't be packed
  */
 function packTheme($theme, $srcDir, $destDir, $copy_example_to_repository = true)
 {
     $themeSrc = $srcDir . '/' . $theme;
     if (!is_dir($themeSrc)) {
         return new Jaws_Error(_t('TMS_ERROR_THEME_DOES_NOT_EXISTS', $theme));
     }
     if (!Jaws_Utils::is_writable($destDir)) {
         return new Jaws_Error(_t('GLOBAL_ERROR_FAILED_DIRECTORY_UNWRITABLE', $destDir), $this->gadget->name);
     }
     $themeDest = $destDir . '/' . $theme . '.zip';
     //If file exists.. delete it
     if (file_exists($themeDest)) {
         @unlink($themeDest);
     }
     require_once PEAR_PATH . 'File/Archive.php';
     $reader = File_Archive::read($themeSrc, $theme);
     $innerWriter = File_Archive::toFiles();
     $writer = File_Archive::toArchive($themeDest, $innerWriter);
     $res = File_Archive::extract($reader, $writer);
     if (PEAR::isError($res)) {
         return new Jaws_Error(_t('TMS_ERROR_COULD_NOT_PACK_THEME'));
     }
     Jaws_Utils::chmod($themeDest);
     if ($copy_example_to_repository) {
         //Copy image to repository/images
         if (file_exists($srcDir . '/example.png')) {
             @copy($srcDir . '/example.png', JAWS_DATA . "themes/repository/Resources/images/{$theme}.png");
             Jaws_Utils::chmod(JAWS_DATA . 'themes/repository/Resources/images/' . $theme . '.png');
         }
     }
     return $themeDest;
 }

 /**
  * @see File_Archive_Reader::next()
  */
 function next()
 {
     if (!parent::next()) {
         return false;
     }
     $this->nbRead++;
     $this->filePos = 0;
     if ($this->nbRead > 1) {
         return false;
     }
     $dataFilename = $this->source->getDataFilename();
     if ($dataFilename !== null) {
         $this->tmpName = null;
         $this->gzfile = gzopen($dataFilename, 'r');
     } else {
         $this->tmpName = tempnam(File_Archive::getOption('tmpDirectory'), 'far');
         //Generate the tmp data
         $dest = new File_Archive_Writer_Files();
         $dest->newFile($this->tmpName);
         $this->source->sendData($dest);
         $dest->close();
         $this->gzfile = gzopen($this->tmpName, 'r');
     }
     return true;
 }

 /**
  * @see File_Archive_Reader::next()
  */
 function next()
 {
     if (!parent::next()) {
         return false;
     }
     $this->nbRead++;
     if ($this->nbRead > 1) {
         return false;
     }
     $dataFilename = $this->source->getDataFilename();
     if ($dataFilename !== null) {
         $this->tmpName = null;
         $this->bzfile = @bzopen($dataFilename, 'r');
         if ($this->bzfile === false) {
             return PEAR::raiseError("bzopen failed to open {$dataFilename}");
         }
     } else {
         $this->tmpName = tempnam(File_Archive::getOption('tmpDirectory'), 'far');
         //Generate the tmp data
         $dest = new File_Archive_Writer_Files();
         $dest->newFile($this->tmpName);
         $this->source->sendData($dest);
         $dest->close();
         $this->bzfile = bzopen($this->tmpName, 'r');
     }
     return true;
 }

 /**
  * Returns downloadable backup file
  *
  * @access  public
  * @return void
  */
 function Backup()
 {
     $this->gadget->CheckPermission('Backup');
     $tmpDir = sys_get_temp_dir();
     $domain = preg_replace("/^(www.)|(:{$_SERVER['SERVER_PORT']})\$|[^a-z0-9\\-\\.]/", '', strtolower($_SERVER['HTTP_HOST']));
     $nameArchive = $domain . '-' . date('Y-m-d') . '.tar.gz';
     $pathArchive = $tmpDir . DIRECTORY_SEPARATOR . $nameArchive;
     //Dump database data
     $dbFileName = 'dbdump.xml';
     $dbFilePath = $tmpDir . DIRECTORY_SEPARATOR . $dbFileName;
     Jaws_DB::getInstance()->Dump($dbFilePath);
     $files = array();
     require_once PEAR_PATH . 'File/Archive.php';
     $files[] = File_Archive::read(JAWS_DATA);
     $files[] = File_Archive::read($dbFilePath, $dbFileName);
     File_Archive::extract($files, File_Archive::toArchive($pathArchive, File_Archive::toFiles()));
     Jaws_Utils::Delete($dbFilePath);
     // browser must download file from server instead of cache
     header("Expires: 0");
     header("Pragma: public");
     header("Cache-Control: must-revalidate, post-check=0, pre-check=0");
     // force download dialog
     header("Content-Type: application/force-download");
     // set data type, size and filename
     header("Content-Disposition: attachment; filename=\"{$nameArchive}\"");
     header("Content-Transfer-Encoding: binary");
     header('Content-Length: ' . @filesize($pathArchive));
     @readfile($pathArchive);
     Jaws_Utils::Delete($pathArchive);
 }

 function exportUploadedFiles($gid)
 {
     require_once "File/Archive.php";
     File_Archive::setOption('zipCompressionLevel', 0);
     $baseDir = CUSTOMER_IMAGE_DIR . $gid;
     $files = list_files_dir($baseDir);
     File_Archive::extract($files, File_Archive::toArchive("campaign_" . $gid . "_uploadedfiles_" . date('dFY') . ".zip", File_Archive::toOutput()));
 }

 /**
  * @see File_Archive_Writer::newFile()
  *
  * Check that one single file is written in the GZip archive
  */
 function newFile($filename, $stat = array(), $mime = "application/octet-stream")
 {
     if ($this->nbFiles > 1) {
         return PEAR::raiseError("A Gz archive can only contain one single file." . "Use Tgz archive to be able to write several files");
     }
     $this->nbFiles++;
     $this->tmpName = tempnam(File_Archive::getOption('tmpDirectory'), 'far');
     $this->gzfile = gzopen($this->tmpName, 'w' . $this->compressionLevel);
     return true;
 }

 /**
  * validate実行
  *
  * @param   mixed   $attributes チェックする値
  * @param   string  $errStr     エラー文字列
  * @param   array   $params     オプション引数
  * @return  string  エラー文字列(エラーの場合)
  * @access  public
  */
 function validate($attributes, $errStr, $params)
 {
     $this->_cabinet = $attributes["cabinet"];
     $file = $attributes["file"];
     $container =& DIContainerFactory::getContainer();
     $commonMain =& $container->getComponent("commonMain");
     $this->_fileAction =& $commonMain->registerClass(WEBAPP_DIR . '/components/file/Action.class.php', "File_Action", "fileAction");
     $this->_fileView =& $commonMain->registerClass(WEBAPP_DIR . '/components/file/View.class.php', "File_View", "fileView");
     $this->_uploadsView =& $container->getComponent("uploadsView");
     $file_path = "cabinet/" . strtolower(session_id()) . timezone_date();
     if (file_exists(FILEUPLOADS_DIR . $file_path)) {
         $result = $this->_fileAction->delDir(FILEUPLOADS_DIR . $file_path);
         if ($result === false) {
             return $errStr;
         }
     }
     mkdir(FILEUPLOADS_DIR . $file_path, octdec(_UPLOAD_FOLDER_MODE));
     $request =& $container->getComponent("Request");
     $request->setParameter("file_path", $file_path);
     $result = $this->_uploadsView->getUploadById($file["upload_id"]);
     if ($result === false) {
         return $errStr;
     }
     $upload = $result[0];
     File_Archive::extract(File_Archive::read(FILEUPLOADS_DIR . $upload["file_path"] . $upload["physical_file_name"] . "/"), $dest = FILEUPLOADS_DIR . $file_path);
     $configView =& $container->getComponent("configView");
     $config = $configView->getConfigByConfname(_SYS_CONF_MODID, "allow_extension");
     if (!isset($config["conf_value"])) {
         return $errStr;
     }
     $this->_allow_extension = $config["conf_value"];
     $cabinetView =& $container->getComponent("cabinetView");
     $used_size = $cabinetView->getUsedSize();
     if ($used_size === false) {
         return $errStr;
     }
     $total_size = $used_size;
     $result = $this->_check(FILEUPLOADS_DIR . $file_path, $total_size);
     if ($result !== true) {
         $this->_fileAction->delDir(FILEUPLOADS_DIR . $file_path);
         return $result;
     }
     $decompress_size = $this->_fileView->getSize(FILEUPLOADS_DIR . $file_path);
     if ($this->_cabinet["cabinet_max_size"] != 0 && $this->_cabinet["cabinet_max_size"] < $used_size + $decompress_size) {
         $this->_fileAction->delDir(FILEUPLOADS_DIR . $file_path);
         $suffix_compresssize = $this->_fileView->formatSize($used_size + $decompress_size);
         $suffix_maxsize = $this->_fileView->formatSize($this->_cabinet["cabinet_max_size"]);
         return sprintf(CABINET_ERROR_DECOMPRESS_MAX_SIZE, $suffix_compresssize, $suffix_maxsize);
     }
     $result = $cabinetView->checkCapacitySize($decompress_size);
     if ($result !== true) {
         $this->_fileAction->delDir(FILEUPLOADS_DIR . $file_path);
         return $result;
     }
 }

 function saveChanges()
 {
     global $CONFIG;
     $_REQUEST->setType('uncompress', 'any');
     if (isset($_FILES['uFiles']) && $this->may($USER, EDIT)) {
         $u = false;
         $ue = false;
         $extensions = $CONFIG->Files->filter;
         foreach ($_FILES['uFiles']['error'] as $i => $e) {
             $parts = explode('.', $_FILES['uFiles']['name'][$i]);
             $extension = array_pop($parts);
             if ($e == UPLOAD_ERR_NO_FILE) {
                 continue;
             }
             $newPath = $this->that->path . '/' . $_FILES['uFiles']['name'][$i];
             if ($e == UPLOAD_ERR_OK) {
                 if ($_REQUEST['uncompress'] && in_array(strtolower(strrchr($_FILES['uFiles']['name'][$i], '.')), array('.tar', '.gz', '.tgz', '.bz2', '.tbz', '.zip', '.ar', '.deb'))) {
                     $tmpfile = $_FILES['uFiles']['tmp_name'][$i] . $_FILES['uFiles']['name'][$i];
                     rename($_FILES['uFiles']['tmp_name'][$i], $tmpfile);
                     $u = true;
                     require_once "File/Archive.php";
                     error_reporting(E_ALL);
                     $curdir = getcwd();
                     chdir($this->path);
                     //FIXME: FIXME!
                     if (@File_Archive::extract(File_Archive::filter(File_Archive::predExtension($extensions), File_Archive::read($tmpfile . '/*')), File_Archive::toFiles()) == null) {
                         $ue = true;
                     } else {
                         Flash::queue(__('Extraction failed'));
                     }
                     chdir($curdir);
                 } elseif (!in_array(strtolower($extension), $extensions)) {
                     Flash::queue(__('Invalid format:') . ' ' . $_FILES['uFiles']['name'][$i], 'warning');
                     continue;
                 } else {
                     $u = (bool) @move_uploaded_file($_FILES['uFiles']['tmp_name'][$i], $newPath);
                 }
             }
             if (!$u) {
                 Flash::queue(__('Upload of file') . ' "' . $_FILES['uFiles']['name'][$i] . '" ' . __('failed') . ' (' . ($e ? $e : __('Check permissions')) . ')', 'warning');
             }
         }
         if ($u) {
             $this->loadStructure(true);
             Flash::queue(__('Your file(s) were uploaded'));
             return true;
         }
         if ($ue) {
             $this->loadStructure(true);
             Flash::queue(__('Your file(s) were uploaded and extracted'));
             return true;
         }
         return false;
     }
 }

 /**
  * Check if input (an array of $_FILES) are .tar or .zip files, if they
  * are then these get unpacked and returns an managed as $_FILES (returning
  * an array with the same structure $_FILES uses and move pics to /tmp)
  *
  * @access  public
  * @param   array   $files   $_FILES
  * @return  array   $_FILES format
  */
 function UnpackFiles($files)
 {
     if (!is_array($files)) {
         return array();
     }
     $cleanFiles = array();
     $tmpDir = sys_get_temp_dir();
     $counter = 1;
     require_once PEAR_PATH . 'File/Archive.php';
     foreach ($files as $key => $file) {
         if (empty($file['tmp_name'])) {
             continue;
         }
         $ext = strrchr($file['name'], '.');
         switch ($ext) {
             case '.gz':
                 $ext = '.tgz';
                 break;
             case '.bz2':
             case '.bzip2':
                 $ext = '.tbz';
                 break;
         }
         $ext = strtolower(ltrim($ext, '.'));
         if (File_Archive::isKnownExtension($ext)) {
             $tmpArchiveName = $tmpDir . DIRECTORY_SEPARATOR . $file['name'];
             if (!move_uploaded_file($file['tmp_name'], $tmpArchiveName)) {
                 continue;
             }
             $reader = File_Archive::read($tmpArchiveName);
             $source = File_Archive::readArchive($ext, $reader);
             if (!PEAR::isError($source)) {
                 while ($source->next()) {
                     $destFile = $tmpDir . DIRECTORY_SEPARATOR . basename($source->getFilename());
                     $sourceFile = $tmpArchiveName . '/' . $source->getFilename();
                     $extract = File_Archive::extract($sourceFile, $tmpDir);
                     if (PEAR::IsError($extract)) {
                         continue;
                     }
                     $cleanFiles['photo' . $counter] = array('name' => basename($source->getFilename()), 'type' => $source->getMime(), 'tmp_name' => $destFile, 'size' => @filesize($destFile), 'error' => 0);
                     $counter++;
                 }
             }
         } else {
             $cleanFiles['photo' . $counter] = $file;
             $counter++;
         }
     }
     return $cleanFiles;
 }

 /**
  * Export language
  *
  * @access  public
  * @return  void
  */
 function Export()
 {
     $lang = jaws()->request->fetch('lang', 'get');
     require_once PEAR_PATH . 'File/Archive.php';
     $tmpDir = sys_get_temp_dir();
     $tmpFileName = "{$lang}.tar";
     $tmpArchiveName = $tmpDir . DIRECTORY_SEPARATOR . $tmpFileName;
     $writerObj = File_Archive::toFiles();
     $src = File_Archive::read(JAWS_DATA . "languages/{$lang}", $lang);
     $dst = File_Archive::toArchive($tmpArchiveName, $writerObj);
     $res = File_Archive::extract($src, $dst);
     if (!PEAR::isError($res)) {
         return Jaws_Utils::Download($tmpArchiveName, $tmpFileName);
     }
     Jaws_Header::Referrer();
 }

    /**
     * ダウンロードメイン表示クラス
     *
     * @access  public
     */
    function execute()
    {
        $header = <<<EOD
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<title>NetCommons</title>
</head>
<body>

EOD;
        $footer = <<<EOD
</body>
</html>
EOD;
        require_once "File/Archive.php";
        $dest = File_Archive::toArchive("document.zip", File_Archive::toOutput());
        $dest->newFile("document.html");
        $download_url = "?action=" . $this->download_action . "&upload_id=";
        $count = substr_count($this->content, $download_url);
        if (!$count) {
            $dest->writeData($header . $this->content . $footer);
            $dest->close();
            exit;
        }
        $upload_id = array();
        $files = array();
        $trans = array();
        $parts = explode($download_url, $this->content);
        for ($i = 1; $i <= $count; $i++) {
            $id = substr($parts[$i], 0, strpos($parts[$i], '"'));
            if (!isset($upload_id[$id])) {
                $upload_id[$id] = true;
                list($pathname, $filename, $physical_file_name, $space_type) = $this->uploadsView->downloadCheck($id, null, 0, "common_download_main");
                if ($pathname != null) {
                    $files[] = $pathname . $physical_file_name;
                    $trans[BASE_URL . '/' . $download_url . $id] = "./" . $physical_file_name;
                    $trans[$download_url . $id] = $physical_file_name;
                }
            }
        }
        clearstatcache();
        $dest->writeData($header . strtr($this->content, $trans) . $footer);
        File_Archive::extract($files, $dest);
    }

 /**
  * _unzipFile
  *
  * @return	bool
  **/
 public function _unzipFile()
 {
     // local file name
     $downloadDirPath = realpath($this->Xupdate->params['temp_path']);
     $downloadFilePath = $this->Xupdate->params['temp_path'] . '/' . $this->target_key . '.zip';
     $exploredDirPath = realpath($downloadDirPath . '/' . $this->target_key);
     if (empty($downloadFilePath)) {
         $this->_set_error_log('getDownloadFilePath not found error in: ' . $this->_getDownloadFilePath());
         return false;
     }
     if (!chdir($exploredDirPath)) {
         $this->_set_error_log('chdir error in: ' . $exploredDirPath);
         return false;
         //chdir error
     }
     File_Archive::extract(File_Archive::read($downloadFilePath . '/'), File_Archive::appender($exploredDirPath));
     return true;
 }

 /**
  * Extract archive Files
  *
  * @access  public
  * @param   array   $files        $_FILES array
  * @param   string  $dest         Destination directory(include end directory separator)
  * @param   bool    $extractToDir Create separate directory for extracted files
  * @param   bool    $overwrite    Overwrite directory if exist
  * @param   int     $max_size     Max size of file
  * @return  bool    Returns TRUE on success or FALSE on failure
  */
 static function ExtractFiles($files, $dest, $extractToDir = true, $overwrite = true, $max_size = null)
 {
     if (empty($files) || !is_array($files)) {
         return new Jaws_Error(_t('GLOBAL_ERROR_UPLOAD'), __FUNCTION__);
     }
     if (isset($files['name'])) {
         $files = array($files);
     }
     require_once PEAR_PATH . 'File/Archive.php';
     foreach ($files as $key => $file) {
         if (isset($file['error']) && !empty($file['error']) || !isset($file['name'])) {
             return new Jaws_Error(_t('GLOBAL_ERROR_UPLOAD_' . $file['error']), __FUNCTION__);
         }
         if (empty($file['tmp_name'])) {
             continue;
         }
         $ext = strrchr($file['name'], '.');
         $filename = substr($file['name'], 0, -strlen($ext));
         if (false !== stristr($filename, '.tar')) {
             $filename = substr($filename, 0, strrpos($filename, '.'));
             switch ($ext) {
                 case '.gz':
                     $ext = '.tgz';
                     break;
                 case '.bz2':
                 case '.bzip2':
                     $ext = '.tbz';
                     break;
                 default:
                     $ext = '.tar' . $ext;
             }
         }
         $ext = strtolower(substr($ext, 1));
         if (!File_Archive::isKnownExtension($ext)) {
             return new Jaws_Error(_t('GLOBAL_ERROR_UPLOAD_INVALID_FORMAT', $file['name']), __FUNCTION__);
         }
         if ($extractToDir) {
             $dest = $dest . $filename;
         }
         if ($extractToDir && !Jaws_Utils::mkdir($dest)) {
             return new Jaws_Error(_t('GLOBAL_ERROR_FAILED_CREATING_DIR', $dest), __FUNCTION__);
         }
         if (!Jaws_Utils::is_writable($dest)) {
             return new Jaws_Error(_t('GLOBAL_ERROR_FAILED_DIRECTORY_UNWRITABLE', $dest), __FUNCTION__);
         }
         $archive = File_Archive::readArchive($ext, $file['tmp_name']);
         if (PEAR::isError($archive)) {
             return new Jaws_Error($archive->getMessage(), __FUNCTION__);
         }
         $writer = File_Archive::_convertToWriter($dest);
         $result = $archive->extract($writer);
         if (PEAR::isError($result)) {
             return new Jaws_Error($result->getMessage(), __FUNCTION__);
         }
         //@unlink($file['tmp_name']);
     }
     return true;
 }

 function init()
 {
     $oKTConfig =& KTConfig::getSingleton();
     $sBasedir = $oKTConfig->get("urls/tmpDirectory");
     $sTmpPath = tempnam($sBasedir, 'archiveimportstorage');
     if ($sTmpPath === false) {
         return PEAR::raiseError(_kt("Could not create temporary directory for archive storage"));
     }
     if (!file_exists($this->sZipPath)) {
         return PEAR::raiseError(_kt("Archive file given does not exist"));
     }
     unlink($sTmpPath);
     mkdir($sTmpPath, 0700);
     $this->sBasePath = $sTmpPath;
     // Set environment language to output character encoding
     $sOutputEncoding = $oKTConfig->get('export/encoding', 'UTF-8');
     $loc = $sOutputEncoding;
     putenv("LANG={$loc}");
     putenv("LANGUAGE={$loc}");
     $loc = setlocale(LC_ALL, $loc);
     // File Archive doesn't unzip properly so sticking to the original unzip functionality
     if ($this->sExtension == 'zip') {
         // ** Original zip functionality
         $sUnzipCommand = KTUtil::findCommand("import/unzip", "unzip");
         if (empty($sUnzipCommand)) {
             return PEAR::raiseError(_kt("unzip command not found on system"));
         }
         $aArgs = array($sUnzipCommand, "-q", "-n", "-d", $sTmpPath, $this->sZipPath);
         $aRes = KTUtil::pexec($aArgs);
         if ($aRes['ret'] !== 0) {
             return PEAR::raiseError(_kt("Could not retrieve contents from zip storage"));
         }
     } else {
         File_Archive::extract(File_Archive::readArchive($this->sExtension, File_Archive::readUploadedFile('file')), $dst = $sTmpPath);
     }
 }

 function appendFile($filename, $dataFilename)
 {
     //Try to read from the cache
     $cache = File_Archive::getOption('cache', null);
     if ($cache !== null && $this->compressionLevel > 0) {
         $id = realpath($dataFilename);
         $id = urlencode($id);
         $id = str_replace('_', '%5F', $id);
         $group = 'FileArchiveZip' . $this->compressionLevel;
         $mtime = filemtime($dataFilename);
         //Tries to read from cache
         if (($data = $cache->get($id, $group)) !== false) {
             $info = unpack('Vmtime/Vcrc/Vnlength', substr($data, 0, 12));
             $data = substr($data, 12);
         }
         //If cache failed or file modified since then
         if ($data === false || $info['mtime'] != $mtime) {
             $data = file_get_contents($dataFilename);
             $info = array('crc' => crc32($data), 'nlength' => strlen($data), 'mtime' => $mtime);
             $data = gzcompress($data, $this->compressionLevel);
             $data = substr($data, 2, strlen($data) - 6);
             $data = pack('VVV', $info['mtime'], $info['crc'], $info['nlength']) . $data;
             $cache->save($data, $id, $group);
         }
         return $this->appendCompressedData($filename, stat($dataFilename), $data, $info['crc'], $info['nlength']);
     }
     //If no cache system, use the standard way
     return parent::appendFile($filename, $dataFilename);
 }