<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 15157 -->
<!-- Reviewed: no -->
<sect1 id="zend.openid.provider">
    <title>Zend_OpenId_Provider</title>
    <para>
        <classname>Zend_OpenId_Provider</classname> kann verwendet werden um OpenID Server zu implementieren. Dieses
        Kapitel bietet Beispiele die Demonstrieren wie ein sehr einfacher Server erstellt werden kann. Für
        die Implementierung eines produktiven OpenId Servers (wie zum Beispiel
        <ulink url="http://www.myopenid.com">www.myopenid.com</ulink>) kann es aber notwendig sein mit
        komplexeren Problemen umzugehen.
    </para>

    <sect2 id="zend.openid.provider.start">
        <title>Schellstart</title>
        <para>
            Das folgende Beispiel beinhaltet Code für das Erstellen eines Benutzerzugang indem
            <classname>Zend_OpenId_Provider::register</classname> verwendet wird. Das Link-Element mit
            <code>rel="openid.server"</code> zeigt auf das eigene Serverscript. Wenn diese Identität zu einer
            OpenID-aktivierten Seite übertragen wird, wird eine Authentifizierung zu diesem Server durchgeführt.
        </para>

        <para>
            Der Code vor dem &lt;html&gt; Tag ist nur ein Trick der automatisch den Benutzerzugang erstellt.
            Man benötigt solch einen Code nicht wenn echte Identitäten verwendet werden.
        </para>

        <example id="zend.openid.provider.example-1">
            <title>Die Identität</title>
            <programlisting role="php"><![CDATA[
<?php
// eine Testidentität erstellen
define("TEST_SERVER", Zend_OpenId::absoluteURL("example-8.php"));
define("TEST_ID", Zend_OpenId::selfURL());
define("TEST_PASSWORD", "123");
$server = new Zend_OpenId_Provider();
if (!$server->hasUser(TEST_ID)) {
    $server->register(TEST_ID, TEST_PASSWORD);
}
?>
<html><head>
<link rel="openid.server" href="<?php echo TEST_SERVER;?>" />
</head><body>
<?php echo TEST_ID;?>
</body></html>
]]></programlisting>
        </example>

        <para>
            Das folgende Identitäts-Serverscript behandelt zwei Arten von Anfragen von OpenID-aktivierten Sites
            (for Assoziation und Authentifizierung). Beide von Ihnen werden von der gleichen Methode behandelt:
            <classname>Zend_OpenId_Provider::handle</classname>. Die zwei Argumente für
            <classname>Zend_OpenId_Provider</classname> Konstruktor sind die URLs des Logins und der Vertrauten Seite,
            welche die Eingabe des End-Benutzers abfragen.
        </para>

        <para>
            Bei Erfolg gibt die Methode <classname>Zend_OpenId_Provider::handle</classname> einen String zurück der zur
            OpenID-aktivierten Seite zurück übergeben werden sollte. Bei einem fehler wird <code>false</code>
            zurückgegeben. Dieses Beispiel gibt eine HTTP 403 Antwort zurück wenn
            <classname>Zend_OpenId_Provider::handle</classname> fehlschlägt. Man erhält diese Antwort
            wenn man dieses Skript mit einem Web-Browser öffnet, weil es eine nicht-OpenID
            konforme Anfrage sendet.
        </para>

        <example id="zend.openid.provider.example-2">
            <title>Einfacher Identitäts Provider</title>
            <programlisting role="php"><![CDATA[
$server = new Zend_OpenId_Provider("example-8-login.php",
                                   "example-8-trust.php");
$ret = $server->handle();
if (is_string($ret)) {
    echo $ret;
} else if ($ret !== true) {
    header('HTTP/1.0 403 Forbidden');
    echo 'Verboten';
}
]]></programlisting>
        </example>

        <note>
            <para>
                Es ist eine gute Idee eine sichere Verbindung (HTTPS) für diese Skripte zu verwenden - und
                speziell für die folgenden interaktiven Scripte - um den Diebstahl von Passwörtern zu verhindern.
            </para>
        </note>

        <para>
            Das folgende Skript implementiert einen Login Schirm für einen Identitäts Server indem
            <classname>Zend_OpenId_Provider</classname> verwendet wird und leitet zu dieser Seite weiter wenn ein
            benötigter Benutzer sich noch nicht eingeloggt hat. Auf dieser Seite gibt der Benutzer sein
            Passwort an um sich anzumelden.
        </para>

        <para>
            Es sollte das Passwort "123" verwendet werden das im obigen Identitäts Skript verwendet wurde.
        </para>

        <para>
            Bei Abschicken, ruft das Skript <classname>Zend_OpenId_Provider::login</classname> mit der akzeptierten
            Benutzer Identität und dem Passwort auf, und leitet anschließend zum Hauptskript des Identitäts
            Providers zurück. Bei Erfolg baut <classname>Zend_OpenId_Provider::login</classname> eine Session zwischen dem
            Benutzer und dem Identitäts-Provider auf und speichert die Informationen über den Benutzer der nun
            angemeldet ist. Alle folgenden Anfragen vom gleichen Benutzer benötigen keine Login-Prozedur mehr -
            selbst wenn diese von einer anderen OpenID aktivierten Web-Seite kommen.
        </para>

        <note>
            <para>
                Es ist zu beachten das die Session nur zwischen den End-Benutzer und dem Identitäts-Provider
                existiert. OpenID aktivierte Seiten wissen nichts darüber.
            </para>
        </note>

        <example id="zend.openid.provider.example-3">
            <title>Einfacher Login Schirm</title>
            <programlisting role="php"><![CDATA[
<?php
$server = new Zend_OpenId_Provider();

if ($_SERVER['REQUEST_METHOD'] == 'POST' &&
    isset($_POST['openid_action']) &&
    $_POST['openid_action'] === 'login' &&
    isset($_POST['openid_identifier']) &&
    isset($_POST['openid_password'])) {
    $server->login($_POST['openid_identifier'],
                   $_POST['openid_password']);
    Zend_OpenId::redirect("example-8.php", $_GET);
}
?>
<html>
<body>
<form method="post">
<fieldset>
<legend>OpenID Login</legend>
<table border=0>
<tr>
<td>Name:</td>
<td>
<input type="text"
       name="openid_identifier"
       value="<?php echo htmlspecialchars($_GET['openid_identity']);?>">
</td>
</tr>
<tr>
<td>Passwort:</td>
<td>
<input type="text"
       name="openid_password"
       value="">
</td>
</tr>
<tr>
<td>&nbsp;</td>
<td>
<input type="submit"
       name="openid_action"
       value="login">
</td>
</tr>
</table>
</fieldset>
</form>
</body>
</html>
]]></programlisting>
        </example>

        <para>
            Der Fakt das der Benutzer jetzt angemeldet ist bedeutet nicht das die Authentifizierung
            notwendigerweise erfolgreich sein muß. Der Benutzer kann entscheiden das er der betreffenden
            OpenID aktivierten Seite nicht vertraut. Der folgende Vertrauens-Schirm erlaubt dem Endbenutzer
            diese Wahl zu treffen. Diese Wahl kann entweder nur für die aktuelle Anfrage oder für "immer"
            gemacht werden. Im zweiten Fall werden Informationen über vertrauenswürdige/nicht
            vertrauenswürdige Seiten in einer internen Datenbank gespeichert, und alle folgenden
            Authentifizierungs Anfragen von dieser Seite werden automatisch gehandhabt ohne einer
            Interaktion des Benutzers.
        </para>

        <example id="zend.openid.provider.example-4">
            <title>Einfacher Vertrauens Schirm</title>
            <programlisting role="php"><![CDATA[
<?php
$server = new Zend_OpenId_Provider();

if ($_SERVER['REQUEST_METHOD'] == 'POST' &&
    isset($_POST['openid_action']) &&
    $_POST['openid_action'] === 'trust') {

    if (isset($_POST['allow'])) {
        if (isset($_POST['forever'])) {
            $server->allowSite($server->getSiteRoot($_GET));
        }
        $server->respondToConsumer($_GET);
    } else if (isset($_POST['deny'])) {
        if (isset($_POST['forever'])) {
            $server->denySite($server->getSiteRoot($_GET));
        }
        Zend_OpenId::redirect($_GET['openid_return_to'],
                              array('openid.mode'=>'cancel'));
    }
}
?>
<html>
<body>
<p>Eine Seite die sich als
<a href="<?php echo htmlspecialchars($server->getSiteRoot($_GET));?>
<?php echo htmlspecialchars($server->getSiteRoot($_GET));?>
</a>
identifiziert hat uns nach Bestätigung  gefragt ob
<a href="<?php echo htmlspecialchars($server->getLoggedInUser());?>">
<?php echo htmlspecialchars($server->getLoggedInUser());?>
</a>
ihre Identitäts URL ist.
</p>
<form method="post">
<input type="checkbox" name="forever">
<label for="forever">für immer</label><br>
<input type="hidden" name="openid_action" value="trust">
<input type="submit" name="allow" value="Allow">
<input type="submit" name="deny" value="Deny">
</form>
</body>
</html>
]]></programlisting>
        </example>

        <para>
            Produktive OpenID Server unterstützen normalerweise die einfache Registrierungs Erweiterung die
            es Benutzern erlaubt einige Informationen über ein Benutzerformular beim Provider nachzufragen.
            In diesem Fall kann die Vertraute Seite erweitert werden um die Eingabe von angefragten Feldern
            zu erlauben oder ein spezielles Benutzerprofil auszuwählen.
        </para>
    </sect2>

    <sect2 id="zend.openid.provider.all">
        <title>Kombinierte Skripte</title>
        <para>
            Es ist möglich alle Provider Funktionalitäten in einem Skript zusammen zu kombinieren. In diesem Fall
            werden Login und Vertraute URLs unterdrückt, und <classname>Zend_OpenId_Provider</classname> nimmt an das diese
            auf die gleiche Seite zeigen mit einem zusätzlichen "openid.action" GET Argument.
        </para>

        <note>
            <para>
                Das folgende Beispiel ist nicht komplett. Es bietet kein GUI für End-Benutzer wie es sein
                sollte, aber es führt automatisches Login und Vertrauen durch. Das wird getan um das Beispiel
                zu vereinfachen, und echte Server müssen Code von den vorherigen Beispielen inkludieren.
            </para>
        </note>

        <example id="zend.openid.provider.example-5">
            <title>Alles zusammen</title>
            <programlisting role="php"><![CDATA[
$server = new Zend_OpenId_Provider();

define("TEST_ID", Zend_OpenId::absoluteURL("example-9-id.php"));
define("TEST_PASSWORD", "123");

if ($_SERVER['REQUEST_METHOD'] == 'GET' &&
    isset($_GET['openid_action']) &&
    $_GET['openid_action'] === 'login') {
    $server->login(TEST_ID, TEST_PASSWORD);
    unset($_GET['openid_action']);
    Zend_OpenId::redirect(Zend_OpenId::selfUrl(), $_GET);
} else if ($_SERVER['REQUEST_METHOD'] == 'GET' &&
    isset($_GET['openid_action']) &&
    $_GET['openid_action'] === 'trust') {
    unset($_GET['openid_action']);
    $server->respondToConsumer($_GET);
} else {
    $ret = $server->handle();
    if (is_string($ret)) {
        echo $ret;
    } else if ($ret !== true) {
        header('HTTP/1.0 403 Forbidden');
        echo 'Verboten';
    }
}
]]></programlisting>
        </example>

        <para>
            Wenn man dieses Beispiel mit den vorherigen Beispielen vergleicht, die in einzelne Seiten aufgeteilt
            sind, sieht man zusätzlich zum Dispatch Code, nur einen Unterschied:
            <code>unset($_GET['openid_action'])</code>. Dieser Aufruf von <code>unset</code> ist notwendig um
            die nächste Anfrage zum Haupthandler zu routen.
        </para>
    </sect2>

    <sect2 id="zend.openid.provider.sreg">
        <title>Einfache Registrierungs Erweiterung (SREG)</title>
        <para>
            Wieder ist der Code vor dem &lt;html&gt; Tag nur ein Trick um die Funktionalität zu demonstrieren.
            Er erstellt einen neuen Benutzerzugang und assoziiert Ihn mit einem Profil (Spitzname und
            Passwort). Solche Tricks werden bei ausgelieferten Providern nicht benötigt wo sich End Benutzer
            auf OpenID Servern registrieren und Ihre Profile eintragen. Die Implementierung dieses GUI würde
            den Rahmen dieses Handbuches sprengen.
        </para>

        <example id="zend.openid.provider.example-6">
            <title>Identität mit Profil</title>
            <programlisting role="php"><![CDATA[
<?php
define("TEST_SERVER", Zend_OpenId::absoluteURL("example-10.php"));
define("TEST_ID", Zend_OpenId::selfURL());
define("TEST_PASSWORD", "123");
$server = new Zend_OpenId_Provider();
if (!$server->hasUser(TEST_ID)) {
    $server->register(TEST_ID, TEST_PASSWORD);
    $server->login(TEST_ID, TEST_PASSWORD);
    $sreg = new Zend_OpenId_Extension_Sreg(array(
        'nickname' =>'test',
        'email' => 'test@test.com'
    ));
    $root = Zend_OpenId::absoluteURL(".");
    Zend_OpenId::normalizeUrl($root);
    $server->allowSite($root, $sreg);
    $server->logout();
}
?>
<html>
<head>
<link rel="openid.server" href="<?php echo TEST_SERVER;?>" />
</head>
<body>
<?php echo TEST_ID;?>
</body>
</html>
]]></programlisting>
        </example>

        <para>
            Die Identität sollte jetzt der OpenID-aktivierten Webseite übergeben werden (verwende das einfache
            Registrierungs Erweiterung Beispiel aus dem vorherigen Kapitel) und sie sollte das folgende OpenID
            Server Skript verwenden.
        </para>

        <para>
            Dieses Skript ist eine Variation des Skripts im "Alles zusammen" Beispiel. Es verwendet den gleichen
            automatischen Login Mechanismus, aber es enthält keinen Code für die Vertrauens-Seite. Der Benutzer
            hat dem Beispielskript bereits für immer vertraut. Dieses Vertrauen wurde durch den Aufruf der
            <classname>Zend_OpenId_Provider::allowSite()</classname> Methode im Identitäts Skript hergestellt. Die gleiche
            Methode assoziiert das Profil mit der vertrauten Seite. Dieses Profil wird automatisch für eine
            Anfrage von der vertrauten URL zurückgegeben.
        </para>

        <para>
            Um die einfache Registrierungs Erweiterung funktionsfähig zu machen ist einfach die Übergabe einer
            Instanz von <classname>Zend_OpenId_Extension_Sreg</classname> als zweites Argument der
            <classname>Zend_OpenId_Provider::handle()</classname> Methode.
        </para>

        <example id="zend.openid.provider.example-7">
            <title>Provider mit SREG</title>
            <programlisting role="php"><![CDATA[
$server = new Zend_OpenId_Provider();
$sreg = new Zend_OpenId_Extension_Sreg();

define("TEST_ID", Zend_OpenId::absoluteURL("example-10-id.php"));
define("TEST_PASSWORD", "123");

if ($_SERVER['REQUEST_METHOD'] == 'GET' &&
    isset($_GET['openid_action']) &&
    $_GET['openid_action'] === 'login') {
    $server->login(TEST_ID, TEST_PASSWORD);
    unset($_GET['openid_action']);
    Zend_OpenId::redirect(Zend_OpenId::selfUrl(), $_GET);
} else if ($_SERVER['REQUEST_METHOD'] == 'GET' &&
    isset($_GET['openid_action']) &&
    $_GET['openid_action'] === 'trust') {
   echo "UNTRUSTED DATA" ;
} else {
    $ret = $server->handle(null, $sreg);
    if (is_string($ret)) {
        echo $ret;
    } else if ($ret !== true) {
        header('HTTP/1.0 403 Forbidden');
        echo 'Verboten';
    }
}
]]></programlisting>
        </example>
    </sect2>

    <sect2 id="zend.openid.provider.else">
        <title>Sonst noch was?</title>
        <para>
            Das Erstellen von OpenID Providern ist eine viel seltenere Aufgabe als die Erstellung von
            OpenID-aktivierten Sites, weswegen dieses Handbuch nicht alle <classname>Zend_OpenId_Provider</classname>
            Features so ausführlich abdeckt wie es für <classname>Zend_OpenId_Consumer</classname> getan wurde.
        </para>

        <para>
            Zusammenfassend enthält <classname>Zend_OpenId_Provider</classname>:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    Ein Set von Methoden um ein End-Benutzer GUI zu Erstellen das es Benutzern erlauben sich
                    zu registrieren und Ihre vertrauten Seiten und Profile zu managen.
                </para>
            </listitem>
            <listitem>
                <para>
                    Einen abstrakten Speicherlayer um Informationen über Benutzer, Ihre Seiten und Ihre Profile
                    zu speichern. Es speichert auch Assoziationen zwischen Providern und OpenID-aktivierten
                    Seiten. Dieser Layer ist ähnlich dem der <classname>Zend_OpenId_Consumer</classname> Klasse. Er
                    verwendet standardmäßg auch den Dateispeicher, kann aber mit anderen Backends abgeleitet
                    werden.
                </para>
            </listitem>
            <listitem>
                <para>
                    Einen Abtraktions Benutzer-Assoziierungs Layer der Web-Browser von Benutzern mit
                    eingeloggten Identitäten verknüpfen kann.
                </para>
            </listitem>
        </itemizedlist>

        <para>
            Die <classname>Zend_OpenId_Provider</classname> Klasse versucht nicht alle möglichen Features abzudecken die
            von OpenID Servern implementiert werden können, z.B. wie digitale Zertifikate, kann aber einfach
            erweitert werden durch <classname>Zend_OpenId_Extension</classname>s oder durch standardmäßige
            Objektorientierte Erweiterungen.
        </para>
    </sect2>
</sect1>
<!--
vim:se ts=4 sw=4 et:
-->
