Update positioning in contact page
[living-lab-site.git] / application / libraries / Auth / OpenID.php
1 <?php
2
3 /**
4  * This is the PHP OpenID library by JanRain, Inc.
5  *
6  * This module contains core utility functionality used by the
7  * library.  See Consumer.php and Server.php for the consumer and
8  * server implementations.
9  *
10  * PHP versions 4 and 5
11  *
12  * LICENSE: See the COPYING file included in this distribution.
13  *
14  * @package OpenID
15  * @author JanRain, Inc. <openid@janrain.com>
16  * @copyright 2005-2008 Janrain, Inc.
17  * @license http://www.apache.org/licenses/LICENSE-2.0 Apache
18  */
19
20 /**
21  * The library version string
22  */
23 define('Auth_OpenID_VERSION', '2.2.2');
24
25 /**
26  * Require the fetcher code.
27  */
28 require_once "Auth/Yadis/PlainHTTPFetcher.php";
29 require_once "Auth/Yadis/ParanoidHTTPFetcher.php";
30 require_once "Auth/OpenID/BigMath.php";
31 require_once "Auth/OpenID/URINorm.php";
32
33 /**
34  * Status code returned by the server when the only option is to show
35  * an error page, since we do not have enough information to redirect
36  * back to the consumer. The associated value is an error message that
37  * should be displayed on an HTML error page.
38  *
39  * @see Auth_OpenID_Server
40  */
41 define('Auth_OpenID_LOCAL_ERROR', 'local_error');
42
43 /**
44  * Status code returned when there is an error to return in key-value
45  * form to the consumer. The caller should return a 400 Bad Request
46  * response with content-type text/plain and the value as the body.
47  *
48  * @see Auth_OpenID_Server
49  */
50 define('Auth_OpenID_REMOTE_ERROR', 'remote_error');
51
52 /**
53  * Status code returned when there is a key-value form OK response to
54  * the consumer. The value associated with this code is the
55  * response. The caller should return a 200 OK response with
56  * content-type text/plain and the value as the body.
57  *
58  * @see Auth_OpenID_Server
59  */
60 define('Auth_OpenID_REMOTE_OK', 'remote_ok');
61
62 /**
63  * Status code returned when there is a redirect back to the
64  * consumer. The value is the URL to redirect back to. The caller
65  * should return a 302 Found redirect with a Location: header
66  * containing the URL.
67  *
68  * @see Auth_OpenID_Server
69  */
70 define('Auth_OpenID_REDIRECT', 'redirect');
71
72 /**
73  * Status code returned when the caller needs to authenticate the
74  * user. The associated value is a {@link Auth_OpenID_ServerRequest}
75  * object that can be used to complete the authentication. If the user
76  * has taken some authentication action, use the retry() method of the
77  * {@link Auth_OpenID_ServerRequest} object to complete the request.
78  *
79  * @see Auth_OpenID_Server
80  */
81 define('Auth_OpenID_DO_AUTH', 'do_auth');
82
83 /**
84  * Status code returned when there were no OpenID arguments
85  * passed. This code indicates that the caller should return a 200 OK
86  * response and display an HTML page that says that this is an OpenID
87  * server endpoint.
88  *
89  * @see Auth_OpenID_Server
90  */
91 define('Auth_OpenID_DO_ABOUT', 'do_about');
92
93 /**
94  * Defines for regexes and format checking.
95  */
96 define('Auth_OpenID_letters',
97        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
98
99 define('Auth_OpenID_digits',
100        "0123456789");
101
102 define('Auth_OpenID_punct',
103        "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~");
104
105 Auth_OpenID_include_init();
106
107 /**
108  * The OpenID utility function class.
109  *
110  * @package OpenID
111  * @access private
112  */
113 class Auth_OpenID {
114
115     /**
116      * Return true if $thing is an Auth_OpenID_FailureResponse object;
117      * false if not.
118      *
119      * @access private
120      */
121     static function isFailure($thing)
122     {
123                 return is_a($thing, 'Auth_OpenID_FailureResponse');
124     }
125
126     /**
127      * Gets the query data from the server environment based on the
128      * request method used.  If GET was used, this looks at
129      * $_SERVER['QUERY_STRING'] directly.  If POST was used, this
130      * fetches data from the special php://input file stream.
131      *
132      * Returns an associative array of the query arguments.
133      *
134      * Skips invalid key/value pairs (i.e. keys with no '=value'
135      * portion).
136      *
137      * Returns an empty array if neither GET nor POST was used, or if
138      * POST was used but php://input cannot be opened.
139      *
140      * See background:
141      * http://lists.openidenabled.com/pipermail/dev/2007-March/000395.html
142      *
143      * @access private
144      */
145     static function getQuery($query_str=null)
146     {
147         $data = array();
148
149         if ($query_str !== null) {
150             $data = Auth_OpenID::params_from_string($query_str);
151         } else if (!array_key_exists('REQUEST_METHOD', $_SERVER)) {
152             // Do nothing.
153         } else {
154           // XXX HACK FIXME HORRIBLE.
155           //
156           // POSTing to a URL with query parameters is acceptable, but
157           // we don't have a clean way to distinguish those parameters
158           // when we need to do things like return_to verification
159           // which only want to look at one kind of parameter.  We're
160           // going to emulate the behavior of some other environments
161           // by defaulting to GET and overwriting with POST if POST
162           // data is available.
163           $data = Auth_OpenID::params_from_string($_SERVER['QUERY_STRING']);
164
165           if ($_SERVER['REQUEST_METHOD'] == 'POST') {
166             $str = file_get_contents('php://input');
167
168             if ($str === false) {
169               $post = array();
170             } else {
171               $post = Auth_OpenID::params_from_string($str);
172             }
173
174             $data = array_merge($data, $post);
175           }
176         }
177
178         return $data;
179     }
180
181     static function params_from_string($str)
182     {
183         $chunks = explode("&", $str);
184
185         $data = array();
186         foreach ($chunks as $chunk) {
187             $parts = explode("=", $chunk, 2);
188
189             if (count($parts) != 2) {
190                 continue;
191             }
192
193             list($k, $v) = $parts;
194             $data[urldecode($k)] = urldecode($v);
195         }
196
197         return $data;
198     }
199
200     /**
201      * Create dir_name as a directory if it does not exist. If it
202      * exists, make sure that it is, in fact, a directory.  Returns
203      * true if the operation succeeded; false if not.
204      *
205      * @access private
206      */
207     static function ensureDir($dir_name)
208     {
209         if (is_dir($dir_name) || @mkdir($dir_name)) {
210             return true;
211         } else {
212             $parent_dir = dirname($dir_name);
213
214             // Terminal case; there is no parent directory to create.
215             if ($parent_dir == $dir_name) {
216                 return true;
217             }
218
219             return (Auth_OpenID::ensureDir($parent_dir) && @mkdir($dir_name));
220         }
221     }
222
223     /**
224      * Adds a string prefix to all values of an array.  Returns a new
225      * array containing the prefixed values.
226      *
227      * @access private
228      */
229     static function addPrefix($values, $prefix)
230     {
231         $new_values = array();
232         foreach ($values as $s) {
233             $new_values[] = $prefix . $s;
234         }
235         return $new_values;
236     }
237
238     /**
239      * Convenience function for getting array values.  Given an array
240      * $arr and a key $key, get the corresponding value from the array
241      * or return $default if the key is absent.
242      *
243      * @access private
244      */
245     static function arrayGet($arr, $key, $fallback = null)
246     {
247         if (is_array($arr)) {
248             if (array_key_exists($key, $arr)) {
249                 return $arr[$key];
250             } else {
251                 return $fallback;
252             }
253         } else {
254             trigger_error("Auth_OpenID::arrayGet (key = ".$key.") expected " .
255                           "array as first parameter, got " .
256                           gettype($arr), E_USER_WARNING);
257
258             return false;
259         }
260     }
261
262     /**
263      * Replacement for PHP's broken parse_str.
264      */
265     static function parse_str($query)
266     {
267         if ($query === null) {
268             return null;
269         }
270
271         $parts = explode('&', $query);
272
273         $new_parts = array();
274         for ($i = 0; $i < count($parts); $i++) {
275             $pair = explode('=', $parts[$i]);
276
277             if (count($pair) != 2) {
278                 continue;
279             }
280
281             list($key, $value) = $pair;
282             $new_parts[urldecode($key)] = urldecode($value);
283         }
284
285         return $new_parts;
286     }
287
288     /**
289      * Implements the PHP 5 'http_build_query' functionality.
290      *
291      * @access private
292      * @param array $data Either an array key/value pairs or an array
293      * of arrays, each of which holding two values: a key and a value,
294      * sequentially.
295      * @return string $result The result of url-encoding the key/value
296      * pairs from $data into a URL query string
297      * (e.g. "username=bob&id=56").
298      */
299     static function httpBuildQuery($data)
300     {
301         $pairs = array();
302         foreach ($data as $key => $value) {
303             if (is_array($value)) {
304                 $pairs[] = urlencode($value[0])."=".urlencode($value[1]);
305             } else {
306                 $pairs[] = urlencode($key)."=".urlencode($value);
307             }
308         }
309         return implode("&", $pairs);
310     }
311
312     /**
313      * "Appends" query arguments onto a URL.  The URL may or may not
314      * already have arguments (following a question mark).
315      *
316      * @access private
317      * @param string $url A URL, which may or may not already have
318      * arguments.
319      * @param array $args Either an array key/value pairs or an array of
320      * arrays, each of which holding two values: a key and a value,
321      * sequentially.  If $args is an ordinary key/value array, the
322      * parameters will be added to the URL in sorted alphabetical order;
323      * if $args is an array of arrays, their order will be preserved.
324      * @return string $url The original URL with the new parameters added.
325      *
326      */
327     static function appendArgs($url, $args)
328     {
329         if (count($args) == 0) {
330             return $url;
331         }
332
333         // Non-empty array; if it is an array of arrays, use
334         // multisort; otherwise use sort.
335         if (array_key_exists(0, $args) &&
336             is_array($args[0])) {
337             // Do nothing here.
338         } else {
339             $keys = array_keys($args);
340             sort($keys);
341             $new_args = array();
342             foreach ($keys as $key) {
343                 $new_args[] = array($key, $args[$key]);
344             }
345             $args = $new_args;
346         }
347
348         $sep = '?';
349         if (strpos($url, '?') !== false) {
350             $sep = '&';
351         }
352
353         return $url . $sep . Auth_OpenID::httpBuildQuery($args);
354                 // Added by Calin-Andrei Burloiu.
355 //        return $url .'/'. $sep . Auth_OpenID::httpBuildQuery($args);
356     }
357
358     /**
359      * Implements python's urlunparse, which is not available in PHP.
360      * Given the specified components of a URL, this function rebuilds
361      * and returns the URL.
362      *
363      * @access private
364      * @param string $scheme The scheme (e.g. 'http').  Defaults to 'http'.
365      * @param string $host The host.  Required.
366      * @param string $port The port.
367      * @param string $path The path.
368      * @param string $query The query.
369      * @param string $fragment The fragment.
370      * @return string $url The URL resulting from assembling the
371      * specified components.
372      */
373     static function urlunparse($scheme, $host, $port = null, $path = '/',
374                         $query = '', $fragment = '')
375     {
376
377         if (!$scheme) {
378             $scheme = 'http';
379         }
380
381         if (!$host) {
382             return false;
383         }
384
385         if (!$path) {
386             $path = '';
387         }
388
389         $result = $scheme . "://" . $host;
390
391         if ($port) {
392             $result .= ":" . $port;
393         }
394
395         $result .= $path;
396
397         if ($query) {
398             $result .= "?" . $query;
399         }
400
401         if ($fragment) {
402             $result .= "#" . $fragment;
403         }
404
405         return $result;
406     }
407
408     /**
409      * Given a URL, this "normalizes" it by adding a trailing slash
410      * and / or a leading http:// scheme where necessary.  Returns
411      * null if the original URL is malformed and cannot be normalized.
412      *
413      * @access private
414      * @param string $url The URL to be normalized.
415      * @return mixed $new_url The URL after normalization, or null if
416      * $url was malformed.
417      */
418     static function normalizeUrl($url)
419     {
420         @$parsed = parse_url($url);
421
422         if (!$parsed) {
423             return null;
424         }
425
426         if (isset($parsed['scheme']) &&
427             isset($parsed['host'])) {
428             $scheme = strtolower($parsed['scheme']);
429             if (!in_array($scheme, array('http', 'https'))) {
430                 return null;
431             }
432         } else {
433             $url = 'http://' . $url;
434         }
435
436         $normalized = Auth_OpenID_urinorm($url);
437         if ($normalized === null) {
438             return null;
439         }
440         list($defragged, $frag) = Auth_OpenID::urldefrag($normalized);
441         return $defragged;
442     }
443
444     /**
445      * Replacement (wrapper) for PHP's intval() because it's broken.
446      *
447      * @access private
448      */
449     static function intval($value)
450     {
451         $re = "/^\\d+$/";
452
453         if (!preg_match($re, $value)) {
454             return false;
455         }
456
457         return intval($value);
458     }
459
460     /**
461      * Count the number of bytes in a string independently of
462      * multibyte support conditions.
463      *
464      * @param string $str The string of bytes to count.
465      * @return int The number of bytes in $str.
466      */
467     static function bytes($str)
468     {
469         return strlen(bin2hex($str)) / 2;
470     }
471
472     /**
473      * Get the bytes in a string independently of multibyte support
474      * conditions.
475      */
476     static function toBytes($str)
477     {
478         $hex = bin2hex($str);
479
480         if (!$hex) {
481             return array();
482         }
483
484         $b = array();
485         for ($i = 0; $i < strlen($hex); $i += 2) {
486             $b[] = chr(base_convert(substr($hex, $i, 2), 16, 10));
487         }
488
489         return $b;
490     }
491
492     static function urldefrag($url)
493     {
494         $parts = explode("#", $url, 2);
495
496         if (count($parts) == 1) {
497             return array($parts[0], "");
498         } else {
499             return $parts;
500         }
501     }
502
503     static function filter($callback, &$sequence)
504     {
505         $result = array();
506
507         foreach ($sequence as $item) {
508             if (call_user_func_array($callback, array($item))) {
509                 $result[] = $item;
510             }
511         }
512
513         return $result;
514     }
515
516     static function update(&$dest, &$src)
517     {
518         foreach ($src as $k => $v) {
519             $dest[$k] = $v;
520         }
521     }
522
523     /**
524      * Wrap PHP's standard error_log functionality.  Use this to
525      * perform all logging. It will interpolate any additional
526      * arguments into the format string before logging.
527      *
528      * @param string $format_string The sprintf format for the message
529      */
530     static function log($format_string)
531     {
532         $args = func_get_args();
533         $message = call_user_func_array('sprintf', $args);
534         error_log($message);
535     }
536
537     static function autoSubmitHTML($form, $title="OpenId transaction in progress")
538     {
539         return("<html>".
540                "<head><title>".
541                $title .
542                "</title></head>".
543                "<body onload='document.forms[0].submit();'>".
544                $form .
545                "<script>".
546                "var elements = document.forms[0].elements;".
547                "for (var i = 0; i < elements.length; i++) {".
548                "  elements[i].style.display = \"none\";".
549                "}".
550                "</script>".
551                "</body>".
552                "</html>");
553     }
554 }
555
556 /*
557  * Function to run when this file is included.
558  * Abstracted to a function to make life easier
559  * for some PHP optimizers.
560  */
561 function Auth_OpenID_include_init() {
562   if (Auth_OpenID_getMathLib() === null) {
563     Auth_OpenID_setNoMathSupport();
564   }
565 }