OpenID library installed
[living-lab-site.git] / application / libraries / Auth / OpenID / AX.php
1 <?php
2
3 /**
4  * Implements the OpenID attribute exchange specification, version 1.0
5  * as of svn revision 370 from openid.net svn.
6  *
7  * @package OpenID
8  */
9
10 /**
11  * Require utility classes and functions for the consumer.
12  */
13 require_once "Auth/OpenID/Extension.php";
14 require_once "Auth/OpenID/Message.php";
15 require_once "Auth/OpenID/TrustRoot.php";
16
17 define('Auth_OpenID_AX_NS_URI',
18        'http://openid.net/srv/ax/1.0');
19
20 // Use this as the 'count' value for an attribute in a FetchRequest to
21 // ask for as many values as the OP can provide.
22 define('Auth_OpenID_AX_UNLIMITED_VALUES', 'unlimited');
23
24 // Minimum supported alias length in characters.  Here for
25 // completeness.
26 define('Auth_OpenID_AX_MINIMUM_SUPPORTED_ALIAS_LENGTH', 32);
27
28 /**
29  * AX utility class.
30  *
31  * @package OpenID
32  */
33 class Auth_OpenID_AX {
34     /**
35      * @param mixed $thing Any object which may be an
36      * Auth_OpenID_AX_Error object.
37      *
38      * @return bool true if $thing is an Auth_OpenID_AX_Error; false
39      * if not.
40      */
41     static function isError($thing)
42     {
43         return is_a($thing, 'Auth_OpenID_AX_Error');
44     }
45 }
46
47 /**
48  * Check an alias for invalid characters; raise AXError if any are
49  * found.  Return None if the alias is valid.
50  */
51 function Auth_OpenID_AX_checkAlias($alias)
52 {
53   if (strpos($alias, ',') !== false) {
54       return new Auth_OpenID_AX_Error(sprintf(
55                    "Alias %s must not contain comma", $alias));
56   }
57   if (strpos($alias, '.') !== false) {
58       return new Auth_OpenID_AX_Error(sprintf(
59                    "Alias %s must not contain period", $alias));
60   }
61
62   return true;
63 }
64
65 /**
66  * Results from data that does not meet the attribute exchange 1.0
67  * specification
68  *
69  * @package OpenID
70  */
71 class Auth_OpenID_AX_Error {
72     function Auth_OpenID_AX_Error($message=null)
73     {
74         $this->message = $message;
75     }
76 }
77
78 /**
79  * Abstract class containing common code for attribute exchange
80  * messages.
81  *
82  * @package OpenID
83  */
84 class Auth_OpenID_AX_Message extends Auth_OpenID_Extension {
85     /**
86      * ns_alias: The preferred namespace alias for attribute exchange
87      * messages
88      */
89     var $ns_alias = 'ax';
90
91     /**
92      * mode: The type of this attribute exchange message. This must be
93      * overridden in subclasses.
94      */
95     var $mode = null;
96
97     var $ns_uri = Auth_OpenID_AX_NS_URI;
98
99     /**
100      * Return Auth_OpenID_AX_Error if the mode in the attribute
101      * exchange arguments does not match what is expected for this
102      * class; true otherwise.
103      *
104      * @access private
105      */
106     function _checkMode($ax_args)
107     {
108         $mode = Auth_OpenID::arrayGet($ax_args, 'mode');
109         if ($mode != $this->mode) {
110             return new Auth_OpenID_AX_Error(
111                             sprintf(
112                                     "Expected mode '%s'; got '%s'",
113                                     $this->mode, $mode));
114         }
115
116         return true;
117     }
118
119     /**
120      * Return a set of attribute exchange arguments containing the
121      * basic information that must be in every attribute exchange
122      * message.
123      *
124      * @access private
125      */
126     function _newArgs()
127     {
128         return array('mode' => $this->mode);
129     }
130 }
131
132 /**
133  * Represents a single attribute in an attribute exchange
134  * request. This should be added to an AXRequest object in order to
135  * request the attribute.
136  *
137  * @package OpenID
138  */
139 class Auth_OpenID_AX_AttrInfo {
140     /**
141      * Construct an attribute information object.  Do not call this
142      * directly; call make(...) instead.
143      *
144      * @param string $type_uri The type URI for this attribute.
145      *
146      * @param int $count The number of values of this type to request.
147      *
148      * @param bool $required Whether the attribute will be marked as
149      * required in the request.
150      *
151      * @param string $alias The name that should be given to this
152      * attribute in the request.
153      */
154     function Auth_OpenID_AX_AttrInfo($type_uri, $count, $required,
155                                      $alias)
156     {
157         /**
158          * required: Whether the attribute will be marked as required
159          * when presented to the subject of the attribute exchange
160          * request.
161          */
162         $this->required = $required;
163
164         /**
165          * count: How many values of this type to request from the
166          * subject. Defaults to one.
167          */
168         $this->count = $count;
169
170         /**
171          * type_uri: The identifier that determines what the attribute
172          * represents and how it is serialized. For example, one type
173          * URI representing dates could represent a Unix timestamp in
174          * base 10 and another could represent a human-readable
175          * string.
176          */
177         $this->type_uri = $type_uri;
178
179         /**
180          * alias: The name that should be given to this attribute in
181          * the request. If it is not supplied, a generic name will be
182          * assigned. For example, if you want to call a Unix timestamp
183          * value 'tstamp', set its alias to that value. If two
184          * attributes in the same message request to use the same
185          * alias, the request will fail to be generated.
186          */
187         $this->alias = $alias;
188     }
189
190     /**
191      * Construct an attribute information object.  For parameter
192      * details, see the constructor.
193      */
194     static function make($type_uri, $count=1, $required=false,
195                   $alias=null)
196     {
197         if ($alias !== null) {
198             $result = Auth_OpenID_AX_checkAlias($alias);
199
200             if (Auth_OpenID_AX::isError($result)) {
201                 return $result;
202             }
203         }
204
205         return new Auth_OpenID_AX_AttrInfo($type_uri, $count, $required,
206                                            $alias);
207     }
208
209     /**
210      * When processing a request for this attribute, the OP should
211      * call this method to determine whether all available attribute
212      * values were requested.  If self.count == UNLIMITED_VALUES, this
213      * returns True.  Otherwise this returns False, in which case
214      * self.count is an integer.
215     */
216     function wantsUnlimitedValues()
217     {
218         return $this->count === Auth_OpenID_AX_UNLIMITED_VALUES;
219     }
220 }
221
222 /**
223  * Given a namespace mapping and a string containing a comma-separated
224  * list of namespace aliases, return a list of type URIs that
225  * correspond to those aliases.
226  *
227  * @param $namespace_map The mapping from namespace URI to alias
228  * @param $alias_list_s The string containing the comma-separated
229  * list of aliases. May also be None for convenience.
230  *
231  * @return $seq The list of namespace URIs that corresponds to the
232  * supplied list of aliases. If the string was zero-length or None, an
233  * empty list will be returned.
234  *
235  * return null If an alias is present in the list of aliases but
236  * is not present in the namespace map.
237  */
238 function Auth_OpenID_AX_toTypeURIs($namespace_map, $alias_list_s)
239 {
240     $uris = array();
241
242     if ($alias_list_s) {
243         foreach (explode(',', $alias_list_s) as $alias) {
244             $type_uri = $namespace_map->getNamespaceURI($alias);
245             if ($type_uri === null) {
246                 // raise KeyError(
247                 // 'No type is defined for attribute name %r' % (alias,))
248                 return new Auth_OpenID_AX_Error(
249                   sprintf('No type is defined for attribute name %s',
250                           $alias)
251                   );
252             } else {
253                 $uris[] = $type_uri;
254             }
255         }
256     }
257
258     return $uris;
259 }
260
261 /**
262  * An attribute exchange 'fetch_request' message. This message is sent
263  * by a relying party when it wishes to obtain attributes about the
264  * subject of an OpenID authentication request.
265  *
266  * @package OpenID
267  */
268 class Auth_OpenID_AX_FetchRequest extends Auth_OpenID_AX_Message {
269
270     var $mode = 'fetch_request';
271
272     function Auth_OpenID_AX_FetchRequest($update_url=null)
273     {
274         /**
275          * requested_attributes: The attributes that have been
276          * requested thus far, indexed by the type URI.
277          */
278         $this->requested_attributes = array();
279
280         /**
281          * update_url: A URL that will accept responses for this
282          * attribute exchange request, even in the absence of the user
283          * who made this request.
284         */
285         $this->update_url = $update_url;
286     }
287
288     /**
289      * Add an attribute to this attribute exchange request.
290      *
291      * @param attribute: The attribute that is being requested
292      * @return true on success, false when the requested attribute is
293      * already present in this fetch request.
294      */
295     function add($attribute)
296     {
297         if ($this->contains($attribute->type_uri)) {
298             return new Auth_OpenID_AX_Error(
299               sprintf("The attribute %s has already been requested",
300                       $attribute->type_uri));
301         }
302
303         $this->requested_attributes[$attribute->type_uri] = $attribute;
304
305         return true;
306     }
307
308     /**
309      * Get the serialized form of this attribute fetch request.
310      *
311      * @returns Auth_OpenID_AX_FetchRequest The fetch request message parameters
312      */
313     function getExtensionArgs()
314     {
315         $aliases = new Auth_OpenID_NamespaceMap();
316
317         $required = array();
318         $if_available = array();
319
320         $ax_args = $this->_newArgs();
321
322         foreach ($this->requested_attributes as $type_uri => $attribute) {
323             if ($attribute->alias === null) {
324                 $alias = $aliases->add($type_uri);
325             } else {
326                 $alias = $aliases->addAlias($type_uri, $attribute->alias);
327
328                 if ($alias === null) {
329                     return new Auth_OpenID_AX_Error(
330                       sprintf("Could not add alias %s for URI %s",
331                               $attribute->alias, $type_uri
332                       ));
333                 }
334             }
335
336             if ($attribute->required) {
337                 $required[] = $alias;
338             } else {
339                 $if_available[] = $alias;
340             }
341
342             if ($attribute->count != 1) {
343                 $ax_args['count.' . $alias] = strval($attribute->count);
344             }
345
346             $ax_args['type.' . $alias] = $type_uri;
347         }
348
349         if ($required) {
350             $ax_args['required'] = implode(',', $required);
351         }
352
353         if ($if_available) {
354             $ax_args['if_available'] = implode(',', $if_available);
355         }
356
357         return $ax_args;
358     }
359
360     /**
361      * Get the type URIs for all attributes that have been marked as
362      * required.
363      *
364      * @return A list of the type URIs for attributes that have been
365      * marked as required.
366      */
367     function getRequiredAttrs()
368     {
369         $required = array();
370         foreach ($this->requested_attributes as $type_uri => $attribute) {
371             if ($attribute->required) {
372                 $required[] = $type_uri;
373             }
374         }
375
376         return $required;
377     }
378
379     /**
380      * Extract a FetchRequest from an OpenID message
381      *
382      * @param request: The OpenID request containing the attribute
383      * fetch request
384      *
385      * @returns mixed An Auth_OpenID_AX_Error or the
386      * Auth_OpenID_AX_FetchRequest extracted from the request message if
387      * successful
388      */
389     static function fromOpenIDRequest($request)
390     {
391         $m = $request->message;
392         $obj = new Auth_OpenID_AX_FetchRequest();
393         $ax_args = $m->getArgs($obj->ns_uri);
394
395         $result = $obj->parseExtensionArgs($ax_args);
396
397         if (Auth_OpenID_AX::isError($result)) {
398             return $result;
399         }
400
401         if ($obj->update_url) {
402             // Update URL must match the openid.realm of the
403             // underlying OpenID 2 message.
404             $realm = $m->getArg(Auth_OpenID_OPENID_NS, 'realm',
405                         $m->getArg(
406                                   Auth_OpenID_OPENID_NS,
407                                   'return_to'));
408
409             if (!$realm) {
410                 $obj = new Auth_OpenID_AX_Error(
411                   sprintf("Cannot validate update_url %s " .
412                           "against absent realm", $obj->update_url));
413             } else if (!Auth_OpenID_TrustRoot::match($realm,
414                                                      $obj->update_url)) {
415                 $obj = new Auth_OpenID_AX_Error(
416                   sprintf("Update URL %s failed validation against realm %s",
417                           $obj->update_url, $realm));
418             }
419         }
420
421         return $obj;
422     }
423
424     /**
425      * Given attribute exchange arguments, populate this FetchRequest.
426      *
427      * @return $result Auth_OpenID_AX_Error if the data to be parsed
428      * does not follow the attribute exchange specification. At least
429      * when 'if_available' or 'required' is not specified for a
430      * particular attribute type.  Returns true otherwise.
431     */
432     function parseExtensionArgs($ax_args)
433     {
434         $result = $this->_checkMode($ax_args);
435         if (Auth_OpenID_AX::isError($result)) {
436             return $result;
437         }
438
439         $aliases = new Auth_OpenID_NamespaceMap();
440
441         foreach ($ax_args as $key => $value) {
442             if (strpos($key, 'type.') === 0) {
443                 $alias = substr($key, 5);
444                 $type_uri = $value;
445
446                 $alias = $aliases->addAlias($type_uri, $alias);
447
448                 if ($alias === null) {
449                     return new Auth_OpenID_AX_Error(
450                       sprintf("Could not add alias %s for URI %s",
451                               $alias, $type_uri)
452                       );
453                 }
454
455                 $count_s = Auth_OpenID::arrayGet($ax_args, 'count.' . $alias);
456                 if ($count_s) {
457                     $count = Auth_OpenID::intval($count_s);
458                     if (($count === false) &&
459                         ($count_s === Auth_OpenID_AX_UNLIMITED_VALUES)) {
460                         $count = $count_s;
461                     }
462                 } else {
463                     $count = 1;
464                 }
465
466                 if ($count === false) {
467                     return new Auth_OpenID_AX_Error(
468                       sprintf("Integer value expected for %s, got %s",
469                               'count.' . $alias, $count_s));
470                 }
471
472                 $attrinfo = Auth_OpenID_AX_AttrInfo::make($type_uri, $count,
473                                                           false, $alias);
474
475                 if (Auth_OpenID_AX::isError($attrinfo)) {
476                     return $attrinfo;
477                 }
478
479                 $this->add($attrinfo);
480             }
481         }
482
483         $required = Auth_OpenID_AX_toTypeURIs($aliases,
484                          Auth_OpenID::arrayGet($ax_args, 'required'));
485
486         foreach ($required as $type_uri) {
487             $attrib = $this->requested_attributes[$type_uri];
488             $attrib->required = true;
489         }
490
491         $if_available = Auth_OpenID_AX_toTypeURIs($aliases,
492                              Auth_OpenID::arrayGet($ax_args, 'if_available'));
493
494         $all_type_uris = array_merge($required, $if_available);
495
496         foreach ($aliases->iterNamespaceURIs() as $type_uri) {
497             if (!in_array($type_uri, $all_type_uris)) {
498                 return new Auth_OpenID_AX_Error(
499                   sprintf('Type URI %s was in the request but not ' .
500                           'present in "required" or "if_available"',
501                           $type_uri));
502
503             }
504         }
505
506         $this->update_url = Auth_OpenID::arrayGet($ax_args, 'update_url');
507
508         return true;
509     }
510
511     /**
512      * Iterate over the AttrInfo objects that are contained in this
513      * fetch_request.
514      */
515     function iterAttrs()
516     {
517         return array_values($this->requested_attributes);
518     }
519
520     function iterTypes()
521     {
522         return array_keys($this->requested_attributes);
523     }
524
525     /**
526      * Is the given type URI present in this fetch_request?
527      */
528     function contains($type_uri)
529     {
530         return in_array($type_uri, $this->iterTypes());
531     }
532 }
533
534 /**
535  * An abstract class that implements a message that has attribute keys
536  * and values. It contains the common code between fetch_response and
537  * store_request.
538  *
539  * @package OpenID
540  */
541 class Auth_OpenID_AX_KeyValueMessage extends Auth_OpenID_AX_Message {
542
543     function Auth_OpenID_AX_KeyValueMessage()
544     {
545         $this->data = array();
546     }
547
548     /**
549      * Add a single value for the given attribute type to the
550      * message. If there are already values specified for this type,
551      * this value will be sent in addition to the values already
552      * specified.
553      *
554      * @param type_uri: The URI for the attribute
555      * @param value: The value to add to the response to the relying
556      * party for this attribute
557      * @return null
558      */
559     function addValue($type_uri, $value)
560     {
561         if (!array_key_exists($type_uri, $this->data)) {
562             $this->data[$type_uri] = array();
563         }
564
565         $values =& $this->data[$type_uri];
566         $values[] = $value;
567     }
568
569     /**
570      * Set the values for the given attribute type. This replaces any
571      * values that have already been set for this attribute.
572      *
573      * @param type_uri: The URI for the attribute
574      * @param values: A list of values to send for this attribute.
575      */
576     function setValues($type_uri, &$values)
577     {
578         $this->data[$type_uri] =& $values;
579     }
580
581     /**
582      * Get the extension arguments for the key/value pairs contained
583      * in this message.
584      *
585      * @param aliases: An alias mapping. Set to None if you don't care
586      * about the aliases for this request.
587      *
588      * @access private
589      */
590     function _getExtensionKVArgs($aliases)
591     {
592         if ($aliases === null) {
593             $aliases = new Auth_OpenID_NamespaceMap();
594         }
595
596         $ax_args = array();
597
598         foreach ($this->data as $type_uri => $values) {
599             $alias = $aliases->add($type_uri);
600
601             $ax_args['type.' . $alias] = $type_uri;
602             $ax_args['count.' . $alias] = strval(count($values));
603
604             foreach ($values as $i => $value) {
605               $key = sprintf('value.%s.%d', $alias, $i + 1);
606               $ax_args[$key] = $value;
607             }
608         }
609
610         return $ax_args;
611     }
612
613     /**
614      * Parse attribute exchange key/value arguments into this object.
615      *
616      * @param ax_args: The attribute exchange fetch_response
617      * arguments, with namespacing removed.
618      *
619      * @return Auth_OpenID_AX_Error or true
620      */
621     function parseExtensionArgs($ax_args)
622     {
623         $result = $this->_checkMode($ax_args);
624         if (Auth_OpenID_AX::isError($result)) {
625             return $result;
626         }
627
628         $aliases = new Auth_OpenID_NamespaceMap();
629
630         foreach ($ax_args as $key => $value) {
631             if (strpos($key, 'type.') === 0) {
632                 $type_uri = $value;
633                 $alias = substr($key, 5);
634
635                 $result = Auth_OpenID_AX_checkAlias($alias);
636
637                 if (Auth_OpenID_AX::isError($result)) {
638                     return $result;
639                 }
640
641                 $alias = $aliases->addAlias($type_uri, $alias);
642
643                 if ($alias === null) {
644                     return new Auth_OpenID_AX_Error(
645                       sprintf("Could not add alias %s for URI %s",
646                               $alias, $type_uri)
647                       );
648                 }
649             }
650         }
651
652         foreach ($aliases->iteritems() as $pair) {
653             list($type_uri, $alias) = $pair;
654
655             if (array_key_exists('count.' . $alias, $ax_args) && ($ax_args['count.' . $alias] !== Auth_OpenID_AX_UNLIMITED_VALUES)) {
656
657                 $count_key = 'count.' . $alias;
658                 $count_s = $ax_args[$count_key];
659
660                 $count = Auth_OpenID::intval($count_s);
661
662                 if ($count === false) {
663                     return new Auth_OpenID_AX_Error(
664                       sprintf("Integer value expected for %s, got %s",
665                               'count. %s' . $alias, $count_s,
666                               Auth_OpenID_AX_UNLIMITED_VALUES)
667                                                     );
668                 }
669
670                 $values = array();
671                 for ($i = 1; $i < $count + 1; $i++) {
672                     $value_key = sprintf('value.%s.%d', $alias, $i);
673
674                     if (!array_key_exists($value_key, $ax_args)) {
675                       return new Auth_OpenID_AX_Error(
676                         sprintf(
677                                 "No value found for key %s",
678                                 $value_key));
679                     }
680
681                     $value = $ax_args[$value_key];
682                     $values[] = $value;
683                 }
684             } else {
685                 $key = 'value.' . $alias;
686
687                 if (!array_key_exists($key, $ax_args)) {
688                   return new Auth_OpenID_AX_Error(
689                     sprintf(
690                             "No value found for key %s",
691                             $key));
692                 }
693
694                 $value = $ax_args['value.' . $alias];
695
696                 if ($value == '') {
697                     $values = array();
698                 } else {
699                     $values = array($value);
700                 }
701             }
702
703             $this->data[$type_uri] = $values;
704         }
705
706         return true;
707     }
708
709     /**
710      * Get a single value for an attribute. If no value was sent for
711      * this attribute, use the supplied default. If there is more than
712      * one value for this attribute, this method will fail.
713      *
714      * @param type_uri: The URI for the attribute
715      * @param default: The value to return if the attribute was not
716      * sent in the fetch_response.
717      *
718      * @return $value Auth_OpenID_AX_Error on failure or the value of
719      * the attribute in the fetch_response message, or the default
720      * supplied
721      */
722     function getSingle($type_uri, $default=null)
723     {
724         $values = Auth_OpenID::arrayGet($this->data, $type_uri);
725         if (!$values) {
726             return $default;
727         } else if (count($values) == 1) {
728             return $values[0];
729         } else {
730             return new Auth_OpenID_AX_Error(
731               sprintf('More than one value present for %s',
732                       $type_uri)
733               );
734         }
735     }
736
737     /**
738      * Get the list of values for this attribute in the
739      * fetch_response.
740      *
741      * XXX: what to do if the values are not present? default
742      * parameter? this is funny because it's always supposed to return
743      * a list, so the default may break that, though it's provided by
744      * the user's code, so it might be okay. If no default is
745      * supplied, should the return be None or []?
746      *
747      * @param type_uri: The URI of the attribute
748      *
749      * @return $values The list of values for this attribute in the
750      * response. May be an empty list.  If the attribute was not sent
751      * in the response, returns Auth_OpenID_AX_Error.
752      */
753     function get($type_uri)
754     {
755         if (array_key_exists($type_uri, $this->data)) {
756             return $this->data[$type_uri];
757         } else {
758             return new Auth_OpenID_AX_Error(
759               sprintf("Type URI %s not found in response",
760                       $type_uri)
761               );
762         }
763     }
764
765     /**
766      * Get the number of responses for a particular attribute in this
767      * fetch_response message.
768      *
769      * @param type_uri: The URI of the attribute
770      *
771      * @returns int The number of values sent for this attribute.  If
772      * the attribute was not sent in the response, returns
773      * Auth_OpenID_AX_Error.
774      */
775     function count($type_uri)
776     {
777         if (array_key_exists($type_uri, $this->data)) {
778             return count($this->get($type_uri));
779         } else {
780             return new Auth_OpenID_AX_Error(
781               sprintf("Type URI %s not found in response",
782                       $type_uri)
783               );
784         }
785     }
786 }
787
788 /**
789  * A fetch_response attribute exchange message.
790  *
791  * @package OpenID
792  */
793 class Auth_OpenID_AX_FetchResponse extends Auth_OpenID_AX_KeyValueMessage {
794     var $mode = 'fetch_response';
795
796     function Auth_OpenID_AX_FetchResponse($update_url=null)
797     {
798         $this->Auth_OpenID_AX_KeyValueMessage();
799         $this->update_url = $update_url;
800     }
801
802     /**
803      * Serialize this object into arguments in the attribute exchange
804      * namespace
805      *
806      * @return $args The dictionary of unqualified attribute exchange
807      * arguments that represent this fetch_response, or
808      * Auth_OpenID_AX_Error on error.
809      */
810     function getExtensionArgs($request=null)
811     {
812         $aliases = new Auth_OpenID_NamespaceMap();
813
814         $zero_value_types = array();
815
816         if ($request !== null) {
817             // Validate the data in the context of the request (the
818             // same attributes should be present in each, and the
819             // counts in the response must be no more than the counts
820             // in the request)
821
822             foreach ($this->data as $type_uri => $unused) {
823                 if (!$request->contains($type_uri)) {
824                     return new Auth_OpenID_AX_Error(
825                       sprintf("Response attribute not present in request: %s",
826                               $type_uri)
827                       );
828                 }
829             }
830
831             foreach ($request->iterAttrs() as $attr_info) {
832                 // Copy the aliases from the request so that reading
833                 // the response in light of the request is easier
834                 if ($attr_info->alias === null) {
835                     $aliases->add($attr_info->type_uri);
836                 } else {
837                     $alias = $aliases->addAlias($attr_info->type_uri,
838                                                 $attr_info->alias);
839
840                     if ($alias === null) {
841                         return new Auth_OpenID_AX_Error(
842                           sprintf("Could not add alias %s for URI %s",
843                                   $attr_info->alias, $attr_info->type_uri)
844                           );
845                     }
846                 }
847
848                 if (array_key_exists($attr_info->type_uri, $this->data)) {
849                     $values = $this->data[$attr_info->type_uri];
850                 } else {
851                     $values = array();
852                     $zero_value_types[] = $attr_info;
853                 }
854
855                 if (($attr_info->count != Auth_OpenID_AX_UNLIMITED_VALUES) &&
856                     ($attr_info->count < count($values))) {
857                     return new Auth_OpenID_AX_Error(
858                       sprintf("More than the number of requested values " .
859                               "were specified for %s",
860                               $attr_info->type_uri)
861                       );
862                 }
863             }
864         }
865
866         $kv_args = $this->_getExtensionKVArgs($aliases);
867
868         // Add the KV args into the response with the args that are
869         // unique to the fetch_response
870         $ax_args = $this->_newArgs();
871
872         // For each requested attribute, put its type/alias and count
873         // into the response even if no data were returned.
874         foreach ($zero_value_types as $attr_info) {
875             $alias = $aliases->getAlias($attr_info->type_uri);
876             $kv_args['type.' . $alias] = $attr_info->type_uri;
877             $kv_args['count.' . $alias] = '0';
878         }
879
880         $update_url = null;
881         if ($request) {
882             $update_url = $request->update_url;
883         } else {
884             $update_url = $this->update_url;
885         }
886
887         if ($update_url) {
888             $ax_args['update_url'] = $update_url;
889         }
890
891         Auth_OpenID::update($ax_args, $kv_args);
892
893         return $ax_args;
894     }
895
896     /**
897      * @return $result Auth_OpenID_AX_Error on failure or true on
898      * success.
899      */
900     function parseExtensionArgs($ax_args)
901     {
902         $result = parent::parseExtensionArgs($ax_args);
903
904         if (Auth_OpenID_AX::isError($result)) {
905             return $result;
906         }
907
908         $this->update_url = Auth_OpenID::arrayGet($ax_args, 'update_url');
909
910         return true;
911     }
912
913     /**
914      * Construct a FetchResponse object from an OpenID library
915      * SuccessResponse object.
916      *
917      * @param success_response: A successful id_res response object
918      *
919      * @param signed: Whether non-signed args should be processsed. If
920      * True (the default), only signed arguments will be processsed.
921      *
922      * @return $response A FetchResponse containing the data from the
923      * OpenID message
924      */
925     static function fromSuccessResponse($success_response, $signed=true)
926     {
927         $obj = new Auth_OpenID_AX_FetchResponse();
928         if ($signed) {
929             $ax_args = $success_response->getSignedNS($obj->ns_uri);
930         } else {
931             $ax_args = $success_response->message->getArgs($obj->ns_uri);
932         }
933         if ($ax_args === null || Auth_OpenID::isFailure($ax_args) ||
934               sizeof($ax_args) == 0) {
935             return null;
936         }
937
938         $result = $obj->parseExtensionArgs($ax_args);
939         if (Auth_OpenID_AX::isError($result)) {
940             #XXX log me
941             return null;
942         }
943         return $obj;
944     }
945 }
946
947 /**
948  * A store request attribute exchange message representation.
949  *
950  * @package OpenID
951  */
952 class Auth_OpenID_AX_StoreRequest extends Auth_OpenID_AX_KeyValueMessage {
953     var $mode = 'store_request';
954
955     /**
956      * @param array $aliases The namespace aliases to use when making
957      * this store response. Leave as None to use defaults.
958      */
959     function getExtensionArgs($aliases=null)
960     {
961         $ax_args = $this->_newArgs();
962         $kv_args = $this->_getExtensionKVArgs($aliases);
963         Auth_OpenID::update($ax_args, $kv_args);
964         return $ax_args;
965     }
966 }
967
968 /**
969  * An indication that the store request was processed along with this
970  * OpenID transaction.  Use make(), NOT the constructor, to create
971  * response objects.
972  *
973  * @package OpenID
974  */
975 class Auth_OpenID_AX_StoreResponse extends Auth_OpenID_AX_Message {
976     var $SUCCESS_MODE = 'store_response_success';
977     var $FAILURE_MODE = 'store_response_failure';
978
979     /**
980      * Returns Auth_OpenID_AX_Error on error or an
981      * Auth_OpenID_AX_StoreResponse object on success.
982      */
983     function make($succeeded=true, $error_message=null)
984     {
985         if (($succeeded) && ($error_message !== null)) {
986             return new Auth_OpenID_AX_Error('An error message may only be '.
987                                     'included in a failing fetch response');
988         }
989
990         return new Auth_OpenID_AX_StoreResponse($succeeded, $error_message);
991     }
992
993     function Auth_OpenID_AX_StoreResponse($succeeded=true, $error_message=null)
994     {
995         if ($succeeded) {
996             $this->mode = $this->SUCCESS_MODE;
997         } else {
998             $this->mode = $this->FAILURE_MODE;
999         }
1000
1001         $this->error_message = $error_message;
1002     }
1003
1004     /**
1005      * Was this response a success response?
1006      */
1007     function succeeded()
1008     {
1009         return $this->mode == $this->SUCCESS_MODE;
1010     }
1011
1012     function getExtensionArgs()
1013     {
1014         $ax_args = $this->_newArgs();
1015         if ((!$this->succeeded()) && $this->error_message) {
1016             $ax_args['error'] = $this->error_message;
1017         }
1018
1019         return $ax_args;
1020     }
1021 }
1022