<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 24249 -->
<!-- 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 <command>rel="openid.server"</command> 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 language="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
            <acronym>URL</acronym>s 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 <constant>FALSE</constant> zurückgegeben. Dieses Beispiel gibt eine
            <acronym>HTTP</acronym> 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 language="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 language="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 language="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 <acronym>URL</acronym>s unterdrückt, und
            <classname>Zend_OpenId_Provider</classname> nimmt an das diese auf die gleiche Seite
            zeigen mit einem zusätzlichen "openid.action" <constant>GET</constant> 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 language="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:
            <methodname>unset($_GET['openid_action'])</methodname>. Dieser Aufruf von
            <methodname>unset()</methodname> 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 language="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
            <methodname>Zend_OpenId_Provider::allowSite()</methodname> Methode im Identitäts Skript
            hergestellt. Die gleiche Methode assoziiert das Profil mit der vertrauten
            <acronym>URL</acronym>. Dieses Profil wird automatisch für eine Anfrage von der
            vertrauten <acronym>URL</acronym> 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 <methodname>Zend_OpenId_Provider::handle()</methodname> Methode.
        </para>

        <example id="zend.openid.provider.example-7">
            <title>Provider mit SREG</title>

            <programlisting language="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>
