PowerIdPDisco.php

Go to the documentation of this file.

<?php
 
 
class sspmod_discopower_PowerIdPDisco extends SimpleSAML_XHTML_IdPDisco
{
 
 
    private $discoconfig;
 
 
    private $cdcDomain;
 
 
    private $cdcLifetime;
 
 
    public function __construct(array $metadataSets, $instance)
    {
        parent::__construct($metadataSets, $instance);
 
        $this->discoconfig = SimpleSAML_Configuration::getConfig('module_discopower.php');
 
        $this->cdcDomain = $this->discoconfig->getString('cdc.domain', null);
        if ($this->cdcDomain !== null && $this->cdcDomain[0] !== '.') {
            // ensure that the CDC domain starts with a dot ('.') as required by the spec
            $this->cdcDomain = '.'.$this->cdcDomain;
        }
 
        $this->cdcLifetime = $this->discoconfig->getInteger('cdc.lifetime', null);
    }
 
 
    protected function log($message)
    {
        SimpleSAML\Logger::info('PowerIdPDisco.'.$this->instance.': '.$message);
    }
 
 
    public static function mcmp(array $a, array $b)
    {
        if (isset($a['name']['en']) && isset($b['name']['en'])) {
            return strcasecmp($a['name']['en'], $b['name']['en']);
        } elseif (isset($a['name']['en'])) {
            return -1; // place name before entity ID
        } elseif (isset($b['name']['en'])) {
            return 1; // Place entity ID after name
        } else {
            return strcasecmp($a['entityid'], $b['entityid']);
        }
    }
 
 
    protected function idplistStructured($list)
    {
        $slist = array();
 
        $order = $this->discoconfig->getValue('taborder');
        if (is_array($order)) {
            foreach ($order as $oe) {
                $slist[$oe] = array();
            }
        }
 
        $enableTabs = $this->discoconfig->getValue('tabs', null);
 
        foreach ($list as $key => $val) {
            $tags = array('misc');
            if (array_key_exists('tags', $val)) {
                $tags = $val['tags'];
            }
            foreach ($tags as $tag) {
                if (!empty($enableTabs) && !in_array($tag, $enableTabs, true)) {
                    continue;
                }
                $slist[$tag][$key] = $val;
            }
        }
 
        foreach ($slist as $tab => $tbslist) {
            uasort($slist[$tab], array('sspmod_discopower_PowerIdPDisco', 'mcmp'));
        }
 
        return $slist;
    }
 
 
    private function processFilter($filter, $entry, $default = true)
    {
        if (in_array($entry['entityid'], $filter['entities.include'], true)) {
            return true;
        }
        if (in_array($entry['entityid'], $filter['entities.exclude'], true)) {
            return false;
        }
 
        if (array_key_exists('tags', $entry)) {
            foreach ($filter['tags.include'] as $fe) {
                if (in_array($fe, $entry['tags'], true)) {
                    return true;
                }
            }
            foreach ($filter['tags.exclude'] as $fe) {
                if (in_array($fe, $entry['tags'], true)) {
                    return false;
                }
            }
        }
        return $default;
    }
 
 
    protected function filterList($list)
    {
        $list = parent::filterList($list);
 
        try {
            $spmd = $this->metadata->getMetaData($this->spEntityId, 'saml20-sp-remote');
        } catch (Exception $e) {
            return $list;
        }
 
        if (!isset($spmd)) {
            return $list;
        }
        if (!array_key_exists('discopower.filter', $spmd)) {
            return $list;
        }
        $filter = $spmd['discopower.filter'];
 
        if (!array_key_exists('entities.include', $filter)) {
            $filter['entities.include'] = array();
        }
        if (!array_key_exists('entities.exclude', $filter)) {
            $filter['entities.exclude'] = array();
        }
        if (!array_key_exists('tags.include', $filter)) {
            $filter['tags.include'] = array();
        }
        if (!array_key_exists('tags.exclude', $filter)) {
            $filter['tags.exclude'] = array();
        }
 
        $defaultrule = true;
        if (array_key_exists('entities.include', $spmd['discopower.filter']) ||
            array_key_exists('tags.include', $spmd['discopower.filter'])
        ) {
 
            $defaultrule = false;
        }
 
        $returnlist = array();
        foreach ($list as $key => $entry) {
            if ($this->processFilter($filter, $entry, $defaultrule)) {
                $returnlist[$key] = $entry;
            }
        }
        return $returnlist;
    }
 
 
    public function handleRequest()
    {
        $this->start();
 
        // no choice made. Show discovery service page
        $idpList = $this->getIdPList();
        $idpList = $this->idplistStructured($this->filterList($idpList));
        $preferredIdP = $this->getRecommendedIdP();
        $faventry = NULL;
        foreach ($idpList AS $tab => $slist) {
            if (!empty($preferredIdP) && array_key_exists($preferredIdP, $slist)) {
                $faventry = $slist[$preferredIdP];
            }
        }
 
        $t = new SimpleSAML_XHTML_Template($this->config, 'discopower:disco.tpl.php', 'disco');
        $discoPowerTabs = array(
            'denmark' => $t->noop('{discopower:tabs:denmark}'),
            'edugain' => $t->noop('{discopower:tabs:edugain}'),
            'finland' => $t->noop('{discopower:tabs:finland}'),
            'greece' => $t->noop('{discopower:tabs:greece}'),
            'southafrica' => $t->noop('{discopower:tabs:southafrica}'),
            'iceland' => $t->noop('{discopower:tabs:iceland}'),
            'incommon' => $t->noop('{discopower:tabs:incommon}'),
            'kalmar' => $t->noop('{discopower:tabs:kalmar}'),
            'misc' => $t->noop('{discopower:tabs:misc}'),
            'norway' => $t->noop('{discopower:tabs:norway}'),
            'sweden' => $t->noop('{discopower:tabs:sweden}'),
            'switzerland' => $t->noop('{discopower:tabs:switzerland}'),
            'ukacessfederation' => $t->noop('{discopower:tabs:ukacessfederation}'),
        );
        $t->data['faventry'] = $faventry;
        $t->data['tabNames'] = $discoPowerTabs;
        $t->data['idplist'] = $idpList;
        $t->data['preferredidp'] = $preferredIdP;
        $t->data['return'] = $this->returnURL;
        $t->data['returnIDParam'] = $this->returnIdParam;
        $t->data['entityID'] = $this->spEntityId;
        $t->data['urlpattern'] = htmlspecialchars(\SimpleSAML\Utils\HTTP::getSelfURLNoQuery());
        $t->data['rememberenabled'] = $this->config->getBoolean('idpdisco.enableremember', false);
        $t->data['rememberchecked'] = $this->config->getBoolean('idpdisco.rememberchecked', false);
        $t->data['defaulttab'] = $this->discoconfig->getValue('defaulttab', 0);
        $t->data['score'] = $this->discoconfig->getValue('score', 'quicksilver');
        $t->show();
    }
 
 
    private function getCDC()
    {
        if (!isset($_COOKIE['_saml_idp'])) {
            return array();
        }
 
        $ret = (string) $_COOKIE['_saml_idp'];
        $ret = explode(' ', $ret);
        foreach ($ret as &$idp) {
            $idp = base64_decode($idp);
            if ($idp === false) {
                // not properly base64 encoded
                return array();
            }
        }
 
        return $ret;
    }
 
 
    protected function setPreviousIdP($idp)
    {
        assert('is_string($idp)');
 
        if ($this->cdcDomain === null) {
            parent::setPreviousIdP($idp);
            return;
        }
 
        $list = $this->getCDC();
 
        $prevIndex = array_search($idp, $list, true);
        if ($prevIndex !== false) {
            unset($list[$prevIndex]);
        }
        $list[] = $idp;
 
        foreach ($list as &$value) {
            $value = base64_encode($value);
        }
        $newCookie = implode(' ', $list);
 
        while (strlen($newCookie) > 4000) {
            // the cookie is too long. Remove the oldest elements until it is short enough
            $tmp = explode(' ', $newCookie, 2);
            if (count($tmp) === 1) {
                // we are left with a single entityID whose base64 representation is too long to fit in a cookie
                break;
            }
            $newCookie = $tmp[1];
        }
 
        $params = array(
            'lifetime' => $this->cdcLifetime,
            'domain'   => $this->cdcDomain,
            'secure'   => true,
            'httponly' => false,
        );
        \SimpleSAML\Utils\HTTP::setCookie('_saml_idp', $newCookie, $params, false);
    }
 
 
    protected function getPreviousIdP()
    {
        if ($this->cdcDomain === null) {
            return parent::getPreviousIdP();
        }
 
        $prevIdPs = $this->getCDC();
        while (count($prevIdPs) > 0) {
            $idp = array_pop($prevIdPs);
            $idp = $this->validateIdP($idp);
            if ($idp !== null) {
                return $idp;
            }
        }
 
        return null;
    }
}