Services/Utilities/classes/class.ilFileUtils.php

Go to the documentation of this file.

<?php
/*
+-----------------------------------------------------------------------------+
| ILIAS open source                                                           |
+-----------------------------------------------------------------------------+
| Copyright (c) 1998-2006 ILIAS open source, University of Cologne            |
|                                                                             |
| This program is free software; you can redistribute it and/or               |
| modify it under the terms of the GNU General Public License                 |
| as published by the Free Software Foundation; either version 2              |
| of the License, or (at your option) any later version.                      |
|                                                                             |
| This program is distributed in the hope that it will be useful,             |
| but WITHOUT ANY WARRANTY; without even the implied warranty of              |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               |
| GNU General Public License for more details.                                |
|                                                                             |
| You should have received a copy of the GNU General Public License           |
| along with this program; if not, write to the Free Software                 |
| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. |
+-----------------------------------------------------------------------------+
*/

include_once 'Services/Utilities/classes/class.ilFileUtilsException.php';


class ilFileUtils
{
        function processZipFile ($a_directory, $a_file, $structure, $ref_id = null, $containerType = null) {

                global $lng;
                include_once("Services/Utilities/classes/class.ilUtil.php");
                                
                $pathinfo = pathinfo($a_file);
                $file = $pathinfo["basename"];

                // Copy zip-file to new directory, unzip and remove it
                // TODO: check archive for broken file
                copy ($a_file, $a_directory . "/" . $file);
                ilUtil::unzip($a_directory . "/" . $file);
                unlink ($a_directory . "/" . $file);

                // Stores filename and paths into $filearray to check for viruses and 
                ilFileUtils::recursive_dirscan($a_directory, $filearray);

                // if there are no files unziped (->broken file!)
                if (empty($filearray)) {
                        throw new ilFileUtilsException($lng->txt("archive_broken"), ilFileUtilsException::$BROKEN_FILE);
                        break;
                }

                // virus handling
                foreach ($filearray["file"] as $key => $value)
                {
                        $vir = ilUtil::virusHandling($filearray[path][$key], $value);
                        if (!$vir[0])
                        {
                                // Unlink file and throw exception
                                unlink($a_file);
                                throw new ilFileUtilsException($lng->txt("file_is_infected")."<br />".$vir[1], ilFileUtilsException::$INFECTED_FILE);
                                break;
                        }
                        else
                        {
                                if ($vir[1] != "")
                                {
                                        throw new ilFileUtilsException($vir[1], ilFileUtilsException::$INFECTED_FILE);
                                        break;
                                }
                        }
                        
                }
                
                // If archive is to be used "flat"
                if (!$structure) 
                {       
                        foreach (array_count_values($filearray["file"]) as $key => $value)
                        {
                                // Archive contains same filenames in different directories 
                                if ($value != "1") 
                                {       
                                        $doublettes .= " '" . $key . "'";
                                        
                                }       
                        }
                        if (isset($doublettes))
                        {
                                throw new ilFileUtilsException($lng->txt("exc_upload_error") . "<br />" . $lng->txt("zip_structure_error") . $doublettes , 
                                                                ilFileUtilsException::$DOUBLETTES_FOUND);
                                break;
                        }
                }

                // Everything fine since we got here; so we can store files and folders into the system (if ref_id is given)
                if ($ref_id != null)
                {
                        ilFileUtils::createObjects ($a_directory, $structure, $ref_id, $containerType);
                }
                
        }

        function recursive_dirscan($dir, &$arr)
        {
                $dirlist = opendir($dir);
                while ($file = readdir ($dirlist))
                {
                        if ($file != '.' && $file != '..')
                        {
                                $newpath = $dir.'/'.$file;
                                $level = explode('/',$newpath);
                                if (is_dir($newpath))
                                {
                                        ilFileUtils::recursive_dirscan($newpath, $arr);
                                }
                                else
                                {
                                        $arr["path"][] = $dir . "/";
                                        $arr["file"][] = end($level);
                                }
                        }
                }
                closedir($dirlist);             
        }


        function createObjects($dir, $structure, $ref_id, $containerType)
        {
                $dirlist = opendir($dir);
                while ($file = readdir ($dirlist))
                {
                        if ($file != '.' && $file != '..')
                        {
                                $newpath = $dir.'/'.$file;
                                $level = explode('/',$newpath);
                                if (is_dir($newpath))
                                {
                                        if ($structure) 
                                        {
                                                $new_ref_id = ilFileUtils::createContainer($file, $ref_id, $containerType);
                                                ilFileUtils::createObjects($newpath, $structure, $new_ref_id, $containerType);
                                        }
                                        else 
                                        {
                                                ilFileUtils::createObjects($newpath, $structure, $ref_id, $containerType);
                                        }
                                }
                                else
                                {
                                        ilFileUtils::createFile (end($level),$dir,$ref_id);
                                }
                        }
                }
                closedir($dirlist);             
        }
        
        
        function createContainer($name, $ref_id, $containerType) 
        {
                if ($containerType == "Category") 
                {
                        include_once("./Modules/Category/classes/class.ilObjCategory.php");
                        $newObj = new ilObjCategory();
                        $newObj->setType("cat");
                }
                if ($containerType == "Folder")
                {
                        include_once("./classes/class.ilObjFolder.php");
                        $newObj = new ilObjFolder();
                        $newObj->setType("fold");               
                }

                $newObj->setTitle($name);
                $newObj->create();
                $newObj->createReference();
                $newObj->putInTree($ref_id);
                $newObj->setPermissions($ref_id);
                $newObj->initDefaultRoles();
                
                if ($newObj->getType() == "cat") 
                {
                        global $lng;
                        $newObj->addTranslation($name,"", $lng->getLangKey(), $lng->getLangKey());
                }
                
                return $newObj->getRefId();
        }
        
        function createFile ($filename, $path, $ref_id)
        {
                // create and insert file in grp_tree
                include_once("./Modules/File/classes/class.ilObjFile.php");
                $fileObj = new ilObjFile();
                $fileObj->setType($this->type);
                $fileObj->setTitle(ilUtil::stripSlashes($filename));
                $fileObj->setFileName(ilUtil::stripSlashes($filename));
                
                // better use this, mime_content_type is deprecated
                include_once("./Services/MediaObjects/classes/class.ilObjMediaObject.php");
                $fileObj->setFileType(ilObjMediaObject::getMimeType($path. "/" . $filename));
                
                $fileObj->setFileSize(filesize($path. "/" . $filename));
                $fileObj->create();
                $fileObj->createReference();

                $fileObj->putInTree($ref_id);
                $fileObj->setPermissions($ref_id);
        
                // upload file to filesystem

                $fileObj->createDirectory();

                $fileObj->storeUnzipedFile($path. "/" . $filename,ilUtil::stripSlashes($filename));

        }
        
        
        function fastBase64Decode ($filein, $fileout) 
        {
                $fh = fopen($filein, 'rb');
                $fh2= fopen($fileout, 'wb');
                stream_filter_append($fh2, 'convert.base64-decode');

                while (!feof($fh)){
                    $chunk = fgets($fh);
                    if ($chunk === false)
                        break;
                    fwrite ($fh2, $chunk);
                }
                fclose ($fh);
                fclose ($fh2);
                return true;
        }

        function fastBase64Encode ($filein, $fileout) 
        {
                $fh = fopen($filein, 'rb');
                $fh2= fopen($fileout, 'wb');
                stream_filter_append($fh2, 'convert.base64-encode');
                
                while (feof ($fh)) {
                        $chunk = fgets($fh,76);
                        if ($chunk === false) 
                        {
                                break;
                        }
                        fwrite ($fh2, $chunk);                  
                }
                fclose ($fh);
                fclose ($fh2);
        }                       
        
        function fastGZip ($in, $out, $level="9")
        {
    if (!file_exists ($in) || !is_readable ($in))
        return false;
    if ((!file_exists ($out) && !is_writable (dirname ($out)) || (file_exists($out) && !is_writable($out)) ))
        return false;
    
    $in_file = fopen ($in, "rb");
    if (!$out_file = gzopen ($out, "wb".$param)) {
        return false;
    }
    
    while (!feof ($in_file)) {
        $buffer = fgets ($in_file, 4096);
        gzwrite ($out_file, $buffer, 4096);
    }

    fclose ($in_file);
    gzclose ($out_file);
    
    return true;
        }

        function fastGunzip ($in, $out)
        {
    if (!file_exists ($in) || !is_readable ($in))
        return false;
    if ((!file_exists ($out) && !is_writable (dirname ($out)) || (file_exists($out) && !is_writable($out)) ))
        return false;

    $in_file = gzopen ($in, "rb");
    $out_file = fopen ($out, "wb");

    while (!gzeof ($in_file)) {
        $buffer = gzread ($in_file, 4096);
        fwrite ($out_file, $buffer, 4096);
    }
 
    gzclose ($in_file);
    fclose ($out_file);
    
    return true;
        }
  
        public static function _lookupMimeType($a_file)
        {
                if(!file_exists($a_file) or !is_readable($a_file))
                {
                        return false;
                }
                
                if(class_exists('finfo'))
                {
                        $finfo = new finfo(FILEINFO_MIME);
                        return $finfo->buffer(file_get_contents($a_file));
                }
                if(function_exists('mime_content_type'))
                {
                        return mime_content_type($a_file);
                }
                return 'application/octet-stream';
        }
        
} // END class.ilFileUtils


?>