Programmer's Reference Guide
| Einführung |
Zend_OpenId_Consumer Grundlagen
Zend_OpenId_Consumer wird verwendet um das OpenID Authentifizierungs Schema auf Webseiten
zu implementieren.
OpenID Authentifikation
Aus der Sicht eines Site Entwicklers, geschieht die Authentifikation von OpenID in drei Schritten:
-
Zeige das OpenID Authentifikations Formular.
-
Akzeptiere die OpenID Identität und übergib Sie an den OpenID Provider.
-
Überprüfe die Antwort des OpenID Providers.
In Wirklichkeit führt das OpenID Authentifikations Protokoll mehr Schritte durch, aber die meisten
von Ihnen sind innerhalb von Zend_OpenId_Consumer gekapselt, und sind für den
Entwickler transparent.
Der OpenID Authentifikations Prozess wird vom End-Benutzer, durch das Ausfüllen seiner Identifikation im entsprechenden Formular und dem Senden des selben, durchgeführt. Das folgende Beispiel zeigt ein einfaches Formular das einen OpenID Identifikator akzeptiert. Es gilt zu beachten das das Beispiel nur einen Login zeigt.
Beispiel #1 Das einfache OpenID Login Formular
<html><body>
<form method="post" action="example-1_2.php"><fieldset>
<legend>OpenID Login</legend>
<input type="text" name="openid_identifier">
<input type="submit" name="openid_action" value="login">
</fieldset></form></body></html>
Beim Übertragen übergibt dieses Formular eine OpenID Identität an das folgende PHP Skript welches
den zweiten Schritt der Authentifizierung durchführt. Das einzige Ding für das dieses PHP Skript
benötigt wird ist in diesem Schritt die Zend_OpenId_Consumer::login() Methode auszurufen.
Das erste Argument dieser Methode akzeptiert eine OpenID Identität und das zweite ist eine URL des
Skripts das den dritten und letzten Schritt der Authentifizierung behandelt.
Beispiel #2 Der Authentifizierungs Anfrage Handler
<?php
require_once "Zend/OpenId/Consumer.php";
$consumer = new Zend_OpenId_Consumer();
if (!$consumer->login($_POST['openid_identifier'], 'example-1_3.php')) {
die("OpenID Login fehlgeschlagen.");
}
Zend_OpenId_Consumer::login() führt eine Suche nach einem gegebenen Identifizierer
durch und findet, bei Erfolg, die Adresse des Identitäts Providers und dessen Lokalen Idenzifizierer
durch. Dann erstellt es eine Assoziation zum gegebenen Provider sodas beide, die Site und der
Provider, um das gleiche Geheimnis wissen das verwendet wurde um die nachfolgende Nachricht zu
verschlüsseln. Das wird eine Authentifikations Anfrage an den Provider übergeben. Es ist zu
beachten das der Web-Browser des End-Benutzers zu einer OpenID Server Site umleitet, wo die
Benutzer die Möglcihkeit haben den Authentifizierungs Prozess fortzuführen.
Ein OpenID Server fragt nochmalerweise Benutzer nach Ihrem Passwort (wenn Sie vorher noch nicht angemeldet waren), wenn der Benutzer dieser Site vertraut und welche Informationen zu der Site zurückgegeben werden können. Diese Interaktionen sind für die OpenID-aktivierte Site nicht sichtbar sodas es für diese keine Möglichkeit gibt ein Benutzerpasswort oder andere Informationen zu bekommen die nicht geöffnet wurden.
Bei Erfolg wird Zend_OpenId_Consumer::login() nie zurückkommen, weil es eine HTTP
Umleitung durchführt, aber im Falle eine Fehler ein false zurückgeben wird. Fehler können durch
eine ungültige Identität, einen toten Provider, Kommunikations Fehler, usw. auftreten.
Der dritte Schritt der Authentifikation wird durch eine Antwort vom OpenID Provider initiiert, nachdem dieser das Benutzerpasswort authentifiziert hat. Diese Antwort wird indirekt, als HTTP Umleitung des Webbrowsers des End-Benutzers, übergeben. Und das einzige, was die Site tun muß, ist zu prüfen ob Antwort gültig ist.
Beispiel #3 Der Authentifizierungs Antwort Prüfer
<?php
require_once "Zend/OpenId/Consumer.php";
$consumer = new Zend_OpenId_Consumer();
if ($consumer->verify($_GET, $id)) {
echo "GÜLTIG $id";
} else {
echo "UNGÜLTIG $id";
}
Diese Prüfung wird durchgeführt indem die Zend_OpenId_Consumer::verify Methode
verwendet wird, welche ein ganzes Array von HTTP Anfrage Argumenten entgegennimmt und prüft ob
diese Antwort durch einen entsprechenden OpenID Provider richtig signiert wurde. Sie kann auch
die erhaltete OpenID Identität, die vom End-Benutzer im ersten Schritt in das zweite (optionale)
Argument eingegeben wurde, zuordnen.
Alle Schritte in einer Seite kombinieren
Das folgende Beispiel kombiniert alle drei Schritte. Es bietet keine zusätzlichen Funktionalitäten. Der einzige Vorteil ist, das Entwickler jetzt keine URLs für Skripte definieren müssen, die den nächsten Schritt handhaben. Standardmäßig verwenden alle Schritte die gleiche URL. Trotzdem enthält das Skript den Dispatchcode der den korrekten Code für jeden Schritt der Authentifikation aufruft.
Beispiel #4 Das komplette OpenID Login Skript
<?php
require_once "Zend/OpenId/Consumer.php";
$status = "";
if (isset($_POST['openid_action']) &&
$_POST['openid_action'] == "login" &&
!empty($_POST['openid_identifier'])) {
$consumer = new Zend_OpenId_Consumer();
if (!$consumer->login($_POST['openid_identifier'])) {
$status = "OpenID Login fehlgeschlagen.<br>";
}
} else if (isset($_GET['openid_mode'])) {
if ($_GET['openid_mode'] == "id_res") {
$consumer = new Zend_OpenId_Consumer();
if ($consumer->verify($_GET, $id)) {
$status = "GÜLTIG $id";
} else {
$status = "UNGÜLTIG $id";
}
} else if ($_GET['openid_mode'] == "cancel") {
$status = "ABGEBROCHEN";
}
}
?>
<html><body>
<?php echo "$status<br>";?>
<form method="post"><fieldset>
<legend>OpenID Login</legend>
<input type="text" name="openid_identifier" value="">
<input type="submit" name="openid_action" value="login">
</fieldset></form></body></html>
Zusätzlich unterscheidet dieser Code zwischen abgebrochen und falschen Authentifizierungs Antworten. Der Provider gibt eine abgebrochene Antwort in den Fällen zurück, wenn ein Identitäts Provider die gegebene Identität nicht kennt oder der Benutzer nicht angemeldet ist oder dieser der Seite nicht vertraut. Eine falsche Antwort nimmt an das die Antwort falsch oder nicht korrekt signiert wurde.
Bereiche
Wenn eine OpenID-aktivierte Site eine Authentifikations Anfrage an einen Provider übergibt, identifiziert diese sich selbst mit einer Bereichs URL. Diese URL kann als Root der vertrauten Site betrachtet werden. Wenn der Benutzer der URL vertraut, dann vertraut er der passenden und den untergeordneten URLs.
Standardmäßig wird der Bereich automatisch auf die URL des Verzeichnisses gesetzt indem das Login Skript ist. Diese Wahl ist für die meisten, aber nicht alle, Fälle ausreichend. Zeitweise wird die komplette Site und nicht ein Verzeichnis verwendet, oder sogar eine Kombination von verschiedenen Server aus einer Domain.
Um diese Fähigkeit zu implementieren müssen Entwickler den realm Wert als drittes Argument an die
Zend_OpenId_Consumer::login Methode übergeben. Im folgenden Beispiel fragt eine einzelne
Interaktion nach vertrauten Zugriff auf alle php.net Sites.
Beispiel #5 Authentifizierungs Anfrage für spezielle Bereiche
<?php
require_once "Zend/OpenId/Consumer.php";
$consumer = new Zend_OpenId_Consumer();
if (!$consumer->login($_POST['openid_identifier'], 'example-3_3.php', 'http://*.php.net/')) {
die("OpenID Login fehlgeschlagen.");
}
Das Beispiel implementiert nur den zweiten Schritt der Authentifikation, der erste und dritte Schritt sind die gleichen wie im ersten Beispiel.
Sofortige Prüfung
In einigen Situationen ist es notwendig zu sehen ob ein Benutzer bereits auf einem vertrauten
OpenID Server eingeloggt ist ohne einer Interaktion mit dem Benutzer. Die
Zend_OpenId_Consumer::check Methode führt genau das durch. Sie wird mit genau den
gleichen Argumenten wie Zend_OpenId_Consumer::login ausgeführt, aber Sie zeigt dem
Benutzer keine OpenID Serverseiten. Deswegen ist Sie aus Sicht des Benutzers transparent und es
scheint als ob er nie die Site verlassen hätte. Der dritte Schritt ist erfolgreich wenn der
Benutzer bereits angemeldet ist und der Site vertraut, andernfalls ist er erfolglos.
Beispiel #6 Sofortige Prüfung ohne Interaktion
<?php
require_once "Zend/OpenId/Consumer.php";
$consumer = new Zend_OpenId_Consumer();
if (!$consumer->check($_POST['openid_identifier'], 'example-4_3.php')) {
die("OpenID Login fehlgeschlaten.");
}
Das Beispiel implementiert nur den zweiten Schritt der Authentifikation, der erste und dritte Schritt sind die gleichen wie im ersten Beispiel.
Zend_OpenId_Consumer_Storage
Es gibt drei Schritte beim Authentifizierungs Prozess von OpenID, und jeder wird durch eine
seperate HTTP Anfrage durchgeführt. Um die Informationen zwischen den Anfragen zu speichern
verwendet Zend_OpenId_Consumer einen internen Speicher.
Entwickler müssen auf diese Speicherung keine Acht geben weil Zend_OpenId_Consumer
standardmäßig einen dateibasierten Speicher unter /tmp verwendet, ähnlich wie PHP Sessions.
Trotzdem kann dieser Speicher nicht in allen Situationen richtig sein. Einige wollen Informationen
in einer Datenbank speichern, wärend andere einen üblichen Speicher für große Web-Farmen verwenden
wollen. Glücklicherweise können Entwickler den Standardspeicher sehr einfach mit Ihrem eigenen
tauschen. Das einzige was implementiert werden muß ist eine eigene Speicherklasse als Kind von
der Zend_OpenId_Consumer_Storage Methode und diese als erstes Argument an den
Zend_OpenId_Consumer Konsturktor zu übergeben.
Das folgende Beispiel demonstriert einen einfachen Speicher der Zend_Db als Backend
verwendet und drei Gruppen von Funktionen enthält. Der erste ist für die Arbeit mit Assoziationen,
der zweite dient dazu erkannte Informationen zu cachen und der dritte ist die Antwort eindeutig zu
prüfen. Die Klasse ist in einer Art implementiert das Sie einfach mit bestehenden oder neuen
Datenbaknen verwendet werden kann. Wenn das notwendig ist, wird eine Datenbanktabelle erstellt
wenn diese nicht existiert.
Beispiel #7 Datenbank Speicher
<?php
class DbStorage extends Zend_OpenId_Consumer_Storage
{
private $_db;
private $_association_table;
private $_discovery_table;
private $_nonce_table;
public function __construct($db,
$association_table = "association",
$discovery_table = "discovery",
$nonce_table = "nonce")
{
$this->_db = $db;
$this->_association_table = $association_table;
$this->_discovery_table = $discovery_table;
$this->_nonce_table = $nonce_table;
$tables = $this->_db->listTables();
if (!in_array($association_table, $tables)) {
$this->_db->getConnection()->exec(
"create table $association_table (" .
" url varchar(256) not null primary key," .
" handle varchar(256) not null," .
" macFunc char(16) not null," .
" secret varchar(256) not null," .
" expires timestamp" .
")");
}
if (!in_array($discovery_table, $tables)) {
$this->_db->getConnection()->exec(
"create table $discovery_table (" .
" id varchar(256) not null primary key," .
" realId varchar(256) not null," .
" server varchar(256) not null," .
" version float," .
" expires timestamp" .
")");
}
if (!in_array($nonce_table, $tables)) {
$this->_db->getConnection()->exec(
"create table $nonce_table (" .
" nonce varchar(256) not null primary key," .
" created timestamp default current_timestamp" .
")");
}
}
public function addAssociation($url, $handle, $macFunc, $secret, $expires)
{
$table = $this->_association_table;
$secret = base64_encode($secret);
$this->_db->query("insert into $table (url, handle, macFunc, secret, expires) " .
"values ('$url', '$handle', '$macFunc', '$secret', $expires)");
return true;
}
public function getAssociation($url, &$handle, &$macFunc, &$secret, &$expires)
{
$table = $this->_association_table;
$this->_db->query("delete from $table where expires < " . time());
$res = $this->_db->fetchRow("select handle, macFunc, secret, expires from $table where url = '$url'");
if (is_array($res)) {
$handle = $res['handle'];
$macFunc = $res['macFunc'];
$secret = base64_decode($res['secret']);
$expires = $res['expires'];
return true;
}
return false;
}
public function getAssociationByHandle($handle, &$url, &$macFunc, &$secret, &$expires)
{
$table = $this->_association_table;
$this->_db->query("delete from $table where expires < " . time());
$res = $this->_db->fetchRow("select url, macFunc, secret, expires from $table where handle = '$handle'");
if (is_array($res)) {
$url = $res['url'];
$macFunc = $res['macFunc'];
$secret = base64_decode($res['secret']);
$expires = $res['expires'];
return true;
}
return false;
}
public function delAssociation($url)
{
$table = $this->_association_table;
$this->_db->query("delete from $table where url = '$url'");
return true;
}
public function addDiscoveryInfo($id, $realId, $server, $version, $expires)
{
$table = $this->_discovery_table;
$this->_db->query("insert into $table (id, realId, server, version, expires) " .
"values ('$id', '$realId', '$server', $version, $expires)");
return true;
}
public function getDiscoveryInfo($id, &$realId, &$server, &$version, &$expires)
{
$table = $this->_discovery_table;
$this->_db->query("delete from $table where expires < " . time());
$res = $this->_db->fetchRow("select realId, server, version, expires from $table where id = '$id'");
if (is_array($res)) {
$realId = $res['realId'];
$server = $res['server'];
$version = $res['version'];
$expires = $res['expires'];
return true;
}
return false;
}
public function delDiscoveryInfo($id)
{
$table = $this->_discovery_table;
$this->_db->query("delete from $table where id = '$id'");
return true;
}
public function isUniqueNonce($nonce)
{
$table = $this->_nonce_table;
try {
$ret = $this->_db->query("insert into $table (nonce) values ('$nonce')");
} catch (Zend_Db_Statement_Exception $e) {
return false;
}
return true;
}
public function purgeNonces($date=null)
{
}
}
$db = Zend_Db::factory('Pdo_Sqlite',
array('dbname'=>'/tmp/openid_consumer.db'));
$storage = new DbStorage($db);
$consumer = new Zend_OpenId_Consumer($storage);
Das Beispiel enthält keinen OpenID Authentifikations Code, aber er basiert auf der gleichen Logik wie die vorhergehenden oder folgenden Beispiele.
Einfache Registrations Erweiterung
Zusätzlich zur Authentifikation kann OpenID für einen leichtgewichtigen Profiltausch verwendet werden. Dieses Feature wird nicht durch die OpenID Authentifikations Spezifikation abgedeckt, aber vom OpenID Einfachen Registrierungs Erweiterungs Protokoll unterstützt. Dieses Protokoll erlaubt es OpenID-aktivierten Sites nach Informationen über End-Benutzern von OpenID Providers zu fragen. Diese Informationen können folgendes beinhalten:
-
nickname - ein UTF-8 String den der End-Benutzer als Spitzname verwenden will.
-
email - die Email Adresse des End-Benutzers wie in Sektion 3.4.1 von RFC2822 spezifiziert.
-
fullname - eine UTF-8 String Repräsentation des kompletten Namens des End-Benutzers.
-
dob - das Geburtsdatum des End-Benutzers als YYYY-MM-DD. Jeder Wert dessen Repräsentation weniger als die speifizierte Anzahl an Ziffern verwendet sollte mit Nullen aufgefüllt werden. Die Länge dieses Wertes muß immer 10 sein. Wenn der End-Benutzer irgendeinen Teil dieser Komponente nicht angeben will, dann muß dieser auf Null gesetzt werden. Wenn ein Benutzer zum Beispiel angeben will das sein Geburtsdatum um 1980 war, aber nicht den Monat oder Tag, dann sollte der zurückgegebene Wert "1980-00-00" sein.
-
gender - das Geschlecht des End-Benutzers, "M" für männlich, "F" für weiblich.
-
postcode - UTF-8 String der dem Postleitzahl System des Landes des End-Benutzers entsprechen sollte.
-
country - das Land des Wohnsitzes des End-Benutzers wie spezifiziert in ISO3166.
-
language - die bevorzugte Sprache des End-Benutzers wie spezifiziert in ISO639.
-
timezone - ASCII String von der Zeitzonen Datenbank. Zum Beispiel, "Europe/Paris" oder "America/Los_Angeles".
Eine OpenID-aktivierte Web-Seite kann nach jeder beliebigen Kombination dieser Felder fragen.
Sie kann auch einige Informationen strikt fordern und es End-Benutzern erlauben andere Informationen
anzubieten oder zu verstecken. Das folgende Beispiel erzeugt ein Objekt der
Zend_OpenId_Extension_Sreg Klasse das einen Spitznamen
(nickname) benötigt und optional nach einer E-Mail (email) und einem
vollständigen Namen (fullname) fragt.
Beispiel #8 Anfragen mit einer einfachen Registrations Erweiterung senden
<?php
require_once "Zend/OpenId/Consumer.php";
require_once "Zend/OpenId/Extension/Sreg.php";
$sreg = new Zend_OpenId_Extension_Sreg(array(
'nickname'=>true,
'email'=>false,
'fullname'=>false), null, 1.1);
$consumer = new Zend_OpenId_Consumer();
if (!$consumer->login($_POST['openid_identifier'], 'example-6_3.php', null, $sreg)) {
die("OpenID Login fehlgeschlagen.");
}
Wie man sieht akzeptiert der Zend_OpenId_Extension_Sreg Konstruktor ein Array an
abgefragten Feldern. Das Array hat den Namen der Felder als Indezes und die erfordert Flags als
Werte. true bedeutet der Wert wird benötigt und false
bedeutet das Feld ist optional. Zend_OpenId_Consumer::login akzeptiert Erweiterungen
oder Listen von Erweiterungen als viertes Argument.
Im dritten Schritt der Authentifikation sollte das Zend_OpenId_Extension_Sreg Objekt
an Zend_OpenId_Consumer::verify übergeben werden. Anschließend wird
Zend_OpenId_Extension_Sreg::getProperties, bei erfolgreicher Authentifizierung,
ein assoziatives Array von benötigten Feldern zurückgeben.
Beispiel #9 Antworten mit einer einfachen Registierungs Erweiterung prüfen
<?php
require_once "Zend/OpenId/Consumer.php";
require_once "Zend/OpenId/Extension/Sreg.php";
$sreg = new Zend_OpenId_Extension_Sreg(array(
'nickname'=>true,
'email'=>false,
'fullname'=>false), null, 1.1);
$consumer = new Zend_OpenId_Consumer();
if ($consumer->verify($_GET, $id, $sreg)) {
echo "GÜLTIG $id<br>\n";
$data = $sreg->getProperties();
if (isset($data['nickname'])) {
echo "Spitzname: " . $data['nickname'] . "<br>\n";
}
if (isset($data['email'])) {
echo "Email: " . $data['email'] . "<br>\n";
}
if (isset($data['fullname'])) {
echo "Vollständiger Name: " . $data['fullname'] . "<br>\n";
}
} else {
echo "UNGÜLTIG $id";
}
Wenn Zend_OpenId_Extension_Sreg ohne Argumente erstellt wurde, sollte der Benutzercode
selbst das Vorhandensein der benötigten Daten prüfen. Trotzdem, wenn das Objekt mit der gleichen
Liste an benötigten Feldern wie im zweiten Schritt erstellt wird, wird es automatisch die Existenz
der benötigten Daten prüfen. In diesem Fall wird Zend_OpenId_Consumer::verify
false zurückgeben wenn irgendeines der benötigten Felder fehlt.
Standardmäßig verwendet Zend_OpenId_Extension_Sreg die Version 1.0 weil die
Spezifikation der Version 1.1 noch nicht fertiggestellt wurde. Trotzdem unterstützen einige
Bibliotheken die Version 1.0 nicht vollständig. Zum Beispiel benötigt www.myopenid.com einen
SREG Namensraum in den Anfragen der nur in 1.1 vorhanden ist. Um mit diesem Server zu Arbeiten
muß die Version 1.1 explizit im Zend_OpenId_Extension_Sreg Konstruktor gesetzt werden.
Das zweite Argument des Zend_OpenId_Extension_Sreg Konstruktors ist eine Policy URL,
die dem End-Benutzer durch den Identitäts Provider zur Verfügung gestellt werden sollte.
Integration mit Zend_Auth
Zend Framework bietet eine spezielle Klasse für die Unterstützung von Benutzer Authentifikation -
Zend_Auth. Diese Klasse kann zusammen mit Zend_OpenId_Consumer verwendet
werden. Das folgende Beispiel zeigt wie OpenIdAdapter das
Zend_Auth_Adapter_Interface mit der authenticate Methode implementiert.
Diese führt eine Authentifikations Anfrage und Verifikation durch.
Der große Unterschied zwischen diesem Adapter und dem bestehenden ist, das er mit zwei HTTP Anfragen arbeitet und einen Dispatch code enthält um den zweiten oder dritten Schritt der OpenID Authentifikation durchzuführen.
Beispiel #10 Zend_Auth Adapter für OpenID
<?php
require_once "Zend/OpenId/Consumer.php";
require_once "Zend/Auth.php";
require_once "Zend/Auth/Adapter/Interface.php";
class OpenIdAdapter implements Zend_Auth_Adapter_Interface {
private $_id = null;
public function __construct($id = null) {
$this->_id = $id;
}
public function authenticate() {
$id = $this->_id;
if (!empty($id)) {
$consumer = new Zend_OpenId_Consumer();
if (!$consumer->login($id)) {
$ret = false;
$mdg = "Authentifizierung fehlgeschlagen.";
}
} else {
$consumer = new Zend_OpenId_Consumer();
if ($consumer->verify($_GET, $id)) {
$ret = true;
$msg = "Authentifizierung erfolgreich";
} else {
$ret = false;
$msg = "Authentifizierung fehlgeschlagen";
}
}
return new Zend_Auth_Result($ret, $id, array($msg));
}
}
$status = "";
$auth = Zend_Auth::getInstance();
if ((isset($_POST['openid_action']) &&
$_POST['openid_action'] == "login" &&
!empty($_POST['openid_identifier'])) ||
isset($_GET['openid_mode'])) {
$adapter = new OpenIdAdapter(@$_POST['openid_identifier']);
$result = $auth->authenticate($adapter);
if ($result->isValid()) {
Zend_OpenId::redirect(Zend_OpenId::selfURL());
} else {
$auth->clearIdentity();
foreach ($result->getMessages() as $message) {
$status .= "$message<br>\n";
}
}
} else if ($auth->hasIdentity()) {
if (isset($_POST['openid_action']) &&
$_POST['openid_action'] == "logout") {
$auth->clearIdentity();
} else {
$status = "Du bist angemeldet als " . $auth->getIdentity() . "<br>\n";
}
}
?>
<html><body>
<?php echo "$status";?>
<form method="post"><fieldset>
<legend>OpenID Login</legend>
<input type="text" name="openid_identifier" value="">
<input type="submit" name="openid_action" value="login">
<input type="submit" name="openid_action" value="logout">
</fieldset></form></body></html>
Mit Zend_Auth wird die Identität des End-Benutzes in den Session Daten gespeichert.
Sie kann mit Zend_Auth::hasIdentity und Zend_Auth::getIdentity
geprüft werden.
Integration mit Zend_Controller
Zuletzt ein paar Worte über die Integration in Model-View-Controller Anwendungen. Solche
Zend Framework Anwendungen werden implementiert durch Verwenden der Zend_Controller
Klasse und Sie verwenden die Zend_Controller_Response_Http Klasse um HTTP Antworten
vorzubereiten und an den Web-Browser des End-Benutzers zurückzusenden.
Zend_OpenId_Consumer bietet keine GUI Möglichkeiten aber es führt HTTP Umleitungen
bei erflgreichen Zend_OpenId_Consumer::login und
Zend_OpenId_Consumer::check durch. Diese Umleitungen könnten nicht richtig funktionieren
oder sogar überhaupt nicht Arbeiten wenn einige Daten bereits an den Web-Browser gesendet wurden. Um
HTTP Umleitungen im MVC Code richtig durchzuführen sollte die echte
Zend_Controller_Response_Http als letztes Argument an
Zend_OpenId_Consumer::login oder Zend_OpenId_Consumer::check gesendet
werden.
| Einführung |