MetaDataStorageHandlerSerialize.php

Go to the documentation of this file.

<?php


class SimpleSAML_Metadata_MetaDataStorageHandlerSerialize extends SimpleSAML_Metadata_MetaDataStorageSource
{

    const EXTENSION = '.serialized';


    private $directory;


    public function __construct($config)
    {
        assert('is_array($config)');

        $globalConfig = SimpleSAML_Configuration::getInstance();

        $cfgHelp = SimpleSAML_Configuration::loadFromArray($config, 'serialize metadata source');

        $this->directory = $cfgHelp->getString('directory');

        /* Resolve this directory relative to the SimpleSAMLphp directory (unless it is
         * an absolute path).
         */
        $this->directory = $globalConfig->resolvePath($this->directory);
    }


    private function getMetadataPath($entityId, $set)
    {
        assert('is_string($entityId)');
        assert('is_string($set)');

        return $this->directory.'/'.rawurlencode($set).'/'.rawurlencode($entityId).self::EXTENSION;
    }


    public function getMetadataSets()
    {
        $ret = array();

        $dh = @opendir($this->directory);
        if ($dh === false) {
            SimpleSAML\Logger::warning(
                'Serialize metadata handler: Unable to open directory: '.var_export($this->directory, true)
            );
            return $ret;
        }

        while (($entry = readdir($dh)) !== false) {

            if ($entry[0] === '.') {
                // skip '..', '.' and hidden files
                continue;
            }

            $path = $this->directory.'/'.$entry;

            if (!is_dir($path)) {
                SimpleSAML\Logger::warning(
                    'Serialize metadata handler: Metadata directory contained a file where only directories should '.
                    'exist: '.var_export($path, true)
                );
                continue;
            }

            $ret[] = rawurldecode($entry);
        }

        closedir($dh);

        return $ret;
    }


    public function getMetadataSet($set)
    {
        assert('is_string($set)');

        $ret = array();

        $dir = $this->directory.'/'.rawurlencode($set);
        if (!is_dir($dir)) {
            // probably some code asked for a metadata set which wasn't available
            return $ret;
        }

        $dh = @opendir($dir);
        if ($dh === false) {
            SimpleSAML\Logger::warning('Serialize metadata handler: Unable to open directory: '.var_export($dir, true));
            return $ret;
        }

        $extLen = strlen(self::EXTENSION);

        while (($file = readdir($dh)) !== false) {
            if (strlen($file) <= $extLen) {
                continue;
            }

            if (substr($file, -$extLen) !== self::EXTENSION) {
                continue;
            }

            $entityId = substr($file, 0, -$extLen);
            $entityId = rawurldecode($entityId);

            $md = $this->getMetaData($entityId, $set);
            if ($md !== null) {
                $ret[$entityId] = $md;
            }
        }

        closedir($dh);

        return $ret;
    }


    public function getMetaData($entityId, $set)
    {
        assert('is_string($entityId)');
        assert('is_string($set)');

        $filePath = $this->getMetadataPath($entityId, $set);

        if (!file_exists($filePath)) {
            return null;
        }

        $data = @file_get_contents($filePath);
        if ($data === false) {
            $error = error_get_last();
            SimpleSAML\Logger::warning(
                'Error reading file '.$filePath.': '.$error['message']
            );
            return null;
        }

        $data = @unserialize($data);
        if ($data === false) {
            SimpleSAML\Logger::warning('Error unserializing file: '.$filePath);
            return null;
        }

        if (!array_key_exists('entityid', $data)) {
            $data['entityid'] = $entityId;
        }

        return $data;
    }


    public function saveMetadata($entityId, $set, $metadata)
    {
        assert('is_string($entityId)');
        assert('is_string($set)');
        assert('is_array($metadata)');

        $filePath = $this->getMetadataPath($entityId, $set);
        $newPath = $filePath.'.new';

        $dir = dirname($filePath);
        if (!is_dir($dir)) {
            SimpleSAML\Logger::info('Creating directory: '.$dir);
            $res = @mkdir($dir, 0777, true);
            if ($res === false) {
                $error = error_get_last();
                SimpleSAML\Logger::error('Failed to create directory '.$dir.': '.$error['message']);
                return false;
            }
        }

        $data = serialize($metadata);

        SimpleSAML\Logger::debug('Writing: '.$newPath);

        $res = file_put_contents($newPath, $data);
        if ($res === false) {
            $error = error_get_last();
            SimpleSAML\Logger::error('Error saving file '.$newPath.': '.$error['message']);
            return false;
        }

        $res = rename($newPath, $filePath);
        if ($res === false) {
            $error = error_get_last();
            SimpleSAML\Logger::error('Error renaming '.$newPath.' to '.$filePath.': '.$error['message']);
            return false;
        }

        return true;
    }


    public function deleteMetadata($entityId, $set)
    {
        assert('is_string($entityId)');
        assert('is_string($set)');

        $filePath = $this->getMetadataPath($entityId, $set);

        if (!file_exists($filePath)) {
            SimpleSAML\Logger::warning(
                'Attempted to erase nonexistent metadata entry '.
                var_export($entityId, true).' in set '.var_export($set, true).'.'
            );
            return;
        }

        $res = unlink($filePath);
        if ($res === false) {
            $error = error_get_last();
            SimpleSAML\Logger::error(
                'Failed to delete file '.$filePath.
                ': '.$error['message']
            );
        }
    }
}