Auth_OpenID_Message Klassenreferenz


Öffentliche Methoden

 Auth_OpenID_Message ($openid_namespace=null)
 isOpenID1 ()
 isOpenID2 ()
 fromPostArgs ($args)
 fromOpenIDArgs ($openid_args)
 _fromOpenIDArgs ($openid_args)
 _getDefaultNamespace ($mystery_alias)
 setOpenIDNamespace ($openid_ns_uri, $implicit)
 getOpenIDNamespace ()
 fromKVForm ($kvform_string)
 copy ()
 toPostArgs ()
 toArgs ()
 toFormMarkup ($action_url, $form_tag_attrs=null, $submit_text="Continue")
 toURL ($base_url)
 toKVForm ()
 toURLEncoded ()
 _fixNS ($namespace)
 hasKey ($namespace, $ns_key)
 getKey ($namespace, $ns_key)
 getArg ($namespace, $key, $default=null)
 getArgs ($namespace)
 updateArgs ($namespace, $updates)
 setArg ($namespace, $key, $value)
 delArg ($namespace, $key)
 getAliasedArg ($aliased_key, $default=null)

Ausführliche Beschreibung

Definiert in Zeile 414 der Datei Message.php.


Dokumentation der Elementfunktionen

_fixNS ( namespace  ) 

private

Definiert in Zeile 728 der Datei Message.php.

00730     {
00731         // Convert an input value into the internally used values of
00732         // this object
00733 
00734         if ($namespace == Auth_OpenID_OPENID_NS) {
00735             if ($this->_openid_ns_uri === null) {
00736                 return new Auth_OpenID_FailureResponse(null,
00737                     'OpenID namespace not set');
00738             } else {
00739                 $namespace = $this->_openid_ns_uri;
00740             }
00741         }
00742 
00743         if (($namespace != Auth_OpenID_BARE_NS) &&
00744               (!is_string($namespace))) {
00745             //TypeError
00746             $err_msg = sprintf("Namespace must be Auth_OpenID_BARE_NS, ".
00747                               "Auth_OpenID_OPENID_NS or a string. got %s",
00748                               print_r($namespace, true));
00749             return new Auth_OpenID_FailureResponse(null, $err_msg);
00750         }
00751 
00752         if (($namespace != Auth_OpenID_BARE_NS) &&
00753             (strpos($namespace, ':') === false)) {
00754             // fmt = 'OpenID 2.0 namespace identifiers SHOULD be URIs. Got %r'
00755             // warnings.warn(fmt % (namespace,), DeprecationWarning)
00756 
00757             if ($namespace == 'sreg') {
00758                 // fmt = 'Using %r instead of "sreg" as namespace'
00759                 // warnings.warn(fmt % (SREG_URI,), DeprecationWarning,)
00760                 return Auth_OpenID_SREG_URI;
00761             }
00762         }
00763 
00764         return $namespace;

_fromOpenIDArgs ( openid_args  ) 

private

Definiert in Zeile 495 der Datei Message.php.

00497     {
00498         global $Auth_OpenID_registered_aliases;
00499 
00500         // Takes an Auth_OpenID_Mapping instance OR an array.
00501 
00502         if (!Auth_OpenID_Mapping::isA($openid_args)) {
00503             $openid_args = new Auth_OpenID_Mapping($openid_args);
00504         }
00505 
00506         $ns_args = array();
00507 
00508         // Resolve namespaces
00509         foreach ($openid_args->items() as $pair) {
00510             list($rest, $value) = $pair;
00511 
00512             $parts = explode('.', $rest, 2);
00513 
00514             if (count($parts) == 2) {
00515                 list($ns_alias, $ns_key) = $parts;
00516             } else {
00517                 $ns_alias = Auth_OpenID_NULL_NAMESPACE;
00518                 $ns_key = $rest;
00519             }
00520 
00521             if ($ns_alias == 'ns') {
00522                 if ($this->namespaces->addAlias($value, $ns_key) === null) {
00523                     return false;
00524                 }
00525             } else if (($ns_alias == Auth_OpenID_NULL_NAMESPACE) &&
00526                        ($ns_key == 'ns')) {
00527                 // null namespace
00528                 if ($this->setOpenIDNamespace($value, false) === false) {
00529                     return false;
00530                 }
00531             } else {
00532                 $ns_args[] = array($ns_alias, $ns_key, $value);
00533             }
00534         }
00535 
00536         if (!$this->getOpenIDNamespace()) {
00537             if ($this->setOpenIDNamespace(Auth_OpenID_OPENID1_NS, true) ===
00538                 false) {
00539                 return false;
00540             }
00541         }
00542 
00543         // Actually put the pairs into the appropriate namespaces
00544         foreach ($ns_args as $triple) {
00545             list($ns_alias, $ns_key, $value) = $triple;
00546             $ns_uri = $this->namespaces->getNamespaceURI($ns_alias);
00547             if ($ns_uri === null) {
00548                 $ns_uri = $this->_getDefaultNamespace($ns_alias);
00549                 if ($ns_uri === null) {
00550 
00551                     $ns_uri = Auth_OpenID_OPENID_NS;
00552                     $ns_key = sprintf('%s.%s', $ns_alias, $ns_key);
00553                 } else {
00554                     $this->namespaces->addAlias($ns_uri, $ns_alias, true);
00555                 }
00556             }
00557 
00558             $this->setArg($ns_uri, $ns_key, $value);
00559         }
00560 
00561         return true;

_getDefaultNamespace ( mystery_alias  ) 

Definiert in Zeile 563 der Datei Message.php.

00565     {
00566         global $Auth_OpenID_registered_aliases;
00567         if ($this->isOpenID1()) {
00568             return @$Auth_OpenID_registered_aliases[$mystery_alias];
00569         }
00570         return null;

Auth_OpenID_Message ( openid_namespace = null  ) 

Definiert in Zeile 416 der Datei Message.php.

00418     {
00419         // Create an empty Message
00420         $this->allowed_openid_namespaces = array(
00421                                Auth_OpenID_OPENID1_NS,
00422                                Auth_OpenID_THE_OTHER_OPENID1_NS,
00423                                Auth_OpenID_OPENID2_NS);
00424 
00425         $this->args = new Auth_OpenID_Mapping();
00426         $this->namespaces = new Auth_OpenID_NamespaceMap();
00427         if ($openid_namespace === null) {
00428             $this->_openid_ns_uri = null;
00429         } else {
00430             $implicit = Auth_OpenID_isOpenID1($openid_namespace);
00431             $this->setOpenIDNamespace($openid_namespace, $implicit);
00432         }

copy (  ) 

Definiert in Zeile 603 der Datei Message.php.

00605     {
00606         return $this;

delArg ( namespace,
key 
)

Definiert in Zeile 876 der Datei Message.php.

00878     {
00879         $namespace = $this->_fixNS($namespace);
00880 
00881         if (Auth_OpenID::isFailure($namespace)) {
00882             return $namespace;
00883         } else {
00884             return $this->args->del(array($namespace, $key));
00885         }

fromKVForm ( kvform_string  ) 

Definiert in Zeile 596 der Datei Message.php.

00598     {
00599         // Create a Message from a KVForm string
00600         return Auth_OpenID_Message::fromOpenIDArgs(
00601                      Auth_OpenID_KVForm::toArray($kvform_string));

fromOpenIDArgs ( openid_args  ) 

Definiert in Zeile 479 der Datei Message.php.

00481     {
00482         // Takes an array.
00483 
00484         // Construct a Message from a parsed KVForm message
00485         $obj = new Auth_OpenID_Message();
00486         if ($obj->_fromOpenIDArgs($openid_args)) {
00487             return $obj;
00488         } else {
00489             return null;
00490         }

fromPostArgs ( args  ) 

Definiert in Zeile 444 der Datei Message.php.

00446     {
00447         // Construct a Message containing a set of POST arguments
00448         $obj = new Auth_OpenID_Message();
00449 
00450         // Partition into "openid." args and bare args
00451         $openid_args = array();
00452         foreach ($args as $key => $value) {
00453 
00454             if (is_array($value)) {
00455                 return null;
00456             }
00457 
00458             $parts = explode('.', $key, 2);
00459 
00460             if (count($parts) == 2) {
00461                 list($prefix, $rest) = $parts;
00462             } else {
00463                 $prefix = null;
00464             }
00465 
00466             if ($prefix != 'openid') {
00467                 $obj->args->set(array(Auth_OpenID_BARE_NS, $key), $value);
00468             } else {
00469                 $openid_args[$rest] = $value;
00470             }
00471         }
00472 
00473         if ($obj->_fromOpenIDArgs($openid_args)) {
00474             return $obj;
00475         } else {
00476             return null;
00477         }

getAliasedArg ( aliased_key,
default = null 
)

Definiert in Zeile 887 der Datei Message.php.

00889     {
00890         if ($aliased_key == 'ns') {
00891             // Return the namespace URI for the OpenID namespace
00892             return $this->getOpenIDNamespace();
00893         }
00894 
00895         $parts = explode('.', $aliased_key, 2);
00896 
00897         if (count($parts) != 2) {
00898             $ns = null;
00899         } else {
00900             list($alias, $key) = $parts;
00901 
00902             if ($alias == 'ns') {
00903               // Return the namespace URI for a namespace alias
00904               // parameter.
00905               return $this->namespaces->getNamespaceURI($key);
00906             } else {
00907               $ns = $this->namespaces->getNamespaceURI($alias);
00908             }
00909         }
00910 
00911         if ($ns === null) {
00912             $key = $aliased_key;
00913             $ns = $this->getOpenIDNamespace();
00914         }
00915 
00916         return $this->getArg($ns, $key, $default);

getArg ( namespace,
key,
default = null 
)

Definiert in Zeile 804 der Datei Message.php.

00806     {
00807         // Get a value for a namespaced key.
00808         $namespace = $this->_fixNS($namespace);
00809 
00810         if (Auth_OpenID::isFailure($namespace)) {
00811             return $namespace;
00812         } else {
00813             if ((!$this->args->contains(array($namespace, $key))) &&
00814               ($default == Auth_OpenID_NO_DEFAULT)) {
00815                 $err_msg = sprintf("Namespace %s missing required field %s",
00816                                    $namespace, $key);
00817                 return new Auth_OpenID_FailureResponse(null, $err_msg);
00818             } else {
00819                 return $this->args->get(array($namespace, $key), $default);
00820             }
00821         }

getArgs ( namespace  ) 

Definiert in Zeile 823 der Datei Message.php.

00825     {
00826         // Get the arguments that are defined for this namespace URI
00827 
00828         $namespace = $this->_fixNS($namespace);
00829         if (Auth_OpenID::isFailure($namespace)) {
00830             return $namespace;
00831         } else {
00832             $stuff = array();
00833             foreach ($this->args->items() as $pair) {
00834                 list($key, $value) = $pair;
00835                 list($pair_ns, $ns_key) = $key;
00836                 if ($pair_ns == $namespace) {
00837                     $stuff[$ns_key] = $value;
00838                 }
00839             }
00840 
00841             return $stuff;
00842         }

getKey ( namespace,
ns_key 
)

Definiert in Zeile 777 der Datei Message.php.

00779     {
00780         // Get the key for a particular namespaced argument
00781         $namespace = $this->_fixNS($namespace);
00782         if (Auth_OpenID::isFailure($namespace)) {
00783             return $namespace;
00784         }
00785         if ($namespace == Auth_OpenID_BARE_NS) {
00786             return $ns_key;
00787         }
00788 
00789         $ns_alias = $this->namespaces->getAlias($namespace);
00790 
00791         // No alias is defined, so no key can exist
00792         if ($ns_alias === null) {
00793             return null;
00794         }
00795 
00796         if ($ns_alias == Auth_OpenID_NULL_NAMESPACE) {
00797             $tail = $ns_key;
00798         } else {
00799             $tail = sprintf('%s.%s', $ns_alias, $ns_key);
00800         }
00801 
00802         return 'openid.' . $tail;

getOpenIDNamespace (  ) 

Definiert in Zeile 591 der Datei Message.php.

00593     {
00594         return $this->_openid_ns_uri;

hasKey ( namespace,
ns_key 
)

Definiert in Zeile 766 der Datei Message.php.

00768     {
00769         $namespace = $this->_fixNS($namespace);
00770         if (Auth_OpenID::isFailure($namespace)) {
00771             // XXX log me
00772             return false;
00773         } else {
00774             return $this->args->contains(array($namespace, $ns_key));
00775         }

isOpenID1 (  ) 

Definiert in Zeile 434 der Datei Message.php.

00436     {
00437         return Auth_OpenID_isOpenID1($this->getOpenIDNamespace());

isOpenID2 (  ) 

Definiert in Zeile 439 der Datei Message.php.

00441     {
00442         return $this->getOpenIDNamespace() == Auth_OpenID_OPENID2_NS;

setArg ( namespace,
key,
value 
)

Definiert in Zeile 860 der Datei Message.php.

00862     {
00863         // Set a single argument in this namespace
00864         $namespace = $this->_fixNS($namespace);
00865 
00866         if (Auth_OpenID::isFailure($namespace)) {
00867             return $namespace;
00868         } else {
00869             $this->args->set(array($namespace, $key), $value);
00870             if ($namespace !== Auth_OpenID_BARE_NS) {
00871                 $this->namespaces->add($namespace);
00872             }
00873             return true;
00874         }

setOpenIDNamespace ( openid_ns_uri,
implicit 
)

Definiert in Zeile 572 der Datei Message.php.

00574     {
00575         if (!in_array($openid_ns_uri, $this->allowed_openid_namespaces)) {
00576             Auth_OpenID::log('Invalid null namespace: "%s"', $openid_ns_uri);
00577             return false;
00578         }
00579 
00580         $succeeded = $this->namespaces->addAlias($openid_ns_uri,
00581                                                  Auth_OpenID_NULL_NAMESPACE,
00582                                                  $implicit);
00583         if ($succeeded === false) {
00584             return false;
00585         }
00586 
00587         $this->_openid_ns_uri = $openid_ns_uri;
00588 
00589         return true;

toArgs (  ) 

Definiert in Zeile 639 der Datei Message.php.

00641     {
00642         // Return all namespaced arguments, failing if any
00643         // non-namespaced arguments exist.
00644         $post_args = $this->toPostArgs();
00645         $kvargs = array();
00646         foreach ($post_args as $k => $v) {
00647             if (strpos($k, 'openid.') !== 0) {
00648                 // raise ValueError(
00649                 //   'This message can only be encoded as a POST, because it '
00650                 //   'contains arguments that are not prefixed with "openid."')
00651                 return null;
00652             } else {
00653                 $kvargs[substr($k, 7)] = $v;
00654             }
00655         }
00656 
00657         return $kvargs;

toFormMarkup ( action_url,
form_tag_attrs = null,
submit_text = "Continue" 
)

Definiert in Zeile 659 der Datei Message.php.

00662     {
00663         $form = "<form accept-charset=\"UTF-8\" ".
00664             "enctype=\"application/x-www-form-urlencoded\"";
00665 
00666         if (!$form_tag_attrs) {
00667             $form_tag_attrs = array();
00668         }
00669 
00670         $form_tag_attrs['action'] = $action_url;
00671         $form_tag_attrs['method'] = 'post';
00672 
00673         unset($form_tag_attrs['enctype']);
00674         unset($form_tag_attrs['accept-charset']);
00675 
00676         if ($form_tag_attrs) {
00677             foreach ($form_tag_attrs as $name => $attr) {
00678                 $form .= sprintf(" %s=\"%s\"", $name, $attr);
00679             }
00680         }
00681 
00682         $form .= ">\n";
00683 
00684         foreach ($this->toPostArgs() as $name => $value) {
00685             $form .= sprintf(
00686                         "<input type=\"hidden\" name=\"%s\" value=\"%s\" />\n",
00687                         $name, $value);
00688         }
00689 
00690         $form .= sprintf("<input type=\"submit\" value=\"%s\" />\n",
00691                          $submit_text);
00692 
00693         $form .= "</form>\n";
00694 
00695         return $form;

toKVForm (  ) 

Definiert in Zeile 704 der Datei Message.php.

00706     {
00707         // Generate a KVForm string that contains the parameters in
00708         // this message. This will fail if the message contains
00709         // arguments outside of the 'openid.' prefix.
00710         return Auth_OpenID_KVForm::fromArray($this->toArgs());

toPostArgs (  ) 

Definiert in Zeile 608 der Datei Message.php.

00610     {
00611         // Return all arguments with openid. in front of namespaced
00612         // arguments.
00613 
00614         $args = array();
00615 
00616         // Add namespace definitions to the output
00617         foreach ($this->namespaces->iteritems() as $pair) {
00618             list($ns_uri, $alias) = $pair;
00619             if ($this->namespaces->isImplicit($ns_uri)) {
00620                 continue;
00621             }
00622             if ($alias == Auth_OpenID_NULL_NAMESPACE) {
00623                 $ns_key = 'openid.ns';
00624             } else {
00625                 $ns_key = 'openid.ns.' . $alias;
00626             }
00627             $args[$ns_key] = $ns_uri;
00628         }
00629 
00630         foreach ($this->args->items() as $pair) {
00631             list($ns_parts, $value) = $pair;
00632             list($ns_uri, $ns_key) = $ns_parts;
00633             $key = $this->getKey($ns_uri, $ns_key);
00634             $args[$key] = $value;
00635         }
00636 
00637         return $args;

toURL ( base_url  ) 

Definiert in Zeile 697 der Datei Message.php.

00699     {
00700         // Generate a GET URL with the parameters in this message
00701         // attached as query parameters.
00702         return Auth_OpenID::appendArgs($base_url, $this->toPostArgs());

toURLEncoded (  ) 

Definiert in Zeile 712 der Datei Message.php.

00714     {
00715         // Generate an x-www-urlencoded string
00716         $args = array();
00717 
00718         foreach ($this->toPostArgs() as $k => $v) {
00719             $args[] = array($k, $v);
00720         }
00721 
00722         sort($args);
00723         return Auth_OpenID::httpBuildQuery($args);

updateArgs ( namespace,
updates 
)

Definiert in Zeile 844 der Datei Message.php.

00846     {
00847         // Set multiple key/value pairs in one call
00848 
00849         $namespace = $this->_fixNS($namespace);
00850 
00851         if (Auth_OpenID::isFailure($namespace)) {
00852             return $namespace;
00853         } else {
00854             foreach ($updates as $k => $v) {
00855                 $this->setArg($namespace, $k, $v);
00856             }
00857             return true;
00858         }


Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:
Copyright © 2003 - 2009 MyOOS [Shopsystem]. All rights reserved.
MyOOS [Shopsystem] is Free Software released under the GNU/GPL License.

Webmaster: info@r23.de (Impressum)
doxygen