MetaDataStorageHandlerPdo.php

Go to the documentation of this file.

<?php
 
 
class SimpleSAML_Metadata_MetaDataStorageHandlerPdo extends SimpleSAML_Metadata_MetaDataStorageSource
{
 
    private $db;
 
    private $tablePrefix;
 
    private $cachedMetadata = array();
 
    public $supportedSets = array(
        'adfs-idp-hosted',
        'adfs-sp-remote',
        'saml20-idp-hosted',
        'saml20-idp-remote',
        'saml20-sp-remote',
        'shib13-idp-hosted',
        'shib13-idp-remote',
        'shib13-sp-hosted',
        'shib13-sp-remote',
        'wsfed-idp-remote',
        'wsfed-sp-hosted'
    );
 
 
    public function __construct($config)
    {
        assert('is_array($config)');
 
        $this->db = SimpleSAML\Database::getInstance();
    }
 
 
    private function load($set)
    {
        assert('is_string($set)');
 
        $tableName = $this->getTableName($set);
 
        if (!in_array($set, $this->supportedSets, true)) {
            return null;
        }
 
        $stmt = $this->db->read("SELECT entity_id, entity_data FROM $tableName");
        if ($stmt->execute()) {
            $metadata = array();
 
            while ($d = $stmt->fetch()) {
                $data = json_decode($d['entity_data'], true);
                if ($data === null) {
                    throw new SimpleSAML_Error_Exception("Cannot decode metadata for entity '${d['entity_id']}'");
                }
                if (!array_key_exists('entityid', $data)) {
                    $data['entityid'] = $d['entity_id'];
                }
                $metadata[$d['entity_id']] = $data;
            }
 
            return $metadata;
        } else {
            throw new Exception('PDO metadata handler: Database error: '.var_export($this->db->getLastError(), true));
        }
    }
 
 
    public function getMetadataSet($set)
    {
        assert('is_string($set)');
 
        if (array_key_exists($set, $this->cachedMetadata)) {
            return $this->cachedMetadata[$set];
        }
 
        $metadataSet = $this->load($set);
        if ($metadataSet === null) {
            $metadataSet = array();
        }
 
        foreach ($metadataSet as $entityId => &$entry) {
            if (preg_match('/__DYNAMIC(:[0-9]+)?__/', $entityId)) {
                $entry['entityid'] = $this->generateDynamicHostedEntityID($set);
            } else {
                $entry['entityid'] = $entityId;
            }
        }
 
        $this->cachedMetadata[$set] = $metadataSet;
        return $metadataSet;
    }
 
 
    private function generateDynamicHostedEntityID($set)
    {
        assert('is_string($set)');
 
        // get the configuration
        $baseurl = \SimpleSAML\Utils\HTTP::getBaseURL();
 
        if ($set === 'saml20-idp-hosted') {
            return $baseurl.'saml2/idp/metadata.php';
        } elseif ($set === 'saml20-sp-hosted') {
            return $baseurl.'saml2/sp/metadata.php';
        } elseif ($set === 'shib13-idp-hosted') {
            return $baseurl.'shib13/idp/metadata.php';
        } elseif ($set === 'shib13-sp-hosted') {
            return $baseurl.'shib13/sp/metadata.php';
        } elseif ($set === 'wsfed-sp-hosted') {
            return 'urn:federation:'.\SimpleSAML\Utils\HTTP::getSelfHost();
        } elseif ($set === 'adfs-idp-hosted') {
            return 'urn:federation:'.\SimpleSAML\Utils\HTTP::getSelfHost().':idp';
        } else {
            throw new Exception('Can not generate dynamic EntityID for metadata of this type: ['.$set.']');
        }
    }
 
 
    public function addEntry($index, $set, $entityData)
    {
        assert('is_string($index)');
        assert('is_string($set)');
        assert('is_array($entityData)');
 
        if (!in_array($set, $this->supportedSets, true)) {
            return false;
        }
 
        $tableName = $this->getTableName($set);
 
        $metadata = $this->db->read(
            "SELECT entity_id, entity_data FROM $tableName WHERE entity_id = :entity_id",
            array(
                'entity_id' => $index,
            )
        );
 
        $retrivedEntityIDs = $metadata->fetch();
 
        $params = array(
            'entity_id'   => $index,
            'entity_data' => json_encode($entityData),
        );
 
        if ($retrivedEntityIDs !== false && count($retrivedEntityIDs) > 0) {
            $rows = $this->db->write(
                "UPDATE $tableName SET entity_data = :entity_data WHERE entity_id = :entity_id",
                $params
            );
        } else {
            $rows = $this->db->write(
                "INSERT INTO $tableName (entity_id, entity_data) VALUES (:entity_id, :entity_data)",
                $params
            );
        }
 
        return $rows === 1;
    }
 
 
    private function getTableName($table)
    {
        assert('is_string($table)');
 
        return $this->db->applyPrefix(str_replace("-", "_", $this->tablePrefix.$table));
    }
 
 
    public function initDatabase()
    {
        $stmt = 0;
        $fine = true;
        foreach ($this->supportedSets as $set) {
            $tableName = $this->getTableName($set);
            $rows = $this->db->write(
                "CREATE TABLE IF NOT EXISTS $tableName (entity_id VARCHAR(255) PRIMARY KEY NOT NULL, entity_data ".
                "TEXT NOT NULL)"
            );
            if ($rows === 0) {
                $fine = false;
            } else {
                $stmt += $rows;
            }
        }
        if (!$fine) {
            return false;
        }
        return $stmt;
    }
 
}