Class yii\authclient\OpenId

                public function buildAuthUrl($identifierSelect = null)
{
    $authUrl = $this->authUrl;
    $claimedId = $this->getClaimedId();
    if (empty($claimedId)) {
        $this->setClaimedId($authUrl);
    }
    $serverInfo = $this->discover($authUrl);
    if ($serverInfo['version'] == 2) {
        if ($identifierSelect !== null) {
            $serverInfo['identifier_select'] = $identifierSelect;
        }
        return $this->buildAuthUrlV2($serverInfo);
    }
    return $this->buildAuthUrlV1($serverInfo);
}

            

                protected function buildAuthUrlV1($serverInfo)
{
    $returnUrl = $this->getReturnUrl();
    /* If we have an openid.delegate that is different from our claimed id,
    we need to somehow preserve the claimed id between requests.
    The simplest way is to just send it along with the return_to url.*/
    if ($serverInfo['identity'] != $this->getClaimedId()) {
        $returnUrl .= (strpos($returnUrl, '?') ? '&' : '?') . 'openid.claimed_id=' . $this->getClaimedId();
    }
    $params = array_merge(
        [
            'openid.return_to' => $returnUrl,
            'openid.mode' => 'checkid_setup',
            'openid.identity' => $serverInfo['identity'],
            'openid.trust_root' => $this->trustRoot,
        ],
        $this->buildSregParams()
    );
    return $this->buildUrl($serverInfo['url'], ['query' => http_build_query($params, '', '&')]);
}

            

                protected function buildAuthUrlV2($serverInfo)
{
    $params = [
        'openid.ns' => 'http://specs.openid.net/auth/2.0',
        'openid.mode' => 'checkid_setup',
        'openid.return_to' => $this->getReturnUrl(),
        'openid.realm' => $this->getTrustRoot(),
    ];
    if ($serverInfo['ax']) {
        $params = array_merge($params, $this->buildAxParams());
    }
    if ($serverInfo['sreg']) {
        $params = array_merge($params, $this->buildSregParams());
    }
    if (!$serverInfo['ax'] && !$serverInfo['sreg']) {
        // If OP doesn't advertise either SREG, nor AX, let's send them both in worst case we don't get anything in return.
        $params = array_merge($this->buildSregParams(), $this->buildAxParams(), $params);
    }
    if ($serverInfo['identifier_select']) {
        $url = 'http://specs.openid.net/auth/2.0/identifier_select';
        $params['openid.identity'] = $url;
        $params['openid.claimed_id']= $url;
    } else {
        $params['openid.identity'] = $serverInfo['identity'];
        $params['openid.claimed_id'] = $this->getClaimedId();
    }
    return $this->buildUrl($serverInfo['url'], ['query' => http_build_query($params, '', '&')]);
}

            

                protected function buildAxParams()
{
    $params = [];
    if (!empty($this->requiredAttributes) || !empty($this->optionalAttributes)) {
        $params['openid.ns.ax'] = 'http://openid.net/srv/ax/1.0';
        $params['openid.ax.mode'] = 'fetch_request';
        $aliases = [];
        $counts = [];
        $requiredAttributes = [];
        $optionalAttributes = [];
        foreach (['requiredAttributes', 'optionalAttributes'] as $type) {
            foreach ($this->$type as $alias => $field) {
                if (is_int($alias)) {
                    $alias = strtr($field, '/', '_');
                }
                $aliases[$alias] = 'http://axschema.org/' . $field;
                if (empty($counts[$alias])) {
                    $counts[$alias] = 0;
                }
                $counts[$alias] += 1;
                ${$type}[] = $alias;
            }
        }
        foreach ($aliases as $alias => $ns) {
            $params['openid.ax.type.' . $alias] = $ns;
        }
        foreach ($counts as $alias => $count) {
            if ($count == 1) {
                continue;
            }
            $params['openid.ax.count.' . $alias] = $count;
        }
        // Don't send empty ax.required and ax.if_available.
        // Google and possibly other providers refuse to support ax when one of these is empty.
        if (!empty($requiredAttributes)) {
            $params['openid.ax.required'] = implode(',', $requiredAttributes);
        }
        if (!empty($optionalAttributes)) {
            $params['openid.ax.if_available'] = implode(',', $optionalAttributes);
        }
    }
    return $params;
}

            

                protected function buildSregParams()
{
    $params = [];
    /* We always use SREG 1.1, even if the server is advertising only support for 1.0.
    That's because it's fully backwards compatible with 1.0, and some providers
    advertise 1.0 even if they accept only 1.1. One such provider is myopenid.com */
    $params['openid.ns.sreg'] = 'http://openid.net/extensions/sreg/1.1';
    if (!empty($this->requiredAttributes)) {
        $params['openid.sreg.required'] = [];
        foreach ($this->requiredAttributes as $required) {
            if (!isset($this->axToSregMap[$required])) {
                continue;
            }
            $params['openid.sreg.required'][] = $this->axToSregMap[$required];
        }
        $params['openid.sreg.required'] = implode(',', $params['openid.sreg.required']);
    }
    if (!empty($this->optionalAttributes)) {
        $params['openid.sreg.optional'] = [];
        foreach ($this->optionalAttributes as $optional) {
            if (!isset($this->axToSregMap[$optional])) {
                continue;
            }
            $params['openid.sreg.optional'][] = $this->axToSregMap[$optional];
        }
        $params['openid.sreg.optional'] = implode(',', $params['openid.sreg.optional']);
    }
    return $params;
}

            

                protected function buildUrl($baseUrl, $additionalUrl)
{
    $baseUrl = parse_url($baseUrl);
    if (!is_array($additionalUrl)) {
        $additionalUrl = parse_url($additionalUrl);
    }
    if (isset($baseUrl['query'], $additionalUrl['query'])) {
        $additionalUrl['query'] = $baseUrl['query'] . '&' . $additionalUrl['query'];
    }
    $urlInfo = array_merge($baseUrl, $additionalUrl);
    $url = $urlInfo['scheme'] . '://'
        . (empty($urlInfo['username']) ? ''
            :(empty($urlInfo['password']) ? "{$urlInfo['username']}@"
                :"{$urlInfo['username']}:{$urlInfo['password']}@"))
        . $urlInfo['host']
        . (empty($urlInfo['port']) ? '' : ":{$urlInfo['port']}")
        . (empty($urlInfo['path']) ? '' : $urlInfo['path'])
        . (empty($urlInfo['query']) ? '' : "?{$urlInfo['query']}")
        . (empty($urlInfo['fragment']) ? '' : "#{$urlInfo['fragment']}");
    return $url;
}

            

                protected function compareUrl($expectedUrl, $actualUrl)
{
    $expectedUrlInfo = parse_url($expectedUrl);
    $actualUrlInfo = parse_url($actualUrl);
    foreach ($expectedUrlInfo as $name => $expectedValue) {
        if ($name == 'query') {
            parse_str($expectedValue, $expectedUrlParams);
            parse_str($actualUrlInfo[$name], $actualUrlParams);
            $paramsDiff = array_diff_assoc($expectedUrlParams, $actualUrlParams);
            if (!empty($paramsDiff)) {
                return false;
            }
        } elseif ($expectedValue != $actualUrlInfo[$name]) {
            return false;
        }
    }
    return true;
}

            

                protected function defaultRequestOptions()
{
    return [
        'userAgent' => Yii::$app->name . ' OpenID Client',
        'timeout' => 30,
        'followLocation' => true,
    ];
}

            

                protected function defaultReturnUrl()
{
    $params = Yii::$app->getRequest()->get();
    foreach ($params as $name => $value) {
        if (strncmp('openid', $name, 6) === 0) {
            unset($params[$name]);
        }
    }
    $params[0] = Yii::$app->requestedRoute;
    $url = Yii::$app->getUrlManager()->createUrl($params);
    return $this->getTrustRoot() . $url;
}

            

                public function discover($url)
{
    if (empty($url)) {
        throw new Exception('No identity supplied.');
    }
    $result = [
        'url' => null,
        'version' => null,
        'identity' => $url,
        'identifier_select' => false,
        'ax' => false,
        'sreg' => false,
    ];
    // Use xri.net proxy to resolve i-name identities
    if (!preg_match('#^https?:#', $url)) {
        $url = 'https://xri.net/' . $url;
    }
    /* We save the original url in case of Yadis discovery failure.
    It can happen when we'll be lead to an XRDS document
    which does not have any OpenID2 services.*/
    $originalUrl = $url;
    // A flag to disable yadis discovery in case of failure in headers.
    $yadis = true;
    // We'll jump a maximum of 5 times, to avoid endless redirections.
    for ($i = 0; $i < 5; $i ++) {
        if ($yadis) {
            $headers = $this->sendRequest($url, 'HEAD');
            $next = false;
            if (isset($headers['x-xrds-location'])) {
                $url = $this->buildUrl($url, trim($headers['x-xrds-location']));
                $next = true;
            }
            if (isset($headers['content-type'])
                && (strpos($headers['content-type'], 'application/xrds+xml') !== false
                    || strpos($headers['content-type'], 'text/xml') !== false)
            ) {
                /* Apparently, some providers return XRDS documents as text/html.
                While it is against the spec, allowing this here shouldn't break
                compatibility with anything.
                ---
                Found an XRDS document, now let's find the server, and optionally delegate.*/
                $content = $this->sendRequest($url, 'GET');
                preg_match_all('#<Service.*?>(.*?)</Service>#s', $content, $m);
                foreach ($m[1] as $content) {
                    $content = ' ' . $content; // The space is added, so that strpos doesn't return 0.
                    // OpenID 2
                    $ns = preg_quote('http://specs.openid.net/auth/2.0/');
                    if (preg_match('#<Type>\s*'.$ns.'(server|signon)\s*</Type>#s', $content, $type)) {
                        if ($type[1] == 'server') {
                            $result['identifier_select'] = true;
                        }
                        preg_match('#<URI.*?>(.*)</URI>#', $content, $server);
                        preg_match('#<(Local|Canonical)ID>(.*)</\1ID>#', $content, $delegate);
                        if (empty($server)) {
                            throw new Exception('No servers found!');
                        }
                        // Does the server advertise support for either AX or SREG?
                        $result['ax'] = (bool) strpos($content, '<Type>http://openid.net/srv/ax/1.0</Type>');
                        $result['sreg'] = strpos($content, '<Type>http://openid.net/sreg/1.0</Type>') || strpos($content, '<Type>http://openid.net/extensions/sreg/1.1</Type>');
                        $server = $server[1];
                        if (isset($delegate[2])) {
                            $result['identity'] = trim($delegate[2]);
                        }
                        $result['url'] = $server;
                        $result['version'] = 2;
                        return $result;
                    }
                    // OpenID 1.1
                    $ns = preg_quote('http://openid.net/signon/1.1');
                    if (preg_match('#<Type>\s*'.$ns.'\s*</Type>#s', $content)) {
                        preg_match('#<URI.*?>(.*)</URI>#', $content, $server);
                        preg_match('#<.*?Delegate>(.*)</.*?Delegate>#', $content, $delegate);
                        if (empty($server)) {
                            throw new Exception('No servers found!');
                        }
                        // AX can be used only with OpenID 2.0, so checking only SREG
                        $result['sreg'] = strpos($content, '<Type>http://openid.net/sreg/1.0</Type>') || strpos($content, '<Type>http://openid.net/extensions/sreg/1.1</Type>');
                        $server = $server[1];
                        if (isset($delegate[1])) {
                            $result['identity'] = $delegate[1];
                        }
                        $result['url'] = $server;
                        $result['version'] = 1;
                        return $result;
                    }
                }
                $next = true;
                $yadis = false;
                $url = $originalUrl;
                $content = null;
                break;
            }
            if ($next) {
                continue;
            }
            // There are no relevant information in headers, so we search the body.
            $content = $this->sendRequest($url, 'GET');
            $location = $this->extractHtmlTagValue($content, 'meta', 'http-equiv', 'X-XRDS-Location', 'content');
            if ($location) {
                $url = $this->buildUrl($url, $location);
                continue;
            }
        }
        if (!isset($content)) {
            $content = $this->sendRequest($url, 'GET');
        }
        // At this point, the YADIS Discovery has failed, so we'll switch to openid2 HTML discovery, then fallback to openid 1.1 discovery.
        $server = $this->extractHtmlTagValue($content, 'link', 'rel', 'openid2.provider', 'href');
        if (!$server) {
            // The same with openid 1.1
            $server = $this->extractHtmlTagValue($content, 'link', 'rel', 'openid.server', 'href');
            $delegate = $this->extractHtmlTagValue($content, 'link', 'rel', 'openid.delegate', 'href');
            $version = 1;
        } else {
            $delegate = $this->extractHtmlTagValue($content, 'link', 'rel', 'openid2.local_id', 'href');
            $version = 2;
        }
        if ($server) {
            // We found an OpenID2 OP Endpoint
            if ($delegate) {
                // We have also found an OP-Local ID.
                $result['identity'] = $delegate;
            }
            $result['url'] = $server;
            $result['version'] = $version;
            return $result;
        }
        throw new Exception('No servers found!');
    }
    throw new Exception('Endless redirection!');
}

            

                protected function extractHtmlTagValue($content, $tag, $matchAttributeName, $matchAttributeValue, $valueAttributeName)
{
    preg_match_all("#<{$tag}[^>]*$matchAttributeName=['\"].*?$matchAttributeValue.*?['\"][^>]*$valueAttributeName=['\"](.+?)['\"][^>]*/?>#i", $content, $matches1);
    preg_match_all("#<{$tag}[^>]*$valueAttributeName=['\"](.+?)['\"][^>]*$matchAttributeName=['\"].*?$matchAttributeValue.*?['\"][^>]*/?>#i", $content, $matches2);
    $result = array_merge($matches1[1], $matches2[1]);
    return empty($result) ? false : $result[0];
}

            

                public function fetchAttributes()
{
    if (isset($this->data['openid_ns']) && $this->data['openid_ns'] == 'http://specs.openid.net/auth/2.0') {
        // OpenID 2.0
        // We search for both AX and SREG attributes, with AX taking precedence.
        return array_merge($this->fetchSregAttributes(), $this->fetchAxAttributes());
    }
    return $this->fetchSregAttributes();
}

            

                protected function fetchAxAttributes()
{
    $alias = null;
    if (isset($this->data['openid_ns_ax']) && $this->data['openid_ns_ax'] != 'http://openid.net/srv/ax/1.0') {
        // It's the most likely case, so we'll check it before
        $alias = 'ax';
    } else {
        // 'ax' prefix is either undefined, or points to another extension, so we search for another prefix
        foreach ($this->data as $key => $value) {
            if (strncmp($key, 'openid_ns_', 10) === 0  && $value == 'http://openid.net/srv/ax/1.0') {
                $alias = substr($key, strlen('openid_ns_'));
                break;
            }
        }
    }
    if (!$alias) {
        // An alias for AX schema has not been found, so there is no AX data in the OP's response
        return [];
    }
    $attributes = [];
    foreach ($this->data as $key => $value) {
        $keyMatch = 'openid_' . $alias . '_value_';
        if (strncmp($key, $keyMatch, strlen($keyMatch))) {
            continue;
        }
        $key = substr($key, strlen($keyMatch));
        if (!isset($this->data['openid_' . $alias . '_type_' . $key])) {
            /* OP is breaking the spec by returning a field without
            associated ns. This shouldn't happen, but it's better
            to check, than cause an E_NOTICE.*/
            continue;
        }
        $key = substr($this->data['openid_' . $alias . '_type_' . $key], strlen('http://axschema.org/'));
        $attributes[$key] = $value;
    }
    return $attributes;
}

            

                protected function fetchSregAttributes()
{
    $attributes = [];
    $sregToAx = array_flip($this->axToSregMap);
    foreach ($this->data as $key => $value) {
        $keyMatch = 'openid_sreg_';
        if (strncmp($key, $keyMatch, strlen($keyMatch))) {
            continue;
        }
        $key = substr($key, strlen($keyMatch));
        if (!isset($sregToAx[$key])) {
            // The field name isn't part of the SREG spec, so we ignore it.
            continue;
        }
        $attributes[$sregToAx[$key]] = $value;
    }
    return $attributes;
}

            

                public function getClaimedId()
{
    if ($this->_claimedId === null) {
        if (isset($this->data['openid_claimed_id'])) {
            $this->_claimedId = $this->data['openid_claimed_id'];
        } elseif (isset($this->data['openid_identity'])) {
            $this->_claimedId = $this->data['openid_identity'];
        }
    }
    return $this->_claimedId;
}

            

                public function getReturnUrl()
{
    if ($this->_returnUrl === null) {
        $this->_returnUrl = $this->defaultReturnUrl();
    }
    return $this->_returnUrl;
}

            

                public function getTrustRoot()
{
    if ($this->_trustRoot === null) {
        $this->_trustRoot = Yii::$app->getRequest()->getHostInfo();
    }
    return $this->_trustRoot;
}

            

                public function hostExists($url)
{
    if (strpos($url, '/') === false) {
        $server = $url;
    } else {
        $server = @parse_url($url, PHP_URL_HOST);
    }
    if (!$server) {
        return false;
    }
    $ips = gethostbynamel($server);
    return !empty($ips);
}

            

                public function init()
{
    if ($this->data === null) {
        $request = Yii::$app->getRequest();
        $this->data = array_merge($request->get(), $request->post()); // OPs may send data as POST or GET.
    }
}

            

                protected function initUserAttributes()
{
    return array_merge(['id' => $this->getClaimedId()], $this->fetchAttributes());
}

            

                protected function sendRequest($url, $method = 'GET', $params = [])
{
    $request = $this->createRequest()
        ->setMethod($method)
        ->setUrl($url)
        ->setData($params);
    if ($this->verifyPeer !== null) {
        $options = [
            'sslVerifyPeer' => $this->verifyPeer
        ];
        if ($this->capath) {
            $options['sslCapath'] = $this->capath;
        }
        if ($this->cainfo) {
            $options['sslCafile'] = $this->cainfo;
        }
        $request->addOptions($options);
    }
    $response = $request->send();
    if ($method == 'HEAD') {
        $headers = [];
        foreach ($response->getHeaders()->toArray() as $name => $values) {
            $headers[strtolower($name)] = array_pop($values);
        }
        return $headers;
    }
    return $response->getContent();
}

            

                public function setClaimedId($claimedId)
{
    $this->_claimedId = $claimedId;
}

            

                public function setReturnUrl($returnUrl)
{
    $this->_returnUrl = $returnUrl;
}

            

                public function setTrustRoot($value)
{
    $this->_trustRoot = $value;
}

            

                public function validate($validateRequiredAttributes = true)
{
    $claimedId = $this->getClaimedId();
    if (empty($claimedId)) {
        return false;
    }
    $params = [
        'openid.assoc_handle' => $this->data['openid_assoc_handle'],
        'openid.signed' => $this->data['openid_signed'],
        'openid.sig' => $this->data['openid_sig'],
    ];
    if (isset($this->data['openid_ns'])) {
        /* We're dealing with an OpenID 2.0 server, so let's set an ns
        Even though we should know location of the endpoint,
        we still need to verify it by discovery, so $server is not set here*/
        $params['openid.ns'] = 'http://specs.openid.net/auth/2.0';
    } elseif (isset($this->data['openid_claimed_id']) && $this->data['openid_claimed_id'] != $this->data['openid_identity']) {
        // If it's an OpenID 1 provider, and we've got claimed_id,
        // we have to append it to the returnUrl, like authUrlV1 does.
        $this->returnUrl .= (strpos($this->returnUrl, '?') ? '&' : '?') . 'openid.claimed_id=' . $claimedId;
    }
    if (!$this->compareUrl($this->data['openid_return_to'], $this->returnUrl)) {
        // The return_to url must match the url of current request.
        return false;
    }
    $serverInfo = $this->discover($claimedId);
    foreach (explode(',', $this->data['openid_signed']) as $item) {
        $value = $this->data['openid_' . str_replace('.', '_', $item)];
        $params['openid.' . $item] = $value;
    }
    $params['openid.mode'] = 'check_authentication';
    $response = $this->sendRequest($serverInfo['url'], 'POST', $params);
    if (preg_match('/is_valid\s*:\s*true/i', $response)) {
        if ($validateRequiredAttributes) {
            return $this->validateRequiredAttributes();
        } else {
            return true;
        }
    } else {
        return false;
    }
}

            

                protected function validateRequiredAttributes()
{
    if (!empty($this->requiredAttributes)) {
        $attributes = $this->fetchAttributes();
        foreach ($this->requiredAttributes as $openIdAttributeName) {
            if (!isset($attributes[$openIdAttributeName])) {
                return false;
            }
        }
    }
    return true;
}