OpenID.php

Go to the documentation of this file.

<?php
 
define('Auth_OpenID_VERSION', '2.2.2');
 
require_once "Auth/Yadis/PlainHTTPFetcher.php";
require_once "Auth/Yadis/ParanoidHTTPFetcher.php";
require_once "Auth/OpenID/BigMath.php";
require_once "Auth/OpenID/URINorm.php";
 
define('Auth_OpenID_LOCAL_ERROR', 'local_error');
 
define('Auth_OpenID_REMOTE_ERROR', 'remote_error');
 
define('Auth_OpenID_REMOTE_OK', 'remote_ok');
 
define('Auth_OpenID_REDIRECT', 'redirect');
 
define('Auth_OpenID_DO_AUTH', 'do_auth');
 
define('Auth_OpenID_DO_ABOUT', 'do_about');
 
define('Auth_OpenID_letters',
       "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
define('Auth_OpenID_digits',
       "0123456789");
 
define('Auth_OpenID_punct',
       "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~");
 
Auth_OpenID_include_init();
 
class Auth_OpenID {
 
    static function isFailure($thing)
    {
        return is_a($thing, 'Auth_OpenID_FailureResponse');
    }
 
    static function getQuery($query_str=null)
    {
        $data = array();
 
        if ($query_str !== null) {
            $data = Auth_OpenID::params_from_string($query_str);
        } else if (!array_key_exists('REQUEST_METHOD', $_SERVER)) {
            // Do nothing.
        } else {
          // XXX HACK FIXME HORRIBLE.
          //
          // POSTing to a URL with query parameters is acceptable, but
          // we don't have a clean way to distinguish those parameters
          // when we need to do things like return_to verification
          // which only want to look at one kind of parameter.  We're
          // going to emulate the behavior of some other environments
          // by defaulting to GET and overwriting with POST if POST
          // data is available.
          $data = Auth_OpenID::params_from_string($_SERVER['QUERY_STRING']);
 
          if ($_SERVER['REQUEST_METHOD'] == 'POST') {
            $str = file_get_contents('php://input');
 
            if ($str === false) {
              $post = array();
            } else {
              $post = Auth_OpenID::params_from_string($str);
            }
 
            $data = array_merge($data, $post);
          }
        }
 
        return $data;
    }
 
    static function params_from_string($str)
    {
        $chunks = explode("&", $str);
 
        $data = array();
        foreach ($chunks as $chunk) {
            $parts = explode("=", $chunk, 2);
 
            if (count($parts) != 2) {
                continue;
            }
 
            list($k, $v) = $parts;
            $data[urldecode($k)] = urldecode($v);
        }
 
        return $data;
    }
 
    static function ensureDir($dir_name)
    {
        if (is_dir($dir_name) || @mkdir($dir_name)) {
            return true;
        } else {
            $parent_dir = dirname($dir_name);
 
            // Terminal case; there is no parent directory to create.
            if ($parent_dir == $dir_name) {
                return true;
            }
 
            return (Auth_OpenID::ensureDir($parent_dir) && @mkdir($dir_name));
        }
    }
 
    static function addPrefix($values, $prefix)
    {
        $new_values = array();
        foreach ($values as $s) {
            $new_values[] = $prefix . $s;
        }
        return $new_values;
    }
 
    static function arrayGet($arr, $key, $fallback = null)
    {
        if (is_array($arr)) {
            if (array_key_exists($key, $arr)) {
                return $arr[$key];
            } else {
                return $fallback;
            }
        } else {
            trigger_error("Auth_OpenID::arrayGet (key = ".$key.") expected " .
                          "array as first parameter, got " .
                          gettype($arr), E_USER_WARNING);
 
            return false;
        }
    }
 
    static function parse_str($query)
    {
        if ($query === null) {
            return null;
        }
 
        $parts = explode('&', $query);
 
        $new_parts = array();
        for ($i = 0; $i < count($parts); $i++) {
            $pair = explode('=', $parts[$i]);
 
            if (count($pair) != 2) {
                continue;
            }
 
            list($key, $value) = $pair;
            $new_parts[urldecode($key)] = urldecode($value);
        }
 
        return $new_parts;
    }
 
    static function httpBuildQuery($data)
    {
        $pairs = array();
        foreach ($data as $key => $value) {
            if (is_array($value)) {
                $pairs[] = urlencode($value[0])."=".urlencode($value[1]);
            } else {
                $pairs[] = urlencode($key)."=".urlencode($value);
            }
        }
        return implode("&", $pairs);
    }
 
    static function appendArgs($url, $args)
    {
        if (count($args) == 0) {
            return $url;
        }
 
        // Non-empty array; if it is an array of arrays, use
        // multisort; otherwise use sort.
        if (array_key_exists(0, $args) &&
            is_array($args[0])) {
            // Do nothing here.
        } else {
            $keys = array_keys($args);
            sort($keys);
            $new_args = array();
            foreach ($keys as $key) {
                $new_args[] = array($key, $args[$key]);
            }
            $args = $new_args;
        }
 
        $sep = '?';
        if (strpos($url, '?') !== false) {
            $sep = '&';
        }
 
        return $url . $sep . Auth_OpenID::httpBuildQuery($args);
    }
 
    static function urlunparse($scheme, $host, $port = null, $path = '/',
                        $query = '', $fragment = '')
    {
 
        if (!$scheme) {
            $scheme = 'http';
        }
 
        if (!$host) {
            return false;
        }
 
        if (!$path) {
            $path = '';
        }
 
        $result = $scheme . "://" . $host;
 
        if ($port) {
            $result .= ":" . $port;
        }
 
        $result .= $path;
 
        if ($query) {
            $result .= "?" . $query;
        }
 
        if ($fragment) {
            $result .= "#" . $fragment;
        }
 
        return $result;
    }
 
    static function normalizeUrl($url)
    {
        @$parsed = parse_url($url);
 
        if (!$parsed) {
            return null;
        }
 
        if (isset($parsed['scheme']) &&
            isset($parsed['host'])) {
            $scheme = strtolower($parsed['scheme']);
            if (!in_array($scheme, array('http', 'https'))) {
                return null;
            }
        } else {
            $url = 'http://' . $url;
        }
 
        $normalized = Auth_OpenID_urinorm($url);
        if ($normalized === null) {
            return null;
        }
        list($defragged, $frag) = Auth_OpenID::urldefrag($normalized);
        return $defragged;
    }
 
    static function intval($value)
    {
        $re = "/^\\d+$/";
 
        if (!preg_match($re, $value)) {
            return false;
        }
 
        return intval($value);
    }
 
    static function bytes($str)
    {
        return strlen(bin2hex($str)) / 2;
    }
 
    static function toBytes($str)
    {
        $hex = bin2hex($str);
 
        if (!$hex) {
            return array();
        }
 
        $b = array();
        for ($i = 0; $i < strlen($hex); $i += 2) {
            $b[] = chr(base_convert(substr($hex, $i, 2), 16, 10));
        }
 
        return $b;
    }
 
    static function urldefrag($url)
    {
        $parts = explode("#", $url, 2);
 
        if (count($parts) == 1) {
            return array($parts[0], "");
        } else {
            return $parts;
        }
    }
 
    static function filter($callback, &$sequence)
    {
        $result = array();
 
        foreach ($sequence as $item) {
            if (call_user_func_array($callback, array($item))) {
                $result[] = $item;
            }
        }
 
        return $result;
    }
 
    static function update(&$dest, &$src)
    {
        foreach ($src as $k => $v) {
            $dest[$k] = $v;
        }
    }
 
    static function log($format_string)
    {
        $args = func_get_args();
        $message = call_user_func_array('sprintf', $args);
        error_log($message);
    }
 
    static function autoSubmitHTML($form, $title="OpenId transaction in progress")
    {
        return("<html>".
               "<head><title>".
               $title .
               "</title></head>".
               "<body onload='document.forms[0].submit();'>".
               $form .
               "<script>".
               "var elements = document.forms[0].elements;".
               "for (var i = 0; i < elements.length; i++) {".
               "  elements[i].style.display = \"none\";".
               "}".
               "</script>".
               "</body>".
               "</html>");
    }
}
 
/*
 * Function to run when this file is included.
 * Abstracted to a function to make life easier
 * for some PHP optimizers.
 */
function Auth_OpenID_include_init() {
  if (Auth_OpenID_getMathLib() === null) {
    Auth_OpenID_setNoMathSupport();
  }
}