使用timthumb.php图片压缩缓存类来让网站自动生成缩略图，可用于帝国cms

时间：2016-03-06 21:44:55

分类：优秀文章

我们在制作网站时很难为页面上的每个栏目、板块都制作相应大小的图片，因为这样非常费时费力，自动生成缩略图也就显得尤为重要，熟悉帝国cms的朋友都知道，帝国cms带有缩略图函数，使用效果尚可，那有没有其他的办法呢，其实有很多。

很多技术人员已经编写了开源的图片缓存生成类用于网站各处图片的缓存，今年我们用到的是timthumb.php，此类可以用来生成图片的缩略图并加以处理，如果在linux环境下安装了optipng或pngcrush工具，也可以进行网站的截图操作，例如网址导航站，这个功能非常实用。下面我们来介绍一下这个缓存类的用法。

访问地址为：http://yuming.com/timthumb.php?src=http://yuming.com/200.jpg&w=200&h=300&q=100&f=3,9|4,2&s=1&ct=1

参数均通过get请求提交，可选参数和说明如下：

src : 需要进行图片缩放的源图片地址，或者是需要进行截图操作的网页地址

webshot : 如果此值为真则进行截图操作

w : 生成图片的宽度，如果宽度或高度只设置了一个值，则根据其中一个值进行等比缩放

h : 生成图片的高度，如果高度和宽度都没有指定，则默认为100*100

zc : 生成图片的缩放模式，可选值0, 1, 2, 3, 默认为1，每个值的不同之处可看下面文件的第100行注释

q : 生成图片的质量，默认90

a : 超出部分的裁剪位置，和缩放模式有关，可选值t, b, l, r, 默认为从顶部裁剪

f : 需要对生成后的图片使用一些过滤器的话，则在这里传不同过滤器的代码和值，具体操作方法可见下面文件的第821行注解

s : 是否对生产的图片进行锐化处理

cc : 生成图片的背景画布颜色

ct : 生成png图片时背景是否透明

下面是这个图片缓存类的完整代码，带有完整的中文注释，非常棒。但是作者我们已经找不到了，感谢他的付出。

该缓存类的官方地址：https://www.binarymoon.co.uk/projects/timthumb/

折叠PHP 代码
  1. <?php  
  2. //定义版本信息  
  3. define ('VERSION', '2.8.10');  
  4. //如果有配置文件，则加载timthumb-config.php，没有的话使用下面的值  
  5. if( file_exists(dirname(__FILE__) . '/timthumb-config.php')){  
  6.   require_once('timthumb-config.php');  
  7. }  
  8. //调试日志记录到web服务器日志中  
  9. if(! defined('DEBUG_ON') ){  
  10.   define ('DEBUG_ON', false);  
  11. }  
  12. //调试级别，高于这个值的level都不会记录，1最低，3最高  
  13. if(! defined('DEBUG_LEVEL') ){  
  14.   define ('DEBUG_LEVEL', 1);  
  15. }  
  16. //最大占用内存限制30M  
  17. if(! defined('MEMORY_LIMIT') ){  
  18.   define ('MEMORY_LIMIT', '30M');  
  19. }  
  20. //关闭仿盗链  
  21. if(! defined('BLOCK_EXTERNAL_LEECHERS') ){  
  22.   define ('BLOCK_EXTERNAL_LEECHERS', false);  
  23. }                     
  24. // 允许从外部获取图片  
  25. if(! defined('ALLOW_EXTERNAL') ){  
  26.   define ('ALLOW_EXTERNAL', TRUE);  
  27. }  
  28. //允许获取所有外部站点url  
  29. if(! defined('ALLOW_ALL_EXTERNAL_SITES') ){  
  30.   define ('ALLOW_ALL_EXTERNAL_SITES', false);  
  31. }  
  32. //启用文件缓存  
  33. if(! defined('FILE_CACHE_ENABLED') ){  
  34.   define ('FILE_CACHE_ENABLED', TRUE);  
  35. }  
  36. //文件缓存更新时间，s  
  37. if(! defined('FILE_CACHE_TIME_BETWEEN_CLEANS')){  
  38.   define ('FILE_CACHE_TIME_BETWEEN_CLEANS', 86400);  
  39. }  
  40. //文件缓存生存时间，s，过了这个时间的缓存文件就会被删除  
  41. if(! defined('FILE_CACHE_MAX_FILE_AGE') ){  
  42.   define ('FILE_CACHE_MAX_FILE_AGE', 86400);  
  43. }  
  44. //缓存文件后缀  
  45. if(! defined('FILE_CACHE_SUFFIX') ){  
  46.   define ('FILE_CACHE_SUFFIX', '.timthumb.txt');  
  47. }  
  48. //缓存文件前缀  
  49. if(! defined('FILE_CACHE_PREFIX') ){  
  50.   define ('FILE_CACHE_PREFIX', 'timthumb');  
  51. }  
  52. //缓存文件目录，留空则使用系统临时目录（推荐）  
  53. if(! defined('FILE_CACHE_DIRECTORY') ){  
  54.   define ('FILE_CACHE_DIRECTORY', './cache');  
  55. }  
  56. //图片最大尺寸，此脚本最大能处理10485760字节的图片，也就是10M  
  57. if(! defined('MAX_FILE_SIZE') ){  
  58.   define ('MAX_FILE_SIZE', 10485760);  
  59. }    
  60. //CURL的超时时间  
  61. if(! defined('CURL_TIMEOUT') ){  
  62.   define ('CURL_TIMEOUT', 20);  
  63. }  
  64. //清理错误缓存的时间  
  65. if(! defined('WAIT_BETWEEN_FETCH_ERRORS') ){  
  66.   define ('WAIT_BETWEEN_FETCH_ERRORS', 3600);  
  67. }  
  68. //浏览器缓存时间  
  69. if(! defined('BROWSER_CACHE_MAX_AGE') ){  
  70.   define ('BROWSER_CACHE_MAX_AGE', 864000);  
  71. }  
  72. //关闭所有浏览器缓存  
  73. if(! defined('BROWSER_CACHE_DISABLE') ){  
  74.   define ('BROWSER_CACHE_DISABLE', false);  
  75. }  
  76. //最大图像宽度  
  77. if(! defined('MAX_WIDTH') ){  
  78.   define ('MAX_WIDTH', 1500);  
  79. }  
  80. //最大图像高度  
  81. if(! defined('MAX_HEIGHT') ){  
  82.   define ('MAX_HEIGHT', 1500);  
  83. }  
  84. //404错误时显示的提示图片地址，设置测值则不会显示具体的错误信息  
  85. if(! defined('NOT_FOUND_IMAGE') ){  
  86.   define ('NOT_FOUND_IMAGE', '');  
  87. }  
  88. //其他错误时显示的提示图片地址，设置测值则不会显示具体的错误信息  
  89. if(! defined('ERROR_IMAGE') ){  
  90.   define ('ERROR_IMAGE', '');  
  91. }  
  92. //PNG图片背景颜色，使用false代表透明  
  93. if(! defined('PNG_IS_TRANSPARENT') ){  
  94.   define ('PNG_IS_TRANSPARENT', FALSE);  
  95. }  
  96. //默认图片质量  
  97. if(! defined('DEFAULT_Q') ){  
  98.   define ('DEFAULT_Q', 90);  
  99. }  
  100. //默认 缩放/裁剪 模式，0：根据传入的值进行缩放（不裁剪）， 1：以最合适的比例裁剪和调整大小（裁剪）， 2：按比例调整大小，并添加边框（裁剪），2：按比例调整大小，不添加边框（裁剪）  
  101. if(! defined('DEFAULT_ZC') ){  
  102.   define ('DEFAULT_ZC', 1);  
  103. }  
  104. //默认需要对图片进行的处理操作，可选值和参数格式请参看processImageAndWriteToCache函数中的$filters和$imageFilters的注释  
  105. if(! defined('DEFAULT_F') ){  
  106.   define ('DEFAULT_F', '');  
  107. }  
  108. //是否对图片进行锐化  
  109. if(! defined('DEFAULT_S') ){  
  110.   define ('DEFAULT_S', 0);  
  111. }  
  112. //默认画布颜色  
  113. if(! defined('DEFAULT_CC') ){  
  114.   define ('DEFAULT_CC', 'ffffff');  
  115. }  
  116. //以下是图片压缩设置，前提是你的主机中有optipng或者pngcrush这两个工具，否则的话不会启用此功能  
  117. //此功能只对png图片有效  
  118. if(! defined('OPTIPNG_ENABLED') ){  
  119.   define ('OPTIPNG_ENABLED', false);  
  120. }    
  121. if(! defined('OPTIPNG_PATH') ){  
  122.   define ('OPTIPNG_PATH', '/usr/bin/optipng');  
  123. } //优先使用optipng,因为有更好的压缩比   
  124. if(! defined('PNGCRUSH_ENABLED') ){  
  125.   define ('PNGCRUSH_ENABLED', false);  
  126. }   
  127. if(! defined('PNGCRUSH_PATH') ){  
  128.   define ('PNGCRUSH_PATH', '/usr/bin/pngcrush');  
  129. } //optipng不存在的话，使用pngcrush  
  130. //图片压缩设置结束  
  131.    
  132.    
  133. /*  
  134.  * * 以下是网站截图配置 
  135.  * 首先，网站截图需要root权限 
  136.  * Ubuntu 上使用网站截图的步骤： 
  137.  *  1.用这个命令安装Xvfb  sudo apt-get install subversion libqt4-webkit libqt4-dev g++ xvfb 
  138.  *  2.新建一个文件夹，并下载下面的源码 
  139.  *  3.用这个命令下载最新的CutyCapt  svn co https://cutycapt.svn.sourceforge.net/svnroot/cutycapt 
  140.  *  4.进入CutyCapt文件夹 
  141.  *  5.编译并安装CutyCapt 
  142.  *  6.尝试运行以下命令：  xvfb-run --server-args="-screen 0, 1024x768x24" CutyCapt --url="http://markmaunder.com/" --out=test.png 
  143.  *  7.如果生成了一个 test.php的图片，证明一切正常，现在通过浏览器试试，访问下面的地址：http://yoursite.com/path/to/timthumb.php?src=http://markmaunder.com/&webshot=1 
  144.  * 
  145.  * 需要注意的地方： 
  146.  *  1.第一次webshot加载时，需要数秒钟，之后加载就很快了 
  147.  * 
  148.  * 高级用户： 
  149.  *  1.如果想提速大约25%，并且你了解linux，可以运行以下命令： 
  150.  *  nohup Xvfb :100 -ac -nolisten tcp -screen 0, 1024x768x24 > /dev/null 2>&1 & 
  151.  *  并设置 WEBSHOT_XVFB_RUNNING 的值为true 
  152.  * 
  153.  * */  
  154. //测试的功能，如果设置此值为true, 并在查询字符串中加上webshot=1,会让脚本返回浏览器的截图，而不是获取图像  
  155. if(! defined('WEBSHOT_ENABLED') ){  
  156.   define ('WEBSHOT_ENABLED', false);  
  157. }  
  158. //定义CutyCapt地址  
  159. if(! defined('WEBSHOT_CUTYCAPT') ){  
  160.   define ('WEBSHOT_CUTYCAPT', '/usr/local/bin/CutyCapt');  
  161. }  
  162. //Xvfb地址  
  163. if(! defined('WEBSHOT_XVFB') ){  
  164.   define ('WEBSHOT_XVFB', '/usr/bin/xvfb-run');  
  165. }  
  166. //截图屏幕宽度1024  
  167. if(! defined('WEBSHOT_SCREEN_X') ){  
  168.   define ('WEBSHOT_SCREEN_X', '1024');  
  169. }  
  170. //截图屏幕高度768  
  171. if(! defined('WEBSHOT_SCREEN_Y') ){  
  172.   define ('WEBSHOT_SCREEN_Y', '768');  
  173. }  
  174. //色深，作者说他只测试过24  
  175. if(! defined('WEBSHOT_COLOR_DEPTH') ){  
  176.   define ('WEBSHOT_COLOR_DEPTH', '24');   
  177. }  
  178. //截图格式  
  179. if(! defined('WEBSHOT_IMAGE_FORMAT') ){  
  180.   define ('WEBSHOT_IMAGE_FORMAT', 'png');  
  181. }  
  182. //截图超时时间，单位s  
  183. if(! defined('WEBSHOT_TIMEOUT') ){  
  184.   define ('WEBSHOT_TIMEOUT', '20');  
  185. }  
  186. //user_agent头  
  187. if(! defined('WEBSHOT_USER_AGENT') ){  
  188.   define ('WEBSHOT_USER_AGENT', "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.2.18) Gecko/20110614 Firefox/3.6.18");  
  189. }  
  190. //是否启用JS  
  191. if(! defined('WEBSHOT_JAVASCRIPT_ON') ){  
  192.   define ('WEBSHOT_JAVASCRIPT_ON', true);  
  193. }  
  194. //是否启用java  
  195. if(! defined('WEBSHOT_JAVA_ON') ){  
  196.   define ('WEBSHOT_JAVA_ON', false);  
  197. }  
  198. //开启flash和其他插件  
  199. if(! defined('WEBSHOT_PLUGINS_ON') ){  
  200.   define ('WEBSHOT_PLUGINS_ON', true);  
  201. }  
  202. //代理服务器  
  203. if(! defined('WEBSHOT_PROXY') ){  
  204.   define ('WEBSHOT_PROXY', '');   
  205. }  
  206. //如果运行了XVFB,此项设为true  
  207. if(! defined('WEBSHOT_XVFB_RUNNING') ){  
  208.   define ('WEBSHOT_XVFB_RUNNING', false);  
  209. }  
  210. // 如果 ALLOW_EXTERNAL 的值为真 并且 ALLOW_ALL_EXTERNAL_SITES 的值为假，那么截图的图片只能从下面这些数组中的域和子域进行  
  211. if(! isset($ALLOWED_SITES)){  
  212.   $ALLOWED_SITES = array (  
  213.     'flickr.com',  
  214.     'staticflickr.com',  
  215.     'picasa.com',  
  216.     'img.youtube.com',  
  217.     'upload.wikimedia.org',  
  218.     'photobucket.com',  
  219.     'imgur.com',  
  220.     'imageshack.us',  
  221.     'tinypic.com',  
  222.   );  
  223. }  
  224. /*截图配置结束*/  
  225.    
  226. // -------------------------------------------------------------  
  227. // -------------------------- 配置结束 ------------------------  
  228. // -------------------------------------------------------------  
  229.    
  230. timthumb::start();  
  231.    
  232. class timthumb {  
  233.     protected $src = "";  //需要获取的图片url  
  234.     protected $is404 = false;  //404错误码  
  235.     protected $docRoot = "";  //服务器文档根目录  
  236.     protected $lastURLError = false; //上一次请求外部url的错误信息  
  237.     protected $localImage = ""; //如果请求的url是本地图片，则为本地图片的地址  
  238.     protected $localImageMTime = 0;  //本地图片的修改时间  
  239.     protected $url = false;  //用parse_url解析src后的数组  
  240.         protected $myHost = "";  //本机域名  
  241.     protected $isURL = false;  //是否为外部图片地址  
  242.     protected $cachefile = ''; //缓存文件地址  
  243.     protected $errors = array();  //错误信息列表  
  244.     protected $toDeletes = array(); //析构函数中需要删除的资源列表  
  245.     protected $cacheDirectory = ''; //缓存地址  
  246.     protected $startTime = 0;  //开始时间  
  247.     protected $lastBenchTime = 0; //上一次debug完成的时间  
  248.     protected $cropTop = false;  //是否启用裁剪  
  249.     protected $salt = "";  //文件修改时间和inode连接的字符串的盐值  
  250.     protected $fileCacheVersion = 1; //文件缓存版本，当这个类升级或者被更改时，这个值应该改变，从而重新生成缓存  
  251.     protected $filePrependSecurityBlock = "<?php die('Execution denied!'); //"; //缓存文件安全头，防止直接访问  
  252.     protected static $curlDataWritten = 0;  //将curl获取到的数据写入缓存文件的长度  
  253.     protected static $curlFH = false;  //curl请求成功后要将获取到的数据写到此文件内  
  254.     /*外部调用接口*/  
  255.     public static function start(){  
  256.         //实例化模型  
  257.         $tim = new timthumb();  
  258.         //检查实例化模型时是否有错误  
  259.         $tim->handleErrors();  
  260.         //此函数为空，用做自定义的数据验证  
  261.         $tim->securityChecks();  
  262.         //尝试读取浏览器缓存  
  263.         if($tim->tryBrowserCache()){  
  264.             //成功的话就输出缓存  
  265.             exit(0);  
  266.         }  
  267.         //检测错误  
  268.         $tim->handleErrors();  
  269.         //如果启用了文件缓存，并且读取服务端缓存  
  270.         if(FILE_CACHE_ENABLED && $tim->tryServerCache()){  
  271.             //成功的话输出缓存  
  272.             exit(0);  
  273.         }  
  274.         //检测读取服务端缓存时的错误  
  275.         $tim->handleErrors();  
  276.         //生成和处理图片主函数  
  277.         $tim->run();  
  278.         //检测图片生成和处理时的错误  
  279.         $tim->handleErrors();  
  280.         //程序执行完毕运行析构方法并退出  
  281.         exit(0);  
  282.     }  
  283.     /*构造方法，用来获取和设置一些基本属性*/  
  284.     public function __construct(){  
  285.         //将允许的域设为全局变量  
  286.         global $ALLOWED_SITES;  
  287.         //记录开始时间  
  288.         $this->startTime = microtime(true);  
  289.         //设置时区  
  290.         date_default_timezone_set('UTC');  
  291.         //写日志，记录请求IP和请求URL  
  292.         $this->debug(1, "Starting new request from " . $this->getIP() . " to " . $_SERVER['REQUEST_URI']);  
  293.         //获取服务器文档根目录  
  294.         $this->calcDocRoot();  
  295.         //获取文件的修改时间和inode,inode只在linux系统下有效  
  296.         $this->salt = @filemtime(__FILE__) . '-' . @fileinode(__FILE__);  
  297.         //记录salt信息，级别3  
  298.         $this->debug(3, "Salt is: " . $this->salt);  
  299.         //如果定义了缓存文件地址  
  300.         if(FILE_CACHE_DIRECTORY){  
  301.             //如果这个地址不存在，或为非目录  
  302.             if(! is_dir(FILE_CACHE_DIRECTORY)){  
  303.                     //建立这个目录  
  304.                 @mkdir(FILE_CACHE_DIRECTORY);  
  305.                 //如果建立失败  
  306.                 if(! is_dir(FILE_CACHE_DIRECTORY)){  
  307.                     //记录错误信息，停止执行  
  308.                     $this->error("Could not create the file cache directory.");  
  309.                     return false;  
  310.                 }  
  311.             }  
  312.             //将缓存地址写入成员属性  
  313.             $this->cacheDirectory = FILE_CACHE_DIRECTORY;  
  314.             //在缓存目录下创建一个index.html文件，防止列目录  
  315.             if (!touch($this->cacheDirectory . '/index.html')) {  
  316.                 //如果出错，记录错误信息  
  317.                 $this->error("Could not create the index.html file - to fix this create an empty file named index.html file in the cache directory.");  
  318.             }  
  319.         //如果没定义缓存文件地址，则用系统的临时文件目录做为缓存文件目录  
  320.         } else {  
  321.             $this->cacheDirectory = sys_get_temp_dir();  
  322.         }  
  323.         //进行缓存检查，清除过期缓存  
  324.         $this->cleanCache();  
  325.         //记录本机域名  
  326.         $this->myHost = preg_replace('/^www\./i', '', $_SERVER['HTTP_HOST']);  
  327.         //获取图片地址，此地址应该由$_GET中的src参数传递  
  328.         $this->src = $this->param('src');  
  329.         //此数组是解析src后的结果，包括scheme,host,port,user,pass,path,query,fragment其中一个或多个值  
  330.         $this->url = parse_url($this->src);  
  331.         //如果图片地址是本机的，则删除图片url中本机的域名部分  
  332.         $this->src = preg_replace('/https?:\/\/(?:www\.)?' . $this->myHost . '/i', '', $this->src);  
  333.         //如果图片地址的长度小于3，则是无效地址  
  334.         if(strlen($this->src) <= 3){  
  335.             //添加错误信息  
  336.             $this->error("No image specified");  
  337.             return false;  
  338.         }  
  339.         //如果开启了防盗链，并且存在来源地址，也就是HTTP_REFERER头，并且来源地址不是本机，则进行防盗链处理  
  340.         if(BLOCK_EXTERNAL_LEECHERS && array_key_exists('HTTP_REFERER', $_SERVER) && (! preg_match('/^https?:\/\/(?:www\.)?' . $this->myHost . '(?:$|\/)/i', $_SERVER['HTTP_REFERER']))){  
  341.             //此base64编码的内容是一张显示 No Hotlinking的图片  
  342.             $imgData = base64_decode("R0lGODlhUAAMAIAAAP8AAP///yH5BAAHAP8ALAAAAABQAAwAAAJpjI+py+0Po5y0OgAMjjv01YUZ\nOGplhWXfNa6JCLnWkXplrcBmW+spbwvaVr/cDyg7IoFC2KbYVC2NQ5MQ4ZNao9Ynzjl9ScNYpneb\nDULB3RP6JuPuaGfuuV4fumf8PuvqFyhYtjdoeFgAADs=");  
  343.             //显示内容为gif图片  
  344.             header('Content-Type: image/gif');  
  345.             //内容长度  
  346.             header('Content-Length: ' . sizeof($imgData));  
  347.             //无网页缓存  
  348.             header('Cache-Control: no-store, no-cache, must-revalidate, max-age=0');  
  349.             //兼容http1.0和https  
  350.             header("Pragma: no-cache");  
  351.             //内容立即过期  
  352.             header('Expires: ' . gmdate ('D, d M Y H:i:s', time()));  
  353.             //输出图片  
  354.             echo $imgData;  
  355.             return false;  
  356.             //退出脚本  
  357.             exit(0);  
  358.         }  
  359.         //如果此时的src属性包含http等字符，说明是外部链接  
  360.         if(preg_match('/^https?:\/\/[^\/]+/i', $this->src)){  
  361.             //写日志，说明这个链接是外部的，级别2  
  362.             $this->debug(2, "Is a request for an external URL: " . $this->src);  
  363.             //将isURL设为true，说明是外部url  
  364.             $this->isURL = true;  
  365.         //如果不包含的话，说明是内部链接  
  366.         } else {  
  367.             $this->debug(2, "Is a request for an internal file: " . $this->src);  
  368.         }  
  369.         //如果图片的src是外部网站，并且配置文件不允许从外部获取图片，则退出  
  370.         if($this->isURL && (! ALLOW_EXTERNAL)){  
  371.             $this->error("You are not allowed to fetch images from an external website.");  
  372.             return false;  
  373.         }  
  374.         //如果允许从外部网站获取图片  
  375.         if($this->isURL){  
  376.             //并且配置文件允许从所有的外部网站获取图片  
  377.             if(ALLOW_ALL_EXTERNAL_SITES){  
  378.                 //写日志，允许从外部网站取回图片，级别2  
  379.                 $this->debug(2, "Fetching from all external sites is enabled.");  
  380.             //如果配置文件不允许从所有的外部网站获取图片  
  381.             } else {  
  382.                 //写日志，只能从指定的外部网站获取图片，级别2  
  383.                 $this->debug(2, "Fetching only from selected external sites is enabled.");  
  384.                 //此为验证位，默认为false  
  385.                 $allowed = false;  
  386.                 //遍历配置文件中允许站点的列表  
  387.                 foreach($ALLOWED_SITES as $site){  
  388.                     //这里对图片的url跟允许访问站点的列表进行验证，前面的条件对应的是有主机名的，后面的内容对应的是没有主机名的，写的很精巧  
  389.                     if ((strtolower(substr($this->url['host'],-strlen($site)-1)) === strtolower(".$site")) || (strtolower($this->url['host'])===strtolower($site))) {  
  390.                         //通过验证则写一条日志，验证成功，级别3  
  391.                         $this->debug(3, "URL hostname {$this->url['host']} matches $site so allowing.");  
  392.                         //验证位为true  
  393.                         $allowed = true;  
  394.                     }  
  395.                 }  
  396.                 //如果没通过验证， 写错误信息并退出  
  397.                 if(! $allowed){  
  398.                     return $this->error("You may not fetch images from that site. To enable this site in timthumb, you can either add it to \$ALLOWED_SITES and set ALLOW_EXTERNAL=true. Or you can set ALLOW_ALL_EXTERNAL_SITES=true, depending on your security needs.");  
  399.                 }  
  400.             }  
  401.         }  
  402.         //缓存文件的前缀，如果是内部图片，用_int_，外部图片用_ext_  
  403.         $cachePrefix = ($this->isURL ? '_ext_' : '_int_');  
  404.         //如果是外部图片地址  
  405.         if($this->isURL){  
  406.             //得到GET字符串的数组  
  407.             $arr = explode('&', $_SERVER ['QUERY_STRING']);  
  408.             //按字母顺序对数组元素排序  
  409.             asort($arr);  
  410.             //生成缓存文件地址  缓存目录 + / + 缓存前缀 + $cachePrefix + 唯一散列值  + 缓存后缀  
  411.             $this->cachefile = $this->cacheDirectory . '/' . FILE_CACHE_PREFIX . $cachePrefix . md5($this->salt . implode('', $arr) . $this->fileCacheVersion) . FILE_CACHE_SUFFIX;  
  412.         //如果是本地图片  
  413.         } else {  
  414.             //获取本地图片地址  
  415.             $this->localImage = $this->getLocalImagePath($this->src);  
  416.             //如果获取不到地址  
  417.             if(! $this->localImage){  
  418.                 //写日志，没有找到此文件，级别1  
  419.                 $this->debug(1, "Could not find the local image: {$this->localImage}");  
  420.                 //记录错误信息  
  421.                 $this->error("Could not find the internal image you specified.");  
  422.                 //设置404错误信息  
  423.                 $this->set404();  
  424.                 //终止执行程序  
  425.                 return false;  
  426.             }  
  427.             //写日志，记录本地图片信息，级别1  
  428.             $this->debug(1, "Local image path is {$this->localImage}");  
  429.             //获取文件修改时间  
  430.             $this->localImageMTime = @filemtime($this->localImage);  
  431.             //生成缓存文件地址,  缓存目录 + / + 缓存前缀 + $cachePrefix + 唯一散列值 + 缓存后缀  
  432.             $this->cachefile = $this->cacheDirectory . '/' . FILE_CACHE_PREFIX . $cachePrefix . md5($this->salt . $this->localImageMTime . $_SERVER ['QUERY_STRING'] . $this->fileCacheVersion) . FILE_CACHE_SUFFIX;  
  433.         }  
  434.         //记录缓存文件地址  
  435.         $this->debug(2, "Cache file is: " . $this->cachefile);  
  436.         //构造函数完成  
  437.         return true;  
  438.     }  
  439.     /*析构方法，删除toDeletes数组中的每一个文件*/  
  440.     public function __destruct(){  
  441.         foreach($this->toDeletes as $del){  
  442.             $this->debug(2, "Deleting temp file $del");  
  443.             @unlink($del);  
  444.         }  
  445.     }  
  446.     /*主函数，通过不同参数调用不同的图片处理函数*/  
  447.     public function run(){  
  448.         //如果是外部的图片链接  
  449.         if($this->isURL){  
  450.             //但是配置文件不允许从外部获取链接  
  451.             if(! ALLOW_EXTERNAL){  
  452.                 //写日志，说明配置文件禁止访问外部图片，级别1  
  453.                 $this->debug(1, "Got a request for an external image but ALLOW_EXTERNAL is disabled so returning error msg.");  
  454.                 //写错误记录  
  455.                 $this->error("You are not allowed to fetch images from an external website.");  
  456.                 //退出执行  
  457.                 return false;  
  458.             }  
  459.             //配置文件允许从外部获取链接，则写日志，接着运行，级别3  
  460.             $this->debug(3, "Got request for external image. Starting serveExternalImage.");  
  461.             //如果get了webshot参数并且为真，则进行截图操作  
  462.             if($this->param('webshot')){  
  463.                 //如果配置文件允许截图  
  464.                 if(WEBSHOT_ENABLED){  
  465.                         //写日志，说明要进行截图操作，级别3  
  466.                     $this->debug(3, "webshot param is set, so we're going to take a webshot.");  
  467.                     //截图操作  
  468.                     $this->serveWebshot();  
  469.                 //如果配置文件不允许截图  
  470.                 } else {  
  471.                     //记录错误信息并退出  
  472.                     $this->error("You added the webshot parameter but webshots are disabled on this server. You need to set WEBSHOT_ENABLED == true to enable webshots.");  
  473.                 }  
  474.             //如果不存在sebshot参数或为假  
  475.             } else {  
  476.                 //写日志，记录不进行截图操作，级别3  
  477.                 $this->debug(3, "webshot is NOT set so we're going to try to fetch a regular image.");  
  478.                 //从外部URL获得图片并处理  
  479.                 $this->serveExternalImage();  
  480.    
  481.             }  
  482.         //否则的话就是内部图片  
  483.         } else {  
  484.             //写日志，记录是内部图片，级别3  
  485.             $this->debug(3, "Got request for internal image. Starting serveInternalImage()");  
  486.             //获得内部图片并处理  
  487.             $this->serveInternalImage();  
  488.         }  
  489.         //程序执行完毕  
  490.         return true;  
  491.     }  
  492.     /*此函数用来处理错误*/  
  493.     protected function handleErrors(){  
  494.         //如果错误列表中有内容  
  495.         if($this->haveErrors()){  
  496.             //首先检测404错误，如果设置了404图片地址并且的确有404错误  
  497.             if(NOT_FOUND_IMAGE && $this->is404()){  
  498.                 //那么输出错误图片，并退出脚本  
  499.                 if($this->serveImg(NOT_FOUND_IMAGE)){  
  500.                     exit(0);  
  501.                 //输出失败的话记录错误信息  
  502.                 } else {  
  503.                     $this->error("Additionally, the 404 image that is configured could not be found or there was an error serving it.");  
  504.                 }  
  505.             }  
  506.             //如果没有404错误，并且定义了错误图片，那么输出此图片  
  507.             if(ERROR_IMAGE){  
  508.                 //输出其他错误提示图片，并退出脚本  
  509.                 if($this->serveImg(ERROR_IMAGE)){  
  510.                     exit(0);  
  511.                 //输出失败的话记录错误信息  
  512.                 } else {  
  513.                     $this->error("Additionally, the error image that is configured could not be found or there was an error serving it.");  
  514.                 }  
  515.             }  
  516.             //如果上面两个常量都没定义，则根据模板输出详细错误信息  
  517.             $this->serveErrors();   
  518.             exit(0);   
  519.         }  
  520.         //没有错误的话返回假  
  521.         return false;  
  522.     }  
  523.     /*此函数用来读取浏览器缓存文件，前提是浏览器缓存的文件有效，具体的实现请看函数内部*/  
  524.     protected function tryBrowserCache(){  
  525.         //如果配置文件关闭了所有浏览器缓存，则写日志，并返回假  
  526.         if(BROWSER_CACHE_DISABLE){   
  527.             $this->debug(3, "Browser caching is disabled"); return false;   
  528.         }  
  529.         //如果浏览器记录了页面上次修改的时间  
  530.         if(!emptyempty($_SERVER['HTTP_IF_MODIFIED_SINCE']) ){  
  531.             //写日志，记录，级别3  
  532.             $this->debug(3, "Got a conditional get");  
  533.             //缓存文件最后修改时间  
  534.             $mtime = false;  
  535.             //如果缓存地址无效  
  536.             if(! is_file($this->cachefile)){  
  537.                 //说明没有缓存，返回假  
  538.                 return false;  
  539.             }  
  540.             //如果存在本地图片修改时间，也就是说所请求的图片是本机的  
  541.             if($this->localImageMTime){  
  542.                 //缓存文件修改时间设置为本地图片修改时间  
  543.                 $mtime = $this->localImageMTime;  
  544.                 //写日志，记录实际文件修改时间，级别3  
  545.                 $this->debug(3, "Local real file's modification time is $mtime");  
  546.             //如果请求的图片不是本地的  
  547.             } else if(is_file($this->cachefile)){  
  548.                 //获取缓存文件修改时间  
  549.                 $mtime = @filemtime($this->cachefile);  
  550.                 //写日志，记录缓存文件修改时间，级别3  
  551.                 $this->debug(3, "Cached file's modification time is $mtime");  
  552.             }  
  553.             //如果没有获取到缓存文件最后修改时间，说明没有缓存，退出  
  554.             if(! $mtime){ return false; }  
  555.             //将浏览器中存储的上次修改时间转为时间戳  
  556.             $iftime = strtotime($_SERVER['HTTP_IF_MODIFIED_SINCE']);  
  557.             //写日志，记录UNIX时间戳，级别3  
  558.             $this->debug(3, "The conditional get's if-modified-since unixtime is $iftime");  
  559.             //如果这个时间小于1秒，说明值无效，退出  
  560.             if($iftime < 1){  
  561.                 //写日志，记录此值无效  
  562.                 $this->debug(3, "Got an invalid conditional get modified since time. Returning false.");  
  563.                 return false;  
  564.             }  
  565.             //如果浏览器存储的时间小于实际缓存文件的最后修改时间，也就是说距上次访问后，文件被更改了，要重新请求页面  
  566.             if($iftime < $mtime){  
  567.                 //写日志，记录文件已被更改，级别3  
  568.                 $this->debug(3, "File has been modified since last fetch.");  
  569.                 return false;  
  570.             //否则就不用重新请求页面，直接读取缓存  
  571.             } else {  
  572.                 //写日志，记录缓存有效，直接读取缓存，级别3  
  573.                 $this->debug(3, "File has not been modified since last get, so serving a 304.");  
  574.                 //设置HTTP头响应码为304  
  575.                 header ($_SERVER['SERVER_PROTOCOL'] . ' 304 Not Modified'); 
  576.                 //记录此次操作，级别1 
  577.                 $this->debug(1, "Returning 304 not modified"); 
  578.                 //读取成功返回真 
  579.                 return true; 
  580.             } 
  581.         } 
  582.         //没有读取到缓存，返回假 
  583.         return false; 
  584.     } 
  585.     /*此函数用来运行缓存文件的GC和读取服务器上的缓存文件*/ 
  586.     protected function tryServerCache(){ 
  587.         //写日志，记录将读取服务端缓存，级别3 
  588.         $this->debug(3, "Trying server cache"); 
  589.         //如果缓存文件存在 
  590.         if(file_exists($this->cachefile)){ 
  591.             //写日志，记录缓存文件存在 
  592.             $this->debug(3, "Cachefile {$this->cachefile} exists"); 
  593.             //如果请求的是外部图片地址 
  594.             if($this->isURL){ 
  595.                 //写日志，记录这是一次外部请求，级别3 
  596.                 $this->debug(3, "This is an external request, so checking if the cachefile is empty which means the request failed previously."); 
  597.                 //如果缓存文件的大小小于1，也就是说是一个无效的缓存文件 
  598.                 if(filesize($this->cachefile) < 1){ 
  599.                     //写日志，记录这是一个空的缓存文件，级别3 
  600.                     $this->debug(3, "Found an empty cachefile indicating a failed earlier request. Checking how old it is."); 
  601.                     //如果已到了配置文件中清理无效缓存的时间 
  602.                     if(time() - @filemtime($this->cachefile) > WAIT_BETWEEN_FETCH_ERRORS){ 
  603.                         //写日志，记录这次删除操作，级别3 
  604.                         $this->debug(3, "File is older than " . WAIT_BETWEEN_FETCH_ERRORS . " seconds. Deleting and returning false so app can try and load file."); 
  605.                         //删除此缓存文件 
  606.                         @unlink($this->cachefile); 
  607.                         //返回假，说明没有读取到服务端缓存 
  608.                         return false; 
  609.                     //否则，空的缓存文件说明上次请求失败，所以要写错误记录 
  610.                     } else { 
  611.                         //写日志，记录空的缓存文件依然有效，级别3 
  612.                         $this->debug(3, "Empty cachefile is still fresh so returning message saying we had an error fetching this image from remote host."); 
  613.                         //设置404错误 
  614.                         $this->set404(); 
  615.                         //设置错误信息 
  616.                         $this->error("An error occured fetching image."); 
  617.                         //返回假代表没有得到缓存 
  618.                         return false;  
  619.                     } 
  620.                 } 
  621.             //否则就是正确的缓存文件 
  622.             } else { 
  623.                 //写日志，记录将要直接读取缓存文件，级别3 
  624.                 $this->debug(3, "Trying to serve cachefile {$this->cachefile}"); 
  625.             } 
  626.             //如果输出图像缓存成功 
  627.             if($this->serveCacheFile()){ 
  628.                 //写日志，记录缓存文件信息，级别3 
  629.                 $this->debug(3, "Succesfully served cachefile {$this->cachefile}"); 
  630.                 return true; 
  631.             //如果不成功 
  632.             } else { 
  633.                 //写日志，记录错误信息，级别3 
  634.                 $this->debug(3, "Failed to serve cachefile {$this->cachefile} - Deleting it from cache."); 
  635.                 //删除此无效缓存，以便下次请求能重新创建 
  636.                 @unlink($this->cachefile); 
  637.                 //同样返回真,因为在serverCacheFile已经记录了错误信息 
  638.                 return true; 
  639.             } 
  640.         } 
  641.     } 
  642.     /*此函数用来记录错误信息*/ 
  643.     protected function error($err){ 
  644.         //写记录，记录错误信息，级别3 
  645.         $this->debug(3, "Adding error message: $err"); 
  646.         //记录到错误信息数组 
  647.         $this->errors[] = $err; 
  648.         return false; 
  649.     } 
  650.     /*测函数用来检测存储错误信息的数组中是否有内容，也就是说在上一个操作中，是否有错误*/ 
  651.     protected function haveErrors(){ 
  652.         if(sizeof($this->errors) > 0){ 
  653.             return true; 
  654.         } 
  655.         return false; 
  656.     } 
  657.     /*此函数输出已存储的错误信息*/ 
  658.     protected function serveErrors(){ 
  659.         //设置http头 
  660.       header ($_SERVER['SERVER_PROTOCOL'] . ' 400 Bad Request'); 
  661.         //循环输出错误列表信息 
  662.         $html = '<ul>'; 
  663.         foreach($this->errors as $err){ 
  664.             $html .= '<li>' . htmlentities($err) . '</li>'; 
  665.         } 
  666.         $html .= '</ul>'; 
  667.         //输出其他错误信息 
  668.         echo '<h1>A TimThumb error has occured</h1>The following error(s) occured:<br />' . $html . '<br />'; 
  669.         echo '<br />Query String : ' . htmlentities ($_SERVER['QUERY_STRING']); 
  670.         echo '<br />TimThumb version : ' . VERSION . '</pre>'; 
  671.     } 
  672.     /*此函数用来读取本地图片*/ 
  673.     protected function serveInternalImage(){ 
  674.         //写日志，记录本地图片地址 
  675.         $this->debug(3, "Local image path is $this->localImage"); 
  676.         //如果地址无效 
  677.         if(! $this->localImage){ 
  678.             //记录此错误，并退出执行 
  679.             $this->sanityFail("localImage not set after verifying it earlier in the code."); 
  680.             return false; 
  681.         } 
  682.         //获取本地图片大小 
  683.         $fileSize = filesize($this->localImage); 
  684.         //如果本地图片的尺寸超过配置文件的相关设置 
  685.         if($fileSize > MAX_FILE_SIZE){ 
  686.             //记录错误原因，并退出 
  687.             $this->error("The file you specified is greater than the maximum allowed file size."); 
  688.             return false; 
  689.         } 
  690.         //如果获取到的图片尺寸无效 
  691.         if($fileSize <= 0){ 
  692.             //记录错误并退出 
  693.             $this->error("The file you specified is <= 0 bytes."); 
  694.             return false; 
  695.         } 
  696.         //如果通过了以上验证，则写日志，记录将用processImageAndWriteToCache函数处理本地图片 
  697.         $this->debug(3, "Calling processImageAndWriteToCache() for local image."); 
  698.         //处理成功则从缓存返回图片 
  699.         if($this->processImageAndWriteToCache($this->localImage)){ 
  700.             $this->serveCacheFile(); 
  701.             return true; 
  702.         //失败则返回假 
  703.         } else {  
  704.             return false; 
  705.         } 
  706.     } 
  707.     /*此函数用来清理缓存*/ 
  708.     protected function cleanCache(){ 
  709.         //如果定义的缓存时间小于0，则退出 
  710.         if (FILE_CACHE_TIME_BETWEEN_CLEANS < 0) { 
  711.             return; 
  712.         } 
  713.         //写日志，记录清除缓存操作，级别3 
  714.         $this->debug(3, "cleanCache() called"); 
  715.         //此文件为记录上次进行清除缓存操作的时间戳文件 
  716.         $lastCleanFile = $this->cacheDirectory . '/timthumb_cacheLastCleanTime.touch'; 
  717.           
  718.         //如果上面定义的文件不存在，说明这是第一次进行清除缓存操作，创建此文件并返回空即可 
  719.         if(! is_file($lastCleanFile)){ 
  720.             //写日志，记录创建文件，级别1 
  721.             $this->debug(1, "File tracking last clean doesn't exist. Creating $lastCleanFile");  
  722.             //创建此文件  
  723.             if (!touch($lastCleanFile)) {  
  724.                 //失败的话报错并退出  
  725.                 $this->error("Could not create cache clean timestamp file.");  
  726.             }  
  727.             return;  
  728.         }  
  729.         //如果已超过缓存时间  
  730.         if(@filemtime($lastCleanFile) < (time() - FILE_CACHE_TIME_BETWEEN_CLEANS) ){  
  731.             //写日志，记录下面进行的清除缓存操作  
  732.             $this->debug(1, "Cache was last cleaned more than " . FILE_CACHE_TIME_BETWEEN_CLEANS . " seconds ago. Cleaning now.");  
  733.             //创建新的清除缓存时间戳文件  
  734.             if (!touch($lastCleanFile)) {  
  735.                 //失败的话记录错误信息  
  736.                 $this->error("Could not create cache clean timestamp file.");  
  737.             }  
  738.             //此数组存的是所有缓存文件，根据前面定义的缓存文件目录和缓存文件后缀得到的  
  739.             $files = glob($this->cacheDirectory . '/*' . FILE_CACHE_SUFFIX);  
  740.             //如果有缓存文件  
  741.             if ($files) {  
  742.                 //计算当前时间和缓存最大生存时间的差值，用于下面判断缓存文件是否删除  
  743.                 $timeAgo = time() - FILE_CACHE_MAX_FILE_AGE;  
  744.                 //遍历缓存文件数组  
  745.                 foreach($files as $file){  
  746.                     //如果文件创建时间小于上面计算的值，也就是说此缓存文件的死期到了，就删除它  
  747.                     if(@filemtime($file) < $timeAgo){  
  748.                             //记录删除缓存文件，级别3  
  749.                         $this->debug(3, "Deleting cache file $file older than max age: " . FILE_CACHE_MAX_FILE_AGE . " seconds");  
  750.                         @unlink($file);  
  751.                     }  
  752.                 }  
  753.             }  
  754.             return true;  
  755.         //如果没超过缓存时间，则不用清除  
  756.         } else {  
  757.             //写日志，记录不用清除缓存  
  758.             $this->debug(3, "Cache was cleaned less than " . FILE_CACHE_TIME_BETWEEN_CLEANS . " seconds ago so no cleaning needed.");  
  759.         }  
  760.         return false;  
  761.     }  
  762.     /*核心函数，处理图片并写入缓存*/  
  763.     protected function processImageAndWriteToCache($localImage){  
  764.         //获取图片信息  
  765.         $sData = getimagesize($localImage);  
  766.         //图像类型标记  
  767.         $origType = $sData[2];  
  768.         //mime类型  
  769.         $mimeType = $sData['mime'];  
  770.         //写日志，记录传入图像的mime类型  
  771.         $this->debug(3, "Mime type of image is $mimeType");  
  772.         //进行图像mime类型验证，只允许gif , jpg 和 png  
  773.         if(! preg_match('/^image\/(?:gif|jpg|jpeg|png)$/i', $mimeType)){  
  774.             //如果不是这四种类型，记录错误信息，并退出脚本  
  775.             return $this->error("The image being resized is not a valid gif, jpg or png.");  
  776.         }  
  777.         //图片处理需要GD库支持，这里检测是否安装了GD库  
  778.         if (!function_exists ('imagecreatetruecolor')) {  
  779.             //没有安装的话推出脚本  
  780.             return $this->error('GD Library Error: imagecreatetruecolor does not exist - please contact your webhost and ask them to install the GD library');  
  781.         }  
  782.         //如果安装了GD库，并且支持图像过滤器函数imagefilter，且支持IMG_FILTER_NEGATE常量  
  783.         if (function_exists ('imagefilter') && defined ('IMG_FILTER_NEGATE')) {  
  784.             //定义一个过滤器效果数组，后面的数字代表需要额外传入的参数  
  785.             $imageFilters = array (  
  786.                     //负片  
  787.                 1 => array (IMG_FILTER_NEGATE, 0),  
  788.                 //黑白的  
  789.                 2 => array (IMG_FILTER_GRAYSCALE, 0),  
  790.                 //亮度级别  
  791.                 3 => array (IMG_FILTER_BRIGHTNESS, 1),  
  792.                 //对比度级别  
  793.                 4 => array (IMG_FILTER_CONTRAST, 1),  
  794.                 //图像转换为制定颜色  
  795.                 5 => array (IMG_FILTER_COLORIZE, 4),  
  796.                 //突出边缘  
  797.                 6 => array (IMG_FILTER_EDGEDETECT, 0),  
  798.                 //浮雕  
  799.                 7 => array (IMG_FILTER_EMBOSS, 0),  
  800.                 //用高斯算法模糊图像  
  801.                 8 => array (IMG_FILTER_GAUSSIAN_BLUR, 0),  
  802.                 //模糊图像  
  803.                 9 => array (IMG_FILTER_SELECTIVE_BLUR, 0),  
  804.                 //平均移除法来达到轮廓效果  
  805.                 10 => array (IMG_FILTER_MEAN_REMOVAL, 0),  
  806.                 //平滑处理  
  807.                 11 => array (IMG_FILTER_SMOOTH, 0),  
  808.             );  
  809.         }  
  810.    
  811.         //生成图片宽度，由get中w参数指定，默认为0          
  812.         $new_width =  (int) abs ($this->param('w', 0));  
  813.         //生成图片高度，由get中h参数指定，默认为0  
  814.         $new_height = (int) abs ($this->param('h', 0));  
  815.         //生成图片缩放模式，由get中zc参数指定，默认为配置文件中DEFAULT_ZC的值  
  816.         $zoom_crop = (int) $this->param('zc', DEFAULT_ZC);  
  817.         //生成图片的质量，由get中q参数指定，默认为配置文件中DEFAULT_Q的值  
  818.         $quality = (int) abs ($this->param('q', DEFAULT_Q));  
  819.         //裁剪的位置  
  820.         $align = $this->cropTop ? 't' : $this->param('a', 'c');  
  821.         //需要进行的图片处理操作，多个过滤器用"|"分割，可选参数请参看$imageFilters处的注释，由于不同的过滤器需要的参数不同，如一个过滤器需要多个参数，多个参数用,分隔。例:1,2|3,1,1  代表对图像分别应用1和3过滤效果，1和3所对应的过滤效果是由$imageFilters数组确定的，其中1号过滤器还需要一个额外的参数，这里传了1，3号过滤器还需要2个额外的参数，这里传了1和1.  
  822.         $filters = $this->param('f', DEFAULT_F);  
  823.         //是否对图片进行锐化，由get中s参数指定，默认为配置文件中DEFAULT_S的值  
  824.         $sharpen = (bool) $this->param('s', DEFAULT_S);  
  825.         //生成图片的默认背景画布颜色，由get中cc参数指定，默认为配置文件中DEFAULT_CC的值  
  826.         $canvas_color = $this->param('cc', DEFAULT_CC);  
  827.         //生成png图片的背景是否透明  
  828.         $canvas_trans = (bool) $this->param('ct', '1');  
  829.    
  830.         // 如果高度和宽度都没有指定，设置他们为100*100  
  831.         if ($new_width == 0 && $new_height == 0) {  
  832.             $new_width = 100;  
  833.             $new_height = 100;  
  834.         }  
  835.    
  836.         // 限制最大高度和最大宽度  
  837.         $new_width = min ($new_width, MAX_WIDTH);  
  838.         $new_height = min ($new_height, MAX_HEIGHT);  
  839.    
  840.         // 检测并设置php运行最大占用内存  
  841.         $this->setMemoryLimit();  
  842.    
  843.         // 打开图像资源  
  844.         $image = $this->openImage ($mimeType, $localImage);  
  845.         //如果打开失败，记录信息并退出脚本  
  846.         if ($image === false) {  
  847.             return $this->error('Unable to open image.');  
  848.         }  
  849.    
  850.         // 获得原始图片，也就是上面打开图片的宽和高  
  851.         $width = imagesx ($image);  
  852.         $height = imagesy ($image);  
  853.         $origin_x = 0;  
  854.         $origin_y = 0;  
  855.    
  856.         // 如果新生成图片的宽或高没有指定，则用此等比算法算出高或宽的值  
  857.         if ($new_width && !$new_height) {  
  858.             $new_height = floor ($height * ($new_width / $width));  
  859.         } else if ($new_height && !$new_width) {  
  860.             $new_width = floor ($width * ($new_height / $height));  
  861.         }  
  862.    
  863.         // 如果缩放模式选择的是3，也就是说get中zc=3或者配置文件中DEFAULT_ZC=3，则进行等比缩放,不裁剪  
  864.         if ($zoom_crop == 3) {  
  865.    
  866.             $final_height = $height * ($new_width / $width);  
  867.             //根据等比算法设置等比计算后的宽或高  
  868.             if ($final_height > $new_height) {  
  869.                 $new_width = $width * ($new_height / $height);  
  870.             } else {  
  871.                 $new_height = $final_height;  
  872.             }  
  873.    
  874.         }  
  875.    
  876.         // 利用处理完毕的长和宽创建新画布，  
  877.         $canvas = imagecreatetruecolor ($new_width, $new_height);  
  878.         //关闭混色模式，也就是把PNG的alpha值保存，从而使背景透明  
  879.         imagealphablending ($canvas, false);  
  880.         //进行默认画布颜色的检测并转换，如果给出的是3个字符长度表示的颜色值  
  881.         if (strlen($canvas_color) == 3) { //if is 3-char notation, edit string into 6-char notation  
  882.             //转换为6个字符表示的颜色值  
  883.             $canvas_color =  str_repeat(substr($canvas_color, 0, 1), 2) . str_repeat(substr($canvas_color, 1, 1), 2) . str_repeat(substr($canvas_color, 2, 1), 2);   
  884.         //如果不是3个长度也不是6个长度的字符串，则为非法字符串，设置为默认值  
  885.         } else if (strlen($canvas_color) != 6) {  
  886.             $canvas_color = DEFAULT_CC;  
  887.         }  
  888.         //将上面得到的R 、G 、B 三种颜色值转换为10进制表示  
  889.         $canvas_color_R = hexdec (substr ($canvas_color, 0, 2));  
  890.         $canvas_color_G = hexdec (substr ($canvas_color, 2, 2));  
  891.         $canvas_color_B = hexdec (substr ($canvas_color, 4, 2));  
  892.    
  893.         // 如果传入图片的格式是png，并且配置文件设置png背景颜色为透明，并且在get传入了ct的值为真，那么就设置背景颜色为透明  
  894.         if(preg_match('/^image\/png$/i', $mimeType) && !PNG_IS_TRANSPARENT && $canvas_trans){   
  895.             $color = imagecolorallocatealpha ($canvas, $canvas_color_R, $canvas_color_G, $canvas_color_B, 127);  
  896.         //反之设置为不透明  
  897.         }else{  
  898.             $color = imagecolorallocatealpha ($canvas, $canvas_color_R, $canvas_color_G, $canvas_color_B, 0);  
  899.         }  
  900.    
  901.         // 使用分配的颜色填充背景  
  902.         imagefill ($canvas, 0, 0, $color);  
  903.            
  904.    
  905.         // 如果缩放模式选择的是2，那么画布的体积是按传入的值创建的，并计算出边框的宽度  
  906.         if ($zoom_crop == 2) {  
  907.             //等比缩放的高度  
  908.             $final_height = $height * ($new_width / $width);  
  909.             //如果计算出的等比高度，大于传入的高度  
  910.             if ($final_height > $new_height) {  
  911.                 //origin_x等于传入的新高度的二分之一  
  912.                 $origin_x = $new_width / 2;  
  913.                 //设置新宽度为等比计算出的值  
  914.                 $new_width = $width * ($new_height / $height);  
  915.                 //计算出两次origin_x的差值  
  916.                 $origin_x = round ($origin_x - ($new_width / 2));  
  917.             //否则，计算出两次origin_y的差值  
  918.             } else {  
  919.                 $origin_y = $new_height / 2;  
  920.                 $new_height = $final_height;  
  921.                 $origin_y = round ($origin_y - ($new_height / 2));  
  922.    
  923.             }  
  924.    
  925.         }  
  926.    
  927.         // 保存图像时保存完整的alpha信息  
  928.         imagesavealpha ($canvas, true);  
  929.    
  930.         //如果缩放模式选择的是1或2或3  
  931.         if ($zoom_crop > 0) {  
  932.    
  933.             $src_x = $src_y = 0;  
  934.             //图片原宽度  
  935.             $src_w = $width;  
  936.             //图片原高度  
  937.             $src_h = $height;  
  938.    
  939.             //图片纵横比  
  940.             $cmp_x = $width / $new_width;  
  941.             $cmp_y = $height / $new_height;  
  942.    
  943.             //裁剪算法  
  944.             if ($cmp_x > $cmp_y) {  
  945.                 $src_w = round ($width / $cmp_x * $cmp_y);  
  946.                 $src_x = round (($width - ($width / $cmp_x * $cmp_y)) / 2);  
  947.    
  948.             } else if ($cmp_y > $cmp_x) {  
  949.    
  950.                 $src_h = round ($height / $cmp_y * $cmp_x);  
  951.                 $src_y = round (($height - ($height / $cmp_y * $cmp_x)) / 2);  
  952.    
  953.             }  
  954.    
  955.             // 根据传入参数算出裁剪的位置  
  956.             if ($align) {  
  957.                 if (strpos ($align, 't') !== false) {  
  958.                     $src_y = 0;  
  959.                 }  
  960.                 if (strpos ($align, 'b') !== false) {  
  961.                     $src_y = $height - $src_h;  
  962.                 }  
  963.                 if (strpos ($align, 'l') !== false) {  
  964.                     $src_x = 0;  
  965.                 }  
  966.                 if (strpos ($align, 'r') !== false) {  
  967.                     $src_x = $width - $src_w;  
  968.                 }  
  969.             }  
  970.    
  971.             //将图像根据算法进行裁剪，并拷贝到背景图片上  
  972.             imagecopyresampled ($canvas, $image, $origin_x, $origin_y, $src_x, $src_y, $new_width, $new_height, $src_w, $src_h);  
  973.    
  974.         } else {  
  975.    
  976.             //裁剪模式选择的是0，则不进行裁剪，并生成图像  
  977.             imagecopyresampled ($canvas, $image, 0, 0, 0, 0, $new_width, $new_height, $width, $height);  
  978.    
  979.         }  
  980.         //如果定义了图片处理操作，并且支持图片处理函数  
  981.         if ($filters != '' && function_exists ('imagefilter') && defined ('IMG_FILTER_NEGATE')) {  
  982.             // 分割每个过滤处理  
  983.             $filterList = explode ('|', $filters);  
  984.             foreach ($filterList as $fl) {  
  985.                 //分割一个过滤操作中的参数  
  986.                 $filterSettings = explode (',', $fl);  
  987.                 //如果所选的过滤操作存在  
  988.                 if (isset ($imageFilters[$filterSettings[0]])) {  
  989.                     //将所有参数转为int类型  
  990.                     for ($i = 0; $i < 4; $i ++) {  
  991.                         if (!isset ($filterSettings[$i])) {  
  992.                             $filterSettings[$i] = null;  
  993.                         } else {  
  994.                             $filterSettings[$i] = (int) $filterSettings[$i];  
  995.                         }  
  996.                     }  
  997.                     //根据$imageFilters中定义的每个过滤效果需要的参数的不同，对图像应用过滤器效果  
  998.                     switch ($imageFilters[$filterSettings[0]][1]) {  
  999.    
  1000.                         case 1:  
  1001.    
  1002.                             imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1]);  
  1003.                             break;  
  1004.    
  1005.                         case 2:  
  1006.    
  1007.                             imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1], $filterSettings[2]);  
  1008.                             break;  
  1009.    
  1010.                         case 3:  
  1011.    
  1012.                             imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1], $filterSettings[2], $filterSettings[3]);  
  1013.                             break;  
  1014.    
  1015.                         case 4:  
  1016.    
  1017.                             imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1], $filterSettings[2], $filterSettings[3], $filterSettings[4]);  
  1018.                             break;  
  1019.    
  1020.                         default:  
  1021.    
  1022.                             imagefilter ($canvas, $imageFilters[$filterSettings[0]][0]);  
  1023.                             break;  
  1024.    
  1025.                     }  
  1026.                 }  
  1027.             }  
  1028.         }  
  1029.    
  1030.         // 如果设置了锐化值，并且系统支持锐化函数，则进行锐化操作  
  1031.         if ($sharpen && function_exists ('imageconvolution')) {  
  1032.    
  1033.             $sharpenMatrix = array (  
  1034.                     array (-1,-1,-1),  
  1035.                     array (-1,16,-1),  
  1036.                     array (-1,-1,-1),  
  1037.                     );  
  1038.    
  1039.             $divisor = 8;  
  1040.             $offset = 0;  
  1041.    
  1042.             imageconvolution ($canvas, $sharpenMatrix, $divisor, $offset);  
  1043.    
  1044.         }  
  1045.         //如果图片是PNG或者GIF，则用imagetruecolortopalette来减小他们的体积  
  1046.         if ( (IMAGETYPE_PNG == $origType || IMAGETYPE_GIF == $origType) && function_exists('imageistruecolor') && !imageistruecolor( $image ) && imagecolortransparent( $image ) > 0 ){  
  1047.             imagetruecolortopalette( $canvas, false, imagecolorstotal( $image ) );  
  1048.         }  
  1049.         //根据生成的不同图片类型，生成图片缓存,$imgType的值用于生成安全头  
  1050.         $imgType = "";  
  1051.         $tempfile = tempnam($this->cacheDirectory, 'timthumb_tmpimg_');  
  1052.         if(preg_match('/^image\/(?:jpg|jpeg)$/i', $mimeType)){   
  1053.             $imgType = 'jpg';  
  1054.             imagejpeg($canvas, $tempfile, $quality);   
  1055.         } else if(preg_match('/^image\/png$/i', $mimeType)){   
  1056.             $imgType = 'png';  
  1057.             imagepng($canvas, $tempfile, floor($quality * 0.09));  
  1058.         } else if(preg_match('/^image\/gif$/i', $mimeType)){  
  1059.             $imgType = 'gif';  
  1060.             imagegif($canvas, $tempfile);  
  1061.         } else {  
  1062.             //如果不是以上三种类型，记录这次错误并退出  
  1063.             return $this->sanityFail("Could not match mime type after verifying it previously.");  
  1064.         }  
  1065.         //优先使用optipng工具进行png图片的压缩，前提是你装了这个工具  
  1066.         if($imgType == 'png' && OPTIPNG_ENABLED && OPTIPNG_PATH && @is_file(OPTIPNG_PATH)){  
  1067.             //记录optipng的地址  
  1068.             $exec = OPTIPNG_PATH;  
  1069.             //写日志，记录optipng将运行，级别3  
  1070.             $this->debug(3, "optipng'ing $tempfile");  
  1071.             //获取图片大小  
  1072.             $presize = filesize($tempfile);  
  1073.             //进行图片压缩操作  
  1074.             $out = `$exec -o1 $tempfile`;  
  1075.                 //清除文件状态缓存    
  1076.             clearstatcache();  
  1077.             //获取压缩后的文件大小  
  1078.             $aftersize = filesize($tempfile);  
  1079.             //算出压缩了多大  
  1080.             $sizeDrop = $presize - $aftersize;  
  1081.             //根据算出的不同的值，写日志，级别1  
  1082.             if($sizeDrop > 0){  
  1083.                 $this->debug(1, "optipng reduced size by $sizeDrop");  
  1084.             } else if($sizeDrop < 0){  
  1085.                 $this->debug(1, "optipng increased size! Difference was: $sizeDrop");  
  1086.             } else {  
  1087.                 $this->debug(1, "optipng did not change image size.");  
  1088.             }  
  1089.         //optipng不存在，就尝试使用pngcrush  
  1090.         } else if($imgType == 'png' && PNGCRUSH_ENABLED && PNGCRUSH_PATH && @is_file(PNGCRUSH_PATH)){ 
  1091.             $exec = PNGCRUSH_PATH; 
  1092.             //和optipng不同的是，pngcrush会将处理完的文件新生成一个文件，所以这里新建个文件 
  1093.             $tempfile2 = tempnam($this->cacheDirectory, 'timthumb_tmpimg_'); 
  1094.             //写日志，记录文件名 
  1095.             $this->debug(3, "pngcrush'ing $tempfile to $tempfile2");  
  1096.             //运行pngcrush  
  1097.             $out = `$exec $tempfile $tempfile2`;  
  1098.             $todel = "";  
  1099.             //如果生成文件成功  
  1100.             if(is_file($tempfile2)){  
  1101.                 //算出压缩后的文件大小的差值  
  1102.                 $sizeDrop = filesize($tempfile) - filesize($tempfile2);  
  1103.                 //如果是一次有效的压缩，则将压缩后的文件作为缓存文件  
  1104.                 if($sizeDrop > 0){  
  1105.                     $this->debug(1, "pngcrush was succesful and gave a $sizeDrop byte size reduction");  
  1106.                     $todel = $tempfile;  
  1107.                     $tempfile = $tempfile2;  
  1108.                 //否则的话则这个文件没有存在的必要  
  1109.                 } else {  
  1110.                     $this->debug(1, "pngcrush did not reduce file size. Difference was $sizeDrop bytes.");  
  1111.                     $todel = $tempfile2;  
  1112.                 }  
  1113.             //没有运行成功也需要删除这个文件  
  1114.             } else {  
  1115.                 $this->debug(3, "pngcrush failed with output: $out");  
  1116.                 $todel = $tempfile2;  
  1117.             }  
  1118.             //删除无效文件或压缩前比较大的文件  
  1119.             @unlink($todel);  
  1120.         }  
  1121.         //在缓存图片上写入安全头  
  1122.         $this->debug(3, "Rewriting image with security header.");  
  1123.         //创建一个新的缓存文件  
  1124.         $tempfile4 = tempnam($this->cacheDirectory, 'timthumb_tmpimg_');  
  1125.         //  
  1126.         $context = stream_context_create ();  
  1127.         //读取生成的图片缓存内容  
  1128.         $fp = fopen($tempfile,'r',0,$context);  
  1129.         //向新缓存文件写入安全头，安全头的长度应该总是$this->filePrependSecurityBlock的长度 + 6  
  1130.         file_put_contents($tempfile4, $this->filePrependSecurityBlock . $imgType . ' ?' . '>');  
  1131.         //将读取出来的缓存图片内容写入新缓存文件  
  1132.         file_put_contents($tempfile4, $fp, FILE_APPEND);  
  1133.         //关闭文件资源  
  1134.         fclose($fp);  
  1135.         //删除之前不安全的图片缓存文件  
  1136.         @unlink($tempfile);  
  1137.         //写日志，给缓存文件加锁～～  
  1138.         $this->debug(3, "Locking and replacing cache file.");  
  1139.         //创建锁文件文件名  
  1140.         $lockFile = $this->cachefile . '.lock';  
  1141.         //创建或打开锁文件  
  1142.         $fh = fopen($lockFile, 'w');  
  1143.         //创建失败直接退出  
  1144.         if(! $fh){  
  1145.             return $this->error("Could not open the lockfile for writing an image.");  
  1146.         }  
  1147.         //如果给锁文件加入写入锁成功  
  1148.         if(flock($fh, LOCK_EX)){  
  1149.             //删除原缓存文件  
  1150.             @unlink($this->cachefile);   
  1151.             //重命名覆盖，将安全的缓存文件作为缓存文件  
  1152.             rename($tempfile4, $this->cachefile);  
  1153.             //释放写入锁  
  1154.             flock($fh, LOCK_UN);  
  1155.             //释放资源  
  1156.             fclose($fh);  
  1157.             //删除锁文件  
  1158.             @unlink($lockFile);  
  1159.         //否则  
  1160.         } else {  
  1161.             //关闭资源  
  1162.             fclose($fh);  
  1163.             //删除锁文件  
  1164.             @unlink($lockFile);  
  1165.             //删除安全的缓存文件  
  1166.             @unlink($tempfile4);  
  1167.             //记录错误并退出  
  1168.             return $this->error("Could not get a lock for writing.");  
  1169.         }  
  1170.         //写日志，记录操作完成  
  1171.         $this->debug(3, "Done image replace with security header. Cleaning up and running cleanCache()");  
  1172.         //释放图片资源  
  1173.         imagedestroy($canvas);  
  1174.         imagedestroy($image);  
  1175.         //生成缓存成功返回真  
  1176.         return true;  
  1177.     }  
  1178.     /*此函数用来获取服务器文档根目录*/  
  1179.     protected function calcDocRoot(){  
  1180.         //直接获取文档根目录  
  1181.         $docRoot = @$_SERVER['DOCUMENT_ROOT'];  
  1182.         //如果定义了LOCAL_FILE_BASE_DIRECTORY，则使用此值  
  1183.         if (defined('LOCAL_FILE_BASE_DIRECTORY')) {  
  1184.             $docRoot = LOCAL_FILE_BASE_DIRECTORY;     
  1185.         }  
  1186.         //如果没有获取到文档根目录，也就是DOCUMENT_ROOT的值  
  1187.         if(!isset($docRoot)){  
  1188.             //写一条记录，说明DOCUMENT_ROOT没找到，注意level是3  
  1189.             $this->debug(3, "DOCUMENT_ROOT is not set. This is probably windows. Starting search 1.");  
  1190.             //用SCRIPT_FILENAME和PHP_SELF来得到文档根目录  
  1191.             if(isset($_SERVER['SCRIPT_FILENAME'])){  
  1192.                 $docRoot = str_replace( '\\', '/', substr($_SERVER['SCRIPT_FILENAME'], 0, 0-strlen($_SERVER['PHP_SELF']))); 
  1193.                 //写一条记录，说明DOCUMENT_ROOT的值是通过SCRIPT_FILENAME和PHP_SELF来得的，级别3 
  1194.                 $this->debug(3, "Generated docRoot using SCRIPT_FILENAME and PHP_SELF as: $docRoot"); 
  1195.             }  
  1196.         } 
  1197.         //如果还是没有获取到文档根目录 
  1198.         if(!isset($docRoot)){ 
  1199.             //先写一条记录，说明还是没得到DOCUMENT_ROOT，级别3 
  1200.             $this->debug(3, "DOCUMENT_ROOT still is not set. Starting search 2."); 
  1201.             //通过PATH_TRANSLATED和PHP_SELF来得到文档根目录，关于PATH_TRANSLATED的说明可以看这里：http://blogs.msdn.com/b/david.wang/archive/2005/08/04/what-is-path-translated.aspx 
  1202.             if(isset($_SERVER['PATH_TRANSLATED'])){ 
  1203.                 $docRoot = str_replace( '\\', '/', substr(str_replace('\\\\', '\\', $_SERVER['PATH_TRANSLATED']), 0, 0-strlen($_SERVER['PHP_SELF']))); 
  1204.                 //写记录，说明说明DOCUMENT_ROOT的值是通过PATH_TRANSLATED和PHP_SELF来得的，级别3 
  1205.                 $this->debug(3, "Generated docRoot using PATH_TRANSLATED and PHP_SELF as: $docRoot"); 
  1206.             }  
  1207.         } 
  1208.         //如果文档根目录不是服务器根目录，则去掉最后一个 '/' 
  1209.         if($docRoot && $_SERVER['DOCUMENT_ROOT'] != '/'){ $docRoot = preg_replace('/\/$/', '', $docRoot); } 
  1210.         //写记录，说明文档根目录的值，级别3 
  1211.         $this->debug(3, "Doc root is: " . $docRoot); 
  1212.         //赋值给成员属性 
  1213.         $this->docRoot = $docRoot; 
  1214.   
  1215.     } 
  1216.   
  1217.     /*此函数用来获取本地图片地址，参数src是相对与文档根目录的地址*/ 
  1218.     protected function getLocalImagePath($src){ 
  1219.         //去掉开头的 /  
  1220.          $src = ltrim($src, '/'); 
  1221.          //如果前面没有获取到文档根目录，出于安全考虑，那么这里只能对timthumbs.php所在的目录下的图片进行操作 
  1222.          if(! $this->docRoot){ 
  1223.             //写日志，级别3，说明下面进行图片地址的检查 
  1224.             $this->debug(3, "We have no document root set, so as a last resort, lets check if the image is in the current dir and serve that."); 
  1225.             //获取去掉所有路径信息的文件名 
  1226.             $file = preg_replace('/^.*?([^\/\\\\]+)$/', '$1', $src);  
  1227.             //如果图片文件和timthumb.php在同一目录下 
  1228.             if(is_file($file)){ 
  1229.                 //返回此图片的路径 
  1230.                 return $this->realpath($file); 
  1231.             } 
  1232.             //如果图片文件和timthumb.php不在同一目录下，写错误信息，出于安全考虑，不会允许一个没有文档根目录并且在timthumbs.php所在的目录以外的文件 
  1233.             return $this->error("Could not find your website document root and the file specified doesn't exist in timthumbs directory. We don't support serving files outside timthumb's directory without a document root for security reasons.");  
  1234.         }  
  1235.    
  1236.          //尝试找这张图片，如果图片地址存在  
  1237.          if(file_exists ($this->docRoot . '/' . $src)) {  
  1238.             //写日志，记录文件地址，级别3  
  1239.             $this->debug(3, "Found file as " . $this->docRoot . '/' . $src);  
  1240.             //返回图片路径  
  1241.             $real = $this->realpath($this->docRoot . '/' . $src);  
  1242.             //验证图片路径是否在本机  
  1243.             if(stripos($real, $this->docRoot) === 0){  
  1244.                 //是的话返回图片地址  
  1245.                 return $real;  
  1246.             } else {  
  1247.                 //否则写日志，没找到指定文件，级别1  
  1248.                 $this->debug(1, "Security block: The file specified occurs outside the document root.");  
  1249.             }  
  1250.         }  
  1251.    
  1252.         //接着找。。。  
  1253.          $absolute = $this->realpath('/' . $src);  
  1254.          //如果决定地址存在  
  1255.          if($absolute && file_exists($absolute)){  
  1256.             //写日志，记录图片绝对地址，级别3   
  1257.             $this->debug(3, "Found absolute path: $absolute");  
  1258.             //如果文档根目录没有定义，记录这个错误信息  
  1259.             if(! $this->docRoot){ $this->sanityFail("docRoot not set when checking absolute path."); }  
  1260.             //验证图片路径是否在本机  
  1261.             if(stripos($absolute, $this->docRoot) === 0){  
  1262.                 //在的话返回图片地址      
  1263.                 return $absolute;  
  1264.             } else {  
  1265.                 //否则写日志，没找到指定的文件，级别1  
  1266.                 $this->debug(1, "Security block: The file specified occurs outside the document root.");  
  1267.             }  
  1268.         }  
  1269.    
  1270.         //如果还没找到指定文件，则逐级向上查找  
  1271.         $base = $this->docRoot;  
  1272.            
  1273.         // 获取查询子目录列表  
  1274.         if (strstr($_SERVER['SCRIPT_FILENAME'],':')) {  
  1275.             $sub_directories = explode('\\', str_replace($this->docRoot, '', $_SERVER['SCRIPT_FILENAME'])); 
  1276.         } else { 
  1277.             $sub_directories = explode('/', str_replace($this->docRoot, '', $_SERVER['SCRIPT_FILENAME'])); 
  1278.         } 
  1279.         //遍历子目录数组 
  1280.         foreach ($sub_directories as $sub){ 
  1281.             //重新组合请求地址 
  1282.             $base .= $sub . '/'; 
  1283.             //写日志，记录搜索记录，级别3 
  1284.             $this->debug(3, "Trying file as: " . $base . $src); 
  1285.             //如果找到了这个文件 
  1286.             if(file_exists($base . $src)){ 
  1287.                 //写日志，记录文件地址，级别3 
  1288.                 $this->debug(3, "Found file as: " . $base . $src); 
  1289.                 //得到实际地址 
  1290.                 $real = $this->realpath($base . $src); 
  1291.                 //如果实际地址的确在本机中，那么返回这个地址 
  1292.                 if(stripos($real, $this->realpath($this->docRoot)) === 0){ 
  1293.                     return $real; 
  1294.                 } else { 
  1295.                     //找不到就写日志，没找到,级别1 
  1296.                     $this->debug(1, "Security block: The file specified occurs outside the document root."); 
  1297.                 } 
  1298.             } 
  1299.         } 
  1300.         //还找不到的话，就返回false; 
  1301.         return false; 
  1302.     } 
  1303.     /*此函数用来获得传入文件参数的真实路径*/ 
  1304.     protected function realpath($path){ 
  1305.         //去除路径中带有..的相对路径 
  1306.         $remove_relatives = '/\w+\/\.\.\//';  
  1307.         while(preg_match($remove_relatives,$path)){  
  1308.             $path = preg_replace($remove_relatives, '', $path); 
  1309.         } 
  1310.         //如果去除后路径中仍有..的相对路径，则用realpath函数返回路径，否则直接返回即可 
  1311.         return preg_match('#^\.\./|/\.\./#', $path) ? realpath($path) : $path; 
  1312.     } 
  1313.     /*此函数用来记录在析构函数中需要删除的资源列表*/ 
  1314.     protected function toDelete($name){ 
  1315.         //写日志，记录需要删除的文件信息 
  1316.         $this->debug(3, "Scheduling file $name to delete on destruct."); 
  1317.         //添加到待删除数组 
  1318.         $this->toDeletes[] = $name; 
  1319.     } 
  1320.     /*此函数是截图操作的具体实现*/ 
  1321.     protected function serveWebshot(){ 
  1322.         //写日志，记录开始截图操作，级别3 
  1323.         $this->debug(3, "Starting serveWebshot"); 
  1324.         //一段提示文字，可以到http://code.google.com/p/timthumb/上按照教程进行网站截图设置 
  1325.         $instr = "Please follow the instructions at http://code.google.com/p/timthumb/ to set your server up for taking website screenshots."; 
  1326.         //如果CutyCapt不存在 
  1327.         if(! is_file(WEBSHOT_CUTYCAPT)){ 
  1328.             //退出执行并记录，CutyCapt未被安装 
  1329.             return $this->error("CutyCapt is not installed. $instr"); 
  1330.         } 
  1331.         //如果xvfb不存在 
  1332.         if(! is_file(WEBSHOT_XVFB)){ 
  1333.             //退出执行并记录，xvfb未被安装 
  1334.             return $this->Error("Xvfb is not installed. $instr"); 
  1335.         } 
  1336.         //CUTYCAPT地址 
  1337.         $cuty = WEBSHOT_CUTYCAPT; 
  1338.         //xvfb地址 
  1339.         $xv = WEBSHOT_XVFB; 
  1340.         //截图屏幕宽度 
  1341.         $screenX = WEBSHOT_SCREEN_X; 
  1342.         //截图屏幕高度 
  1343.         $screenY = WEBSHOT_SCREEN_Y; 
  1344.         //截图色深 
  1345.         $colDepth = WEBSHOT_COLOR_DEPTH; 
  1346.         //截图保存格式 
  1347.         $format = WEBSHOT_IMAGE_FORMAT; 
  1348.         //截图超时时间，单位ms 
  1349.         $timeout = WEBSHOT_TIMEOUT * 1000; 
  1350.         //USER_AGENT头 
  1351.         $ua = WEBSHOT_USER_AGENT; 
  1352.         //是否启用js 
  1353.         $jsOn = WEBSHOT_JAVASCRIPT_ON ? 'on' : 'off'; 
  1354.         //是否启用java 
  1355.         $javaOn = WEBSHOT_JAVA_ON ? 'on' : 'off'; 
  1356.         //是否启用其他插件 
  1357.         $pluginsOn = WEBSHOT_PLUGINS_ON ? 'on' : 'off'; 
  1358.         //是否启用代理 
  1359.         $proxy = WEBSHOT_PROXY ? ' --http-proxy=' . WEBSHOT_PROXY : ''; 
  1360.         //在缓存文件目录，建立一个具有唯一文件名的文件，文件名前缀为timthumb_webshot，用户存储截图后的图片 
  1361.         $tempfile = tempnam($this->cacheDirectory, 'timthumb_webshot'); 
  1362.         //目标网站地址 
  1363.         $url = $this->src; 
  1364.         //验证url合法性 
  1365.         if(! preg_match('/^https?:\/\/[a-zA-Z0-9\.\-]+/i', $url)){ 
  1366.             //不合法退出执行 
  1367.             return $this->error("Invalid URL supplied."); 
  1368.         } 
  1369.         //过滤掉非法字符 
  1370.         $url = preg_replace('/[^A-Za-z0-9\-\.\_\~:\/\?\#\[\]\@\!\$\&\'\(\)\*\+\,\;\=]+/', '', $url);  
  1371.         //优先使用CUTYCAPT  
  1372.         if(WEBSHOT_XVFB_RUNNING){  
  1373.             //设置系统变量，配置图形输出显示。  
  1374.             putenv('DISPLAY=:100.0');  
  1375.             //组装shell命令  
  1376.             $command = "$cuty $proxy --max-wait=$timeout --user-agent=\"$ua\" --javascript=$jsOn --java=$javaOn --plugins=$pluginsOn --js-can-open-windows=off --url=\"$url\" --out-format=$format --out=$tempfile";  
  1377.         //否则使用XVFB  
  1378.         } else {  
  1379.             $command = "$xv --server-args=\"-screen 0, {$screenX}x{$screenY}x{$colDepth}\" $cuty $proxy --max-wait=$timeout --user-agent=\"$ua\" --javascript=$jsOn --java=$javaOn --plugins=$pluginsOn --js-can-open-windows=off --url=\"$url\" --out-format=$format --out=$tempfile";  
  1380.         }  
  1381.         //写日志，记录执行的命令，级别3  
  1382.         $this->debug(3, "Executing command: $command");  
  1383.         //执行命令并捕获输出  
  1384.         $out = `$command`;  
  1385.         //写日志，记录输出，级别3  
  1386.         $this->debug(3, "Received output: $out");  
  1387.         //如果刚刚创建的唯一文件名的文件失败  
  1388.         if(! is_file($tempfile)){  
  1389.             //设置404错误  
  1390.             $this->set404();  
  1391.             //推出脚本  
  1392.             return $this->error("The command to create a thumbnail failed.");  
  1393.         }  
  1394.         //启用裁剪  
  1395.         $this->cropTop = true;  
  1396.         //对截取到的图片文件处理并生成缓存  
  1397.         if($this->processImageAndWriteToCache($tempfile)){  
  1398.             //成功的话写日志，并从缓存读取此图片  
  1399.             $this->debug(3, "Image processed succesfully. Serving from cache");  
  1400.             //返回从缓存中读取的文件内容  
  1401.             return $this->serveCacheFile();  
  1402.         //没成功就返回假咯  
  1403.         } else {  
  1404.             return false;  
  1405.         }  
  1406.     }  
  1407.     /*此函数用来从外部url获取图像*/  
  1408.     protected function serveExternalImage(){  
  1409.         //验证url合法性  
  1410.         if(! preg_match('/^https?:\/\/[a-zA-Z0-9\-\.]+/i', $this->src)){  
  1411.             $this->error("Invalid URL supplied.");  
  1412.             return false;  
  1413.         }  
  1414.         //生成临时缓存文件  
  1415.         $tempfile = tempnam($this->cacheDirectory, 'timthumb');  
  1416.         //写日志，记录读取外部图像到临时文件，级别3  
  1417.         $this->debug(3, "Fetching external image into temporary file $tempfile");  
  1418.         //将临时缓存文件加入到待删除列表  
  1419.         $this->toDelete($tempfile);  
  1420.         //请求url并将结果写入到临时缓存文件中，如果没有成功  
  1421.         if(! $this->getURL($this->src, $tempfile)){  
  1422.             //删除此缓存文件  
  1423.             @unlink($this->cachefile);  
  1424.             //再创建一个新的缓存文件  
  1425.             touch($this->cachefile);  
  1426.             //写日志，记录错误信息，级别3  
  1427.             $this->debug(3, "Error fetching URL: " . $this->lastURLError);  
  1428.             //写错误信息，并退出  
  1429.             $this->error("Error reading the URL you specified from remote host." . $this->lastURLError);  
  1430.             return false;  
  1431.         }  
  1432.         //得到获取到图片的MIME类型  
  1433.         $mimeType = $this->getMimeType($tempfile);  
  1434.         //如果不在这三种类型中  
  1435.         if(! preg_match("/^image\/(?:jpg|jpeg|gif|png)$/i", $mimeType)){  
  1436.             //写日志，记录错误信息，级别3  
  1437.             $this->debug(3, "Remote file has invalid mime type: $mimeType");  
  1438.             //删除现有缓存文件  
  1439.             @unlink($this->cachefile);  
  1440.             //创建新缓存文件  
  1441.             touch($this->cachefile);  
  1442.             //写错误信息并退出  
  1443.             $this->error("The remote file is not a valid image.");  
  1444.             return false;  
  1445.         }  
  1446.         //处理图像并缓存  
  1447.         if($this->processImageAndWriteToCache($tempfile)){  
  1448.             $this->debug(3, "Image processed succesfully. Serving from cache");  
  1449.             //成功的话返回缓存信息  
  1450.             return $this->serveCacheFile();  
  1451.         } else {  
  1452.             //失败返回假  
  1453.             return false;  
  1454.         }  
  1455.     }  
  1456.     /*此函数用来将curl获取到的数据写入对应文件中*/  
  1457.     public static function curlWrite($h, $d){  
  1458.         //将数据写入文件  
  1459.         fwrite(self::$curlFH, $d);  
  1460.         //记录数据长度  
  1461.         self::$curlDataWritten += strlen($d);  
  1462.         //如果图片大小超过了配置文件的限制，则返回0  
  1463.         if(self::$curlDataWritten > MAX_FILE_SIZE){  
  1464.             return 0;  
  1465.         //否则返回图片大小  
  1466.         } else {  
  1467.             return strlen($d);  
  1468.         }  
  1469.     }  
  1470.     /*此函数用来读取并输出服务端缓存*/  
  1471.     protected function serveCacheFile(){  
  1472.         //写日志，记录读取缓存的地址  
  1473.         $this->debug(3, "Serving {$this->cachefile}");  
  1474.         //如果缓存地址无效  
  1475.         if(! is_file($this->cachefile)){  
  1476.             //添加到错误记录  
  1477.             $this->error("serveCacheFile called in timthumb but we couldn't find the cached file.");  
  1478.             //停止执行脚本  
  1479.             return false;  
  1480.         }  
  1481.         //缓存地址有效的话，已只读方式打开文件  
  1482.         $fp = fopen($this->cachefile, 'rb'); 
  1483.         //如果打开失败，直接退出脚本，并记录错误信息 
  1484.         if(! $fp){ return $this->error("Could not open cachefile."); } 
  1485.         //设定文件指针跳过filePrependSecurityBlock值，也就是跳过安全头后开始读 
  1486.         fseek($fp, strlen($this->filePrependSecurityBlock), SEEK_SET); 
  1487.         //读出文件的mime类型 
  1488.         $imgType = fread($fp, 3); 
  1489.         //再跳过这个mime类型的值 
  1490.         fseek($fp, 3, SEEK_CUR); 
  1491.         //如果现在文件的指针不是在安全头后6个字符的位置，说明缓存文件可能已损坏 
  1492.         if(ftell($fp) != strlen($this->filePrependSecurityBlock) + 6){ 
  1493.             //删除此缓存文件 
  1494.             @unlink($this->cachefile); 
  1495.             //记录错误并退出执行 
  1496.             return $this->error("The cached image file seems to be corrupt."); 
  1497.         } 
  1498.         //缓存图片的实际大小应该是文件大小 - 安全头大小 
  1499.         $imageDataSize = filesize($this->cachefile) - (strlen($this->filePrependSecurityBlock) + 6); 
  1500.         //设置输出必要的HTTP头 
  1501.         $this->sendImageHeaders($imgType, $imageDataSize); 
  1502.         //输出文件指针处所有剩余数据 
  1503.         $bytesSent = @fpassthru($fp); 
  1504.         //关闭文件资源 
  1505.         fclose($fp); 
  1506.         //如果此方法执行成功，则返回真 
  1507.         if($bytesSent > 0){ 
  1508.             return true; 
  1509.         } 
  1510.         //如果fpassthru不成功，则用file_get_contents读取并输出 
  1511.         $content = file_get_contents ($this->cachefile); 
  1512.         //如果读取成功 
  1513.         if ($content != FALSE) { 
  1514.             //截取掉安全头 
  1515.             $content = substr($content, strlen($this->filePrependSecurityBlock) + 6); 
  1516.             //输出图像 
  1517.             echo $content; 
  1518.             //写日志，记录读取缓存的方式 
  1519.             $this->debug(3, "Served using file_get_contents and echo"); 
  1520.             return true; 
  1521.         //读取失败的话记录错误信息并退出执行 
  1522.         } else { 
  1523.             $this->error("Cache file could not be loaded."); 
  1524.             return false; 
  1525.         } 
  1526.     } 
  1527.     /*此函数设置图片输出必要的http头*/ 
  1528.     protected function sendImageHeaders($mimeType, $dataSize){ 
  1529.         //补全图片的mime信息 
  1530.         if(! preg_match('/^image\//i', $mimeType)){  
  1531.             $mimeType = 'image/' . $mimeType; 
  1532.         } 
  1533.         //将jpg的mime类型写标准，这里不标准的原因是在验证文件安全头时追求了便利性 
  1534.         if(strtolower($mimeType) == 'image/jpg'){ 
  1535.             $mimeType = 'image/jpeg'; 
  1536.         } 
  1537.         //浏览器缓存失效时间 
  1538.         $gmdate_expires = gmdate ('D, d M Y H:i:s', strtotime ('now +10 days')) . ' GMT'; 
  1539.         //文档最后被修改时间，用来让浏览器判断是否需要重新请求页面 
  1540.         $gmdate_modified = gmdate ('D, d M Y H:i:s') . ' GMT'; 
  1541.         // 设置HTTP头 
  1542.         header ('Content-Type: ' . $mimeType); 
  1543.         header ('Accept-Ranges: none');  
  1544.         header ('Last-Modified: ' . $gmdate_modified); 
  1545.         header ('Content-Length: ' . $dataSize); 
  1546.         //如果配置文件禁止浏览器缓存，则设置相应的HTTP头信息 
  1547.         if(BROWSER_CACHE_DISABLE){ 
  1548.             $this->debug(3, "Browser cache is disabled so setting non-caching headers."); 
  1549.             header('Cache-Control: no-store, no-cache, must-revalidate, max-age=0'); 
  1550.             header("Pragma: no-cache"); 
  1551.             header('Expires: ' . gmdate ('D, d M Y H:i:s', time())); 
  1552.         //否则按配置文件设置缓存时间 
  1553.         } else { 
  1554.             $this->debug(3, "Browser caching is enabled"); 
  1555.             header('Cache-Control: max-age=' . BROWSER_CACHE_MAX_AGE . ', must-revalidate'); 
  1556.             header('Expires: ' . $gmdate_expires); 
  1557.         } 
  1558.         //运行成功返回真 
  1559.         return true; 
  1560.     } 
  1561.     /*自定义的验证函数*/ 
  1562.     protected function securityChecks(){ 
  1563.     } 
  1564.     /*此函数用来获取$_GET数组中的参数，并允许设置默认值*/ 
  1565.     protected function param($property, $default = ''){ 
  1566.         //如果参数存在则返回此参数 
  1567.         if (isset ($_GET[$property])) { 
  1568.             return $_GET[$property]; 
  1569.         //不存在的话返回默认值 
  1570.         } else { 
  1571.             return $default; 
  1572.         } 
  1573.     } 
  1574.     /*此函数根据传入mime类型，打开图像资源*/ 
  1575.     protected function openImage($mimeType, $src){ 
  1576.         switch ($mimeType) { 
  1577.             case 'image/jpeg': 
  1578.                 $image = imagecreatefromjpeg ($src); 
  1579.                 break; 
  1580.   
  1581.             case 'image/png': 
  1582.                 $image = imagecreatefrompng ($src); 
  1583.                 break; 
  1584.   
  1585.             case 'image/gif': 
  1586.                 $image = imagecreatefromgif ($src); 
  1587.                 break; 
  1588.             //不是这三种的话，脚本退出 
  1589.             default: 
  1590.                 $this->error("Unrecognised mimeType"); 
  1591.         } 
  1592.         //返回图像资源 
  1593.         return $image; 
  1594.     } 
  1595.     /*没啥说的，获取客户端IP*/ 
  1596.     protected function getIP(){ 
  1597.         $rem = @$_SERVER["REMOTE_ADDR"]; 
  1598.         $ff = @$_SERVER["HTTP_X_FORWARDED_FOR"]; 
  1599.         $ci = @$_SERVER["HTTP_CLIENT_IP"]; 
  1600.         if(preg_match('/^(?:192\.168|172\.16|10\.|127\.)/', $rem)){  
  1601.             if($ff){ return $ff; } 
  1602.             if($ci){ return $ci; } 
  1603.             return $rem; 
  1604.         } else { 
  1605.             if($rem){ return $rem; } 
  1606.             if($ff){ return $ff; } 
  1607.             if($ci){ return $ci; } 
  1608.             return "UNKNOWN"; 
  1609.         } 
  1610.     } 
  1611.     /*debug运行日志函数，用来向系统日志记录操作信息*/ 
  1612.     protected function debug($level, $msg){ 
  1613.         //如果开启了debug，并且$level也就是调试级别小于等于配置文件中的值，则开始记录 
  1614.         if(DEBUG_ON && $level <= DEBUG_LEVEL){ 
  1615.             //格式化并记录开始时间，保留小数点后6位,这个时间代表实例化类后到这个debug执行所经历的时间 
  1616.             $execTime = sprintf('%.6f', microtime(true) - $this->startTime); 
  1617.             //这个值代表从上次debug结束，到这次debug的用时 
  1618.             $tick = sprintf('%.6f', 0); 
  1619.             //如果上次debug时间存在，则用当前时间减去上次debug时间，得出差值 
  1620.             if($this->lastBenchTime > 0){ 
  1621.                 $tick = sprintf('%.6f', microtime(true) - $this->lastBenchTime); 
  1622.             } 
  1623.             //将时间更新 
  1624.             $this->lastBenchTime = microtime(true); 
  1625.             //将debug信息写到系统日志中 
  1626.             error_log("TimThumb Debug line " . __LINE__ . " [$execTime : $tick]: $msg"); 
  1627.         } 
  1628.     } 
  1629.     /*此函数用来记录未知BUG*/ 
  1630.     protected function sanityFail($msg){ 
  1631.         //记录BUG信息 
  1632.         return $this->error("There is a problem in the timthumb code. Message: Please report this error at <a href='http://code.google.com/p/timthumb/issues/list'>timthumb's bug tracking page</a>: $msg");  
  1633.     }  
  1634.     /*此函数用来返回图片文件的MIME信息*/  
  1635.     protected function getMimeType($file){  
  1636.         //获取图片文件的信息  
  1637.         $info = getimagesize($file);  
  1638.         //成功则返回MIME信息  
  1639.         if(is_array($info) && $info['mime']){  
  1640.             return $info['mime'];  
  1641.         }  
  1642.         //失败返回空  
  1643.         return '';  
  1644.     }  
  1645.     /*此函数用来检测并设置php运行时最大占用内存的值*/  
  1646.     protected function setMemoryLimit(){  
  1647.         //获取php.ini中的最大内存占用的值  
  1648.         $inimem = ini_get('memory_limit');  
  1649.         //将上面得到的值转换为以字节为单位的数值  
  1650.         $inibytes = timthumb::returnBytes($inimem);  
  1651.         //算出配置文件中内存限制的值  
  1652.         $ourbytes = timthumb::returnBytes(MEMORY_LIMIT);  
  1653.         //如果php配置文件中的值小于自己设定的值  
  1654.         if($inibytes < $ourbytes){  
  1655.             //则将php.ini配置中关于最大内存的值设置为自己设定的值  
  1656.             ini_set ('memory_limit', MEMORY_LIMIT);  
  1657.             //写日志，记录改变内存操作，级别3  
  1658.             $this->debug(3, "Increased memory from $inimem to " . MEMORY_LIMIT);  
  1659.         //如果自己设置的值小于php.ini中的值  
  1660.         } else {  
  1661.             //则不进行任何操作，写日志记录此条信息即可，级别3  
  1662.             $this->debug(3, "Not adjusting memory size because the current setting is " . $inimem . " and our size of " . MEMORY_LIMIT . " is smaller.");  
  1663.         }  
  1664.     }  
  1665.     /*此函数将G, KB, MB 转为B(字节)*/  
  1666.     protected static function returnBytes($size_str){  
  1667.         //取最后一个单位值，进行转换操作，并返回转换后的值  
  1668.         switch (substr ($size_str, -1))  
  1669.         {  
  1670.             case 'M': case 'm': return (int)$size_str * 1048576;  
  1671.             case 'K': case 'k': return (int)$size_str * 1024;  
  1672.             case 'G': case 'g': return (int)$size_str * 1073741824;  
  1673.             default: return $size_str;  
  1674.         }  
  1675.     }  
  1676.     /*此函数用来将url中的资源读取到tempfile文件中*/  
  1677.     protected function getURL($url, $tempfile){  
  1678.         //重置上次url请求错误信息  
  1679.         $this->lastURLError = false;  
  1680.         //进行url编码  
  1681.         $url = preg_replace('/ /', '%20', $url);  
  1682.         //优先使用curl扩展  
  1683.         if(function_exists('curl_init')){  
  1684.             //写日志，记录将使用curl扩展访问url，级别3  
  1685.             $this->debug(3, "Curl is installed so using it to fetch URL.");  
  1686.             //打开文件  
  1687.             self::$curlFH = fopen($tempfile, 'w');  
  1688.             //如果打开失败，记录错误信息并退出  
  1689.             if(! self::$curlFH){  
  1690.                 $this->error("Could not open $tempfile for writing.");  
  1691.                 return false;  
  1692.             }  
  1693.             //重置写入长度  
  1694.             self::$curlDataWritten = 0;  
  1695.             //写日志，记录访问的url信息，级别3  
  1696.             $this->debug(3, "Fetching url with curl: $url");  
  1697.             //初始化curl  
  1698.             $curl = curl_init($url);  
  1699.             //curl选项设置  
  1700.             curl_setopt ($curl, CURLOPT_TIMEOUT, CURL_TIMEOUT);  
  1701.             curl_setopt ($curl, CURLOPT_USERAGENT, "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/534.30 (KHTML, like Gecko) Chrome/12.0.742.122 Safari/534.30");  
  1702.             curl_setopt ($curl, CURLOPT_RETURNTRANSFER, TRUE);  
  1703.             curl_setopt ($curl, CURLOPT_HEADER, 0);  
  1704.             curl_setopt ($curl, CURLOPT_SSL_VERIFYPEER, FALSE);  
  1705.             //关闭会话时执行curlWrite  
  1706.             curl_setopt ($curl, CURLOPT_WRITEFUNCTION, 'timthumb::curlWrite');  
  1707.             @curl_setopt ($curl, CURLOPT_FOLLOWLOCATION, true);  
  1708.             @curl_setopt ($curl, CURLOPT_MAXREDIRS, 10);  
  1709.             //执行本次请求，并将结果赋给$curlResult  
  1710.             $curlResult = curl_exec($curl);  
  1711.             //释放文件资源  
  1712.             fclose(self::$curlFH);  
  1713.             //获取最后一个受到的HTTP码  
  1714.             $httpStatus = curl_getinfo($curl, CURLINFO_HTTP_CODE);  
  1715.             //如果是404，那么设置404错误并退出  
  1716.             if($httpStatus == 404){  
  1717.                 $this->set404();  
  1718.             }  
  1719.             //如果请求成功  
  1720.             if($curlResult){  
  1721.                 //关闭curl，并执行curlWrite将数据写到文件中  
  1722.                 curl_close($curl);  
  1723.                 //返回真，请求完成  
  1724.                 return true;  
  1725.             //如果请求不成功  
  1726.             } else {  
  1727.                 //记录错误信息  
  1728.                 $this->lastURLError = curl_error($curl);  
  1729.                 //关闭资源  
  1730.                 curl_close($curl);  
  1731.                 //执行不成功  
  1732.                 return false;  
  1733.             }  
  1734.         //如果不支持curl，用file_get_contents获取数据  
  1735.         } else {  
  1736.             //获取数据  
  1737.             $img = @file_get_contents ($url);  
  1738.             //如果获取失败  
  1739.             if($img === false){  
  1740.                 //记录返回的错误信息数组  
  1741.                 $err = error_get_last();  
  1742.                 //如果记录到了，并且有错误信息  
  1743.                 if(is_array($err) && $err['message']){  
  1744.                     //则记录这个错误信息  
  1745.                     $this->lastURLError = $err['message'];  
  1746.                 //否则的话记录整个错误信息  
  1747.                 } else {  
  1748.                     $this->lastURLError = $err;  
  1749.                 }  
  1750.                 //如果错误信息中有404，则设置为404错误  
  1751.                 if(preg_match('/404/', $this->lastURLError)){  
  1752.                     $this->set404();  
  1753.                 }  
  1754.                 //返回假  
  1755.                 return false;  
  1756.             }  
  1757.             //如果将读取的图片写入文件失败  
  1758.             if(! file_put_contents($tempfile, $img)){  
  1759.                 //写错误信息并退出执行  
  1760.                 $this->error("Could not write to $tempfile.");  
  1761.                 return false;  
  1762.             }  
  1763.             //没问题的话执行成功  
  1764.             return true;  
  1765.         }  
  1766.    
  1767.     }  
  1768.     /*此函数输出指定的图片，用于输出错误信息中*/  
  1769.     protected function serveImg($file){  
  1770.         //获取图像信息  
  1771.         $s = getimagesize($file);  
  1772.         //如果获取不到图像信息，推出  
  1773.         if(! ($s && $s['mime'])){  
  1774.             return false;  
  1775.         }  
  1776.         //设置http头，输出图片  
  1777.         header ('Content-Type: ' . $s['mime']);  
  1778.         header ('Content-Length: ' . filesize($file) );  
  1779.         header ('Cache-Control: no-store, no-cache, must-revalidate, max-age=0');  
  1780.         header ("Pragma: no-cache");  
  1781.         //使用readfile输出图片  
  1782.         $bytes = @readfile($file);  
  1783.         if($bytes > 0){  
  1784.             return true;  
  1785.         }  
  1786.         //如果失败，使用file_get_contents和echo输出图片  
  1787.         $content = @file_get_contents ($file);  
  1788.         if ($content != FALSE){  
  1789.             echo $content;  
  1790.             return true;  
  1791.         }  
  1792.         //还失败的话返回假  
  1793.         return false;  
  1794.     }  
  1795.     /*此函数设置404 错误码*/  
  1796.     protected function set404(){  
  1797.         $this->is404 = true;  
  1798.     }  
  1799.     /*此函数返回404错误码*/  
  1800.     protected function is404(){  
  1801.         return $this->is404;  
  1802.     }  
  1803. }  

 

分享

相关文章

相关推荐

为帝国CMS用户提供动力

Copyright © 2016 CmsDX.com All Rights Reserved.