Image.php

<?php
/**
 * Munee: Optimising Your Assets
 *
 * @copyright Cody Lundquist 2013
 * @license http://opensource.org/licenses/mit-license.php
 */

namespace Munee\Asset\Type;

use Munee\ErrorException;
use Munee\Asset\Type;
use Munee\Utils;

/**
 * Handles Images
 *
 * @author Cody Lundquist
 */
class Image extends Type
{
    /**
     * @var array
     */
    protected $_options = array(
        // How many filters can be done within the `allowedFiltersTimeLimit`
        'numberOfAllowedFilters' => 3,
        // Number of seconds - default is 5 minutes
        'allowedFiltersTimeLimit' => 300,
        // Should the referrer be checked for security
        'checkReferrer' => true,
        // Use a placeholder for missing images?
        'placeholders' => false,
        'maxAllowedResizeWidth' => 1920,
        'maxAllowedResizeHeight' => 1080
    );

    protected $_placeholder = false;

    /**
     * Checks to see if cache exists and is the latest, if it does, return it
     *
     * Extra security checks for images
     *
     * @param string $originalFile
     * @param string $cacheFile
     *
     * @return bool|string
     */
    protected function _checkCache($originalFile, $cacheFile)
    {
        if (! $return = parent::_checkCache($originalFile, $cacheFile)) {
            /**
             * If using the placeholder when the original file doesn't exist
             * and it has already been cached, return the cached contents.
             * Also make sure the placeholder hasn't been modified since being cached.
             */
            $this->_placeholder = $this->_parsePlaceholders($originalFile);
            if (
                ! file_exists($originalFile) &&
                $this->_placeholder &&
                file_exists($this->_placeholder) &&
                file_exists($cacheFile) &&
                filemtime($cacheFile) > filemtime($this->_placeholder)
            ) {
                return file_get_contents($cacheFile);
            }

            if ($this->_options['checkReferrer']) {
                $this->_checkReferrer();
            }

            $this->_checkNumberOfAllowedFilters($cacheFile);
        }

        return $return;
    }

    /**
     * Overwrite the _setupFile function so placeholder images can be shown instead of broken images
     *
     *
     * @param string $originalFile
     * @param string $cacheFile
     */
    protected function _setupFile($originalFile, $cacheFile)
    {
        if (! file_exists($originalFile)) {
            // If we are using a placeholder and that exists, use it!
            if ($this->_placeholder && file_exists($this->_placeholder)) {
                $originalFile = $this->_placeholder;
            }
        }

        parent::_setupFile($originalFile, $cacheFile);

    }

    /**
     * Set additional headers just for an Image
     */
    public function getHeaders()
    {
        switch ($this->_request->ext) {
            case 'jpg':
            case 'jpeg':
                $this->_response->headerController->headerField('Content-Type', 'image/jpg');
                break;
            case 'png':
                $this->_response->headerController->headerField('Content-Type', 'image/png');
                break;
            case 'gif':
                $this->_response->headerController->headerField('Content-Type', 'image/gif');
                break;
        }
    }

    /**
     * Check to make sure the referrer domain is the same as the domain where the image exists.
     *
     * @throws ErrorException
     */
    protected function _checkReferrer()
    {
        if (! isset($_SERVER['HTTP_REFERER'])) {
            throw new ErrorException('Direct image manipulation is not allowed.');
        }

        $referrer = preg_replace('%^https?://%', '', $_SERVER['HTTP_REFERER']);
        if (! preg_match("%^{$_SERVER['SERVER_NAME']}%", $referrer)) {
            throw new ErrorException('Referrer does not match the correct domain.');
        }
    }

    /**
     * Check number of allowed resizes within a set time limit
     *
     * @param string $checkImage
     *
     * @throws ErrorException
     */
    protected function _checkNumberOfAllowedFilters($checkImage)
    {
        $pathInfo = pathinfo($checkImage);
        $fileNameHash = preg_replace('%-.*$%', '', $pathInfo['filename']);
        // Grab all the similar files
        $cachedImages = glob($pathInfo['dirname'] . DS . $fileNameHash . '*');
        // Loop through and remove the ones that are older than the time limit
        foreach ($cachedImages as $k => $image) {
            if (filemtime($image) < time() - $this->_options['allowedFiltersTimeLimit']) {
                unset($cachedImages[$k]);
            }
        }
        // Check and see if we've reached the maximum allowed resizes within the current time limit.
        if (count($cachedImages) >= $this->_options['numberOfAllowedFilters']) {
            throw new ErrorException('You cannot create anymore resizes/manipulations at this time.');
        }
    }

    /**
     * @param string $file
     *
     * @return boolean|string
     *
     * @throws ErrorException
     */
    protected function _parsePlaceholders($file)
    {
        $ret = false;
        if (! empty($this->_options['placeholders'])) {
            // If it's a string, use the image for all missing images.
            if (is_string($this->_options['placeholders'])) {
                $this->_options['placeholders'] = array('*' => $this->_options['placeholders']);
            }

            foreach ($this->_options['placeholders'] as $path => $placeholder) {
                // Setup path for regex
                $regex = '^' . $this->_request->docroot . str_replace(array('*', $this->_request->docroot), array('.*?', ''), $path) . '$';
                if (preg_match("%{$regex}%", $file)) {
                    if ('http' == substr($placeholder, 0, 4)) {
                        $ret = $this->_getImageByUrl($placeholder);
                    } else {
                        $ret = $placeholder;
                    }
                    break;
                }
            }
        }

        return $ret;
    }

    /**
     * Grabs an image by URL from another server
     *
     * @param string $url
     *
     * @return string
     */
    protected function _getImageByUrl($url)
    {
        $cacheFolder = MUNEE_CACHE . DS . 'placeholders';
        Utils::createDir($cacheFolder);
        $requestOptions = serialize($this->_request->options);
        $originalFile = array_shift($this->_request->files);

        $fileName = $cacheFolder . DS . md5($url) . '-' . md5($requestOptions . $originalFile);
        if (! file_exists($fileName)) {
            file_put_contents($fileName, file_get_contents($url));
        }

        return $fileName;
    }
}