Previous Next

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:

  1. Zeige das OpenID Authentifikations Formular.

  2. Akzeptiere die OpenID Identität und übergib Sie an den OpenID Provider.

  3. Ü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.

Example #1 Das einfache OpenID Login Formular


OpenID Login

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.

Example #2 Der Authentifizierungs Anfrage Handler

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.

Example #3 Der Authentifizierungs Antwort Prüfer

verify($_GET, $id)) {
    echo "GÜLTIG ". htmlspecialchars($id);
} else {
    echo "UNGÜLTIG" . htmlspecialchars($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.

Example #4 Das komplette OpenID Login Skript

login($_POST['openid_identifier'])) {
        $status = "OpenID Login fehlgeschlagen.
"; } } 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 " . htmlspecialchars($id); } else { $status = "UNGÜLTIG " . htmlspecialchars($id); } } else if ($_GET['openid_mode'] == "cancel") { $status = "ABGEBROCHEN"; } } ?> ";?>
OpenID Login

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.

Example #5 Authentifizierungs Anfrage für spezielle Bereiche

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.

Example #6 Sofortige Prüfung ohne Interaktion

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.

Example #7 Datenbank Speicher

_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.

Example #8 Anfragen mit einer einfachen Registrations Erweiterung senden

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.

Example #9 Antworten mit einer einfachen Registierungs Erweiterung prüfen

true,
    'email'=>false,
    'fullname'=>false), null, 1.1);
$consumer = new Zend_OpenId_Consumer();
if ($consumer->verify($_GET, $id, $sreg)) {
    echo "GÜLTIG " . htmlspecialchars($id) . "
\n"; $data = $sreg->getProperties(); if (isset($data['nickname'])) { echo "Spitzname: " . htmlspecialchars($data['nickname']) . "
\n"; } if (isset($data['email'])) { echo "Email: " . htmlspecialchars($data['email']) . "
\n"; } if (isset($data['fullname'])) { echo "Vollständiger Name: " . htmlspecialchars($data['fullname']) . "
\n"; } } else { echo "UNGÜLTIG " . htmlspecialchars($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.

Example #10 Zend_Auth Adapter für OpenID

_id = $id;
    }

    public function authenticate() {
        $id = $this->_id;
        if (!empty($id)) {
            $consumer = new Zend_OpenId_Consumer();
            if (!$consumer->login($id)) {
                $ret = false;
                $msg = "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
\n"; } } } else if ($auth->hasIdentity()) { if (isset($_POST['openid_action']) && $_POST['openid_action'] == "logout") { $auth->clearIdentity(); } else { $status = "Du bist angemeldet als " . $auth->getIdentity() . "
\n"; } } ?>
OpenID Login

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.

Previous Next
Introduction to Zend Framework
Übersicht
Installation
Zend_Acl
Einführung
Verfeinern der Zugriffskontrolle
Fortgeschrittene Verwendung
Zend_Auth
Einführung
Datenbanktabellen Authentifizierung
Digest Authentication
HTTP Authentication Adapter
LDAP Authentifizierung
Open ID Authentifikation
Zend_Cache
Einführung
Die Theorie des Cachens
Zend_Cache Frontends
Zend_Cache Backends
Zend_Captcha
Introduction
Captcha Operation
Captcha Adapters
Zend_Config
Einleitung
Theory of Operation
Zend_Config_Ini
Zend_Config_Xml
Zend_Console_Getopt
Einführung in Getopt
Definieren von Getopt Regeln
Holen von Optionen und Argumenten
Konfigurieren von Zend_Console_Getopt
Zend_Controller
Zend_Controller Schnellstart
Zend_Controller Grundlagen
Der Front Controller
Das Request Objekt
Der Standard Router: Zend_Controller_Router_Rewrite
Der Dispatcher
Action Kontroller
Action Helfer
Das Response Objekt
Plugins
Eine konventionelle modulare Verzeichnis Struktur verwenden
MVC Ausnahmen
Migration von vorhergehenden Versionen
Zend_Currency
Einführung in Zend_Currency
Arbeiten mit Währungen
Migration von vorhergehenden Versionen
Zend_Date
Einführung
Theorie der Arbeitsweise
Basis Methoden
Zend_Date API Übersicht
Erstellen von Datumswerten
Konstanten für generelle Datums Funktionen
Funktionierende Beispiele
Zend_Db
Zend_Db_Adapter
Zend_Db_Statement
Zend_Db_Profiler
Zend_Db_Select
Zend_Db_Table
Zend_Db_Table_Row
Zend_Db_Table_Rowset
Zend_Db_Table Relationships
Zend_Debug
Variablen ausgeben
Zend_Dojo
Introduction
Zend_Dojo_Data: dojo.data Envelopes
Dojo View Helpers
Dojo Form Elements and Decorators
Zend_Dom
Introduction
Zend_Dom_Query
Zend_Exception
Verwenden von Ausnahmen
Zend_Feed
Einführung
Feeds importieren
Feeds von Websites abrufen
Einen RSS Feed konsumieren
Einen Atom Feed konsumieren
Einen einzelnen Atom Eintrag konsumieren
Verändern der Feed- und Eintragsstruktur
Eigene Klassen für Feeds und Einträge
Zend_File
Zend_File_Transfer
Validators for Zend_File_Transfer
Zend_Filter
Einführung
Standard Filter Klassen
Filter Ketten
Filter schreiben
Zend_Filter_Input
Zend_Filter_Inflector
Zend_Form
Zend_Form
Schnellstart mit Zend_Form
Erstellen von Form Elementen mit Hilfe von Zend_Form_Element
Erstellen von Form durch Verwendung von Zend_Form
Erstellen von eigenem Form Markup durch Zend_Form_Decorator
Standard Form Elemente die mit dem With Zend Framework ausgeliefert werden
Standard Form Dekoratore die mit dem Zend Framework ausgeliefert werden
Internationalisierung von Zend_Form
Fortgeschrittene Verwendung von Zend_Form
Zend_Gdata
Einführung zu Gdata
Authentifizierung mit AuthSub
Authentifizieren mit ClientLogin
Google Kalender verwenden
Verwenden der Google Dokumente Listen Daten API
Google Tabellenkalkulation verwenden
Google Apps Provisionierung verwenden
Google Base verwenden
Verwenden der YouTube Daten API
Picasa Web Alben verwenden
Gdata Ausnahmen auffangen
Zend_Http
Zend_Http_Client - Einführung
Zend_Http_Client - Fortgeschrittende Nutzung
Zend_Http_Client - Verbindungsadapter
Zend_Http_Cookie und Zend_Http_CookieJar
Zend_Http_Response
Zend_InfoCard
Einführung
Zend_Json
Einführung
Grundlegende Verwendung
JSON Objects
XML zu JSON Konvertierung
Zend_Json_Server - JSON-RPC server
Zend_Layout
Einführung
Zend_Layout Schnellstart
Zend_Layout Konfigurations Optionen
Erweiterte Verwendung von Zend_Layout
Zend_Ldap
Einleitung
Zend_Loader
Dynamisches Laden von Dateien und Klassen
Plugins laden
Zend_Locale
Einführung
Zend_Locale verwenden
Normalisierung und Lokalisierung
Arbeiten mit Daten und Zeiten
Unterstützte Sprachen für Gebietsschemata
Unterstützte Regionen für Gebietsschemata
Zend_Log
Übersicht
Writer
Formatter
Filter
Zend_Mail
Einführung
Versand über SMTP
Versand von mehreren E-Mails über eine SMTP Verbindung
Verwendung von unterschiedlichen Versandwegen
HTML E-Mail
Anhänge
Empfänger hinzufügen
Die MIME Abgrenzung kontrollieren
Zusätzliche Kopfzeilen
Zeichensätze
Kodierung
SMTP Authentifizierung
SMTP Übertragungen sichern
Lesen von Mail Nachrichten
Zend_Measure
Einführung
Erstellung einer Maßeinheit
Ausgabe von Maßeinheiten
Manipulation von Maßeinheiten
Arten von Maßeinheiten
Zend_Memory
Übersicht
Memory Manager
Memory Objekte
Zend_Mime
Zend_Mime
Zend_Mime_Message
Zend_Mime_Part
Zend_OpenId
Einführung
Zend_OpenId_Consumer Grundlagen
Zend_OpenId_Provider
Zend_Paginator
Introduction
Usage
Configuration
Advanced usage
Zend_Pdf
Einführung
Erstellen und Laden von PDF Dokumenten
Änderungen von PDF Dokumenten speichern
Dokument Seiten
Zeichnen
Dokument Informationen und Metadaten
Anwendungsbeispiel für die Zend_Pdf Komponente
Zend_Registry
Die Registry verwenden
Zend_Rest
Einführung
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Überblick
Indexerstellung
Einen Index durchsuchen
Abfragesprache
Abfrage Erzeugungs API
Zeichensätze
Erweiterbarkeit
Zusammenarbeit Mit Java Lucene
Erweitert
Die besten Anwendungen
Zend_Server
Einführung
Zend_Server_Reflection
Zend_Service
Einführung
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_Flickr
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Einführung
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Mitgelieferte Services
Zend_Service_StrikeIron: Erweiterte Verwendung
Zend_Service_Technorati
Zend_Service_Yahoo
Zend_Session
Einführung
Grundsätzliche Verwendung
Fortgeschrittene Benutzung
Globales Session Management
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL Zugriffsmethoden
AutoDiscovery. Einführung
Automatische Erkennung von Klassen.
Funktionen für Autodiscovery.
Automatische Erkennung. Datentypen.
Zend_Test
Introduction
Zend_Test_PHPUnit
Zend_Text
Zend_Text_Figlet
Zend_TimeSync
Einführung
Arbeiten mit Zend_TimeSync
Zend_Translate
Einführung
Adapter für Zend_Translate
Benutzen von Übersetzungs Adaptoren
Zend_Uri
Zend_Uri
Zend_Validate
Einführung
Standard Prüfklassen
Kettenprüfungen
Schreiben von Prüfern
Zend_Version
Auslesen der Version des Zend Frameworks
Zend_View
Einführung
Controller Skripte
View Scripte
View Helfer
Zend_View_Abstract
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Einführung
Zend_XmlRpc_Client
Zend_XmlRpc_Server
Zend Framework Voraussetzungen
PHP Version
PHP Erweiterungen
Zend Framework Komponenten
Zend Framework Abhängigkeiten
Zend Framework Coding Standard für PHP
Übersicht
PHP Dateiformatierung
Namens Konventionen
Code Stil
Urheberrecht Informationen