class.ilErrorHandling.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2009 ILIAS open source, Extended GPL, see docs/LICENSE */
/* Copyright (c) 2015 Richard Klees, Extended GPL, see docs/LICENSE */
/* Copyright (c) 2016 Stefan Hecken, Extended GPL, see docs/LICENSE */
 
require_once 'Services/Environment/classes/class.ilRuntime.php';
 
require_once("Services/Exceptions/classes/class.ilDelegatingHandler.php");
require_once("Services/Exceptions/classes/class.ilPlainTextHandler.php");
require_once("Services/Exceptions/classes/class.ilTestingHandler.php");
set_include_path("./Services/Database/lib/PEAR" . PATH_SEPARATOR . ini_get('include_path'));
if (!class_exists('PEAR')) {
        require_once 'PEAR.php';
}
use Whoops\Run;
use Whoops\Handler\PrettyPageHandler;
use Whoops\Handler\CallbackHandler;
use Whoops\Exception\Inspector;
 
class ilErrorHandling extends PEAR
{
        var $DEBUG_ENV;
 
        var $FATAL;
 
        var $WARNING;
 
        var $MESSAGE;
 
        protected static $whoops_handlers_registered = false;
 
        public function __construct()
        {
                parent::__construct();
 
                // init vars
                $this->DEBUG_ENV = true;
                $this->FATAL     = 1;
                $this->WARNING   = 2;
                $this->MESSAGE   = 3;
 
                $this->error_obj = false;
                
                $this->initWhoopsHandlers();
                
                // somehow we need to get rid of the whoops error handler
                restore_error_handler();
                set_error_handler(array($this, "handlePreWhoops"));
        }
        
        protected function initWhoopsHandlers() {
                if (self::$whoops_handlers_registered) {
                        // Only register whoops error handlers once.
                        return;
                }
                
                $ilRuntime = $this->getIlRuntime();
                $this->whoops = $this->getWhoops();
                
                $this->whoops->pushHandler(new ilDelegatingHandler($this));
                
                if ($ilRuntime->shouldLogErrors()) {
                        $this->whoops->pushHandler($this->loggingHandler());
                }
                
                $this->whoops->register();
                
                self::$whoops_handlers_registered = true;
        }
 
        public function getHandler() {
                // TODO: * Use Whoops in production mode? This would require an appropriate
                //                 error-handler.
                //               * Check for context? The current implementation e.g. would output HTML for
                //                 for SOAP.
 
                if ($this->isDevmodeActive()) {
                        return $this->devmodeHandler();
                }
 
                return $this->defaultHandler();
        }
 
        function getLastError()
        {
                return $this->error_obj;
        }
 
        function errorHandler($a_error_obj)
        {
                global $log;
 
                // see bug 18499 (some calls to raiseError do not pass a code, which leads to security issues, if these calls
                // are done due to permission checks)
                if ($a_error_obj->getCode() == null)
                {
                        $a_error_obj->code = $this->WARNING;
                }
 
                $this->error_obj =& $a_error_obj;
//echo "-".$_SESSION["referer"]."-";
                if ($_SESSION["failure"] && substr($a_error_obj->getMessage(), 0, 22) != "Cannot find this block")
                {
                        $m = "Fatal Error: Called raise error two times.<br>".
                                "First error: ".$_SESSION["failure"].'<br>'.
                                "Last Error:". $a_error_obj->getMessage();
                        //return;
                        $log->write($m);
                        #$log->writeWarning($m);
                        #$log->logError($a_error_obj->getCode(), $m);
                        unset($_SESSION["failure"]);
                        die ($m);
                }
 
                if (substr($a_error_obj->getMessage(), 0, 22) == "Cannot find this block")
                {
                        if (DEVMODE == 1)
                        {
                                echo "<b>DEVMODE</b><br><br>";
                                echo "<b>Template Block not found.</b><br>";
                                echo "You used a template block in your code that is not available.<br>";
                                echo "Native Messge: <b>".$a_error_obj->getMessage()."</b><br>";
                                if (is_array($a_error_obj->backtrace))
                                {
                                        echo "Backtrace:<br>";
                                        foreach ($a_error_obj->backtrace as $b)
                                        {
                                                if ($b["function"] == "setCurrentBlock" &&
                                                        basename($b["file"]) != "class.ilTemplate.php")
                                                {
                                                        echo "<b>";
                                                }
                                                echo "File: ".$b["file"].", ";
                                                echo "Line: ".$b["line"].", ";
                                                echo $b["function"]."()<br>";
                                                if ($b["function"] == "setCurrentBlock" &&
                                                        basename($b["file"]) != "class.ilTemplate.php")
                                                {
                                                        echo "</b>";
                                                }
                                        }
                                }
                                exit;
                        }
                        return;
                }
 
                if (is_object($log) and $log->enabled == true)
                {
                        $log->write($a_error_obj->getMessage());
                        #$log->logError($a_error_obj->getCode(),$a_error_obj->getMessage());
                }
 
//echo $a_error_obj->getCode().":"; exit;
                if ($a_error_obj->getCode() == $this->FATAL)
                {
                        trigger_error(stripslashes($a_error_obj->getMessage()), E_USER_ERROR);
                        exit();
                }
 
                if ($a_error_obj->getCode() == $this->WARNING)
                {
                        if ($this->DEBUG_ENV)
                        {
                                $message = $a_error_obj->getMessage();
                        }
                        else
                        {
                                $message = "Under Construction";
                        }
 
                        $_SESSION["failure"] = $message;
 
                        if (!defined("ILIAS_MODULE"))
                        {
                                ilUtil::redirect("error.php");
                        }
                        else
                        {
                                ilUtil::redirect("../error.php");
                        }
                }
 
                if ($a_error_obj->getCode() == $this->MESSAGE)
                {
                        $_SESSION["failure"] = $a_error_obj->getMessage();
                        // save post vars to session in case of error
                        $_SESSION["error_post_vars"] = $_POST;
 
                        if (empty($_SESSION["referer"]))
                        {
                                $dirname = dirname($_SERVER["PHP_SELF"]);
                                $ilurl = parse_url(ILIAS_HTTP_PATH);
                                $subdir = substr(strstr($dirname,$ilurl["path"]),strlen($ilurl["path"]));
                                $updir = "";
 
                                if ($subdir)
                                {
                                        $num_subdirs = substr_count($subdir,"/");
 
                                        for ($i=1;$i<=$num_subdirs;$i++)
                                        {
                                                $updir .= "../";
                                        }
                                }
                                ilUtil::redirect($updir."index.php");
                        }
 
                        /* #12104 
                        check if already GET-Parameters exists in Referer-URI                    
                        if (substr($_SESSION["referer"],-4) == ".php")
                        {
                                $glue = "?";
                        }
                        else
                        {
                            // this did break permanent links (".html&")
                                $glue = "&";
                        }
                        */
                        ilUtil::redirect($_SESSION["referer"]);                 
                }
        }
 
        function getMessage()
        {
                return $this->message;
        }
        function setMessage($a_message)
        {
                $this->message = $a_message;
        }
        function appendMessage($a_message)
        {
                if($this->getMessage())
                {
                        $this->message .= "<br /> ";
                }
                $this->message .= $a_message;
        }
        
        public static function _ilErrorWriter($errno, $errstr, $errfile, $errline)
        {
                global $ilLog;
                
                switch($errno)
                {
                        case E_USER_ERROR:
                                $ilLog->write('PHP errror: '.$errstr.'. FATAL error on line '.$errline.' in file '.$errfile);
                                unset($ilLog);
                                exit(1);
                        
                        case E_USER_WARNING:
                                $ilLog->write('PHP warning: ['.$errno.'] '.$errstr.' on line '.$errline.' in file '.$errfile);
                                break;
                        
                }                               
                return true;
        }
        
        protected function getIlRuntime() {
                return ilRuntime::getInstance();
        }
        
        protected function getWhoops() {
                return new Run();
        }
        
        protected function isDevmodeActive() {
                return DEVMODE == 1;
        }
 
        protected function defaultHandler() {
                // php7-todo : alex, 1.3.2016: Exception -> Throwable, please check
                return new CallbackHandler(function($exception, Inspector $inspector, Run $run) {
                        global $lng;
 
                        require_once("Services/Logging/classes/error/class.ilLoggingErrorSettings.php");
                        require_once("Services/Logging/classes/error/class.ilLoggingErrorFileStorage.php");
                        require_once("Services/Utilities/classes/class.ilUtil.php");
 
                        $session_id = substr(session_id(),0,5);
                        $err_num = rand(1, 9999);
                        $file_name = $session_id."_".$err_num;
 
                        $logger = ilLoggingErrorSettings::getInstance();
                        if(!empty($logger->folder())) {
                                $lwriter = new ilLoggingErrorFileStorage($inspector, $logger->folder(), $file_name);
                                $lwriter->write();
                        }
 
                        //Use $lng if defined or fallback to english
                        if($lng !== null) {
                                $lng->loadLanguageModule('logging');
                                $message = sprintf($lng->txt("log_error_message"), $file_name);
 
                                if($logger->mail()) {
                                        $message .= " ".sprintf($lng->txt("log_error_message_send_mail"), $logger->mail(), $file_name, $logger->mail());
                                }
                        } else {
                                $message = "Error ".$file_name." occurred.";
 
                                if($logger->mail()) {
                                        $message .= ' '.'Please send a mail to <a href="mailto:'.$logger->mail().'?subject=code: '.$file_name.'">'.$logger->mail().'%s</a>';
                                }
                        }
 
                        ilUtil::sendFailure($message, true);
                        ilUtil::redirect("error.php");
                });
        }
 
        protected function devmodeHandler() {
                global $ilLog;
                
                switch (ERROR_HANDLER) {
                        case "TESTING":
                                return new ilTestingHandler();
                        case "PLAIN_TEXT":
                                return new ilPlainTextHandler();
                        case "PRETTY_PAGE":
                                return new PrettyPageHandler();
                        default:
                                if ($ilLog) {
                                        $ilLog->write("Unknown or undefined error handler '".ERROR_HANDLER."'. "
                                                                 ."Falling back to PrettyPageHandler.");
                                }
                                return new PrettyPageHandler();
                }
        }
        
        protected function loggingHandler() {
                // php7-todo : alex, 1.3.2016: Exception -> Throwable, please check
                return new CallbackHandler(function($exception, Inspector $inspector, Run $run) {
                        global $ilLog;
 
                        if(is_object($ilLog)) {
                                $message = $exception->getMessage().' in '.$exception->getFile().":".$exception->getLine();
                                $ilLog->error($exception->getCode().' '.$message);
                        }
                        
                        // Send to system logger
                        error_log($exception->getMessage());
                });
        }
        
        public function handlePreWhoops($level, $message, $file, $line)
        {
                global $ilLog;
                
                if ($level & error_reporting()) {
                        
                        // correct-with-php5-removal JL start
                        // ignore all E_STRICT that are E_NOTICE (or nothing at all) in PHP7
                        if (version_compare(PHP_VERSION, '7.0.0', '<')) {
                                if ($level == E_STRICT) {
                                        if (!stristr($message, "should be compatible") &&
                                                !stristr($message, "should not be called statically") &&
                                                !stristr($message, "should not be abstract")) {
                                                return true;
                                        };
                                }
                        }
                        // correct-with-php5-removal end
 
                        if (!$this->isDevmodeActive()) {
                                // log E_USER_NOTICE, E_STRICT, E_DEPRECATED, E_USER_DEPRECATED only
                                if ($level >= E_USER_NOTICE) {  
                                        
                                        if ($ilLog) {                           
                                                $severity = Whoops\Util\Misc::TranslateErrorCode($level);
                                                $ilLog->write("\n\n".$severity." - ".$message."\n".$file." - line ".$line."\n");
                                        }
                                        return true;
                                }
                        }
                        
                        // trigger whoops error handling
                        if($this->whoops)
                        {
                                return $this->whoops->handleError($level, $message, $file, $line);
                        }
                }
                
                return false;
        }
        
} // END class.ilErrorHandling