/**
* 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;
}
/**
* 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;
}
/**
* This function performs exactly as readSource, but with two additional parameters
* ($reachable and $baseDir) that will be set so that $reachable."/".$baseDir == $URL
* and $reachable can be reached (in case of error)
*
* @access private
*/
function _readSource(&$toConvert, $URL, &$reachable, &$baseDir, $symbolic = null, $uncompression = 0, $directoryDepth = -1)
{
$source =& File_Archive::_convertToReader($toConvert);
if (PEAR::isError($source)) {
return $source;
}
if (is_array($URL)) {
$converted = array();
foreach ($URL as $key => $foo) {
$converted[] =& File_Archive::_convertToReader($URL[$key]);
}
return File_Archive::readMulti($converted);
}
//No need to uncompress more than $directoryDepth
//That's not perfect, and some archives will still be uncompressed just
//to be filtered out :(
if ($directoryDepth >= 0) {
$uncompressionLevel = min($uncompression, $directoryDepth);
} else {
$uncompressionLevel = $uncompression;
}
require_once dirname(__FILE__) . '/Archive/Reader.php';
$std = File_Archive_Reader::getStandardURL($URL);
//Modify the symbolic name if necessary
$slashPos = strrpos($std, '/');
if ($symbolic === null) {
if ($slashPos === false) {
$realSymbolic = $std;
} else {
$realSymbolic = substr($std, $slashPos + 1);
}
} else {
$realSymbolic = $symbolic;
}
if ($slashPos !== false) {
$baseFile = substr($std, 0, $slashPos + 1);
$lastFile = substr($std, $slashPos + 1);
} else {
$baseFile = '';
$lastFile = $std;
}
if (strpos($lastFile, '*') !== false || strpos($lastFile, '?') !== false) {
//We have to build a regexp here
$regexp = str_replace(array('\\*', '\\?'), array('[^/]*', '[^/]'), preg_quote($lastFile));
$result = File_Archive::_readSource($source, $baseFile, $reachable, $baseDir, null, 0, -1);
return File_Archive::filter(File_Archive::predEreg('^' . $regexp . '$'), $result);
}
//If the URL can be interpreted as a directory, and we are reading from the file system
if ((empty($URL) || is_dir($URL)) && $source === null) {
require_once dirname(__FILE__) . "/Archive/Reader/Directory.php";
require_once dirname(__FILE__) . "/Archive/Reader/ChangeName.php";
if ($uncompressionLevel != 0) {
require_once dirname(__FILE__) . "/Archive/Reader/Uncompress.php";
$result = new File_Archive_Reader_Uncompress(new File_Archive_Reader_Directory($std, '', $directoryDepth), $uncompressionLevel);
} else {
$result = new File_Archive_Reader_Directory($std, '', $directoryDepth);
}
if ($directoryDepth >= 0) {
require_once dirname(__FILE__) . '/Archive/Reader/Filter.php';
require_once dirname(__FILE__) . '/Archive/Predicate/MaxDepth.php';
$tmp =& File_Archive::filter(new File_Archive_Predicate_MaxDepth($directoryDepth), $result);
unset($result);
$result =& $tmp;
}
if (!empty($realSymbolic)) {
if ($symbolic === null) {
$realSymbolic = '';
}
$tmp =& new File_Archive_Reader_AddBaseName($realSymbolic, $result);
unset($result);
$result =& $tmp;
}
//If the URL can be interpreted as a file, and we are reading from the file system
} else {
if (is_file($URL) && substr($URL, -1) != '/' && $source === null) {
require_once dirname(__FILE__) . "/Archive/Reader/File.php";
$result = new File_Archive_Reader_File($URL, $realSymbolic);
//Else, we will have to build a complex reader
} else {
require_once dirname(__FILE__) . "/Archive/Reader/File.php";
$realPath = $std;
// Try to find a file with a known extension in the path (
// (to manage URLs like archive.tar/directory/file)
$pos = 0;
do {
if ($pos + 1 < strlen($realPath)) {
$pos = strpos($realPath, '/', $pos + 1);
} else {
$pos = false;
}
if ($pos === false) {
$pos = strlen($realPath);
}
$file = substr($realPath, 0, $pos);
$baseDir = substr($realPath, $pos + 1);
$dotPos = strrpos($file, '.');
$extension = '';
if ($dotPos !== false) {
$extension = substr($file, $dotPos + 1);
}
} while ($pos < strlen($realPath) && (!File_Archive::isKnownExtension($extension) || is_dir($file) && $source == null));
$reachable = $file;
//If we are reading from the file system
if ($source === null) {
//Create a file reader
$result = new File_Archive_Reader_File($file);
} else {
//Select in the source the file $file
require_once dirname(__FILE__) . "/Archive/Reader/Select.php";
$result = new File_Archive_Reader_Select($file, $source);
}
require_once dirname(__FILE__) . "/Archive/Reader/Uncompress.php";
$tmp = new File_Archive_Reader_Uncompress($result, $uncompressionLevel);
unset($result);
$result = $tmp;
//Select the requested folder in the uncompress reader
$isDir = $result->setBaseDir($std);
if (PEAR::isError($isDir)) {
return $isDir;
}
if ($isDir && $symbolic == null) {
//Default symbolic name for directories is empty
$realSymbolic = '';
}
if ($directoryDepth >= 0) {
//Limit the maximum depth if necessary
require_once dirname(__FILE__) . "/Archive/Predicate/MaxDepth.php";
$tmp = new File_Archive_Reader_Filter(new File_Archive_Predicate($directoryDepth + substr_count(substr($std, $pos + 1), '/')), $result);
unset($result);
$result =& $tmp;
}
if ($std != $realSymbolic) {
require_once dirname(__FILE__) . "/Archive/Reader/ChangeName.php";
//Change the base name to the symbolic one if necessary
$tmp = new File_Archive_Reader_ChangeBaseName($std, $realSymbolic, $result);
unset($result);
$result =& $tmp;
}
}
}
$cacheCondition = File_Archive::getOption('cacheCondition');
if ($cacheCondition !== false && preg_match($cacheCondition, $URL)) {
$tmp =& File_Archive::cache($result);
unset($result);
$result =& $tmp;
}
return $result;
}
