IMAGE BODY GUARD

<?php
/**
 * Project : Image Body Guard
 * File    : ImageGuard.class.php
 *
 * @author Neige < neige at orphyx dot net >
 * @copyright &copy; 2007 - Neige
 * @package Image Body Guard
 * @version 1.0.0
 * @licence http://creativecommons.org/licenses/by-nc-sa/2.0/fr/
 */

/**
 * @package Image Body Guard
 */
class ImageBodyGuard
{
	/**
	 * Callback function to check authorization to display image
	 * @var string
	 */
	protected $_auth_handler;

	/**
	 * Substring to check presence in HTTP Referer
	 * @var string
	 */
	protected $_referer_check;

	/**
	 * Default directory to use
	 * @var string
	 */
	protected $_directory;

	/**
	 * Image to display when display not authorized
	 * Contents : header (mime type) and image contents
	 * @var array
	 */
	protected $_forbidden_image = array();

	/**
	 * Header to be sent for image to display
	 * @var string
	 */
	public $_header;

	/**
	 * Instance of the object
	 * @var object
	 */
	protected static $_instance;

	/**
	 * Returns the unique instance of the class
	 * @return object
	 */
	public static function getInstance()
	{
		if (empty(self::$_instance))
		{
			self::$_instance = new ImageGuard();
		}
		return self::$_instance;
	}

	/**
	 * Setter for $_auth_handler
	 * @param string The function name
	 */
	public function set_auth_handler($function_name)
	{
		if (is_callable($function_name))
		{
			$this -> _auth_handler = $function_name;
		}
	}

	/**
	 * Setter for $_referer_check
	 * @param string Substring to search for in HTTP Referer
	 */
	public function set_referer_check($referer_check)
	{
		$this -> _referer_check = (string) $referer_check;
	}

	/**
	 * Setter for $_forbidden_image
	 * @param string Path to image
	 */
	public function set_forbidden_image($image)
	{
		$image_size = $this -> _get_image_size($image);
		$this -> _forbidden_image = array(
			'header' => 'Content-Type: ' . $image_size['mime'],
			'contents' => file_get_contents($image));
	}

	/**
	 * Setter for $_directory
	 * @param string Default directory
	 */

	/**
	 * Checks if referer is ok
	 * @todo Allow multiple referers to display image
	 */
	protected function _check_referer()
	{
		$referer_ok = TRUE;
		if (!empty($this -> _referer_check))
		{
			if (array_key_exists('HTTP_REFERER', $_SERVER))
			{
				$referer = $_SERVER['HTTP_REFERER'];
				if (stristr($referer, $this -> _referer_check) === FALSE)
				{
					$referer_ok = FALSE;
				}
			}
		}
		return $referer_ok;
	}

	/**
	 * Check if display is authorized according
	 * to auth callback function
	 */
	protected function _check_auth()
	{
		if (!empty($this -> _auth_handler) && function_exists($this -> _auth_handler))
		{
			if (call_user_func($this -> _auth_handler))
			{
				return TRUE;
			}
			else
			{
				return FALSE;
			}
		}
		else
		{
			return TRUE;
		}
	}

	/**
	 * Check general auth
	 */
	protected function _is_auth()
	{
		return ($this -> _check_auth() && $this -> _check_referer());
	}

	/**
	 * Display forbidden image if not authorized
	 * @todo Display a message if no default image file
	 */
	protected function display_forbidden()
	{
		if (!empty($this -> _forbidden_image))
		{
			header($this -> _forbidden_image['header']);
			echo $this -> _forbidden_image['contents'];
		}
		else
		{
			throw new Exception('IBG_Forbidden');
		}
	}

	/**
	 * Display the image
	 * @param string $filename Image filename
	 * @param string $directory Directory where image is located
	 */
	public function display($file_name, $directory = '')
	{
		if ($this -> _is_auth())
		{
			$image_content = $this -> get_image($file_name, $directory);
			header($this -> _header);
			echo $image_content;
		}
		else
		{
			$this -> display_forbidden();
		}
	}

	/**
	 * Returns image contents and sets $this -> header
	 * @param string $image_file
	 * @param string $directory
	 */
	public function get_image($image_file, $directory = '')
	{
		$image_size = $this -> _get_image_size($image_file, $directory);
		$this -> _header = 'Content-Type: ' . $image_size['mime'];
		$image_content = @file_get_contents($image_file);
		if ($image_content === FALSE)
		{
			throw new Exception('IBG_Error_occured');
		}
		else
		{
			return $image_content;
		}
	}

	/**
	 * Returns image size, mime type and other data provided
	 * by php native function getimagesize()
	 * @param string $image_file
	 * @param string $directory
	 */
	protected function _get_image_size($image_file, $directory = '')
	{
		if (!empty($this -> directory) && empty($directory))
		{
			$directory = $this -> _directory;
		}
		if (is_file($directory . $image_file))
		{
			if (!$image_size = getimagesize($image_file))
			{
				throw new Exception('IBG_Not_an_image');
			}
			else
			{
				return $image_size;
			}
		}
		else
		{
			throw new Exception('IBG_File_not_exists');
		}
	}
}
?>

<?php

/*
 * EXEMPLE D'UTILISATION
 */

$imageBG = ImageBodyGuard::getInstance();
$imageBG -> set_auth_handler('auth');
$imageBG -> set_referer_check('domaine.tld');

$image = $_GET['image'];

$imageBG -> display($image);

?>