Warnungen und Notizen in den Status einer Exception erheben

[hotti]

hi,

so langsam hab ich es satt, laufend ins Error_Log meines Webservers zu gucken.
Siehe Thema: Wenns knallt, will ich das sofort im Browser sehen!
Wie kann ich das einschalten, geht das?

Hotti

[ChrisB]

Hi,

so langsam hab ich es satt, laufend ins Error_Log meines Webservers zu gucken.
Siehe Thema: Wenns knallt, will ich das sofort im Browser sehen!
Wie kann ich das einschalten, geht das?

http://www.php.net/manual/en/errorfunc.configuration.php#ini.display-errors

MfG ChrisB

[hotti]

Hi,

so langsam hab ich es satt, laufend ins Error_Log meines Webservers zu gucken.
Siehe Thema: Wenns knallt, will ich das sofort im Browser sehen!
Wie kann ich das einschalten, geht das?

http://www.php.net/manual/en/errorfunc.configuration.php#ini.display-errors

OK, ich habs jetzt:

  
error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);  
ini_set('track_errors', True);  

und dann im try-block $php_errormsg abfragen, wenn was drinsteht, Exception werfen. Getestet, geht einwandfrei ;)

Danke Dir!
Horst Hacke

[hotti]

und dann im try-block $php_errormsg abfragen, wenn was drinsteht, Exception werfen. Getestet, geht einwandfrei ;)

Oder einfach error_get_last() fragen:

  
		if(error_get_last()){  
			$eo = (object)error_get_last();  
			throw new Exception(sprintf("%s at %s, line %u", $eo->message, $eo->file, $eo->line));  
		}  

;)

[zehbaeh]

Möchtest Du nicht eher in einer mit "set_error_handler" gesetzten Funktion für die Fehler/Warnungen/Notices passende Exceptions* werfen?!

*(ErrorException oder davon abgeleitet)

[hotti]

Möchtest Du nicht eher in einer mit "set_error_handler" gesetzten Funktion für die Fehler/Warnungen/Notices passende Exceptions* werfen?!

*(ErrorException oder davon abgeleitet)

hi, danke für jeden Tipp ;)
In PHP ist das alles ein bischen komplizierter als in Perl.
Es soll in meinen Scripts die Möglichkeit geben:

• Warnungen in den Status einer Exception zu erheben (RaiseError),
• Exceptions mit oder ohne Backtrace werfen zu können.

Heute morgen hab ich das alles mal unter einen Hut gebracht, prinzipiell gibt es jetzt eine eigene Eception-Class, die von der PHP-Exception-Class erbt. Im Default ist der Backtrace eingeschaltet. Für den Fall, dass error_get_last() eine Exception werfen soll (quasi alle Warnungen, Notices...), kriegt meine Exception-Instanz den Backtrace von error_get_last().

Das alles zusammen sieht dann so aus:

  
<?php  
  
error_reporting(NULL); // I have my own ...!!!  
class MyBase{  
	public function __construct($cfg = array()){  
		$this->DBH = $this->dbh($cfg);  
	}  
  
	private function dbh(&$cfg = array()){  
		$default = array(  
			'user' => '',  
			'pass' => '',  
			'host' => 'localhost',  
			'port' => 3306,  
			'base' => 'myweb',  
		);  
		$cred = array_merge($default, $cfg);  
		$mysqli = mysqli_init();  
		mysqli_options($mysqli, MYSQLI_OPT_CONNECT_TIMEOUT, 3);  
  
  
		mysqli_real_connect($mysqli, $cred['host'], $cred['user'], $cred['pass'], $cred['base']);  
		if($mysqli->connect_errno){  
			throw new MyException('Keine Verbindung', array('trace' => 0));  
		}  
		return $mysqli;  
	}  
  
  
	public function browse(){  
		$res = $this->DBH->query("SELECT url, id FROM perlbase ORDER BY title");  
		if(!$res) throw new MyException($this->DBH->error, array('trace' => 1));  
		while($r = mysqli_fetch_object($res)){  
			//print_r($r);  
		}  
	}  
  
}  
  
class MyException extends Exception{  
	public function __construct($message = '', $trace = array()){  
		$default = array(  
			'trace' => 1,  
			'file'  => $this->getFile(),  
			'line'  => $this->getLine(),  
		);  
		$this->TRACE   = array_merge($default, $trace);  
		$this->MESSAGE = $message;  
	}  
	public function getMyMessage(){  
		if($this->TRACE['trace'] == 1){  
			return sprintf("%s at %s, line %u", $this->MESSAGE, $this->TRACE['file'], $this->TRACE['line']);  
		}  
		else{  
			return $this->MESSAGE;  
		}  
	}  
  
}  
  
///////////////////////////////////////////////////////////////////////////  
// main class  
// put out  
try{  
	$mb = new MyBase;  
	$mb->browse();  
  
	$x .= 1; // Provoziere eine NOTICE  
	if(error_get_last()){  
		$eo = (object)error_get_last();  
		throw new MyException($eo->message, array('trace' => 1, 'file' => $eo->file, 'line' => $eo->line));  
	}  
	print "Alles ist gut gegangen\n";  
}  
catch(MyException $e){  
	printf("MyException: %s", $e->getMyMessage());  
}  
  
?>  

[zehbaeh]

Hmm... das erscheint mir umständlich. Ich hatte da eher an was Gegenteiliges gedacht.)

Beispiel (reduziert):

  
<?php  
  
class NoticeException  extends ErrorException {}  
class WarningException extends ErrorException {}  
  
class Errors  
{  
    private $severity = array();  
    public $onFatal = NULL;  
  
    public function __construct($severity = E_ALL)  
    {  
        error_reporting(E_ALL);  
        $this->setDisplay(FALSE);  
        set_error_handler(array($this, 'onError'), E_ALL);  
        register_shutdown_function(array($this, 'onShutdown'));  
        $this->setSeverity($severity);  
    }  
  
    public function __destruct()  
    {  
        restore_error_handler();  
        $this->onFatal = NULL;  
    }  
  
    public function setDisplay($enable)  
    {  
        ini_set('display_errors', (bool)$enable);  
        return $this;  
    }  
  
    public function getDisplay()  
    {  
        return (bool)ini_get('display_errors');  
    }  
  
    public function setSeverity($severity)  
    {  
        $notices  = E_NOTICE  | E_USER_NOTICE | E_STRICT | E_DEPRECATED | E_USER_DEPRECATED;  
        $warnings = E_WARNING | E_USER_WARNING;  
        switch (0|$severity) {  
            case E_NOTICE:  
                $severity = $notices;  
                break;  
            case E_WARNING:  
                $severity = E_ALL ^ ($notices);  
                break;  
            default:  
                $severity |= E_ALL ^ ($notices | $warnings);  
                break;  
        }  
        array_push($this->severity, $severity);  
        return $this;  
    }  
  
    public function getSeverity()  
    {  
        return end($this->severity);  
    }  
  
    public function restoreSeverity()  
    {  
        if (count($this->severity) > 1) {  
            array_pop($this->severity);  
        }  
        return $this;  
    }  
  
    public function onError($severity, $message, $filepath, $line)  
    {  
        switch ($this->maskSeverity($severity)) {  
            case 0:  
                return 0 !== (error_reporting() & $severity);  
            case E_NOTICE:  
            case E_USER_NOTICE:  
            case E_STRICT:  
            case E_DEPRECATED:  
            case E_USER_DEPRECATED:  
                throw new NoticeException($message, 2, $severity, $filepath, $line);  
            case E_WARNING:  
            case E_USER_WARNING:  
                throw new WarningException($message, 1, $severity, $filepath, $line);  
            default:  
                throw new ErrorException($message, 0, $severity, $filepath, $line);  
        }  
    }  
  
    public function onShutdown()  
    {  
        $error = error_get_last();  
        if ($error && is_callable($this->onFatal)) {  
            call_user_func_array($this->onFatal, $error);  
        }  
    }  
  
    protected function maskSeverity($severity)  
    {  
        return $severity & $this->getSeverity();  
    }  
}  
  
$errors = new Errors;  
try {  
    $a = $b; // undefined  
} catch(Exception $e) {  
    echo get_class($e), ' ', $e->getMessage(), PHP_EOL;  
}  
  
$errors->setSeverity(E_WARNING);  
try {  
    $c = $a[WTF]; // undefined - ignored  
    fopen('WTF', 'r'); // warning thrown  
} catch(Exception $e) {  
    echo get_class($e), ' ', $e->getMessage(), PHP_EOL;  
}  
  
try {  
    trigger_error('The current user sucks', E_USER_ERROR);  
} catch(Exception $e) {  
    echo get_class($e), ' ', $e->getMessage(), PHP_EOL;  
}  
$errors->restoreSeverity();  
  
$errors->onFatal = function($severity, $message) {  
    echo 'FATAL: ', $message, PHP_EOL;  
};  
// uncatchable fatal error -> shutdown  
try {  
~FALSE;  
} catch(Exception $e) {  
    echo $e->getMessage(), PHP_EOL;  
}  

[dedlfix]

Tach!

error_reporting(NULL); // I have my own ...!!!

Abgesehen davon, dass der Wert ein Integer sein sollte, also 0 statt NULL korrekter wäre, schaltest du damit nur nebenbei die Fehlermeldungen aus. Besser wäre ein ini_set('display_errors', 0); Selbst wenn du deine eigene Fehlermeldungsroutine verwendest, solltest du den error_reporting-Wert auf != 0 lassen. Egal welchen Wert du einstellst, ein eigener Error-Handler wird immer aufgerufen. Mit einem parameterlosen Aufruf von error_reporting() bekommt man (darin) diesen eingestellten Wert zurückgeliefert. Ausnahme ist ein vorangestelltes @, das dann dafür sorgt, dass 0 zurückgeliefert wird. Somit hat man in einem eigenen Error-Handler die Möglichkeit zwischen gewollter Unterdrückung und nicht behandelten Fehlern zu unterscheiden. Ein generelles 0 verhindert diese Unterscheidungsmöglichkeit.

class MyException extends Exception{
  public function __construct($message = '', $trace = array()){
    $default = array(
      'trace' => 1,
      'file'  => $this->getFile(),
      'line'  => $this->getLine(),
    );
    $this->TRACE   = array_merge($default, $trace);
    $this->MESSAGE = $message;
  }
  public function getMyMessage(){
    if($this->TRACE['trace'] == 1){
      return sprintf("%s at %s, line %u", $this->MESSAGE, $this->TRACE['file'], $this->TRACE['line']);
    }
    else{
      return $this->MESSAGE;
    }
  }
}

Du erweiterst die Standard-Klasse Exception, nutzt dann aber komplett eigene Eigenschaften und eine Ausgabemethode, anstatt die vorhandenen Mitglieder zu nutzen beziehungsweise zu überschreiben. Warum? Warum lässt du dann nicht gleich Exception unverwendet?

Zudem bekommst du auf diese Weise in $this->TRACE['line'] ohne die Übergabe der error_get_last()-Werte mit dem $this->getLine() die Zeile des MyException-Wurfs, womit dann diese Information nicht mehr sinnvoll ist.

$x .= 1; // Provoziere eine NOTICE
if(error_get_last()){
$eo = (object)error_get_last();
throw new MyException($eo->message, array('trace' => 1, 'file' => $eo->file, 'line' => $eo->line));

Na das ist ja auch unnötig umständlich. So musst du explizit nach aufgetretenen Fehlern fragen und dann kommen drei Zeilen nur zum Werfen. Dazu noch der doppelte Aufruf von error_get_last(), nur weil dir die Array-Schreibweise nicht gefällt. Sonst reichte ein

if ($eo = error_get_last()) {

Aber wie gesagt, es geht viel einfacher, wenn man die eingebauten Mechanismen nutzte.

class ErrorException extends Exception {  
  protected $context = array();  
	  
  public function __construct($no, $msg, $file, $line, $context){  
    parent::__construct($msg, $no);  
    $this->file = $file; // Datei und Zeile setzen, sonst sind das die Werte vom throw im ErrorHandler  
    $this->line = $line;  
    $this->context = $context;  
  }  
  
  public static function ErrorHandler($no, $msg, $file, $line, $context) {  
    if (error_reporting())  
      throw new ExException($no, $msg, $file, $line, $context);  
    return true;  
  }  
}  
  
set_error_handler("ErrorException::ErrorHandler");

ErrorException nutzt die Mitglieder der Elternklasse. Lediglich der (Variablen-)Kontext kommt angedeuteterweise hinzu. Außerdem wird ein eigener Error-Handler aktiviert, der im Falle eines Falles ohne große Umstände von PHP selbst angesprungen wird.

try {  
  $x .= 1; // Provoziere eine NOTICE  
  print "Alles ist gut gegangen\n";  
} catch (Exception $e) {  
  echo "Exception: ", $e;  
}

So einfach kann es gehen. Wenn man mal keine Exception bekommen mag, dann kommt ein @ vor die potentiell fehlerwerfende Zeile. Die Ausgabe ist derzeit ein Exception-Trace. Geändert werden kann das durch Überschreiben von __toString().

dedlfix.

[hotti]

hi,

Aber wie gesagt, es geht viel einfacher, wenn man die eingebauten Mechanismen nutzte.

Ja, das interessiert mich.

class ErrorException extends Exception {

protected $context = array();

public function __construct($no, $msg, $file, $line, $context){
    parent::__construct($msg, $no);
    $this->file = $file; // Datei und Zeile setzen, sonst sind das die Werte vom throw im ErrorHandler
    $this->line = $line;
    $this->context = $context;
  }

public static function ErrorHandler($no, $msg, $file, $line, $context) {
    if (error_reporting())
      throw new ExException($no, $msg, $file, $line, $context);
    return true;
  }
}

set_error_handler("ErrorException::ErrorHandler");

  
Leider bekomme ich:  
PHP Fatal error:  Cannot redeclare class ErrorException in D:\home\dev\error\_handler.php on line 18  
  
Wo ist der Fehler?  
Hotti  

[hotti]

hi,

So einfach kann es gehen. Wenn man mal keine Exception bekommen mag, dann kommt ein @ vor die potentiell fehlerwerfende Zeile. Die Ausgabe ist derzeit ein Exception-Trace. Geändert werden kann das durch Überschreiben von __toString().

Oh, ich habs jetzt kapiert, set_error_handler(), echt Klasse, danke Dir!!!!

__toString() ist auch Klasse, backtrace like Perl mit "\n" unterdrücken geht nun auch ;)

Werde auch noch Einiges nachlesen in der Doku...

Viele Grüße,
Hotti

[Tom]

Hello,

Oder einfach error_get_last() fragen:

Woher bekomme ich die Typisierung, die in [type] zurückgegeben wird?

Sind das Error-Konstanten http://de.php.net/manual/en/errorfunc.constants.php, oder wieder was Neues?

Liebe Grüße aus dem schönen Oberharz

Tom vom Berg

[Fred Furunkelstein 2012]

Moin!

Woher bekomme ich die Typisierung, die in [type] zurückgegeben wird?

http://www.php.net/manual/de/errorfunc.constants.php

Fred

[Tom]

Hello,

Moin!

Woher bekomme ich die Typisierung, die in [type] zurückgegeben wird?

Sind das Error-Konstanten http://de.php.net/manual/en/errorfunc.constants.php, oder wieder was Neues?

http://www.php.net/manual/de/errorfunc.constants.php

Jein.
Ich fragte ja nicht, wo ich die Fehlerkonstanten finden kann, die sind mir hinlänglich bekannt. Ich fragte, ob es diese Fehlerkonstanten sind, die in [type] zurückgegeben werden (auch kombiniert, falls zutreffend), oder ob es wieder eine neue Sammlung ist.

Wo steht das?

Das konnte ich nämlich nicht finden oder habe es mehrfach überlesen.

Und dann gleich noch eine dumme Frage: funktioniert error_get_last() immer, oder nur wenn irgendwelche Schalter vorher betätigt wurden?

Und: nein, ich kann es nicht ausprobieren im Moment! Außerdem wäre ergäbe Ausprobieren auch eine eher zufällige Antwort.

Liebe Grüße aus dem schönen Oberharz

Tom vom Berg

[dedlfix]

Tach!

Woher bekomme ich die Typisierung, die in [type] zurückgegeben wird?
Sind das Error-Konstanten http://de.php.net/manual/en/errorfunc.constants.php, oder wieder was Neues?

Sieht nach den Werten aus, die auch durch die Error-Konstanten repräsentiert werden. Es ist wohl nur / mal wieder nur eine neue inkonsistente Benennung. Damit haben wir $error_types und $errno beim Error-Handler, $level bei error_rrporting() und $type hier.

Wo steht das?

Sicher in den Quellen. Im Handbuch ist das nicht explizit erwähnt. Da es aber Typ heißt und nicht Nummer, ist es nur eine Kategorisierung, und eine solche ist mit den Konstanten-Werten bereits vorhanden. (Wobei der Begriff "Nummer" ja auch Verwendung findet: $errno.) Zudem ist unter "See also" ein Verweis auf die Error-Konstanten angeführt.

Du wirst jedenfalls so schnell keine eindeutige Fehlernummer in das Gesamtsystem PHP implementiert bekommen.

Und dann gleich noch eine dumme Frage: funktioniert error_get_last() immer, oder nur wenn irgendwelche Schalter vorher betätigt wurden?

Dazu ist nichts erwähnt. Ich gehe davon aus, dass es immer funktioniert. Allerdings ist die Aussagekraft dieser Funktion recht gering. Sie sagt was zum letzten Fehler aus, aber nicht, ob der gerade eben oder schon vor Jahrhunderten aufgetreten ist.

dedlfix.

[Tom]

Hello,

Du wirst jedenfalls so schnell keine eindeutige Fehlernummer in das Gesamtsystem PHP implementiert bekommen.

Du hast mich :-)

Wäre ja auch zu schön gewesen!

Und dann gleich noch eine dumme Frage: funktioniert error_get_last() immer, oder nur wenn irgendwelche Schalter vorher betätigt wurden?

Dazu ist nichts erwähnt. Ich gehe davon aus, dass es immer funktioniert. Allerdings ist die Aussagekraft dieser Funktion recht gering. Sie sagt was zum letzten Fehler aus, aber nicht, ob der gerade eben oder schon vor Jahrhunderten aufgetreten ist.

Das ist aber im ersten Anlauf bei fast allen Fehlerbehandlungssystemen so.

Ein wirklich intelligentes System in einer nie wieder gesehenen Schlankheit habe ich bisher nur bei DOS-Errors in Turbo-Pascal gefunden. Dort führte jeder DOS-Error zu einem Runtime-Error mit Abbruch. Wenn der Programmierer aber entschied, die Fehler selber zu behandeln, so musste er zumindest den Fehlercode abrufen (und damit zurücksetzen), typischerweise zur eigenen Behandlung.

Anderenfalls haben sich sämtliche nachfolgenden Aufrufe dieser Funktionsgruppe geweigert, zu arbeiten und damit denselben Fehler stehengelassen. Ob das nachher mit dem DOS Protected Mode Interface mit mehreren Threads auch noch funktioniert hat, weiß ich nicht mehr.

Das war meiner Meinung nach aber trotzdem ein sehr solider Ansatz.

Dieses Konzept aus der Compilersprache könnte man hier auch leicht auf PHP übertragen, zumal ja erstmal immer nur ein Thread betrachtet werden muss.

BTW nochmal zum Thema Konzept:
PHP würde mMn sowieso besser Punkten, wenn es nicht das OOP-Konzept, sondern das Unit-Konzept verfolgt hätte. Das ist von einfachen bis zu komplexen Anwendungen hin konsistent und transparent. Da PHP als Client-Server-Programmiersprache keine GUI beinhalten muss, ist das Konezpt vollständig einhaltbar. Für die Vorgangsbearbeitung könnte ein intelligenteres Sessiontracking sinnvoll sein.

Liebe Grüße aus dem schönen Oberharz

Tom vom Berg

[hotti]

hi Tom,

BTW nochmal zum Thema Konzept:
PHP würde mMn sowieso besser Punkten, wenn es nicht das OOP-Konzept, sondern das Unit-Konzept verfolgt hätte. Das ist von einfachen bis zu komplexen Anwendungen hin konsistent und transparent. Da PHP als Client-Server-Programmiersprache keine GUI beinhalten muss, ist das Konezpt vollständig einhaltbar. Für die Vorgangsbearbeitung könnte ein intelligenteres Sessiontracking sinnvoll sein.

Tja, in Perl ist das alles viel einfacher zu machen, was die betreff Fehlerbehandlung in PHP gebaut haben, ist schon sehr verwirrend.

In PHP den error_handler zur Exception umzubiegen, hat den z.B: Effekt, dass mysqli_real_connect mit einer Fehlermeldung die Exception schmeißt, da kommt _meine Exception mit dem schlichten "Keine Verbindung zur DB" zu spät ;)

Daher reicht mir error_get_last() vollkommen, wenn es mehrere Fehler gibt, na und: ich kriege den Letzten, hab ich den weg, kriege ich wieder den Letzen usw., und so kriege die auch Alle, weil ICH DIE ALLE IM BROWSER sehe ;D

(Perl würde mir gleich den Ersten zeigen, aber das wäre dann auch nur Einer)

Hotti

PD: In Perl den Error-Handler umzubiegen hat keine Nebeneffekte, da kann ich machen, was ich will (die, Carp::croak, Carp::confess) und was DBI betrifft, da gibts das Attribut RaiseError.

[Fred Furunkelstein 2012]

Hello,

Moin!

Woher bekomme ich die Typisierung, die in [type] zurückgegeben wird?

Sind das Error-Konstanten http://de.php.net/manual/en/errorfunc.constants.php, oder wieder was Neues?

Das sind die Konstanten.

Wo steht das?

Wenn Du in http://php.net/manual/de/function.error-get-last.php nachliest, dann sollte Dir diese Idee kommen. Natürlich muss man spekulieren, weil die Dokumentation das so ganz einwandfrei nicht hergibt. Aber was soll der Hinweis auf die Konstanten sonst an der Stelle.

Und mit "Fehler-Typ" sind die Namen der Konstanten ja auch bestens beschrieben.

Auch das Beispiel:

Array

(  
    [type] => 8  
    [message] => Undefined variable: a  
    [file] => C:\WWW\index.php  
    [line] => 2  
)

gibt einen "Typ" 8 zurück, E_NOTICE passt also.

Fred.

[Tom]

Hello,

Wo steht das?

Wenn Du in http://php.net/manual/de/function.error-get-last.php nachliest, dann sollte Dir diese Idee kommen.

Klar, die hatte ich ja auch, sonst hätte ich nicht explizit danach gefragt.

Natürlich muss man spekulieren, weil die Dokumentation das so ganz einwandfrei nicht hergibt. Aber was soll der Hinweis auf die Konstanten sonst an der Stelle.

Genau diese Annahme (mal wieder Spekulation oder tiefste Quellcoderecherche notwendig) unterstützt ja auch Dedlfix in seiner Antwort. Ich hatte das auch befürchtet, aber auch irgendwie gehofft, dass es irgendwo definitiv im Manual beschrieben steht und ich es nur überlesen hatte.

Liebe Grüße aus dem schönen Oberharz

Tom vom Berg

[Tom]

Hello,

so langsam hab ich es satt, laufend ins Error_Log meines Webservers zu gucken.
Siehe Thema: Wenns knallt, will ich das sofort im Browser sehen!
Wie kann ich das einschalten, geht das?

Das halte ich für kontraproduktiv!

Wenn die Fehlerausgabe nicht voll implementiert ist im deinem Programmfluss, also auch der Darstellung, dann zerschießt sie dir doch die ganze Ausgabe. Es ist besser, während der Entwirklung auf einer zweiten Konsole "tail -f error.log" mitlaufen zu lassen. Da solltgen dann ja auch die Datenbank-Fehler landen mit einem sinnvollen Hinweis versehen. -> http://de3.php.net/manual/en/function.error-log.php

Und schließlich wirst Du ja auch die Ausgaben für die Benutzer sehen wollen - die aber innerhalb des Designs, um sie dann mit den wahren Fehlergründen vergleichen zu können.

Liebe Grüße aus dem schönen Oberharz

Tom vom Berg

[hotti]

Hello,

so langsam hab ich es satt, laufend ins Error_Log meines Webservers zu gucken.
Siehe Thema: Wenns knallt, will ich das sofort im Browser sehen!
Wie kann ich das einschalten, geht das?

Das halte ich für kontraproduktiv!

Das ErrorLog ist kein Spucknapf!

Wenn die Fehlerausgabe nicht voll implementiert ist im deinem Programmfluss, also auch der Darstellung, dann zerschießt sie dir doch die ganze Ausgabe.

Bei mir nicht, alles was am Ende rausgeht, muss über try/catch ;)

Es ist besser, während der Entwirklung auf einer zweiten Konsole "tail -f error.log" mitlaufen zu lassen.

Umständlich, hinderlich, kontraproduktiv und bei meinem Provider gar nicht möglich.

Viele Grüße aus Hackenheim/Rheinland Pfalz!