博客&文章

timthumb.php详解

发布时间：2020-05-06

用过timthumb这个类的都应该很熟悉，此类可以用来生成图片的缩略图并加以处理，如果在linux环境下安装了optipng或pngcrush工具，也可以进行网站的截图操作。功能非常的强大，所以趁着假期花了两天时间把源码从头到尾很详细的注释了一遍。简单说一下此类的使用方法：

访问地址为：http://localhost/timthumb.php?src=http://localhost/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图片时背景是否透明

关于截图操作就不多说了，文件里做了很详细的注释，下面就是注释完的文件：

  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. //图片压缩设置结束
  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. /*截图配置结束*/
  226. // ————————————————————-
  227. // ————————– 配置结束 ————————
  228. // ————————————————————-
  230. timthumb::start();
  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+0Po5y0OgAMjjv01YUZnOGplhWXfNa6JCLnWkXplrcBmW+spbwvaVr/cDyg7IoFC2KbYVC2NQ5MQ4ZNao9Ynzjl9ScNYpnebnDULB3RP6JuPuaGfuuV4fumf8PuvqFyhYtjdoeFgAADs=”);
  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();
  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’;
  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.         }
  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’);
  830.         // 如果高度和宽度都没有指定，设置他们为100*100
  831.         if ($new_width == 0 && $new_height == 0) {
  832.             $new_width = 100;
  833.             $new_height = 100;
  834.         }
  836.         // 限制最大高度和最大宽度
  837.         $new_width = min ($new_width, MAX_WIDTH);
  838.         $new_height = min ($new_height, MAX_HEIGHT);
  840.         // 检测并设置php运行最大占用内存
  841.         $this->setMemoryLimit();
  843.         // 打开图像资源
  844.         $image = $this->openImage ($mimeType, $localImage);
  845.         //如果打开失败，记录信息并退出脚本
  846.         if ($image === false) {
  847.             return $this->error(‘Unable to open image.’);
  848.         }
  850.         // 获得原始图片，也就是上面打开图片的宽和高
  851.         $width = imagesx ($image);
  852.         $height = imagesy ($image);
  853.         $origin_x = 0;
  854.         $origin_y = 0;
  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.         }
  863.         // 如果缩放模式选择的是3，也就是说get中zc=3或者配置文件中DEFAULT_ZC=3，则进行等比缩放,不裁剪
  864.         if ($zoom_crop == 3) {
  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.             }
  874.         }
  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));
  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.         }
  901.         // 使用分配的颜色填充背景
  902.         imagefill ($canvas, 0, 0, $color);
  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));
  923.             }
  925.         }
  927.         // 保存图像时保存完整的alpha信息
  928.         imagesavealpha ($canvas, true);
  930.         //如果缩放模式选择的是1或2或3
  931.         if ($zoom_crop > 0) {
  933.             $src_x = $src_y = 0;
  934.             //图片原宽度
  935.             $src_w = $width;
  936.             //图片原高度
  937.             $src_h = $height;
  939.             //图片纵横比
  940.             $cmp_x = $width / $new_width;
  941.             $cmp_y = $height / $new_height;
  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);
  948.             } else if ($cmp_y > $cmp_x) {
  950.                 $src_h = round ($height / $cmp_y * $cmp_x);
  951.                 $src_y = round (($height – ($height / $cmp_y * $cmp_x)) / 2);
  953.             }
  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.             }
  971.             //将图像根据算法进行裁剪，并拷贝到背景图片上
  972.             imagecopyresampled ($canvas, $image, $origin_x, $origin_y, $src_x, $src_y, $new_width, $new_height, $src_w, $src_h);
  974.         } else {
  976.             //裁剪模式选择的是0，则不进行裁剪，并生成图像
  977.             imagecopyresampled ($canvas, $image, 0, 0, 0, 0, $new_width, $new_height, $width, $height);
  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]) {
  1000.                         case 1:
  1002.                             imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1]);
  1003.                             break;
  1005.                         case 2:
  1007.                             imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1], $filterSettings[2]);
  1008.                             break;
  1010.                         case 3:
  1012.                             imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1], $filterSettings[2], $filterSettings[3]);
  1013.                             break;
  1015.                         case 4:
  1017.                             imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1], $filterSettings[2], $filterSettings[3], $filterSettings[4]);
  1018.                             break;
  1020.                         default:
  1022.                             imagefilter ($canvas, $imageFilters[$filterSettings[0]][0]);
  1023.                             break;
  1025.                     }
  1026.                 }
  1027.             }
  1028.         }
  1030.         // 如果设置了锐化值，并且系统支持锐化函数，则进行锐化操作
  1031.         if ($sharpen && function_exists (‘imageconvolution’)) {
  1033.             $sharpenMatrix = array (
  1034.                     array (-1,-1,-1),
  1035.                     array (-1,16,-1),
  1036.                     array (-1,-1,-1),
  1037.                     );
  1039.             $divisor = 8;
  1040.             $offset = 0;
  1042.             imageconvolution ($canvas, $sharpenMatrix, $divisor, $offset);
  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;
  1215.     }
  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.         }
  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.         }
  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.         }
  1270.         //如果还没找到指定文件，则逐级向上查找
  1271.         $base = $this->docRoot;
  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;
  1581.             case ‘image/png’:
  1582.                 $image = imagecreatefrompng ($src);
  1583.                 break;
  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.         }
  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. }
大熊wordpress凭借多年的wordpress企业主题制作经验，坚持以“为用户而生的wordpress主题”为宗旨，累计为2000多家客户提供品质wordpress建站服务，得到了客户的一致好评。我们一直用心对待每一个客户，我们坚信：“善待客户，将会成为终身客户”。大熊wordpress能坚持多年，是因为我们一直诚信。我们明码标价（wordpress做网站需要多少钱），从不忽悠任何客户，我们的报价宗旨：“拒绝暴利，只保留合理的利润”。如果您有网站建设、网站改版、网站维护等方面的需求，请立即咨询右侧在线客服或拨打咨询热线：18324743309，我们会详细为你一一解答你心中的疑难。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

相关文章

写给所有做网站的朋友的一封信

写给所有做网站的朋友的一封信

现在就开始执行“1+N”互联网推广和没有开始执行的人，一两天看不出任何区别； 一两个月看来差异也是微乎其微的；但在2-5年的长远时间来看的时候，你的高质量询盘不断增加，你的互联网资产已经建立完成，对手已经很难匹敌，现在你看到这段文字的时候就是最好的开始，现在就是最好的时候，马上开始“1+N”体系的整体互联网推广吧，我们和你一起，开创互联网大未来！

点击查看详情

准备开启WordPress网站建设推广？

我们相信高端漂亮的网站不应该是昂贵的，这就是wordpress对每个人都是免费的原因
wordpress建站免费入门，并提供价格合理的wordpress建站套餐。

联系我们 定制开发