首页 / WordPress入门 / timthumb.php详解

timthumb.php详解

    • 珂李斯

    发布于

    by

    用过timthumb这个类的都应该很熟悉，此类可以用来生成图片的缩略图并加以处理，如果在linux环境下安装了…

    用过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 ‘<h2>A TimThumb error has occured</h2>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入门、

    本文收集自互联网，转载请注明来源。
    如有侵权，请联系 wper_net@163.com 删除。

    【上一篇】:

    【下一篇】:

    猜你喜欢GUESS YOU LIKE

    评论 (0)COMMENT

    登录 账号发表你的看法，还没有账号？立即免费 注册


  • 还没有任何评论，赶紧来占个楼吧！