MetaDataStorageSource.php

Go to the documentation of this file.

<?php
 
 
abstract class SimpleSAML_Metadata_MetaDataStorageSource
{
 
 
    public static function parseSources($sourcesConfig)
    {
        assert(is_array($sourcesConfig));
 
        $sources = array();
 
        foreach ($sourcesConfig as $sourceConfig) {
            if (!is_array($sourceConfig)) {
                throw new Exception("Found an element in metadata source configuration which wasn't an array.");
            }
 
            $sources[] = self::getSource($sourceConfig);
        }
 
        return $sources;
    }
 
 
    public static function getSource($sourceConfig)
    {
        assert(is_array($sourceConfig));
 
        if (array_key_exists('type', $sourceConfig)) {
            $type = $sourceConfig['type'];
        } else {
            $type = 'flatfile';
        }
 
        switch ($type) {
            case 'flatfile':
                return new SimpleSAML_Metadata_MetaDataStorageHandlerFlatFile($sourceConfig);
            case 'xml':
                return new SimpleSAML_Metadata_MetaDataStorageHandlerXML($sourceConfig);
            case 'serialize':
                return new SimpleSAML_Metadata_MetaDataStorageHandlerSerialize($sourceConfig);
            case 'mdx':
            case 'mdq':
                return new \SimpleSAML\Metadata\Sources\MDQ($sourceConfig);
            case 'pdo':
                return new SimpleSAML_Metadata_MetaDataStorageHandlerPdo($sourceConfig);
            default:
                // metadata store from module
                try {
                    $className = SimpleSAML\Module::resolveClass(
                        $type,
                        'MetadataStore',
                        'SimpleSAML_Metadata_MetaDataStorageSource'
                    );
                } catch (Exception $e) {
                    throw new SimpleSAML\Error\CriticalConfigurationError(
                        "Invalid 'type' for metadata source. Cannot find store '$type'.",
                        null
                    );
                }
                return new $className($sourceConfig);
        }
    }
 
 
    public function getMetadataSet($set)
    {
        return array();
    }
 
 
    public function getEntityIdFromHostPath($hostPath, $set, $type = 'entityid')
    {
 
        $metadataSet = $this->getMetadataSet($set);
        if ($metadataSet === null) {
            // this metadata source does not have this metadata set
            return null;
        }
 
        foreach ($metadataSet as $index => $entry) {
            if (!array_key_exists('host', $entry)) {
                continue;
            }
 
            if ($hostPath === $entry['host']) {
                if ($type === 'entityid') {
                    return $entry['entityid'];
                } else {
                    return $index;
                }
            }
        }
 
        // no entries matched, we should return null
        return null;
    }
 
 
    public function getPreferredEntityIdFromCIDRhint($set, $ip, $type = 'entityid')
    {
 
        $metadataSet = $this->getMetadataSet($set);
 
        foreach ($metadataSet as $index => $entry) {
            $cidrHints = array();
            
            // support hint.cidr for idp discovery
            if (array_key_exists('hint.cidr', $entry) && is_array($entry['hint.cidr'])) {
                $cidrHints = $entry['hint.cidr'];
            }
 
            // support discohints in idp metadata for idp discovery
            if (array_key_exists('DiscoHints', $entry) 
                && array_key_exists('IPHint', $entry['DiscoHints']) 
                && is_array($entry['DiscoHints']['IPHint'])) {
                // merge with hints derived from discohints, but prioritize hint.cidr in case it is used
                $cidrHints = array_merge($entry['DiscoHints']['IPHint'], $cidrHints);
            }
 
            if (empty($cidrHints)) {
                continue;
            }
 
            foreach ($cidrHints as $hint_entry) {
                if (SimpleSAML\Utils\Net::ipCIDRcheck($hint_entry, $ip)) {
                    if ($type === 'entityid') {
                        return $entry['entityid'];
                    } else {
                        return $index;
                    }
                }
            }
        }
 
        // no entries matched, we should return null
        return null;
    }
 
 
    /*
     *
     */
    private function lookupIndexFromEntityId($entityId, $set)
    {
        assert(is_string($entityId));
        assert(isset($set));
 
        $metadataSet = $this->getMetadataSet($set);
 
        // check for hostname
        $currenthost = \SimpleSAML\Utils\HTTP::getSelfHost(); // sp.example.org
 
        foreach ($metadataSet as $index => $entry) {
            if ($index === $entityId) {
                return $index;
            }
            if ($entry['entityid'] === $entityId) {
                if ($entry['host'] === '__DEFAULT__' || $entry['host'] === $currenthost) {
                    return $index;
                }
            }
        }
 
        return null;
    }
 
 
    public function getMetaData($index, $set)
    {
 
        assert(is_string($index));
        assert(isset($set));
 
        $metadataSet = $this->getMetadataSet($set);
 
        if (array_key_exists($index, $metadataSet)) {
            return $metadataSet[$index];
        }
 
        $indexlookup = $this->lookupIndexFromEntityId($index, $set);
        if (isset($indexlookup) && array_key_exists($indexlookup, $metadataSet)) {
            return $metadataSet[$indexlookup];
        }
 
        return null;
    }
}