mimemagic.php

php 开发的内容管理系统

<?php
/** Module defining helper functions for detecting and dealing with mime types.
 *
 * @package MediaWiki
 */

 /** Defines a set of well known mime types
 * This is used as a fallback to mime.types files.
 * An extensive list of well known mime types is provided by
 * the file mime.types in the includes directory.
 */
define('MM_WELL_KNOWN_MIME_TYPES',<<<END_STRING
application/ogg ogg ogm
application/pdf pdf
application/x-javascript js
application/x-shockwave-flash swf
audio/midi mid midi kar
audio/mpeg mpga mpa mp2 mp3
audio/x-aiff aif aiff aifc
audio/x-wav wav
audio/ogg ogg
image/x-bmp bmp
image/gif gif
image/jpeg jpeg jpg jpe
image/png png
image/svg+xml svg
image/tiff tiff tif
image/vnd.djvu djvu
text/plain txt
text/html html htm
video/ogg ogm ogg
video/mpeg mpg mpeg
END_STRING
);

 /** Defines a set of well known mime info entries
 * This is used as a fallback to mime.info files.
 * An extensive list of well known mime types is provided by
 * the file mime.info in the includes directory.
 */
define('MM_WELL_KNOWN_MIME_INFO', <<<END_STRING
application/pdf [OFFICE]
text/javascript application/x-javascript [EXECUTABLE]
application/x-shockwave-flash [MULTIMEDIA]
audio/midi [AUDIO]
audio/x-aiff [AUDIO]
audio/x-wav [AUDIO]
audio/mp3 audio/mpeg [AUDIO]
application/ogg audio/ogg video/ogg [MULTIMEDIA]
image/x-bmp image/bmp [BITMAP]
image/gif [BITMAP]
image/jpeg [BITMAP]
image/png [BITMAP]
image/svg image/svg+xml [DRAWING]
image/tiff [BITMAP]
image/vnd.djvu [BITMAP]
text/plain [TEXT]
text/html [TEXT]
video/ogg [VIDEO]
video/mpeg [VIDEO]
unknown/unknown application/octet-stream application/x-empty [UNKNOWN]
END_STRING
);

#note: because this file is possibly included by a function,
#we need to access the global scope explicitely!
global $wgLoadFileinfoExtension;

if ($wgLoadFileinfoExtension) {
	if(!extension_loaded('fileinfo')) dl('fileinfo.' . PHP_SHLIB_SUFFIX);
}

/** Implements functions related to mime types such as detection and mapping to
* file extension,
*
* Instances of this class are stateles, there only needs to be one global instance
* of MimeMagic. Please use wfGetMimeMagic to get that instance.
* @package MediaWiki
*/
class MimeMagic {

	/**
	* Mapping of media types to arrays of mime types.
	* This is used by findMediaType and getMediaType, respectively
	*/
	var $mMediaTypes= NULL;

	/** Map of mime type aliases
	*/
	var $mMimeTypeAliases= NULL;

	/** map of mime types to file extensions (as a space seprarated list)
	*/
	var $mMimeToExt= NULL;

	/** map of file extensions types to mime types (as a space seprarated list)
	*/
	var $mExtToMime= NULL;

	/** Initializes the MimeMagic object. This is called by wfGetMimeMagic when instantiation
	* the global MimeMagic singleton object.
	*
	* This constructor parses the mime.types and mime.info files and build internal mappings.
	*/
	function MimeMagic() {
		/*
		*   --- load mime.types ---
		*/

		global $wgMimeTypeFile;

		$types= MM_WELL_KNOWN_MIME_TYPES;

		if ($wgMimeTypeFile) {
			if (is_file($wgMimeTypeFile) and is_readable($wgMimeTypeFile)) {
				wfDebug("MimeMagic::MimeMagic: loading mime types from $wgMimeTypeFile\n");

				$types.= "\n";
				$types.= file_get_contents($wgMimeTypeFile);
			}
			else wfDebug("MimeMagic::MimeMagic: can't load mime types from $wgMimeTypeFile\n");
		}
		else wfDebug("MimeMagic::MimeMagic: no mime types file defined, using build-ins only.\n");

		$types= str_replace(array("\r\n","\n\r","\n\n","\r\r","\r"),"\n",$types);
		$types= str_replace("\t"," ",$types);

		$this->mMimeToExt= array();
		$this->mToMime= array();

		$lines= explode("\n",$types);
		foreach ($lines as $s) {
			$s= trim($s);
			if (empty($s)) continue;
			if (strpos($s,'#')===0) continue;

			$s= strtolower($s);
			$i= strpos($s,' ');

			if ($i===false) continue;

			#print "processing MIME line $s<br>";

			$mime= substr($s,0,$i);
			$ext= trim(substr($s,$i+1));

			if (empty($ext)) continue;

			if (@$this->mMimeToExt[$mime]) $this->mMimeToExt[$mime] .= ' '.$ext;
			else $this->mMimeToExt[$mime]= $ext;

			$extensions= explode(' ',$ext);

			foreach ($extensions as $e) {
				$e= trim($e);
				if (empty($e)) continue;

				if (@$this->mExtToMime[$e]) $this->mExtToMime[$e] .= ' '.$mime;
				else $this->mExtToMime[$e]= $mime;
			}
		}

		/*
		*   --- load mime.info ---
		*/

		global $wgMimeInfoFile;

		$info= MM_WELL_KNOWN_MIME_INFO;

		if ($wgMimeInfoFile) {
			if (is_file($wgMimeInfoFile) and is_readable($wgMimeInfoFile)) {
				wfDebug("MimeMagic::MimeMagic: loading mime info from $wgMimeInfoFile\n");

				$info.= "\n";
				$info.= file_get_contents($wgMimeInfoFile);
			}
			else wfDebug("MimeMagic::MimeMagic: can't load mime info from $wgMimeInfoFile\n");
		}
		else wfDebug("MimeMagic::MimeMagic: no mime info file defined, using build-ins only.\n");

		$info= str_replace(array("\r\n","\n\r","\n\n","\r\r","\r"),"\n",$info);
		$info= str_replace("\t"," ",$info);

		$this->mMimeTypeAliases= array();
		$this->mMediaTypes= array();

		$lines= explode("\n",$info);
		foreach ($lines as $s) {
			$s= trim($s);
			if (empty($s)) continue;
			if (strpos($s,'#')===0) continue;

			$s= strtolower($s);
			$i= strpos($s,' ');

			if ($i===false) continue;

			#print "processing MIME INFO line $s<br>";

			$match= array();
			if (preg_match('!\[\s*(\w+)\s*\]!',$s,$match)) {
				$s= preg_replace('!\[\s*(\w+)\s*\]!','',$s);
				$mtype= trim(strtoupper($match[1]));
			}
			else $mtype= MEDIATYPE_UNKNOWN;

			$m= explode(' ',$s);

			if (!isset($this->mMediaTypes[$mtype])) $this->mMediaTypes[$mtype]= array();

			foreach ($m as $mime) {
				$mime= trim($mime);
				if (empty($mime)) continue;

				$this->mMediaTypes[$mtype][]= $mime;
			}

			if (sizeof($m)>1) {
				$main= $m[0];
				for ($i=1; $i<sizeof($m); $i+= 1) {
					$mime= $m[$i];
					$this->mMimeTypeAliases[$mime]= $main;
				}
			}
		}

	}

	/** returns a list of file extensions for a given mime type
	* as a space separated string.
	*/
	function getExtensionsForType($mime) {
		$mime= strtolower($mime);

		$r= @$this->mMimeToExt[$mime];

		if (@!$r and isset($this->mMimeTypeAliases[$mime])) {
			$mime= $this->mMimeTypeAliases[$mime];
			$r= @$this->mMimeToExt[$mime];
		}

		return $r;
	}

	/** returns a list of mime types for a given file extension
	* as a space separated string.
	*/
	function getTypesForExtension($ext) {
		$ext= strtolower($ext);

		$r= @$this->mExtToMime[$ext];
		return $r;
	}

	/** returns a single mime type for a given file extension.
	* This is always the first type from the list returned by getTypesForExtension($ext).
	*/
	function guessTypesForExtension($ext) {
		$m= $this->getTypesForExtension( $ext );
		if( is_null($m) ) return NULL;

		$m= trim( $m );
		$m= preg_replace('/\s.*$/','',$m);

		return $m;
	}


	/** tests if the extension matches the given mime type.
	* returns true if a match was found, NULL if the mime type is unknown,
	* and false if the mime type is known but no matches where found.
	*/
	function isMatchingExtension($extension,$mime) {
		$ext= $this->getExtensionsForType($mime);

		if (!$ext) {
			return NULL;  //unknown
		}

		$ext= explode(' ',$ext);

		$extension= strtolower($extension);
 		if (in_array($extension,$ext)) {
			return true;
		}

		return false;
	}

	/** returns true if the mime type is known to represent
	* an image format supported by the PHP GD library.
	*/
	function isPHPImageType( $mime ) {
		#as defined by imagegetsize and image_type_to_mime
		static $types = array(
			'image/gif', 'image/jpeg', 'image/png',
			'image/x-bmp', 'image/xbm', 'image/tiff',
			'image/jp2', 'image/jpeg2000', 'image/iff',
			'image/xbm', 'image/x-xbitmap',
			'image/vnd.wap.wbmp', 'image/vnd.xiff',
			'image/x-photoshop',
			'application/x-shockwave-flash',
		);

		return in_array( $mime, $types );
	}

	/**
	 * Returns true if the extension represents a type which can
	 * be reliably detected from its content. Use this to determine
	 * whether strict content checks should be applied to reject
	 * invalid uploads; if we can't identify the type we won't
	 * be able to say if it's invalid.
	 *
	 * @todo Be more accurate when using fancy mime detector plugins;
	 *       right now this is the bare minimum getimagesize() list.
	 * @return bool
	 */
	function isRecognizableExtension( $extension ) {
		static $types = array(
			'gif', 'jpeg', 'jpg', 'png', 'swf', 'psd',
			'bmp', 'tiff', 'tif', 'jpc', 'jp2',
			'jpx', 'jb2', 'swc', 'iff', 'wbmp',
			'xbm', 'djvu'
		);
		return in_array( strtolower( $extension ), $types );
	}


	/** mime type detection. This uses detectMimeType to detect the mim type of the file,
	* but applies additional checks to determine some well known file formats that may be missed
	* or misinterpreter by the default mime detection (namely xml based formats like XHTML or SVG).
	*
	* @param string $file The file to check
	* @param bool $useExt switch for allowing to use the file extension to guess the mime type. true by default.
	*
	* @return string the mime type of $file
	*/
	function guessMimeType( $file, $useExt=true ) {
		$fname = 'MimeMagic::guessMimeType';
		$mime= $this->detectMimeType($file,$useExt);

		// Read a chunk of the file
		$f = fopen( $file, "rt" );
		if( !$f ) return "unknown/unknown";
		$head = fread( $f, 1024 );
		fclose( $f );