MetaDataStorageHandler.php

Go to the documentation of this file.

<?php
 
 
class SimpleSAML_Metadata_MetaDataStorageHandler
{
 
 
    private static $metadataHandler = null;
 
 
    private $sources;
 
 
    public static function getMetadataHandler()
    {
        if (self::$metadataHandler === null) {
            self::$metadataHandler = new SimpleSAML_Metadata_MetaDataStorageHandler();
        }
 
        return self::$metadataHandler;
    }
 
 
    protected function __construct()
    {
        $config = SimpleSAML_Configuration::getInstance();
 
        $sourcesConfig = $config->getArray('metadata.sources', null);
 
        // for backwards compatibility, and to provide a default configuration
        if ($sourcesConfig === null) {
            $type = $config->getString('metadata.handler', 'flatfile');
            $sourcesConfig = array(array('type' => $type));
        }
 
        try {
            $this->sources = SimpleSAML_Metadata_MetaDataStorageSource::parseSources($sourcesConfig);
        } catch (Exception $e) {
            throw new Exception(
                "Invalid configuration of the 'metadata.sources' configuration option: ".$e->getMessage()
            );
        }
    }
 
 
    public function getGenerated($property, $set)
    {
        // first we check if the user has overridden this property in the metadata
        try {
            $metadataSet = $this->getMetaDataCurrent($set);
            if (array_key_exists($property, $metadataSet)) {
                return $metadataSet[$property];
            }
        } catch (Exception $e) {
            // probably metadata wasn't found. In any case we continue by generating the metadata
        }
 
        // get the configuration
        $config = SimpleSAML_Configuration::getInstance();
        assert($config instanceof SimpleSAML_Configuration);
 
        $baseurl = \SimpleSAML\Utils\HTTP::getSelfURLHost().$config->getBasePath();
 
        if ($set == 'saml20-sp-hosted') {
            if ($property === 'SingleLogoutServiceBinding') {
                return \SAML2\Constants::BINDING_HTTP_REDIRECT;
            }
        } elseif ($set == 'saml20-idp-hosted') {
            switch ($property) {
                case 'SingleSignOnService':
                    return $baseurl.'saml2/idp/SSOService.php';
 
                case 'SingleSignOnServiceBinding':
                    return \SAML2\Constants::BINDING_HTTP_REDIRECT;
 
                case 'SingleLogoutService':
                    return $baseurl.'saml2/idp/SingleLogoutService.php';
 
                case 'SingleLogoutServiceBinding':
                    return \SAML2\Constants::BINDING_HTTP_REDIRECT;
            }
        } elseif ($set == 'shib13-idp-hosted') {
            if ($property === 'SingleSignOnService') {
                return $baseurl.'shib13/idp/SSOService.php';
            }
        }
 
        throw new Exception('Could not generate metadata property '.$property.' for set '.$set.'.');
    }
 
 
    public function getList($set = 'saml20-idp-remote')
    {
        assert('is_string($set)');
 
        $result = array();
 
        foreach ($this->sources as $source) {
            $srcList = $source->getMetadataSet($set);
 
            foreach ($srcList as $key => $le) {
                if (array_key_exists('expire', $le)) {
                    if ($le['expire'] < time()) {
                        unset($srcList[$key]);
                        SimpleSAML\Logger::warning(
                            "Dropping metadata entity ".var_export($key, true).", expired ".
                            SimpleSAML\Utils\Time::generateTimestamp($le['expire'])."."
                        );
                    }
                }
            }
 
            /* $result is the last argument to array_merge because we want the content already
             * in $result to have precedence.
             */
            $result = array_merge($srcList, $result);
        }
 
        return $result;
    }
 
 
    public function getMetaDataCurrent($set)
    {
        return $this->getMetaData(null, $set);
    }
 
 
    public function getMetaDataCurrentEntityID($set, $type = 'entityid')
    {
        assert('is_string($set)');
 
        // first we look for the hostname/path combination
        $currenthostwithpath = \SimpleSAML\Utils\HTTP::getSelfHostWithPath(); // sp.example.org/university
 
        foreach ($this->sources as $source) {
            $index = $source->getEntityIdFromHostPath($currenthostwithpath, $set, $type);
            if ($index !== null) {
                return $index;
            }
        }
 
        // then we look for the hostname
        $currenthost = \SimpleSAML\Utils\HTTP::getSelfHost(); // sp.example.org
 
        foreach ($this->sources as $source) {
            $index = $source->getEntityIdFromHostPath($currenthost, $set, $type);
            if ($index !== null) {
                return $index;
            }
        }
 
        // then we look for the DEFAULT entry
        foreach ($this->sources as $source) {
            $entityId = $source->getEntityIdFromHostPath('__DEFAULT__', $set, $type);
            if ($entityId !== null) {
                return $entityId;
            }
        }
 
        // we were unable to find the hostname/path in any metadata source
        throw new Exception(
            'Could not find any default metadata entities in set ['.$set.'] for host ['.$currenthost.' : '.
            $currenthostwithpath.']'
        );
    }
 
 
    public function getPreferredEntityIdFromCIDRhint($set, $ip)
    {
        foreach ($this->sources as $source) {
            $entityId = $source->getPreferredEntityIdFromCIDRhint($set, $ip);
            if ($entityId !== null) {
                return $entityId;
            }
        }
 
        return null;
    }
 
 
    public function getMetaData($index, $set)
    {
        assert('is_string($set)');
 
        if ($index === null) {
            $index = $this->getMetaDataCurrentEntityID($set, 'metaindex');
        }
 
        assert('is_string($index)');
 
        foreach ($this->sources as $source) {
            $metadata = $source->getMetaData($index, $set);
 
            if ($metadata !== null) {
 
                if (array_key_exists('expire', $metadata)) {
                    if ($metadata['expire'] < time()) {
                        throw new Exception(
                            'Metadata for the entity ['.$index.'] expired '.
                            (time() - $metadata['expire']).' seconds ago.'
                        );
                    }
                }
 
                $metadata['metadata-index'] = $index;
                $metadata['metadata-set'] = $set;
                assert('array_key_exists("entityid", $metadata)');
                return $metadata;
            }
        }
 
        throw new SimpleSAML_Error_MetadataNotFound($index);
    }
 
 
    public function getMetaDataConfig($entityId, $set)
    {
        assert('is_string($entityId)');
        assert('is_string($set)');
 
        $metadata = $this->getMetaData($entityId, $set);
        return SimpleSAML_Configuration::loadFromArray($metadata, $set.'/'.var_export($entityId, true));
    }
 
 
    public function getMetaDataConfigForSha1($sha1, $set)
    {
        assert('is_string($sha1)');
        assert('is_string($set)');
 
        $result = array();
 
        foreach ($this->sources as $source) {
            $srcList = $source->getMetadataSet($set);
 
            /* $result is the last argument to array_merge because we want the content already
             * in $result to have precedence.
             */
            $result = array_merge($srcList, $result);
        }
        foreach ($result as $remote_provider) {
 
            if (sha1($remote_provider['entityid']) == $sha1) {
                $remote_provider['metadata-set'] = $set;
 
                return SimpleSAML_Configuration::loadFromArray(
                    $remote_provider,
                    $set.'/'.var_export($remote_provider['entityid'], true)
                );
            }
        }
 
        return null;
    }
}