| Current File : /home/escuelai/php/MIME/Type.php |
<?php
/* vim: set expandtab tabstop=4 shiftwidth=4: */
/**
* Part of MIME_Type
*
* PHP version 4 and 5
*
* @category File
* @package MIME_Type
* @author Ian Eure <ieure@php.net>
* @license http://www.gnu.org/copyleft/lesser.html LGPL
* @link http://pear.php.net/package/MIME_Type
*/
require_once 'PEAR.php';
$_fileCmd = &PEAR::getStaticProperty('MIME_Type', 'fileCmd');
$_fileCmd = 'file';
/**
* Class for working with MIME types
*
* @category MIME
* @package MIME_Type
* @author Ian Eure <ieure@php.net>
* @license http://www.gnu.org/copyleft/lesser.html LGPL
* @version Release: @version@
* @link http://pear.php.net/package/MIME_Type
*
* @method string autoDetect($file, $params = false) Autodetect a file's MIME-type (can be called statically and on an MIME_Type object)
*/
class MIME_Type
{
/**
* The MIME media type
*
* @var string
*/
public $media = '';
/**
* The MIME media sub-type
*
* @var string
*/
public $subType = '';
/**
* Optional MIME parameters
*
* @var array
*/
public $parameters = array();
/**
* List of valid media types.
* A media type is the string in front of the slash.
* The media type of "text/xml" would be "text".
*
* @var array
*/
public $validMediaTypes = array(
'text',
'image',
'audio',
'video',
'application',
'multipart',
'message'
);
/**
* If the finfo functions shall be used when they are available
*
* @var boolean
*/
public $useFinfo = true;
/**
* If mime_content_type shall be used when available
*
* @var boolean
*/
public $useMimeContentType = true;
/**
* If the file command shall be used when available
*
* @var boolean
*/
public $useFileCmd = true;
/**
* If the in-built file extension detection shall be used
*
* @var boolean
*/
public $useExtension = true;
/**
* Path to the "magic" file database.
* If NULL, the default one is used
*
* @var string
*/
public $magicFile = null;
/**
* Constructor.
*
* If $type is set, if will be parsed and the appropriate class vars set.
* If not, you get an empty class.
* This is useful, but not quite as useful as parsing a type.
*
* @param string $type MIME type
*/
public function __construct($type = false)
{
if ($type) {
$this->parse($type);
}
}
/**
* Make "autoDetect" method available.
*
* @param string $method Method to call. Only "autoDetect" supported.
* @param array $arguments Function parameters.
*
* @return string MIME type
*/
public function __call($method, $arguments)
{
if ($method !== 'autoDetect') {
return trigger_error(
'Call to undefined method MIME_TYPE::' . $method . '()',
E_USER_ERROR
);
}
$type = call_user_func_array(array($this, '_autoDetect'), $arguments);
$this->parse($type);
return $type;
}
/**
* Make "autoDetect" method available statically.
*
* @param string $method Method to call. Only "autoDetect" supported.
* @param array $arguments Function parameters.
*
* @return string MIME type
*/
public static function __callStatic($method, $arguments)
{
if ($method !== 'autoDetect') {
return trigger_error(
'Call to undefined method MIME_TYPE::' . $method . '()',
E_USER_ERROR
);
}
$mt = new MIME_Type();
return call_user_func_array(array($mt, '_autoDetect'), $arguments);
}
/**
* Parse a mime-type and set the class variables.
*
* @param string $type MIME type to parse
*
* @return boolean True if the type has been parsed, false if not
*/
public function parse($type)
{
if ($type instanceof PEAR_Error) {
return false;
}
$this->media = $this->getMedia($type);
$this->subType = $this->getSubType($type);
$this->parameters = array();
if (MIME_Type::hasParameters($type)) {
include_once 'MIME/Type/Parameter.php';
foreach (MIME_Type::getParameters($type) as $param) {
$param = new MIME_Type_Parameter($param);
$this->parameters[$param->name] = $param;
}
}
return true;
}
/**
* Does this type have any parameters?
*
* @param string $type MIME type to check
*
* @return boolean true if $type has parameters, false otherwise
*/
public static function hasParameters($type)
{
if (strstr($type, ';')) {
return true;
}
return false;
}
/**
* Get a MIME type's parameters
*
* @param string $type MIME type to get parameters of
*
* @return array $type's parameters
*/
public static function getParameters($type)
{
$params = array();
$tmp = explode(';', $type);
for ($i = 1; $i < count($tmp); $i++) {
$params[] = trim($tmp[$i]);
}
return $params;
}
/**
* Strip parameters from a MIME type string.
*
* @param string $type MIME type string
*
* @return string MIME type with parameters removed
*/
public static function stripParameters($type)
{
if (strstr($type, ';')) {
return substr($type, 0, strpos($type, ';'));
}
return $type;
}
/**
* Removes comments from a media type, subtype or parameter.
*
* @param string $string String to strip comments from
* @param string $comment Comment is stored in there.
* Do not set it to NULL if you want the comment.
*
* @return string String without comments
*/
public static function stripComments($string, &$comment)
{
if (strpos($string, '(') === false) {
return $string;
}
$inquote = false;
$escaped = false;
$incomment = 0;
$newstring = '';
for ($n = 0; $n < strlen($string); $n++) {
if ($escaped) {
if ($incomment == 0) {
$newstring .= $string[$n];
} else if ($comment !== null) {
$comment .= $string[$n];
}
$escaped = false;
} else if ($string[$n] == '\\') {
$escaped = true;
} else if (!$inquote && $incomment > 0 && $string[$n] == ')') {
$incomment--;
if ($incomment == 0 && $comment !== null) {
$comment .= ' ';
}
} else if (!$inquote && $string[$n] == '(') {
$incomment++;
} else if ($string[$n] == '"') {
if ($inquote) {
$inquote = false;
} else {
$inquote = true;
}
} else if ($incomment == 0) {
$newstring .= $string[$n];
} else if ($comment !== null) {
$comment .= $string[$n];
}
}
if ($comment !== null) {
$comment = trim($comment);
}
return $newstring;
}
/**
* Get a MIME type's media
* Note: 'media' refers to the portion before the first slash
*
* @param string $type MIME type to get media of
*
* @return string $type's media
*/
public static function getMedia($type)
{
$tmp = explode('/', $type);
return strtolower(trim(MIME_Type::stripComments($tmp[0], $null)));
}
/**
* Get a MIME type's subtype
*
* @param string $type MIME type to get subtype of
*
* @return string $type's subtype, null if invalid mime type
*/
public static function getSubType($type)
{
$tmp = explode('/', $type);
if (!isset($tmp[1])) {
return null;
}
$tmp = explode(';', $tmp[1]);
return strtolower(trim(MIME_Type::stripComments($tmp[0], $null)));
}
/**
* Create a textual MIME type from object values
*
* This function performs the opposite function of parse().
*
* @return string MIME type string
*/
public function get()
{
$type = strtolower($this->media . '/' . $this->subType);
if (count($this->parameters)) {
foreach ($this->parameters as $key => $null) {
$type .= '; ' . $this->parameters[$key]->get();
}
}
return $type;
}
/**
* Is this type experimental?
*
* Note: Experimental types are denoted by a leading 'x-' in the media or
* subtype, e.g. text/x-vcard or x-world/x-vrml.
*
* @param string $type MIME type to check
*
* @return boolean true if $type is experimental, false otherwise
*/
public static function isExperimental($type)
{
if (substr(MIME_Type::getMedia($type), 0, 2) == 'x-'
|| substr(MIME_Type::getSubType($type), 0, 2) == 'x-'
) {
return true;
}
return false;
}
/**
* Is this a vendor MIME type?
*
* Note: Vendor types are denoted with a leading 'vnd. in the subtype.
*
* @param string $type MIME type to check
*
* @return boolean true if $type is a vendor type, false otherwise
*/
public static function isVendor($type)
{
if (substr(MIME_Type::getSubType($type), 0, 4) == 'vnd.') {
return true;
}
return false;
}
/**
* Is this a wildcard type?
*
* @param string $type MIME type to check
*
* @return boolean true if $type is a wildcard, false otherwise
*/
public static function isWildcard($type)
{
if ($type == '*/*' || MIME_Type::getSubtype($type) == '*') {
return true;
}
return false;
}
/**
* Perform a wildcard match on a MIME type
*
* Example:
* MIME_Type::wildcardMatch('image/*', 'image/png')
*
* @param string $card Wildcard to check against
* @param string $type MIME type to check
*
* @return boolean true if there was a match, false otherwise
*/
public static function wildcardMatch($card, $type)
{
if (!MIME_Type::isWildcard($card)) {
return false;
}
if ($card == '*/*') {
return true;
}
if (MIME_Type::getMedia($card) == MIME_Type::getMedia($type)) {
return true;
}
return false;
}
/**
* Add a parameter to this type
*
* @param string $name Attribute name
* @param string $value Attribute value
* @param string $comment Comment for this parameter
*
* @return void
*/
public function addParameter($name, $value, $comment = false)
{
$tmp = new MIME_Type_Parameter();
$tmp->name = $name;
$tmp->value = $value;
$tmp->comment = $comment;
$this->parameters[$name] = $tmp;
}
/**
* Remove a parameter from this type
*
* @param string $name Parameter name
*
* @return void
*/
public function removeParameter($name)
{
unset($this->parameters[$name]);
}
/**
* Autodetect a file's MIME-type
*
* @param string $file Path to the file to get the type of
* @param bool $params Append MIME parameters if true
*
* @return string $file's MIME-type on success, PEAR_Error otherwise
*
* @since 1.3.0
*
* @internal Tries to use fileinfo extension at first. If that
* does not work, mime_magic is used. If this is also not available
* or does not succeed, "file" command is tried to be executed with
* System_Command. When that fails, too, then we use our in-built
* extension-to-mimetype-mapping list.
*/
protected function _autoDetect($file, $params = false)
{
// Sanity checks
if (!file_exists($file)) {
return PEAR::raiseError("File \"$file\" doesn't exist");
}
if (!is_readable($file)) {
return PEAR::raiseError("File \"$file\" is not readable");
}
if ($this->useFinfo && function_exists('finfo_file')) {
$finfo = finfo_open(FILEINFO_MIME, $this->magicFile);
if ($finfo) {
$type = finfo_file($finfo, $file);
finfo_close($finfo);
if ($type !== false && $type !== '') {
return MIME_Type::_handleDetection($type, $params);
}
}
}
if ($this->useMimeContentType && function_exists('mime_content_type')) {
$type = mime_content_type($file);
if ($type !== false && $type !== '') {
return MIME_Type::_handleDetection($type, $params);
}
}
if ($this->useFileCmd) {
@include_once 'System/Command.php';
if (class_exists('System_Command')) {
$type = $this->_fileAutoDetect($file);
if ($type !== false && $type !== '') {
return MIME_Type::_handleDetection($type, $params);
}
}
}
if ($this->useExtension) {
include_once 'MIME/Type/Extension.php';
$mte = new MIME_Type_Extension();
return $mte->getMIMEType($file);
}
return PEAR::raiseError("Sorry, couldn't determine file type.");
}
/**
* Handles a detected MIME type and modifies it if necessary.
*
* @param string $type MIME Type of a file
* @param bool $params Append MIME parameters if true
*
* @return string $file's MIME-type on success, PEAR_Error otherwise
*/
protected static function _handleDetection($type, $params)
{
// _fileAutoDetect() may have returned an error.
if (PEAR::isError($type)) {
return $type;
}
// Don't return an empty string
if (!$type || !strlen($type)) {
return PEAR::raiseError("Sorry, couldn't determine file type.");
}
// Strip parameters if present & requested
if (MIME_Type::hasParameters($type) && !$params) {
$type = MIME_Type::stripParameters($type);
}
return $type;
}
/**
* Autodetect a file's MIME-type with 'file' and System_Command
*
* @param string $file Path to the file to get the type of
*
* @return string $file's MIME-type
*
* @since 1.0.0beta1
*/
protected function _fileAutoDetect($file)
{
$cmd = new System_Command();
$magic = '';
// Make sure we have the 'file' command.
$fileCmd = PEAR::getStaticProperty('MIME_Type', 'fileCmd');
if (!$cmd->which($fileCmd)) {
unset($cmd);
return PEAR::raiseError("Can't find file command \"{$fileCmd}\"");
}
if (strlen($this->magicFile)) {
$magic = '--magic-file ' . escapeshellarg($this->magicFile);
}
$cmd->pushCommand($fileCmd, $magic, "-bi " . escapeshellarg($file));
$res = $cmd->execute();
unset($cmd);
return $res;
}
}
?>