class.ilFileXMLParser.php

Go to the documentation of this file.

<?php

/* Copyright (c) 1998-2010 ILIAS open source, Extended GPL, see docs/LICENSE */

include_once './Services/Xml/classes/class.ilSaxParser.php';
include_once 'Modules/File/classes/class.ilFileException.php';
include_once 'Services/Utilities/classes/class.ilFileUtils.php';

class ilFileXMLParser extends ilSaxParser
{
    public static $CONTENT_NOT_COMPRESSED = 0;
    public static $CONTENT_GZ_COMPRESSED = 1;
    public static $CONTENT_ZLIB_COMPRESSED = 2;
    public static $CONTENT_COPY = 4;
    // begin-patch fm
    public static $CONTENT_REST = 5;
    // end-patch fm
    public $file;
    public $obj_id;
    public $result;
    public $mode;
    //var $content;

    public $tmpFilename;


    public function __construct(&$file, $a_xml_data, $obj_id = -1, $mode = 0)
    {
        parent::__construct();
        $this->file = $file;
        $this->setXMLContent($a_xml_data);
        $this->obj_id = $obj_id;
        $this->result = false;
        $this->mode = $mode;
    }


    public function setImportDirectory($a_val)
    {
        $this->importDirectory = $a_val;
    }


    public function getImportDirectory()
    {
        return $this->importDirectory;
    }


    public function setHandlers($a_xml_parser)
    {
        xml_set_object($a_xml_parser, $this);
        xml_set_element_handler($a_xml_parser, 'handlerBeginTag', 'handlerEndTag');
        xml_set_character_data_handler($a_xml_parser, 'handlerCharacterData');
    }


    public function handlerBeginTag($a_xml_parser, $a_name, $a_attribs)
    {
        global $DIC;
        $ilErr = $DIC['ilErr'];

        global $DIC;
        $ilLog = $DIC['ilLog'];

        switch ($a_name) {
            case 'File':
                if (isset($a_attribs["obj_id"])) {
                    $read_obj_id = ilUtil::__extractId($a_attribs["obj_id"], IL_INST_ID);
                    if ($this->obj_id != -1 && (int) $read_obj_id != -1 && (int) $this->obj_id != (int) $read_obj_id) {
                        throw new ilFileException("Object IDs (xml $read_obj_id and argument " . $this->obj_id . ") do not match!", ilFileException::$ID_MISMATCH);
                    }
                }
                if (isset($a_attribs["type"])) {
                    $this->file->setFileType($a_attribs["type"]);
                }
                $this->file->setVersion($this->file->getVersion() + 1);
                break;
            case 'Content':
                $this->tmpFilename = ilUtil::ilTempnam();
                $this->mode = ilFileXMLParser::$CONTENT_NOT_COMPRESSED;
                $this->isReadingFile = true;
                #echo $a_attribs["mode"];
                if (isset($a_attribs["mode"])) {
                    if ($a_attribs["mode"] == "GZIP") {
                        if (!function_exists("gzread")) {
                            throw new ilFileException("Deflating with gzip is not supported", ilFileException::$ID_DEFLATE_METHOD_MISMATCH);
                        }

                        $this->mode = ilFileXMLParser::$CONTENT_GZ_COMPRESSED;
                    } elseif ($a_attribs["mode"] == "ZLIB") {
                        if (!function_exists("gzuncompress")) {
                            throw new ilFileException("Deflating with zlib (compress/uncompress) is not supported", ilFileException::$ID_DEFLATE_METHOD_MISMATCH);
                        }

                        $this->mode = ilFileXMLParser::$CONTENT_ZLIB_COMPRESSED;
                    } elseif ($a_attribs["mode"] == "COPY") {
                        $this->mode = ilFileXMLParser::$CONTENT_COPY;
                    } // begin-patch fm
                    elseif ($a_attribs['mode'] == 'REST') {
                        $this->mode = ilFileXMLParser::$CONTENT_REST;
                    }
                    // end-patch fm
                }
        }
    }


    public function handlerEndTag($a_xml_parser, $a_name)
    {
        $this->cdata = trim($this->cdata);

        $GLOBALS['DIC']['ilLog']->write(__METHOD__ . ': ' . $this->cdata);

        switch ($a_name) {
            case 'File':
                $this->result = true;
                break;
            case 'Filename':
                if (strlen($this->cdata) == 0) {
                    throw new ilFileException("Filename ist missing!");
                }

                $this->file->setFilename(basename(self::normalizeRelativePath($this->cdata)));
                $this->file->setTitle($this->cdata);

                break;
            case 'Title':
                $this->file->setTitle(trim($this->cdata));
                break;
            case 'Description':
                $this->file->setDescription(trim($this->cdata));
                break;
            case 'Rating':
                $this->file->setRating((bool) $this->cdata);
                break;
            case 'Content':
                $GLOBALS['DIC']['ilLog']->write($this->mode);
                $this->isReadingFile = false;
                $baseDecodedFilename = ilUtil::ilTempnam();
                if ($this->mode == ilFileXMLParser::$CONTENT_COPY) {
                    $this->tmpFilename = $this->getImportDirectory() . "/" . self::normalizeRelativePath($this->cdata);
                } // begin-patch fm
                elseif ($this->mode == ilFileXMLParser::$CONTENT_REST) {
                    include_once './Services/WebServices/Rest/classes/class.ilRestFileStorage.php';
                    $storage = new ilRestFileStorage();
                    $this->tmpFilename = $storage->getStoredFilePath(self::normalizeRelativePath($this->cdata));
                    if (!ilFileUtils::fastBase64Decode($this->tmpFilename, $baseDecodedFilename)) {
                        throw new ilFileException("Base64-Decoding failed", ilFileException::$DECOMPRESSION_FAILED);
                    }
                    $this->tmpFilename = $baseDecodedFilename;
                } // end-patch fm
                else {
                    if (!ilFileUtils::fastBase64Decode($this->tmpFilename, $baseDecodedFilename)) {
                        throw new ilFileException("Base64-Decoding failed", ilFileException::$DECOMPRESSION_FAILED);
                    }
                    if ($this->mode == ilFileXMLParser::$CONTENT_GZ_COMPRESSED) {
                        if (!ilFileUtils::fastGunzip($baseDecodedFilename, $this->tmpFilename)) {
                            throw new ilFileException("Deflating with fastzunzip failed", ilFileException::$DECOMPRESSION_FAILED);
                        }
                        unlink($baseDecodedFilename);
                    } elseif ($this->mode == ilFileXMLParser::$CONTENT_ZLIB_COMPRESSED) {
                        if (!ilFileUtils::fastGunzip($baseDecodedFilename, $this->tmpFilename)) {
                            throw new ilFileException("Deflating with fastDecompress failed", ilFileException::$DECOMPRESSION_FAILED);
                        }
                        unlink($baseDecodedFilename);
                    } else {
                        $this->tmpFilename = $baseDecodedFilename;
                    }
                }
                //$this->content = $content;
                // see #17211
                if (is_file($this->tmpFilename)) {
                    $this->file->setFileSize(filesize($this->tmpFilename)); // strlen($this->content));
                }

                // if no file type is given => lookup mime type
                if (!$this->file->getFileType()) {
                    global $DIC;
                    $ilLog = $DIC['ilLog'];

                    #$ilLog->write(__METHOD__.': Trying to detect mime type...');
                    include_once('./Services/Utilities/classes/class.ilFileUtils.php');
                    $this->file->setFileType(ilFileUtils::_lookupMimeType($this->tmpFilename));
                }

                break;
        }

        $this->cdata = '';

        return;
    }


    public function handlerCharacterData($a_xml_parser, $a_data)
    {
        if ($a_data != "\n") {
            // begin-patch fm
            if ($this->isReadingFile && $this->mode != ilFileXMLParser::$CONTENT_COPY && $this->mode != ilFileXMLParser::$CONTENT_REST) { // begin-patch fm
                $handle = fopen($this->tmpFilename, "a");
                fwrite($handle, $a_data);
                fclose($handle);
            } else {
                $this->cdata .= $a_data;
            }
        }
    }


    public function setFileContents()
    {
        if (!file_exists($this->tmpFilename)) {
            ilLoggerFactory::getLogger('file')->error(__METHOD__ . ' "' . $this->tmpFilename . '" file not found.');

            return;
        }

        if (filesize($this->tmpFilename) == 0) {
            return;
        }

        $filedir = $this->file->getDirectory($this->file->getVersion());

        if (!is_dir($filedir)) {
            $this->file->createDirectory();
            ilUtil::makeDir($filedir);
        }

        $filename = $filedir . "/" . $this->file->getFileName();

        if (file_exists($filename)) {
            unlink($filename);
        }

        return ilFileUtils::rename($this->tmpFilename, $filename);
    }


    public function updateFileContents()
    {
        if ($this->setFileContents()) {
            require_once("./Services/History/classes/class.ilHistory.php");
            ilHistory::_createEntry($this->file->getId(), "replace", $this->file->getFilename() . "," . $this->file->getVersion());
            $this->file->addNewsNotification("file_updated");
        }
    }


    public function start()
    {
        $this->startParsing();

        return $this->result > 0;
    }


    public static function normalizeRelativePath($path)
    {
        $path = str_replace('\\', '/', $path);

        while (preg_match('#\p{C}+|^\./#u', $path)) {
            $path = preg_replace('#\p{C}+|^\./#u', '', $path);
        }

        $parts = [];
        foreach (explode('/', $path) as $part) {
            switch ($part) {
                case '':
                case '.':
                    break;
                case '..':
                    array_pop($parts);
                    break;
                default:
                    $parts[] = $part;
                    break;
            }
        }

        return implode('/', $parts);
    }
}