├── .gitignore
├── composer.json
├── autoload.php
├── src
    ├── function
    │   ├── FilterValid.php
    │   └── Tools.php
    └── library
    │   └── Http.php
├── README.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | .DS_Store
3 | composer.lock
4 | /vendor
5 | /tests


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "jjonline/php-helper",
 3 |     "description": "常用的函数和类",
 4 |     "keywords": ["function","class","library"],
 5 |     "homepage": "https://github.com/jjonline/php-helper",
 6 |     "type": "library",
 7 |     "authors": [
 8 |         {
 9 |             "name": "Jea杨",
10 |             "email": "jjonline@jjonline.cn",
11 |             "homepage": "http://blog.jjonline.cn/"
12 |         }
13 |     ],
14 |     "license": "GPL-3.0",
15 |     "require": {
16 |         "php": ">=5.4"
17 |     },
18 |     "autoload": {
19 |         "psr-4": {
20 |             "jjonline\\library\\": "src/library",
21 |             "jjonline\\helper\\": "src/function"
22 |         }
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/autoload.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * jjonline/php-helper额外提供的自动加载文件
 4 |  * @authors Jea杨 (JJonline@JJonline.Cn)
 5 |  * @date    2017-08-07 10:01:41
 6 |  * @version $Id$
 7 |  */
 8 | 
 9 | /**
10 |  * 注册自动加载函数
11 |  */
12 | spl_autoload_register(function ($class) {
13 |     // 加载静态方法类
14 |     if (0 === stripos($class, "jjonline\\helper\\")) {
15 |         $filename = __DIR__ . DIRECTORY_SEPARATOR
16 |                   . str_replace("jjonline\\helper\\", 'src' . DIRECTORY_SEPARATOR. 'function' . DIRECTORY_SEPARATOR, $class)
17 |                   . '.php';
18 |         file_exists($filename) && require($filename);
19 |     }
20 |     // 加载对象类
21 |     if (0 === stripos($class, "jjonline\\library\\")) {
22 |         $filename = __DIR__ . DIRECTORY_SEPARATOR
23 |                   . str_replace("jjonline\\library\\", 'src' . DIRECTORY_SEPARATOR . 'library' . DIRECTORY_SEPARATOR, $class)
24 |                   . '.php';
25 |         file_exists($filename) && require($filename);
26 |     }
27 | });
28 | 


--------------------------------------------------------------------------------
/src/function/FilterValid.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * 常用表单过滤和检测函数
  4 |  * FileName FilterValid.php
  5 |  * @authors Jea杨 (JJonline@JJonline.Cn)
  6 |  * @date    2017-08-03 17:32:38
  7 |  * @version $Id$
  8 |  */
  9 | 
 10 | namespace jjonline\helper;
 11 | 
 12 | class FilterValid
 13 | {
 14 | 
 15 |     /**
 16 |      * 检测传入的变量是否为合法邮箱 提供两种方法 可选内置fliter函数 
 17 |      * 默认正则[邮箱用户名(即@符号之前的部分)构成部分为数字、字母、下划线、中划线和点均可，且开头必须是数字或字母]
 18 |      * @param  string $mail
 19 |      * @return boolean
 20 |      */
 21 |     public static function is_mail_valid($mail)
 22 |     {
 23 |         # PHP内置filter_var方式较为宽泛 不予采用
 24 |         /* !"#$%&'*+-/0123456789=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ^_ `abcdefghijklmnopqrstuvwxyz{|}~ 的类型均正确
 25 |          也就是说 这种格式的邮箱 JJon#?`!#$%&'*+-/line@JJonline.Cn 也会被filter_var认为是合法邮箱 不符合人类认知 暂不采用
 26 |          详见：http://www.cs.tut.fi/~jkorpela/rfc/822addr.html
 27 |         */
 28 |         #return !!filter_var($mail,FILTER_VALIDATE_EMAIL);
 29 |         #正则方式 '/^\w+(?:[-+.]\w+)*@\w+(?:[-.]\w+)*\.\w+(?:[-.]\w+)*$/' 邮箱域名顶级后缀至少两个字符
 30 |         return preg_match('/^\w+(?:[-+.]\w+)*@\w+(?:[-.]\w+)*\.\w{2,}$/',$mail) === 1;
 31 |     }
 32 | 
 33 |     /**
 34 |      * 检测传入的变量是否为天朝手机号
 35 |      * @param  mixed $phone
 36 |      * @return boolean
 37 |      */
 38 |     public static function is_phone_valid($phone)
 39 |     {
 40 |         #Fixed 171 170x
 41 |         #详见：http://digi.163.com/15/0812/16/B0R42LSH00162OUT.html
 42 |         #2017-8-13新增196、198、199号段 http://www.miinac.gov.cn/components/Notice.action?doType=view&id=150951658150000389527
 43 |         return preg_match('/^13[\d]{9}$|14^[0-9]\d{8}$|^15[0-9]\d{8}$|^166\d{8}$|^170[015789]\d{7}$|^171[89]\d{7}$|^17[4678]\d{8}$|^18[0-9]\d{8}$|^198\d{8}$|^199\d{8}$/',$phone) === 1;
 44 |     }
 45 | 
 46 |     /**
 47 |      * 检测Url是否为合法的http或https链接
 48 |      * --------
 49 |      * 1、仅检测http、https打头的网址字符串
 50 |      * 2、网址中可带端口号
 51 |      * 3、网址中可带get变量
 52 |      * 4、网址中可带锚点
 53 |      * --------
 54 |      * @param  mixed $url
 55 |      * @return boolean
 56 |      */
 57 |     public static function is_url_valid($url)
 58 |     {
 59 |         return preg_match('/^http[s]?:\/\/(?:(?:[0-9]{1,3}\.){3}[0-9]{1,3}|(?:[0-9a-z_!~*\'()-]+\.)*(?:[0-9a-z][0-9a-z-]{0,61})?[0-9a-z]\.[a-z]{2,6})(?::[0-9]{1,4})?(?:(?:\/\?)|(?:\/[0-9a-zA-Z_!~\*\'\(?:\)\.;\?:@&=\+\$,%#-\/]*)?)$/i',$url) === 1;
 60 |     }
 61 | 
 62 |     /**
 63 |      * 检测传入的变量是否为一个合法的账户id
 64 |      * ---------
 65 |      * 提供两种方法:函数方法和正则方法
 66 |      * 默认数字ID长度为4至11位
 67 |      * ---------
 68 |      * @param  mixed $uid       待检测的数字ID
 69 |      * @param  int   $minLength 允许的uid最短位数 默认4
 70 |      * @param  int   $maxLength 允许的uid最长位数 默认11
 71 |      * @return boolean
 72 |      */
 73 |     public static function is_uid_valid($uid, $minLength = 4, $maxLength = 11)
 74 |     {
 75 |         #正则方式
 76 |         return preg_match('/^[1-9]\d{'.( $minLength - 1 ).','.( $maxLengt - 1 ).'}$/',$uid) === 1;
 77 |         #函数方式 可能未编译ctype扩展不存在ctype_digit内置函数
 78 |         return strlen($uid)>=$minLength && strlen($uid)<=$maxLength && ctype_digit((string)$uid);
 79 |     }
 80 | 
 81 |     /**
 82 |      * 检测传入的变量是否为一个合法的账户密码
 83 |      * ---------
 84 |      * 1、必须同时包含数字和字母
 85 |      * 2、通过第二个参数指定最小长度，默认值6
 86 |      * 3、通过第三个可选参数指定最大长度，默认值18
 87 |      * ---------
 88 |      * @param  string $password 需要被判断的字符串
 89 |      * @param  int $minLength 允许的账户密码最短位数 默认6
 90 |      * @param  int $maxLength 允许的账户密码最长位数 默认16
 91 |      * @return boolean
 92 |      */
 93 |     public static function is_password_valid($password, $minLength = 6, $maxLength = 18)
 94 |     {
 95 |         if(strlen($password) > $maxLength || strlen($password) < $minLength)
 96 |         {
 97 |             return false;
 98 |         }
 99 |         return preg_match('/\d{1,'.$maxLength.'}/',$password) === 1 && preg_match('/[a-zA-Z]{1,'.$maxLength.'}/',$password) === 1;
100 |     }
101 | 
102 |     /**
103 |      * 检查字符串是否是UTF8编码下的中文
104 |      * @param  string $string 字符串
105 |      * @return boolean
106 |      */
107 |     public static function is_chinese_valid($str)
108 |     {
109 |         return preg_match("/[\x{4e00}-\x{9fa5}]+/u", $str) === 1;
110 |     }
111 | 
112 |     /**
113 |      * 检查字符串是否是UTF8编码
114 |      * @param  string $string 字符串
115 |      * @return boolean
116 |      */
117 |     public static function is_utf8_valid($str)
118 |     {
119 |         $c    = 0;
120 |         $b    = 0;
121 |         $bits = 0;
122 |         $len  = strlen($str);
123 |         for($i = 0; $i<$len; $i++)
124 |         {
125 |             $c = ord($str[$i]);
126 |             if($c > 128){
127 |                 if(($c >= 254)) return false;
128 |                 elseif($c >= 252) $bits=6;
129 |                 elseif($c >= 248) $bits=5;
130 |                 elseif($c >= 240) $bits=4;
131 |                 elseif($c >= 224) $bits=3;
132 |                 elseif($c >= 192) $bits=2;
133 |                 else return false;
134 |                 if(($i+$bits) > $len) return false;
135 |                 while($bits > 1){
136 |                     $i++;
137 |                     $b = ord($str[$i]);
138 |                     if($b < 128 || $b > 191) return false;
139 |                     $bits--;
140 |                 }
141 |             }
142 |         }
143 |         return true;
144 |     }
145 | 
146 |     /**
147 |      * 检测传入的变量是否为一个合法的天朝身份证号（15位、18位兼容）
148 |      * @param  mixed $citizen_id
149 |      * @return false|[]
150 |      */
151 |     public static function is_citizen_id_valid($citizen_id)
152 |     {
153 |         $id                 =   strtoupper($citizen_id);
154 |         if(!(preg_match('/^\d{17}(\d|X)$/',$id) || preg_match('/^\d{15}$/',$id)))
155 |         {
156 |             return false;
157 |         }
158 |         # 15位老号码转换为18位
159 |         $Wi                 =   array(7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1); 
160 |         $Ai                 =   array('1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'); 
161 |         $cardNoSum          =   0;
162 |         if(strlen($id)==16)
163 |         {
164 |             $id             =   substr(0, 6).'19'.substr(6, 9); 
165 |             for($i = 0; $i < 17; $i++) {
166 |                 $cardNoSum +=   substr($id,$i,1) * $Wi[$i];
167 |             }  
168 |             $seq            =   $cardNoSum % 11; 
169 |             $id             =   $id.$Ai[$seq];
170 |         }
171 |         # 效验18位身份证最后一位字符的合法性
172 |         $cardNoSum          =   0;
173 |         $id17               =   substr($id,0,17);
174 |         $lastString         =   substr($id,17,1);
175 |         for($i = 0; $i < 17; $i++)
176 |         {
177 |             $cardNoSum     +=   substr($id,$i,1) * $Wi[$i];
178 |         }  
179 |         $seq                =   $cardNoSum % 11;
180 |         $realString         =   $Ai[$seq];
181 |         # 最后一位效验失败 不是合法身份证号
182 |         if($lastString     !=   $realString) {
183 |             return false;
184 |         }
185 |         # 地域仅能精确到省、自治区信息，再往下就需大量数据支撑才能精确
186 |         $oProvice   = array(
187 |                 11 => "北京",
188 |                 12 => "天津",
189 |                 13 => "河北",
190 |                 14 => "山西",
191 |                 15 => "内蒙古",
192 |                 21 => "辽宁",
193 |                 22 => "吉林",
194 |                 23 => "黑龙江",
195 |                 31 => "上海",
196 |                 32 => "江苏",
197 |                 33 => "浙江",
198 |                 34 => "安徽",
199 |                 35 => "福建",
200 |                 36 => "江西",
201 |                 37 => "山东",
202 |                 41 => "河南",
203 |                 42 => "湖北 ",
204 |                 43 => "湖南",
205 |                 44 => "广东",
206 |                 45 => "广西",
207 |                 46 => "海南",
208 |                 50 => "重庆",
209 |                 51 => "四川",
210 |                 52 => "贵州",
211 |                 53 => "云南",
212 |                 54 => "西藏",
213 |                 61 => "陕西",
214 |                 62 => "甘肃",
215 |                 63 => "青海",
216 |                 64 => "宁夏",
217 |                 65 => "新疆",
218 |                 71 => "台湾",
219 |                 81 => "香港",
220 |                 82 => "澳门",
221 |                 91 => "国外"
222 |         );
223 |         $Provice    = substr($id, 0, 2);
224 |         $BirthYear  = substr($id, 6, 4);
225 |         $BirthMonth = substr($id, 10, 2);
226 |         $BirthDay   = substr($id, 12, 2);
227 |         $Sex        = substr($id, 16,1) % 2 ;//男1 女0
228 |         # 省份数据
229 |         if(!isset($oProvice[$Provice]))
230 |         {
231 |             return false;
232 |         }
233 |         # 年份超限
234 |         if($BirthYear > 2078 || $BirthYear < 1900)
235 |         {
236 |             return false;
237 |         }
238 |         # 年月日是否合法
239 |         $RealDate           =   strtotime($BirthYear.'-'.$BirthMonth.'-'.$BirthDay);
240 |         if(date('Y',$RealDate) != $BirthYear || date('m',$RealDate) != $BirthMonth || date('d',$RealDate) != $BirthDay)
241 |         {
242 |             return false;
243 |         }
244 |         # 效验成功 返回关联数组，便于从身份证号中提取基本信息 boolean判断为true
245 |         return array('id'=>$id,'location'=>$oProvice[$Provice],'Y'=>$BirthYear,'m'=>$BirthMonth,'d'=>$BirthDay,'sex'=>$Sex);
246 |     }
247 | }
248 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | jjonline/php-helper
  2 | ===================
  3 | 
  4 | [![Latest Stable Version](https://poser.pugx.org/jjonline/php-helper/v/stable)](https://packagist.org/packages/jjonline/php-helper)
  5 | [![License](https://poser.pugx.org/jjonline/php-helper/license)](https://packagist.org/packages/jjonline/php-helper)
  6 | [![Build Status](https://travis-ci.org/jjonline/php-helper.svg?branch=master)](https://travis-ci.org/jjonline/php-helper)
  7 | 
  8 | jjonline/php-helper是日常开发过程中积累提炼而来，收集整理了基于静态类的多个常用函数方法和通用的对象类，PHP版本要求至少5.4，基于命名空间，适配composer，方便composer一键安装和管理。
  9 | 
 10 | ## 安装
 11 | 
 12 | 方法1、composer安装后使用composer的自动加载器
 13 | 
 14 | `composer require jjonline/php-helper`
 15 | 
 16 | 
 17 | 方法2、下载代码包后直接使用包提供的自动加载器
 18 | 
 19 | `require_once './autoload.php';`
 20 | 
 21 | > 强烈建议使用composer进行包管理和安装
 22 | 
 23 | 
 24 | ## 文档
 25 | 
 26 | 快速示例：
 27 | ~~~
 28 | use jjonline\helper\FilterValid;
 29 | use jjonline\helper\Tools;
 30 | use jjonline\library\Http;
 31 | 
 32 | // 表单效验
 33 | $isMailValid     = FilterValid::is_mail_valid('jjonline@jjonline.cn');
 34 | $isPhoneValid    = FilterValid::is_phone_valid('13800138000');
 35 | 
 36 | // ...
 37 | 
 38 | // 通用方法
 39 | $isMobileBrowser = Tools::is_mobile_browser();
 40 | $status          = Tools::rm_dir('./test');
 41 | 
 42 | // ...
 43 | 
 44 | // 通用http操纵类Post方法
 45 | $Http            = Http::init();
 46 | $excuteStatus    = $Http->setData('postField','postVallue')
 47 |                         ->setTimeOut(10)
 48 |                         ->setReferer('http://blog.jjonline.cn')
 49 |                         ->setUserAgent('Mozilla/5.0')
 50 |                         ->setRequestHeader('X-Powered-By','JJonline.Cn')
 51 |                         ->setRequestCookie('cookieName','cookieValue')
 52 |                         ->post('http://blog.jjonline.cn');
 53 | if($excuteStatus)
 54 | {
 55 |     $Http->save('/var/www/index.html');
 56 |     echo $Http->getBody();
 57 | }
 58 | 
 59 | // 通用http操纵类Get方法
 60 | $excuteStatus = $Http->reset()->get('http://blog.jjonline.cn');
 61 | if($excuteStatus)
 62 | {
 63 |     $Http->save('/var/www/index1.html');
 64 |     print_r($Http->getResponseCookie());
 65 | }
 66 | ~~~
 67 | 
 68 | jjonline/php-helper包含两部分：
 69 | 
 70 | * 静态类函数方法：`src/function`目录下
 71 | * 对象类：`src/library`目录下
 72 | 
 73 | ----
 74 | 
 75 | ### FilterValid 表单验证静态类
 76 | 
 77 | 引入命名空间：`use jjonline\helper\FilterValid`
 78 | 
 79 | + **`boolean FilterValid::is_mail_valid(string $str)`**
 80 | 
 81 |   检测传入的字符串是否符合邮箱格式
 82 | 
 83 | + **`boolean FilterValid::is_phone_valid(mixed $str|number)`**
 84 | 
 85 |   检测传入的字符串或数字是否符合天朝手机号格式
 86 | 
 87 | + **`boolean FilterValid::is_url_valid(string $url)`**
 88 | 
 89 |   检测传入的字符串是否为http或http打头的网址，可包含端口号、get参数和锚点
 90 | 
 91 | + **`boolean FilterValid::is_uid_valid(mixd $uid[[,$min_len = 4],$max_len = 11])`**
 92 | 
 93 |   检测传入的数字是否为一个数字ID，第二个可选参数指定最小长度默认值4；第三个可选参数指定最大长度默认值11
 94 | 
 95 | + **`boolean FilterValid::is_password_valid(string $pwd[,$min_len = 6,$max_len = 18])`**
 96 | 
 97 |   检测传入的字符串是否为同时包含数字和字母的合法密码，第二个可选参数指定最小长度默认值4；第三个可选参数指定最大长度默认值18
 98 | 
 99 | + **`boolean FilterValid::is_chinese_valid(string $str)`**
100 | 
101 |   检测传入的字符串是否全部为中文汉字
102 | 
103 | + **`boolean FilterValid::is_utf8_valid(string $str)`**
104 | 
105 |   检测传入的字符串是否utf8编码
106 | 
107 | + **`mixd[false|array] FilterValid::is_citizen_id_valid(string $citizen_id)`**
108 | 
109 |   检测传入的字符串是否为合乎编码规范的天朝身份证号，兼容16位和18位，合乎规范返回从身份证号提取的出生年月、归属地、性别和身份证号组成的数组，否则返回false；注意传入16位老号码合乎规范的话返回数组中的身份证号将转换为18位！
110 | 
111 | ### Tools 常用工具方法静态类
112 | 
113 | 引入命名空间：`use jjonline\helper\Tools`
114 | 
115 | + **`boolean Tools::is_weixin_browser([string $userAgent = null])`**
116 | 
117 |   检测当前浏览器环境是否为微信浏览器，或者传入浏览器userAgent字符串检测是否为微信浏览器，参数可选
118 | 
119 | + **`boolean Tools::is_mobile_browser()`**
120 | 
121 |   检测当前浏览器环境是否为移动端浏览器，当然微信浏览器也会返回true
122 | 
123 | + **`string Tools::hide_name(string $userName)`**
124 | 
125 |   用户名脱敏处理，字符长度小于3返回3个\*，长度大于3则返回首尾各1个字符以及中间的3个\*号字符
126 | 
127 | + **`string Tools::hide_ipv4(string $ip)`**
128 | 
129 |   IPv4地址脱敏处理，返回IPv4中间两位脱敏后的字符，例如：223.\*\*.\*\*.5
130 | 
131 | + **`string Tools::nl2p(string $str)`**
132 | 
133 |   nl2br的类似函数，只不过是将换行符`\n`、`\r`或`\n\r`转换为成对的`p`标签
134 | 
135 | + **`string Tools::time_ago(mixed $unixTimeStamp)`**
136 | 
137 |   将Unix时间戳转换为`xx前`这种模糊表示法，例如：`刚刚`、`1分钟前`、`2小时前`、`3周前`、`1个月前(07-11)`、`3年前(2014-12-02)` 等
138 | 
139 | + **`boolean Tools::is_ssl()`**
140 | 
141 |   检测当前请求是否为https请求
142 | 
143 | + **`mixed Tools::get_client_ip([$isLong = 0],[$isAdv = false])`**
144 | 
145 |   获取客户端的IPv4地址，第一个可选参数1和true返回IPv4数字表示法，0和false返回IPv4字符串，默认值0；第二个可选参数是否检测http代理情况，false不检测，true检测，默认值false
146 | 
147 | + **`void Tools::redirect(string $url[[,int $time = 0],$text = null])`**
148 | 
149 |   网页重定向，也就是网页跳转啦！第一参数跳转的url，第二个可选参数跳转等待时间，第三个可选参数跳转等待时显示的文本
150 | 
151 | + **`string|null Tools::dump(string $str[,$echo=true[, $label=null[, $strict=true]]])`**
152 | 
153 |   开发时浏览器友好的调试输出任意变量，来源于ThinkPHP，一般调试输出仅需要将调试变量当做第一个参数
154 |     >第二个可选参数为false将返回处理好的字符串，为true直接输出没有返回值，默认值为true;
155 | 
156 |     >第三个可选参数指定本次调试的标签，也就是在输出或返回值前加上这个标签值，便于开发调试，默认值null；
157 | 
158 |     >第四个可选参数指定本次输出是否严格模式，也就是在输出或返回值的时候是否将html标签转义，默认值true；
159 | 
160 | 
161 | + **`string Tools::transfer_encrypt(string $str[, $key = 'jjonline'[, $expiry = 0]])`**
162 | 
163 |   来源于discuz的可逆加解密算法，用于有有效期效验的数据交换，加密强度很弱，请甄别使用场景
164 |     >第二个可选参数：本次加密的秘钥，默认加了一个秘钥`jjonline`
165 | 
166 |     >第三个可选参数：本次加密的有效时间，单位秒，在该参数指定的时间内解密有效，默认值0表示永不失效
167 | 
168 | + **string Tools::transfer_decrypt(string $str[, $key = 'jjonline'])`**
169 | 
170 |   将transfer_encrypt加密的值解密，并效验有效期，成功返回原串，失败或失效返回空字符串
171 |     >第一个参数：待解密的密文
172 | 
173 |     >第二个参数：解密的秘钥
174 | 
175 |     >返回值：已失效或解密失败返回空值，解密成功返回解密后明文
176 | 
177 |   **特别留意：超过过期时间有秘钥也是能解密出明文的，只不过方法体本身效验是否过期，过期就认为解密失败**
178 | 
179 | + **`string Tools::mbsubstr(string $str [,$start = 0[, $length[, $charset = "utf-8"]]])`**
180 | 
181 |   返回参数指定的参数截取字符串，参数与原生函数`mb_substr`一致，这是一个兼容处理函数
182 | 
183 | + **`Tools::get_rand_string([$len = 6[, $type = ''[, $addChars = '']]])`**
184 | 
185 |   获取随机字符串，来源于ThinkPHP
186 |     >第一个**可选参数**指定返回字符串长度，默认值6
187 | 
188 |     >第二个**可选参数**指定返回字符串类型，取值空字符串、0字母、1数字、2大写字母、3小写字母、4中文，默认值空表示返回大小写字母和数字混合的随机字符串，0表示返回大小写字母混合的字符串，以此类推
189 | 
190 |     >第三个**可选参数**指定附加的用于返回值随机字符串的字符元素，函数中的数字、大小写字母去除了易混淆的字母oOLl和数字0和1，若不需要去除通过第三个参数附加进去即可，默认值空字符串
191 | 
192 | + **`string  Tools::clear_js_code(string $html)`**
193 | 
194 |   去除字符串中的js代码，包括大段的由<script>标签包裹的代码和各标签属性中on开头的事件属性
195 | 
196 | + **`string to_absolute_url(string $sUrl,string $baseUrl)`**
197 | 
198 |   将当前网页中的相对超链接转换为带域名的完整超链接
199 |     >第一个参数指定当前网页中的相对网址链接，例如：`./../../article/news/1.html`
200 | 
201 |     >第二个参数指定当前网页的网址Url，例如：`http://blog.jjonline.cn/a/html/top/idea.html`
202 | 
203 | + **`boolean Tools::rm_dir(string $dir)`**
204 | 
205 |   删除目录以及目录下的所有文件，原生函数`rmdir`只能删除非空目录
206 | 
207 | + **`boolean Tools::generate_uuid([$opt = false])`**
208 | 
209 |   生成唯一性相当棒的uuid，例如：`32EC26AB-70CD-B80D-FB72-ABD8B5CC9AA8`
210 |     >可选参数传值`true`或`false`，默认值`false`，表示返回的uuid不包裹大括号，传值`true`则返回包裹大括号的uuid，例如:`{32EC26AB-70CD-B80D-FB72-ABD8B5CC9AA8}`
211 | 
212 | ----
213 | 
214 | ### Http 网络请求对象类
215 | 
216 | 引入命名空间：`use jjonline\library\Http`
217 | 
218 | #### 初始化
219 | 
220 | + **`HttpObject Http::init()`**
221 | 
222 |   初始化Http单例类，返回http单例对象，例如：`$http = Http::init()`
223 | 
224 | #### 设置方法
225 | 
226 | + **`HttpObject $http->setUrl(string $url)`**
227 | 
228 |   设置请求的网址url
229 | 
230 | + **HttpObject `$http->setTimeOut(int $time)`**
231 | 
232 |   设置请求连接上之后的超时时间，一个int型数字，单位：秒
233 | 
234 | + **`HttpObject $http->setRequestHeader(mixed $key[,string $value = null])`**
235 | 
236 |   设置自定义请求头信息，参数比较灵活
237 |     ~~~
238 |     第一种传参方式：第一个参数为header头的名称部分，第二个参数为header头的值部分
239 |     $http->setRequestHeader('X-Powered-By','PHP/7.0.22')
240 | 
241 |     第二种传参方式：仅第一个参数二维数组，一次可设置多个header头项目
242 |     $http->setRequestHeader([['X-Powered-By'=>'PHP/7.0.22'],['X-User-By'=>'JJonline']])
243 | 
244 |     第三种传参方式：仅第一个参数字符串，完整的header头
245 |     $http->setRequestHeader('X-Powered-By: PHP/7.0.22')
246 |     ~~~
247 | 
248 | + **`HttpObject $http->setReferer([string $key = null])`**
249 | 
250 |   设置请求头信息中的Referer来源，必须是一个合法的网址
251 | 
252 | + **`HttpObject $http->setUserAgent(string $userAgent)`**
253 | 
254 |   设置请求头信息中的userAgent浏览器头信息
255 | 
256 | + **`HttpObject $http->setData(mixed $key[,string $value = null])`**
257 | 
258 |   设置请求中post发送的表单数据，参数比较灵活
259 |     ~~~
260 |     第一种传参方式：第一个参数为post数据的名称部分，第二个参数为post数据的值部分
261 |     $http->setData('name','Jea')
262 |     $http->setData('sex','男')
263 | 
264 |     第二种传参方式：仅第一个参数二维数组，一次可设置多个fieldKey-fieldValue
265 |     $http->setData([['name'=>'Jea'],['sex'=>'男']])
266 | 
267 |     第三种传参方式：仅第一个参数字符串，完整的url拼接格式，注意传值需要urlencode
268 |     $http->setData('name=Jea&sex=%E7%94%B7')
269 |     ~~~
270 | 
271 | + **`HttpObject $http->setRequestCookie(mixed $key[,string $value = null])`**
272 | 
273 |   设置请求时发送的cookie，参数比较灵活
274 |     ~~~
275 |     第一种传参方式：第一个参数为cookie的名称部分，第二个参数为cookie的值部分
276 |     $http->setRequestCookie('cookieName','cookieValue')
277 | 
278 |     第二种传参方式：仅第一个参数二维数组，一次可设置多个cookie
279 |     $http->setRequestCookie([['cookieName1'=>'cookieValue1'],['cookieName2'=>'cookieValue2']])
280 | 
281 |     第三种传参方式：仅第一个参数字符串，符合curl_setopt原生设置cookie键值对的字符串
282 |     $http->setRequestCookie('cookie_a=1; cookie_b=2') //注意分号和其后的空格
283 |     ~~~
284 | 
285 | + **`HttpObject $http->setUploadFile(string $field_name,string $file_dir)`**
286 | 
287 |   置Post方法上传的文件
288 |   第一个参数设置表单名，第二个参数设置拟上传文件路径
289 | 
290 | + **`HttpObject $http->setOption(mixed $key[,mixed $value = null])`**
291 | 
292 |   高阶自定义设置cUrl原生参数，直接操纵`curl_setopt`函数的设置项，参数比较灵活，常量参考：[点此](http://php.net/manual/zh/function.curl-setopt.php)
293 |     ~~~
294 |     第一种传参方式：与curl_setopt(resource $ch , int $option , mixed $value )的第2、3两个参数一致即可
295 |     $http->setRequestCookie(CURLOPT_CRLF,true) //第一个参数为常量
296 |     $http->setRequestCookie('CURLOPT_CRLF',true) //该种方法也是可以的，但不推荐
297 | 
298 |     第二种传参方式：仅第一个参数二维数组，一次可设置多个
299 |     $http->setRequestCookie([['CURLOPT_CRLF'=>true],[CURLOPT_FILETIME=>true]])
300 |     ~~~
301 | 
302 | 
303 | #### 获取设置的值方法
304 | 
305 | + **`string $http->getUrl()`**
306 | 
307 |   获取设置的请求url
308 | 
309 | + **`int $http->getTimeOut()`**
310 | 
311 |   获取设置的超时时间
312 | 
313 | + **`mixed $http->getRequestHeader([string $key = null])`**
314 | 
315 |   获取设置的header，可选参数为header名称部分
316 |     ~~~
317 |     string $http->getRequestHeader('X-Powered-By')
318 |     array  $http->getRequestHeader() //返回所有设置的header数组格式
319 |     ~~~
320 | 
321 | + **`string $http->getReferer()`**
322 | 
323 |   获取设置的Referer
324 | 
325 | + **`string $http->getUserAgent()`**
326 | 
327 |   获取设置的UserAgent
328 | 
329 | + **`mixed $http->getData([string $key = null])`**
330 | 
331 |   获取设置的表单数据
332 |     ~~~
333 |     string $http->getData('fieldName')
334 |     array  $http->getData() //返回所有设置的表单数组
335 |     ~~~
336 | 
337 | + **`mixed $http->geetRequestCookie([string $key = null])`**
338 | 
339 |   获取设置的cookie数据
340 |     ~~~
341 |     string $http->geetRequestCookie('cookieName')
342 |     array  $http->geetRequestCookie() //返回所有设置的cookie
343 |     ~~~
344 | 
345 | + **`mixed $http->getOption([string $key = null])`**
346 | 
347 |     获取设置的curl_setopt高阶参数
348 |     ~~~
349 |     string $http->getOption(CURLOPT_FILETIME)
350 |     array  $http->getOption() //返回所有设置的curl_setopt高阶参数
351 |     ~~~
352 | 
353 | #### 执行请求和写入数据
354 | 
355 | + **`boolean $http->get([string $url = null])`**
356 | 
357 |   执行get请求，返回布尔值，true执行成功，false执行异常
358 |   >可选参数为快捷设置请求的url，可代替setUrl方法
359 | 
360 | + **`boolean $http->post([string $url = null[,array $data = []]])`**
361 | 
362 |   执行post请求，返回布尔值，true执行成功，false执行异常
363 |   >第一个可选参数为设置请求的url，第二个可选数组参数设置表单数据，格式与setData第二种传参方式一致
364 | 
365 | + **`boolean $http->save(string $local_file_dir)`**
366 | 
367 |   成功执行get或post后，存储请求到的数据，俗称：下载
368 |     ~~~
369 |     参数为保存的路径，包括文件名和后缀，例如
370 |     $ret = $http->get($url);
371 |     $ret && $http->save($dir);
372 |     ~~~
373 | 
374 | #### 获取执行请求后的数据
375 | 
376 | + **`string $http->getResult()`**
377 | 
378 |   获取请求成功后返回的包含header头的原始数据
379 | 
380 | + **`string $http->getHeader()`**
381 | 
382 |   获取请求成功后返回数据的整个header头字符串
383 | 
384 | + **`string $http->getBody()`**
385 | 
386 |   获取请求成功后返回数据的body主体内容，譬如：请求某个api后返回的json字符串
387 | 
388 | + **`array $http->getResponseCookie()`**
389 | 
390 |   获取请求成功后返回数据中的cookie键值对数组
391 |   ~~~
392 |   该方法有个可选参数，取值true或false
393 |   默认值false表示返回处理好的cookie键值对二维数组
394 |   例如：[['JID'=>'so7i7srvbk4c5dd0748df8va23'],['token'=>'6a4ee8169908dc4ec0700008fe0c1085']]
395 |   传值true表示返回header头中cookie键值对的原始表示法的一维数组，用于进一步处理获取一些信息
396 |   例如：[
397 |         'JID=so7i7srvbk4c5dd0748df8va23; path=/; domain=.jjonline.cn; HttpOnly',
398 |         'token=6a4ee8169908dc4ec0700008fe0c1085; path=/; domain=.jjonline.cn; HttpOnly'
399 |         ]
400 |   ~~~
401 | 
402 | + **`string $http->getError()`**
403 | 
404 |   获取请求失败后的错误描述字符串，`curl_error`的返回值
405 | 
406 | + **`int $http->getErrno()`**
407 | 
408 |   获取请求失败后的错误号，`curl_errno`的返回值，没有出错返回数字0，出错返回不为0的数字
409 | 
410 | + **`array $http->getInfo()`**
411 | 
412 |   获取http请求连接资源句柄的信息数组，`curl_getinfo`无第二个参数的返回值
413 | 
414 | #### 重置数据单例复用
415 | 
416 | + **`HttpObject $http->reset([boolean $isResetOption = false])`**
417 | 
418 |   一次http请求完毕需要再次请求之前为了防止两次数据乱入，再下一次请求执行之前调用`reset`方法清理掉上一次设置的参数，可选参数表示是否清理掉setOption方法设置的cUrl核心参数，默认值false表示不清理，需要清理传入true，传入true后在再次执行新请求前需重新设置各个参数
419 | 
420 | #### Http类示例
421 | 
422 | **sample1、get请求晶晶博客**
423 | 
424 | ~~~
425 | uese jjonline\helper\Tools;
426 | use jjonline\library\Http;
427 | $http = Http::init();
428 | // [可选的]设置请求时的header头Referer
429 | $http->setReferer('http://blog.jjonline.cn');
430 | // [可选的]设置请求时的header头User-Agent值
431 | $http->setUserAgent('Mozilla/5.0 (Windows NT 6.1; Win64; x64) Chrome/60.0.3112.90 Safari/537.36');
432 | // [可选的]设置请求时的cookie
433 | $http->setRequestCookie('JID','so7i7srvbk4c5dd0748df8va23');
434 | // setData方法在get请求时无效，若需要为get方法传递get变量，请拼接好变量后通过setUrl方法设置
435 | // 设置请求晶晶的博客首页的Url
436 | $http->setUrl('http://blog.jjonline.cn');
437 | // 执行get请求并判断执行状态
438 | $isSuccess = $http->get();
439 | /**
440 | * $http->setUrl('http://blog.jjonline.cn'); 和 $isSuccess = $http->get();也可以简写成
441 | * $isSuccess = $http->get('http://blog.jjonline.cn');
442 | */
443 | /**
444 | * 上述的代码也可以这样写：
445 | * $isSuccess = $http->setReferer('http://blog.jjonline.cn')
446 | *            ->setUserAgent('Mozilla/5.0 (Windows NT 6.1; Win64; x64) Chrome/60.0.3112.90 Safari/537.36')
447 | *            ->setRequestCookie('JID','so7i7srvbk4c5dd0748df8va23')
448 | *            ->setUrl('http://blog.jjonline.cn')
449 | *            ->get();
450 | */
451 | if($isSuccess)
452 | {
453 |    echo '请求成功，header数据为：';
454 |    Tools::dump($http->getHeader());
455 |    echo 'body数据为：';
456 |    Tools::dump($http->getBody());
457 | }else {
458 |    echo '请求失败，curl_error()返回值为：'.$http->getError().'curl_errno()返回值为：'.$http->getErrno();
459 | }
460 | ~~~
461 | 
462 | **sample2、get请求下载图片**
463 | 
464 | ~~~
465 | use jjonline\library\Http;
466 | $http      = Http::init();
467 | $isSuccess = $http->get('http://blog.jjonline.cn/Images/mm.jpg');
468 | $isSuccess && $http->save('./m.jpg');//此时若不出现异常和错误，脚本所在目录会看到下载的这张图片
469 | ~~~
470 | 
471 | 
472 | **sample3、post请求**
473 | 
474 | ~~~
475 | use jjonline\library\Http;
476 | $http      = Http::init();
477 | // 设置参数和post提交的数据
478 | $http->setOption(CURLOPT_FILETIME,true)
479 |   ->setReferer('http://blog.jjonline.cn')
480 |   ->setUserAgent('Mozilla/5.0 (Windows NT 6.1; Win64; x64) Chrome/60.0.3112.90 Safari/537.36')
481 |   ->setRequestCookie('JID','so7i7srvbk4c5dd0748df8va23')
482 |   ->setData('postField1','这是post发送的名为postField1的值')
483 |   ->setData('postField2','这是post发送的名为postField2的值')
484 |   ->post('http://blog.jjonline.cn');
485 | // 接下来的代码省略，当然啦我的博客个人首页对post响应与get无异
486 | 
487 | //再来一个post请求，请求之前需要reset掉设置的请求参数
488 | $http->reset()
489 |      ->setData('postData','reset之后原先设置的post请求参数不再生效')
490 |      ->post('http://blog.jjonline.cn');
491 | ~~~
492 | 
493 | **sample4、post上传文件**
494 | 
495 | ~~~
496 | use jjonline\library\Http;
497 | $http      = Http::init();
498 | // 设置过程省略一部分...
499 | $http->setUploadFile('FileField','../mm.jpg')
500 |      ->post('http://blog.jjonline.cn');
501 | // 当然，这里post之前依然可以调用setOption、setReferer等之类的方法
502 | // 这里上传文件后假设被请求的服务器端（也就是接收文件上传方）是PHP开发的
503 | // 那么可以通过$_FILES['FileField']读取到这个上传的文件
504 | ~~~


--------------------------------------------------------------------------------
/src/library/Http.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Http操纵类：
  4 |  *     1、发送get请求
  5 |  *     2、发送post请求
  6 |  *     3、上传文件
  7 |  *     4、下载文件
  8 |  * @authors Jea杨 (JJonline@JJonline.Cn)
  9 |  * @date    2017-08-04 16:51:07
 10 |  * @version $Id$
 11 |  */
 12 | namespace jjonline\library;
 13 | use Exception;
 14 | 
 15 | class Http {
 16 |     // 请求url
 17 |     private $url;
 18 |     // 请求超时时间，默认30秒
 19 |     private $timeout = 30;
 20 |     // curl参数--带一些默认值
 21 |     private $option  = array(
 22 |         // 是否将http请求的header头作为数据量输出，要手动处理cookie此项会强行重置
 23 |         CURLOPT_HEADER         => true,
 24 |         // userAgent设置 默认为Chrome60 win7x64版
 25 |         CURLOPT_USERAGENT      => 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.90 Safari/537.36',
 26 |         // 网络协议的类型，天朝IPv6还未大范围普及
 27 |         // 默认值CURL_IPRESOLVE_WHATEVER时有时解析域名时会优先解析到IPv6导致卡顿
 28 |         CURLOPT_IPRESOLVE      => CURL_IPRESOLVE_V4,//CURL_IPRESOLVE_WHATEVER、CURL_IPRESOLVE_V4、CURL_IPRESOLVE_V6
 29 |         // 等待超时、连接上之后传输数据的超时时间，单位秒
 30 |         CURLOPT_TIMEOUT        => 30,
 31 |         // HTTP请求头中Accept-Encoding的值，空值发送所有支持的编码类型
 32 |         CURLOPT_ENCODING       => '',
 33 |         // 将请求结果以字符串返回而不是直接输出
 34 |         CURLOPT_RETURNTRANSFER => true,
 35 |         // 默认禁用https连接的ssl证书效验，可通过setOption方法自主定制
 36 |         CURLOPT_SSL_VERIFYPEER => false,
 37 |         // 连接超时，建立连接的超时时间，单位秒
 38 |         CURLOPT_CONNECTTIMEOUT => 10,
 39 |     );
 40 |     //设置进请求header头的key-value数组
 41 |     private $requestHeader  = [];
 42 |     // curl发送的数据
 43 |     private $data           = [];
 44 |     // curl发送的cookie
 45 |     private $requestCookie  = [];
 46 |     // curl返回的cookie
 47 |     private $responseCookie = [];
 48 |     // curl返回http结果的header头部分
 49 |     private $header         = '';
 50 |     // curl返回http结果的body部分
 51 |     private $body           = '';
 52 |     // curl执行后可能的错误信息
 53 |     private $error          = '';
 54 |     // curl执行后可能的错误号
 55 |     private $errno;
 56 |     // curl_getinfo返回的信息
 57 |     private $info;
 58 |     // curl返回的带header头的字符串结果
 59 |     private $result         = '';
 60 |     private static $instance;
 61 | 
 62 |     private function __construct() {}
 63 | 
 64 |     /**
 65 |      * 初始化实例对象 单例Instance
 66 |      * @return self
 67 |      */
 68 |     public static function init()
 69 |     {
 70 |         if (self::$instance === null) {
 71 |             self::$instance = new self;
 72 |         }
 73 |         return self::$instance;
 74 |     }
 75 | 
 76 |     /**
 77 |      * 单例对象可重用，但不同请求需要重置配置或数据
 78 |      * @param  boolean $isResetOption 是否重置cUrl的配置项，默认否
 79 |      * @return $this
 80 |      */
 81 |     public function reset($isResetOption = false)
 82 |     {
 83 |         // 重置参数数据和返回结果数据
 84 |         $this->requestHeader  = [];
 85 |         $this->data           = [];
 86 |         $this->requestCookie  = [];
 87 |         $this->responseCookie = [];
 88 |         $this->result         = '';
 89 |         $this->header         = '';
 90 |         $this->body           = '';
 91 |         $this->error          = '';
 92 |         $this->errno          = null;
 93 |         $this->info           = null;
 94 |         // 重置配置参数，此处清除配置将清除本类默认的初始化cUrl参数
 95 |         if($isResetOption)
 96 |         {
 97 |             $this->option     = [];
 98 |         }
 99 |         return $this;
100 |     }
101 | 
102 |     /**
103 |      * 设置cUrl自定义配置值，通过该方法直接操纵curl配置项
104 |      * 例如设置`CURLOPT_REFERER`传入本次请求的http请求头中的Referer值
105 |      * @param string|array $key   curl配置项的key或者key-value的数组
106 |      * @param mixed        $value curl配置项的的value
107 |      * @return $this
108 |      */
109 |     public function setOption($key,$value = null)
110 |     {
111 |         if(is_array($key))
112 |         {
113 |             // $this->option = array_merge($this->option,$key);
114 |             // 避免array_merge重新组合数组$this->option中的整数键名
115 |             foreach ($key as $_key => $value) {
116 |                 $_key = constant(strtoupper($_key));//兼容以字符串形式传入curl设置参数
117 |                 if(is_null($_key))
118 |                 {
119 |                     throw new Exception('Constant Name Do Not Exist '.$key, 500);
120 |                 }
121 |                 $this->option[$_key] = $value;
122 |             }
123 |         }else{
124 |             $this->option[$key] = $value;
125 |         }
126 |         return $this;
127 |     }
128 | 
129 |     /**
130 |      * 获取配置项的值
131 |      * @param  strign $key 配置项key的名称，默认null返回整个配置项数组
132 |      * @return mixed
133 |      */
134 |     public function getOption($key = null)
135 |     {
136 |         if(!empty($key))
137 |         {
138 |             $_key = constant(strtoupper($key));
139 |             if(is_null($_key))
140 |             {
141 |                 throw new Exception('Constant Name Do Not Exist '.$key, 500);
142 |             }
143 |             return isset($this->option[$_key]) ? $this->option[$_key] : null;
144 |         }
145 |         return $this->option;
146 |     }
147 | 
148 |     /**
149 |      * 设置请求体Referer
150 |      * @param string $referer 设置请求体的Referer字符串|一个有效的网址
151 |      */
152 |     public function setReferer($referer)
153 |     {
154 |         if (filter_var($referer, FILTER_VALIDATE_URL)) {
155 |             $this->option[CURLOPT_REFERER] = $referer;
156 |             return $this;
157 |         }
158 |         throw new Exception('Http Referer is invalid.', 500);
159 |     }
160 | 
161 |     /**
162 |      * 获取已设置的Referer
163 |      * @return string
164 |      */
165 |     public function getReferer()
166 |     {
167 |         return isset($this->option[CURLOPT_REFERER]) ? $this->option[CURLOPT_REFERER] : '';
168 |     }
169 | 
170 |     /**
171 |      * 设置请求体header头中User-Agent值
172 |      * 本类默认设置useAgent值为win7x64位下的chrome浏览器60版本的头信息
173 |      * @param string $userAgent 设置的User-Agent值
174 |      */
175 |     public function setUserAgent($userAgent)
176 |     {
177 |         $this->option[CURLOPT_USERAGENT] = $userAgent;
178 |         return $this;
179 |     }
180 | 
181 |     /**
182 |      * 获取设置的userAgent头信息，未手动设置将获取默认值
183 |      * @return string
184 |      */
185 |     public function getUserAgent()
186 |     {
187 |         return isset($this->option[CURLOPT_USERAGENT]) ? $this->option[CURLOPT_USERAGENT] : '';
188 |     }
189 | 
190 |     /**
191 |      * 设置请求头信息
192 |      * @param string $key   请求头信息中的名称项，例如：'Content-type'
193 |      * @param string $value 请求头信息中的值项，例如：'text/plain'
194 |      * @return $this
195 |      */
196 |     public function setRequestHeader($key,$value = null)
197 |     {
198 |         if (is_array($key)) {
199 |             /**
200 |              * $key是二维数组形式
201 |              * [[key=>value],[key=>value]...]
202 |              */
203 |             $this->requestHeader = array_merge($this->requestHeader,$key);
204 |         } else {
205 |             if ($value === null) {
206 |                 // $key传入的是'Content-type: text/plain'这种形式的字符串
207 |                 $_header = explode(':', $key);
208 |                 if(is_array($_header) && count($_header) == 2)
209 |                 {
210 |                     $this->requestHeader[trim($_header[0])] = trim($_header[1]);
211 |                 }
212 |             } else {
213 |                 $this->requestHeader[$key] = $value;
214 |             }
215 |         }
216 |         return $this;
217 |     }
218 | 
219 |     /**
220 |      * 获取已设置的请求头信息
221 |      * @param  string $key 设置的请求头名称
222 |      * @return string
223 |      */
224 |     public function getRequestHeader($key = null)
225 |     {
226 |         if(!empty($key))
227 |         {
228 |             return isset($this->requestHeader[$key]) ? $this->requestHeader[$key] : null;
229 |         }
230 |         return $this->requestHeader;
231 |     }
232 | 
233 |     /**
234 |      * 设置curl发送的数据
235 |      * @param string|array $key   curl发送数据的key名称或数组包裹的多个key-value或事先已拼接好的数据字符串
236 |      * @param string       $value 第一个参数为string时的value值
237 |      * @return $this
238 |      */
239 |     public function setData($key,$value = null)
240 |     {
241 |         if (is_array($key)) {
242 |             /**
243 |              * $key是二维数组形式
244 |              * [[key=>value],[key=>value]...]
245 |              */
246 |             $this->data = array_merge($this->data,$key);
247 |         } else {
248 |             if ($value === null) {
249 |                 // urlencoded后的字符串形式，例如a=1&b=2&c=3，也就是符合CURLOPT_POSTFIELDS格式要求的字符串
250 |                 parse_str(urldecode($key),$parse_data);
251 |                 if(is_array($parse_data) && $parse_data)
252 |                 {
253 |                     $this->data = array_merge($this->data,$parse_data);
254 |                 }
255 |             } else {
256 |                 $this->data[$key] = $value;
257 |             }
258 |         }
259 |         return $this;
260 |     }
261 | 
262 |     /**
263 |      * 获取已设置的curl拟发送的数据
264 |      * @param  string $key 拟发送数据的key名称，默认null获取所有
265 |      * @return mixed
266 |      */
267 |     public function getData($key = null)
268 |     {
269 |         if(!empty($key))
270 |         {
271 |             return isset($this->data[$key]) ? $this->data[$key] : null;
272 |         }
273 |         return $this->data;
274 |     }
275 | 
276 |     /**
277 |      * 设置发送的cookie键和名
278 |      * 方法体进行了适当的包装，不涉及到文件IO操作
279 |      * @param string|array $key   cookie的key名 | 包装好的key-value二维数组 | CURLOPT_COOKIE参数指定的字符格式
280 |      * @param string       $value cookie的值或
281 |      * @param $this
282 |      */
283 |     public function setRequestCookie($key,$value = null)
284 |     {
285 |         if (is_array($key)) {
286 |             /**
287 |              * $key是二维数组形式
288 |              * [[key=>value],[key=>value]...]
289 |              */
290 |             $this->requestCookie = array_merge($this->requestCookie,$key);
291 |         } else {
292 |             if ($value === null) {
293 |                 $cookie_str  = $key;//例如`cookie_a=1; cookie_b=2; cookie_c=3`注意分号和空格
294 |                 // parse成统一的数组，最后包装处理
295 |                 $cookie_item = explode(';', $cookie_str);
296 |                 foreach ($cookie_item as $_key => $_value) {
297 |                     list($kkey,$vval)           = explode('=', trim($_value));
298 |                     $this->requestCookie[$kkey] = $vval;
299 |                 }
300 |             } else {
301 |                 $this->requestCookie[$key] = $value;
302 |             }
303 |         }
304 |         return $this;
305 |     }
306 | 
307 |     /**
308 |      * 获取设置的cookie值
309 |      * @param  string $key 设置的cookie中的key值
310 |      * @return mixed
311 |      */
312 |     public function getRequstCookie($key = null)
313 |     {
314 |         if(!empty($key))
315 |         {
316 |             return isset($this->requestCookie[$key]) ? $this->requestCookie[$key] : null;
317 |         }
318 |         return $this->requestCookie;
319 |     }
320 | 
321 |     /**
322 |      * 获取返回结果值的cookie
323 |      * @param  boolean $isOriginCookie 是否获取键值对成字符串的原始cookie
324 |      * @return []
325 |      */
326 |     public function getResponseCookie($isOriginCookie = false)
327 |     {
328 |         if($this->responseCookie)
329 |         {
330 |             return $isOriginCookie === false ? $this->responseCookie['parsed'] : $this->responseCookie['origin'];
331 |         }
332 |         return [];
333 |     }
334 | 
335 |     /**
336 |      * 上传文件方法
337 |      * @param string $field_name post该文件的name字段名称
338 |      * @param string $file_dir   拟上传文件的路径
339 |      */
340 |     public function setUploadFile($field_name,$file_dir)
341 |     {
342 |         if(!is_file($file_dir))
343 |         {
344 |             throw new Exception($file_dir.' File Not Exists', 500);
345 |         }
346 |         $path      = realpath($file_dir);
347 |         $finfo     = new \finfo(FILEINFO_MIME_TYPE);//FILEINFO_MIME
348 |         $mime_type = $finfo->file($file_dir);
349 |         $base_name = basename($file_dir);
350 |         if(class_exists('\CURLFile'))
351 |         {
352 |             $this->option[CURLOPT_SAFE_UPLOAD]     = true;
353 |             $this->data[$field_name]               = new \CURLFile($path,$mime_type,$base_name);
354 |         }else {
355 |             //5.3、5.4
356 |             if (defined('CURLOPT_SAFE_UPLOAD')) {
357 |                 $this->option[CURLOPT_SAFE_UPLOAD] = false;
358 |             }
359 |             $this->data[$field_name] = '@'.$path.";type=".$mime_type.";filename=".$base_name;
360 |         }
361 |         return $this;
362 |     }
363 | 
364 |     /**
365 |      * 设置cUrl请求连接的超时时间|默认值30秒
366 |      * @param int $timeout 设置的超时时间，单位：秒
367 |      */
368 |     public function setTimeOut($timeout)
369 |     {
370 |         $this->timeout = intval($timeout);
371 |         return $this;
372 |     }
373 | 
374 |     /**
375 |      * 获取设置的链接超时时间，单位：秒
376 |      * @return int
377 |      */
378 |     public function getTimeOut()
379 |     {
380 |         return $this->timeout;
381 |     }
382 | 
383 |     /**
384 |      * 设置请求的Url
385 |      * @param string $url 请求url
386 |      */
387 |     public function setUrl($url)
388 |     {
389 |         if (filter_var($url, FILTER_VALIDATE_URL)) {
390 |             $this->url = $url;
391 |             return $this;
392 |         }
393 |         throw new Exception('Target URL is invalid.', 500);
394 |     }
395 | 
396 |     /**
397 |      * 读取设置的Url
398 |      * @return string
399 |      */
400 |     public function getUrl()
401 |     {
402 |         return $this->url;
403 |     }
404 | 
405 |     /**
406 |      * 返回可能的错误描述信息 等价于 curl_error()返回的结果
407 |      * @return string
408 |      */
409 |     public function getError()
410 |     {
411 |         return $this->error;
412 |     }
413 | 
414 |     /**
415 |      * 返回可能的错误号 等价于 curl_errno()返回的结果
416 |      * @return int
417 |      */
418 |     public function getErrno()
419 |     {
420 |         return $this->errno;
421 |     }
422 | 
423 |     /**
424 |      * 返回curl执行完毕的info信息 等价于 curl_getinfo()返回的结果
425 |      * @return []
426 |      */
427 |     public function getInfo()
428 |     {
429 |         return $this->info;
430 |     }
431 | 
432 |     /**
433 |      * 返回curl执行完毕后的header信息
434 |      * @return string
435 |      */
436 |     public function getHeader()
437 |     {
438 |         return $this->header;
439 |     }
440 | 
441 |     /**
442 |      * 返回curl执行完毕后的body信息
443 |      * @return string
444 |      */
445 |     public function getBody()
446 |     {
447 |         return $this->body;
448 |     }
449 | 
450 |     /**
451 |      * 返回curl执行完毕后的请求体完整字符串包括header和body|执行出错返回空串
452 |      * @return string
453 |      */
454 |     public function getResult()
455 |     {
456 |         return $this->result === false ? '' : $this->result;
457 |     }
458 | 
459 |     /**
460 |      * 执行get提交
461 |      * @param  string $url get提交的Url
462 |      * @return boolean
463 |      */
464 |     public function get($url = null)
465 |     {
466 |         if(!empty($url))
467 |         {
468 |             $this->setUrl($url);
469 |         }
470 | 
471 |         // 检查url是否设置
472 |         if(empty($this->url))
473 |         {
474 |             throw new Exception('Target URL is invalid.', 500);
475 |         }
476 |         $url = $this->url;
477 | 
478 |         // 防止setOption方法重置了参数
479 |         $this->option[CURLOPT_HEADER]         = true;
480 |         $this->option[CURLOPT_HTTPGET]        = true;
481 |         $this->option[CURLOPT_RETURNTRANSFER] = true;
482 |         //处理可能的自定义请求体header
483 |         $this->_handleRequestHeader();
484 |         // 可能的待处理的cookie
485 |         $this->_handleRequestCookie();
486 | 
487 |         // 链接超时时间
488 |         $this->option[CURLOPT_TIMEOUT]        = $this->timeout;
489 | 
490 |         // CURLOPT_URL亦可设置请求Url
491 |         $ch     = curl_init($url);
492 |         // 数组方式设置各参数项
493 |         curl_setopt_array($ch, $this->option);
494 | 
495 |         // execute
496 |         $this->result = curl_exec($ch);
497 |         $this->errno  = curl_errno($ch);
498 |         $this->error  = $this->errno ? curl_error($ch) : '';
499 |         $this->info   = curl_getinfo($ch);
500 | 
501 |         curl_close($ch);
502 | 
503 |         if($this->errno == 0)
504 |         {
505 |             list($this->header, $this->body) = explode("\r\n\r\n", $this->result,2);
506 |             $this->_handleResponse();
507 |             $this->_handleResponseCookie($this->header);
508 |             return true;// 请求成功 通过getXXX的多个方法获得返回的数据
509 |         }
510 |         return false;// 请求出现错误，返回false
511 |     }
512 | 
513 |     /**
514 |      * 提交post请求
515 |      * @param  string $url  post提交的url
516 |      * @param  array  $data post提交的数据，可通过setData提前设置
517 |      * @return boolean
518 |      */
519 |     public function post($url,$data = [])
520 |     {
521 |         if(!empty($url))
522 |         {
523 |             $this->setUrl($url);
524 |         }
525 |         if(!empty($data))
526 |         {
527 |             $this->setData($data);
528 |         }
529 | 
530 |         // 检查url是否设置
531 |         if(empty($this->url))
532 |         {
533 |             throw new Exception('Target URL is invalid.', 500);
534 |         }
535 |         $url = $this->url;
536 | 
537 |         // 防止setOption方法重置了参数
538 |         $this->option[CURLOPT_HEADER]         = true;
539 |         $this->option[CURLOPT_HTTPGET]        = false;
540 |         $this->option[CURLOPT_POST]           = true;
541 |         $this->option[CURLOPT_RETURNTRANSFER] = true;
542 |         //处理可能的自定义请求体header
543 |         $this->_handleRequestHeader();
544 |         // 可能的待处理的cookie
545 |         $this->_handleRequestCookie();
546 | 
547 |         // 链接超时时间
548 |         $this->option[CURLOPT_TIMEOUT]        = $this->timeout;
549 | 
550 |         // CURLOPT_URL亦可设置请求Url
551 |         $ch     = curl_init($url);
552 |         // 数组方式设置各参数项
553 |         curl_setopt_array($ch, $this->option);
554 |         // 设置可能的数据
555 |         curl_setopt($ch,CURLOPT_POSTFIELDS,$this->data);
556 | 
557 |         // execute
558 |         $this->result = curl_exec($ch);
559 |         $this->errno  = curl_errno($ch);
560 |         $this->error  = $this->errno ? curl_error($ch) : '';
561 |         $this->info   = curl_getinfo($ch);
562 | 
563 |         curl_close($ch);
564 | 
565 |         if($this->errno == 0)
566 |         {
567 |             list($this->header, $this->body) = explode("\r\n\r\n", $this->result,2);
568 |             $this->_handleResponse();
569 |             $this->_handleResponseCookie($this->header);
570 |             return true;
571 |         }
572 |         return false;//请求出现错误，返回false
573 |     }
574 | 
575 |     /**
576 |      * 将返回的body保存至脚本所在服务器文件系统
577 |      * @param  string $local_dir 本地存储的路径，完整的待文件名和文件后缀的相对或绝对路径
578 |      * @return boolean
579 |      */
580 |     public function save($local_dir)
581 |     {
582 |         if ($this->error) {
583 |             return false;
584 |         }
585 |         $fp = @fopen($local_dir, 'w');
586 |         if ($fp === false) {
587 |             return false;
588 |         }
589 |         fwrite($fp, $this->body);
590 |         fclose($fp);
591 |         // fopen -- fwrite -- fclose方法可能出现E_WARNING错误
592 |         // 自定义set_error_handler可捕获处理，此处暂不使用最简单的file_put_contents方法
593 |         // file_put_contents($local_dir, $this->body);
594 |         return true;
595 |     }
596 | 
597 |     /**
598 |      * 处理发送的header条目
599 |      * @return void
600 |      */
601 |     private function _handleRequestHeader()
602 |     {
603 |         $this->requestHeader['Expect']    = '';
604 |         $_header = [];
605 |         foreach ($this->requestHeader as $key => $value) {
606 |             $_header[]                    = $key.': '.$value;
607 |         }
608 |         $this->option[CURLOPT_HTTPHEADER] = $_header;
609 |     }
610 | 
611 |     /**
612 |      * 处理发送的cookie
613 |      * @return void
614 |      */
615 |     private function _handleRequestCookie()
616 |     {
617 |         if($this->requestCookie)
618 |         {
619 |             $cookie = [];
620 |             foreach ($this->requestCookie as $key => $value) {
621 |                 $cookie[] = $key.'='.urlencode($value);
622 |             }
623 |             $cookie                       = implode('; ', $cookie);
624 |             $this->option[CURLOPT_COOKIE] = $cookie;
625 |         }
626 |     }
627 | 
628 |     /**
629 |      * 修正处理返回结果中的header头中可能包含100和200状态的情况
630 |      * @return vois
631 |      */
632 |     private function _handleResponse()
633 |     {
634 |         if($this->header == 'HTTP/1.1 100 Continue' && stripos($this->body,'HTTP') === 0)
635 |         {
636 |             list($this->header, $this->body) = explode("\r\n\r\n", $this->body,2);
637 |         }
638 |     }
639 | 
640 |     /**
641 |      * 处理返回结果http的header头中的cookie
642 |      * 将解析出来的返回的cookie成键值对$responseCookie中
643 |      * @param  string $header http返回结果集的header头
644 |      * @return void
645 |      */
646 |     private function _handleResponseCookie($header = '')
647 |     {
648 |         preg_match_all("/set\-cookie:([^\r\n]*)/i", $header, $matches);
649 |         if(isset($matches[1]))
650 |         {
651 |             $cookie  = [];
652 |             $_cookie = [];
653 |             foreach ($matches[1] as $key => $value) {
654 |                 $cookie[]            = urldecode(trim($value));
655 |                 $parsed              = [];
656 |                 $parsed              = explode(';', trim($value),2);
657 |                 $parsed              = explode('=', urldecode($parsed[0]));
658 |                 // 解析成key-value键值对数组
659 |                 $_cookie[$parsed[0]] = $parsed[1];
660 |             }
661 |             $this->responseCookie['origin'] = $cookie;
662 |             $this->responseCookie['parsed'] = $_cookie;
663 |         }
664 |     }
665 | }
666 | 


--------------------------------------------------------------------------------
/src/function/Tools.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * 常用PHP函数方法汇总
  4 |  * FileName Tools.php
  5 |  * @authors Jea杨 (JJonline@JJonline.Cn)
  6 |  * @date    2017-08-03 15:07:09
  7 |  * @version $Id$
  8 |  */
  9 | 
 10 | namespace jjonline\helper;
 11 | 
 12 | class Tools
 13 | {
 14 | 
 15 |     /**
 16 |      * 
 17 |      * 判断是否微信浏览器内打开
 18 |      * @param  string  $userAget 可选参数 用户浏览器useAgent头
 19 |      * @return boolean
 20 |      */
 21 |     public static function is_weixin_browser($userAget = '')
 22 |     {
 23 |         if(!$userAget)
 24 |         {
 25 |             $userAget = $_SERVER['HTTP_USER_AGENT'];
 26 |         }
 27 |         if ( strpos($userAget, 'MicroMessenger') !== false )
 28 |         {
 29 |             return true;
 30 |         }
 31 |         return false;
 32 |     }
 33 | 
 34 |     /**
 35 |      * 判断是否移动端浏览器
 36 |      * @return boolean
 37 |      */
 38 |     public static function is_mobile_browser()
 39 |     {
 40 |         // 如果有HTTP_X_WAP_PROFILE则一定是移动设备
 41 |         if(isset ($_SERVER['HTTP_X_WAP_PROFILE']))
 42 |         {
 43 |             return true;
 44 |         }
 45 |         // 如果via信息含有wap则一定是移动设备,部分服务商会屏蔽该信息
 46 |         if(isset($_SERVER['HTTP_VIA']) && stristr($_SERVER['HTTP_VIA'], "wap"))
 47 |         {
 48 |             return  true;
 49 |         }
 50 |         // userAgent匹配
 51 |         if (isset ($_SERVER['HTTP_USER_AGENT']))
 52 |         {
 53 |             $clientkeywords = array(
 54 |                 'nokia',
 55 |                 'sony',
 56 |                 'ericsson',
 57 |                 'mot',
 58 |                 'samsung',
 59 |                 'htc',
 60 |                 'sgh',
 61 |                 'lg',
 62 |                 'sharp',
 63 |                 'sie-',
 64 |                 'philips',
 65 |                 'panasonic',
 66 |                 'alcatel',
 67 |                 'lenovo',
 68 |                 'iphone',
 69 |                 'ipod',
 70 |                 'blackberry',
 71 |                 'meizu',
 72 |                 'android',
 73 |                 'netfront',
 74 |                 'symbian',
 75 |                 'ucweb',
 76 |                 'windowsce',
 77 |                 'palm',
 78 |                 'operamini',
 79 |                 'operamobi',
 80 |                 'openwave',
 81 |                 'nexusone',
 82 |                 'cldc',
 83 |                 'midp',
 84 |                 'wap',
 85 |                 'mobile'
 86 |             );
 87 |             if(preg_match("/(" . implode('|', $clientkeywords) . ")/i", strtolower($_SERVER['HTTP_USER_AGENT'])))
 88 |             {
 89 |                 return true;
 90 |             }
 91 |         }
 92 |         // 协议法，因为有可能不准确，放到最后判断
 93 |         if(isset ($_SERVER['HTTP_ACCEPT']))
 94 |         {
 95 |             // 如果只支持wml并且不支持html那一定是移动设备
 96 |             // 如果支持wml和html但是wml在html之前则是移动设备
 97 |             if((strpos($_SERVER['HTTP_ACCEPT'], 'vnd.wap.wml') !== false) && (strpos($_SERVER['HTTP_ACCEPT'], 'text/html') === false || (strpos($_SERVER['HTTP_ACCEPT'], 'vnd.wap.wml') < strpos($_SERVER['HTTP_ACCEPT'], 'text/html'))))
 98 |             {
 99 |                 return true;
100 |             }
101 |         }
102 |         return false;
103 |     }
104 | 
105 |     /**
106 |      * 用户名加星隐藏核心信息
107 |      * @param  string $nickname 用户名、昵称
108 |      * @return string 隐藏处理后的用户名、昵称
109 |      */
110 |     public static function hide_name($nickname)
111 |     {
112 |         if(mb_strlen($nickname) <=3)
113 |         {
114 |             return '***';
115 |         }
116 |         $begin = self::mbsubstr($nickname,0,1,'utf8');
117 |         $end   = self::mbsubstr($nickname,-1,1,'utf8');
118 |         return $begin.'***'.$end;
119 |     }
120 | 
121 |     /**
122 |      * 隐藏ip v4地址的中间两位
123 |      * @param  string $ip_v4 ipV4的地址
124 |      * @return string 处理隐藏后的地址
125 |      */
126 |     public static function hide_ipv4($ip_v4)
127 |     {
128 |         $ip = explode('.', $ip_v4);
129 |         if(count($ip) == 4)
130 |         {
131 |             $ip[1] = '**';
132 |             $ip[2] = '**';
133 |             return implode('.', $ip);
134 |         }
135 |         return $ip_v4;
136 |     }
137 | 
138 |     /**
139 |      * nl2br的类似函数，将(多个)换行替换成p标签
140 |      * @param  string $str
141 |      * @return string
142 |      */
143 |     public static function nl2p($str)
144 |     {
145 |         $str = str_replace(array('<p>', '</p>', '<br>', '<br/>', '<br />'), '', $str);
146 |         return '<p>'.preg_replace("/([\n|\r\n|\r]{1,})/i", "</p>\n<p>", trim($str)).'</p>';
147 |     }
148 | 
149 |     /**
150 |      * 将一个Unix时间戳转换成“xx前”模糊时间表达方式
151 |      * @param  mixed $timestamp Unix时间戳
152 |      * @return boolean
153 |      */
154 |     public static function time_ago($timestamp)
155 |     {
156 |         $etime = time() - $timestamp;
157 |         if ($etime < 1) return '刚刚';
158 |             $interval = array (
159 |             12 * 30 * 24 * 60 * 60  =>  '年前 ('.date('Y-m-d', $timestamp).')',
160 |             30 * 24 * 60 * 60       =>  '个月前 ('.date('m-d', $timestamp).')',
161 |             7 * 24 * 60 * 60        =>  '周前 ('.date('m-d', $timestamp).')',
162 |             24 * 60 * 60            =>  '天前',
163 |             60 * 60                 =>  '小时前',
164 |             60                      =>  '分钟前',
165 |             1                       =>  '秒前'
166 |         );
167 |         foreach ($interval as $secs => $str) {
168 |             $d = $etime / $secs;
169 |             if ($d >= 1) {
170 |                 $r = round($d);
171 |                 return $r . $str;
172 |             }
173 |         }
174 |     }
175 | 
176 |     /**
177 |      * 判断是否SSL协议
178 |      * @return boolean
179 |      */
180 |     public static function is_ssl()
181 |     {
182 |         if(isset($_SERVER['HTTPS']) && ('1' == $_SERVER['HTTPS'] || 'on' == strtolower($_SERVER['HTTPS'])))
183 |         {
184 |             return true;
185 |         }elseif(isset($_SERVER['SERVER_PORT']) && ('443' == $_SERVER['SERVER_PORT'] ))
186 |         {
187 |             return true;
188 |         }
189 |         return false;
190 |     }
191 | 
192 |     /**
193 |      * 获取客户端IP地址
194 |      * @param  mixed $type 返回类型 0|false 返回IP地址 1|true 返回IPV4地址数字
195 |      * @param  boolean $adv 是否进行高级模式获取（有可能被伪装）---代理情况 
196 |      * @return mixed
197 |      */
198 |     public static function get_client_ip($type = 0,$adv=false)
199 |     {
200 |         $type       =  $type ? 1 : 0;
201 |         static $ip  =   NULL;
202 |         if ($ip !== NULL) return $ip[$type];
203 |         if($adv){
204 |             if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
205 |                 $arr    =   explode(',', $_SERVER['HTTP_X_FORWARDED_FOR']);
206 |                 $pos    =   array_search('unknown',$arr);
207 |                 if(false !== $pos) unset($arr[$pos]);
208 |                 $ip     =   trim($arr[0]);
209 |             }elseif (isset($_SERVER['HTTP_CLIENT_IP'])) {
210 |                 $ip     =   $_SERVER['HTTP_CLIENT_IP'];
211 |             }elseif (isset($_SERVER['REMOTE_ADDR'])) {
212 |                 $ip     =   $_SERVER['REMOTE_ADDR'];
213 |             }
214 |         }elseif (isset($_SERVER['REMOTE_ADDR'])) {
215 |             $ip     =   $_SERVER['REMOTE_ADDR'];
216 |         }
217 |         // IP地址合法验证
218 |         $long = sprintf("%u",ip2long($ip));
219 |         $ip   = $long ? array($ip, $long) : array('0.0.0.0', 0);
220 |         return $ip[$type];
221 |     }
222 | 
223 |     /**
224 |      * URL重定向 重定向后调用该函数的脚本将终止运行
225 |      * @param string  $url 重定向的URL地址
226 |      * @param integer $time 重定向的等待时间（秒）
227 |      * @param string  $msg 重定向前的提示信息
228 |      * @return void
229 |      */
230 |     public static function redirect($url, $time=0, $msg='')
231 |     {
232 |         //多行URL地址支持
233 |         $url        = str_replace(array("\n", "\r"), '', $url);
234 |         if (empty($msg))
235 |             $msg    = "系统将在{$time}秒之后自动跳转到{$url}！";
236 |         if (!headers_sent()) {
237 |             // redirect
238 |             if (0 === $time) {
239 |                 header('Location: ' . $url);
240 |             } else {
241 |                 header("refresh:{$time};url={$url}");
242 |                 echo($msg);
243 |             }
244 |             exit();
245 |         } else {
246 |             $str      = "<meta http-equiv='Refresh' content='{$time};URL={$url}'>";
247 |             if ($time != 0)
248 |                 $str .= $msg;
249 |             exit($str);
250 |         }
251 |     }
252 | 
253 |     /**
254 |      * 用于调试:浏览器友好的变量输出
255 |      * @param mixed   $var 变量
256 |      * @param boolean $echo 是否输出 默认为True 如果为false 则返回输出字符串
257 |      * @param string  $label 标签 默认为空
258 |      * @param boolean $strict 是否严谨 默认为true
259 |      * @return void|string
260 |      */
261 |     public static function dump($var, $echo=true, $label=null, $strict=true)
262 |     {
263 |         $label = ($label === null) ? '' : rtrim($label) . ' ';
264 |         if (!$strict) {
265 |             if (ini_get('html_errors')) {
266 |                 $output = print_r($var, true);
267 |                 $output = '<pre>' . $label . htmlspecialchars($output, ENT_QUOTES) . '</pre>';
268 |             } else {
269 |                 $output = $label . print_r($var, true);
270 |             }
271 |         } else {
272 |             ob_start();
273 |             var_dump($var);
274 |             $output = ob_get_clean();
275 |             if (!extension_loaded('xdebug')) {
276 |                 $output = preg_replace('/\]\=\>\n(\s+)/m', '] => ', $output);
277 |                 $output = '<pre>' . $label . htmlspecialchars($output, ENT_QUOTES) . '</pre>';
278 |             }
279 |         }
280 |         if ($echo) {
281 |             echo($output);
282 |             return null;
283 |         }else
284 |             return $output;
285 |     }
286 | 
287 |     /**
288 |     * 可逆的字符串加密和解密方法-discuz中的方法
289 |     * 该函数密文的安全性主要在于密匙并且是可逆的
290 |     * 
291 |     * 该可逆加密主要用于一些需要时间有效性效验的数据交换中，加密强度很弱
292 |     * 若用于密码处理建议使用password_hash和password_verfiy
293 |     *
294 |     *                       ###警告###
295 |     * ********过期时间参数并不意味着过期后就无法解密出明文了********
296 |     * 
297 |     * @param  string  $string    明文或密文
298 |     * @param  boolean $isEncode  是否解密，true则为解密 false默认表示加密字符串
299 |     * @param  string  $key       密钥 默认jjonline
300 |     * @param  int     $expiry    密钥有效期 单位：秒 默认0为永不过期
301 |     * @return string 空字符串表示解密失败|密文已过期 
302 |     */ 
303 |     public static function reversible_crypt($string, $isEncode = false, $key = 'jjonline', $expiry = 0)
304 |     {
305 |         $ckey_length            =   4;
306 |         // 密匙
307 |         $key                    =   md5($key ? $key : 'jjonline'); 
308 |         // 密匙a会参与加解密
309 |         $keya                   =   md5(substr($key, 0, 16));
310 |         // 密匙b会用来做数据完整性验证
311 |         $keyb                   =   md5(substr($key, 16, 16));
312 |         // 密匙c用于变化生成的密文
313 |         $keyc                   =   $ckey_length ? ($isEncode ? substr($string, 0, $ckey_length): substr(md5(microtime()), -$ckey_length)) : '';
314 |         // 参与运算的密匙
315 |         $cryptkey               =   $keya.md5($keya.$keyc);
316 |         $key_length             =   strlen($cryptkey);
317 |         // 明文，前10位用来保存时间戳，解密时验证数据有效性，10到26位用来保存$keyb(密匙b)，解密时会通过这个密匙验证数据完整性
318 |         // 如果是解码的话，会从第$ckey_length位开始，因为密文前$ckey_length位保存 动态密匙，以保证解密正确
319 |         $string                 =   $isEncode ? base64_decode(substr($string, $ckey_length)) : sprintf('%010d', $expiry ? $expiry + time() : 0).substr(md5($string.$keyb), 0, 16).$string;
320 |         $string_length          =   strlen($string);
321 |         $result                 =   '';
322 |         $box                    =   range(0, 255);
323 |         $rndkey                 =   array();
324 |         // 产生密匙簿
325 |         for($i = 0; $i <= 255; $i++) {
326 |             $rndkey[$i]         =   ord($cryptkey[$i % $key_length]);
327 |         }
328 |         // 用固定的算法，打乱密匙簿，增加随机性，好像很复杂，实际上并不会增加密文的强度
329 |         for($j = $i = 0; $i < 256; $i++) {
330 |             $j                  =   ($j + $box[$i] + $rndkey[$i]) % 256;
331 |             $tmp                =   $box[$i];
332 |             $box[$i]            =   $box[$j];
333 |             $box[$j]            =   $tmp;
334 |         }
335 |         // 核心加解密部分
336 |         for($a = $j = $i = 0; $i < $string_length; $i++) {
337 |             $a                  =   ($a + 1) % 256;
338 |             $j                  =   ($j + $box[$a]) % 256;
339 |             $tmp                =   $box[$a];
340 |             $box[$a]            =   $box[$j];
341 |             $box[$j]            =   $tmp;
342 |             // 从密匙簿得出密匙进行异或，再转成字符
343 |             $result            .=   chr(ord($string[$i]) ^ ($box[($box[$a] + $box[$j]) % 256]));
344 |         }
345 |         if($isEncode) {
346 |             // substr($result, 0, 10) == 0 验证数据有效性
347 |             // substr($result, 0, 10) - time() > 0 验证数据有效性
348 |             // substr($result, 10, 16) == substr(md5(substr($result, 26).$keyb), 0, 16) 验证数据完整性
349 |             // 验证数据有效性，请看未加密明文的格式
350 |             if((substr($result, 0, 10) == 0 || substr($result, 0, 10) - time() > 0) && substr($result, 10, 16) == substr(md5(substr($result, 26).$keyb), 0, 16)) {
351 |                 return substr($result, 26);
352 |             } else {
353 |                 return '';
354 |             }
355 |         } else {
356 |             // 把动态密匙保存在密文里，这也是为什么同样的明文，生成不同密文后能解密的原因
357 |             // 因为加密后的密文可能是一些特殊字符，复制过程可能会丢失，所以用base64编码
358 |             return $keyc.str_replace('=', '', base64_encode($result));
359 |         }
360 |     }
361 | 
362 |     /**
363 |      * 对时间有效性的数据进行可逆的加密，对reversible_crypt方法的可识别封装
364 |      * @param  string  $string 待加密字符串
365 |      * @param  string  $key    加密秘钥
366 |      * @param  integer $expiry 加密的密文失效时间，0默认表示：永不失效
367 |      * @return string
368 |      */
369 |     public static function transfer_encrypt($string, $key = 'jjonline', $expiry = 0)
370 |     {
371 |         return self::reversible_crypt($string, false, $key, $expiry);
372 |     }
373 | 
374 |     /**
375 |      * 对时间有效性的数据进行效验并解密
376 |      * 由reversible_encrypt加密的密文进行解密
377 |      * 
378 |      *                       ###警告###
379 |      * ********过期时间参数并不意味着过期后就无法解密出明文了********
380 |      * 
381 |      * 密文过期并不意味着无法解密出明文，只是在密文中加入了一种过期效验机制由方法体自动完成效验罢了
382 |      * 
383 |      * @param  string $string 密文字符串
384 |      * @param  string $key    解密秘钥
385 |      * @return string
386 |      */
387 |     public static function transfer_decrypt($string, $key = 'jjonline')
388 |     {
389 |         return self::reversible_crypt($string, true, $key);
390 |     }
391 | 
392 |     /**
393 |      * 字符串截取，支持中文和其他编码
394 |      * @param  string $str 需要转换的字符串
395 |      * @param  int    $start 开始位置
396 |      * @param  int    $length 截取长度
397 |      * @param  string $charset 编码格式，默认utf8
398 |      * @return string
399 |      */
400 |     public static function mbsubstr($str, $start = 0, $length, $charset = "utf-8")
401 |     {
402 |         if(function_exists("mb_substr"))
403 |         {
404 |             $slice         = mb_substr($str, $start, $length, $charset);
405 |         }elseif(function_exists('iconv_substr')) {
406 |             $slice         = iconv_substr($str,$start,$length,$charset);
407 |         }else{
408 |             $re['utf-8']   = "/[\x01-\x7f]|[\xc2-\xdf][\x80-\xbf]|[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xff][\x80-\xbf]{3}/";
409 |             $re['gb2312']  = "/[\x01-\x7f]|[\xb0-\xf7][\xa0-\xfe]/";
410 |             $re['gbk']     = "/[\x01-\x7f]|[\x81-\xfe][\x40-\xfe]/";
411 |             $re['big5']    = "/[\x01-\x7f]|[\x81-\xfe]([\x40-\x7e]|\xa1-\xfe])/";
412 |             preg_match_all($re[$charset], $str, $match);
413 |             $slice         = join("",array_slice($match[0], $start, $length));
414 |         }
415 |         return $slice;
416 |     }
417 | 
418 |     /**
419 |      * 产生随机字串
420 |      * 默认长度6位 字母和数字混合 支持中文
421 |      * @param string $len 长度
422 |      * @param string $type 字串类型
423 |      * 0 字母 1 数字 2大写字母 3小写字母 4中文
424 |      * 默认：大小写字母和数字混合并且去除了容易混淆的字母oOLl和数字01
425 |      * @param string $addChars 额外添加进去的字符
426 |      * @return string
427 |      */
428 |     public static function get_rand_string($len = 6, $type = '', $addChars = '')
429 |     {
430 |         $str ='';
431 |         switch($type) {
432 |             case 0:
433 |                 $chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.$addChars;
434 |                 break;
435 |             case 1:
436 |                 $chars = str_repeat('0123456789',3);
437 |                 break;
438 |             case 2:
439 |                 $chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.$addChars;
440 |                 break;
441 |             case 3:
442 |                 $chars = 'abcdefghijklmnopqrstuvwxyz'.$addChars;
443 |                 break;
444 |             case 4:
445 |                 $chars = "们以我到他会作时要动国产的一是工就年阶义发成部民可出能方进在了不和有大这主中人上为来分生对于学下级地个用同行面说种过命度革而多子后自社加小机也经力线本电高量长党得实家定深法表着水理化争现所二起政三好十战无农使性前等反体合斗路图把结第里正新开论之物从当两些还天资事队批点育重其思与间内去因件日利相由压员气业代全组数果期导平各基或月毛然如应形想制心样干都向变关问比展那它最及外没看治提五解系林者米群头意只明四道马认次文通但条较克又公孔领军流入接席位情运器并飞原油放立题质指建区验活众很教决特此常石强极土少已根共直团统式转别造切九你取西持总料连任志观调七么山程百报更见必真保热委手改管处己将修支识病象几先老光专什六型具示复安带每东增则完风回南广劳轮科北打积车计给节做务被整联步类集号列温装即毫知轴研单色坚据速防史拉世设达尔场织历花受求传口断况采精金界品判参层止边清至万确究书术状厂须离再目海交权且儿青才证低越际八试规斯近注办布门铁需走议县兵固除般引齿千胜细影济白格效置推空配刀叶率述今选养德话查差半敌始片施响收华觉备名红续均药标记难存测士身紧液派准斤角降维板许破述技消底床田势端感往神便贺村构照容非搞亚磨族火段算适讲按值美态黄易彪服早班麦削信排台声该击素张密害侯草何树肥继右属市严径螺检左页抗苏显苦英快称坏移约巴材省黑武培著河帝仅针怎植京助升王眼她抓含苗副杂普谈围食射源例致酸旧却充足短划剂宣环落首尺波承粉践府鱼随考刻靠够满夫失包住促枝局菌杆周护岩师举曲春元超负砂封换太模贫减阳扬江析亩木言球朝医校古呢稻宋听唯输滑站另卫字鼓刚写刘微略范供阿块某功套友限项余倒卷创律雨让骨远帮初皮播优占死毒圈伟季训控激找叫云互跟裂粮粒母练塞钢顶策双留误础吸阻故寸盾晚丝女散焊功株亲院冷彻弹错散商视艺灭版烈零室轻血倍缺厘泵察绝富城冲喷壤简否柱李望盘磁雄似困巩益洲脱投送奴侧润盖挥距触星松送获兴独官混纪依未突架宽冬章湿偏纹吃执阀矿寨责熟稳夺硬价努翻奇甲预职评读背协损棉侵灰虽矛厚罗泥辟告卵箱掌氧恩爱停曾溶营终纲孟钱待尽俄缩沙退陈讨奋械载胞幼哪剥迫旋征槽倒握担仍呀鲜吧卡粗介钻逐弱脚怕盐末阴丰雾冠丙街莱贝辐肠付吉渗瑞惊顿挤秒悬姆烂森糖圣凹陶词迟蚕亿矩康遵牧遭幅园腔订香肉弟屋敏恢忘编印蜂急拿扩伤飞露核缘游振操央伍域甚迅辉异序免纸夜乡久隶缸夹念兰映沟乙吗儒杀汽磷艰晶插埃燃欢铁补咱芽永瓦倾阵碳演威附牙芽永瓦斜灌欧献顺猪洋腐请透司危括脉宜笑若尾束壮暴企菜穗楚汉愈绿拖牛份染既秋遍锻玉夏疗尖殖井费州访吹荣铜沿替滚客召旱悟刺脑措贯藏敢令隙炉壳硫煤迎铸粘探临薄旬善福纵择礼愿伏残雷延烟句纯渐耕跑泽慢栽鲁赤繁境潮横掉锥希池败船假亮谓托伙哲怀割摆贡呈劲财仪沉炼麻罪祖息车穿货销齐鼠抽画饲龙库守筑房歌寒喜哥洗蚀废纳腹乎录镜妇恶脂庄擦险赞钟摇典柄辩竹谷卖乱虚桥奥伯赶垂途额壁网截野遗静谋弄挂课镇妄盛耐援扎虑键归符庆聚绕摩忙舞遇索顾胶羊湖钉仁音迹碎伸灯避泛亡答勇频皇柳哈揭甘诺概宪浓岛袭谁洪谢炮浇斑讯懂灵蛋闭孩释乳巨徒私银伊景坦累匀霉杜乐勒隔弯绩招绍胡呼痛峰零柴簧午跳居尚丁秦稍追梁折耗碱殊岗挖氏刃剧堆赫荷胸衡勤膜篇登驻案刊秧缓凸役剪川雪链渔啦脸户洛孢勃盟买杨宗焦赛旗滤硅炭股坐蒸凝竟陷枪黎救冒暗洞犯筒您宋弧爆谬涂味津臂障褐陆啊健尊豆拔莫抵桑坡缝警挑污冰柬嘴啥饭塑寄赵喊垫丹渡耳刨虎笔稀昆浪萨茶滴浅拥穴覆伦娘吨浸袖珠雌妈紫戏塔锤震岁貌洁剖牢锋疑霸闪埔猛诉刷狠忽灾闹乔唐漏闻沈熔氯荒茎男凡抢像浆旁玻亦忠唱蒙予纷捕锁尤乘乌智淡允叛畜俘摸锈扫毕璃宝芯爷鉴秘净蒋钙肩腾枯抛轨堂拌爸循诱祝励肯酒绳穷塘燥泡袋朗喂铝软渠颗惯贸粪综墙趋彼届墨碍启逆卸航衣孙龄岭骗休借".$addChars;
446 |                 break;
447 |             default :
448 |                 // 默认去掉了容易混淆的字符oOLl和数字01，要添加请使用addChars参数
449 |                 $chars='ABCDEFGHIJKMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz23456789'.$addChars;
450 |                 break;
451 |         }
452 |         if($len>10 ) {//位数过长重复字符串一定次数
453 |             $chars= $type==1? str_repeat($chars,$len) : str_repeat($chars,5);
454 |         }
455 |         if($type!=4) {
456 |             $chars   =   str_shuffle($chars);
457 |             $str     =   substr($chars,0,$len);
458 |         }else{
459 |             // 中文随机字
460 |             for($i=0;$i<$len;$i++)
461 |             {
462 |               $str.= self::mbsubstr($chars, floor(mt_rand(0,mb_strlen($chars,'utf-8')-1)),1,'utf-8');
463 |             }
464 |         }
465 |         return $str;
466 |     }
467 | 
468 |     /**
469 |      * 清理html内容中的js代码和各种标签内包裹的onXX事件--待完善
470 |      * 直接清理掉所有标签内属性即可
471 |      * {
472 |      *     1、清理所有js代码
473 |      *     2、清理所有标签内属性性质的js事件
474 |      * }
475 |      * @param  string $content 待清理的html文本
476 |      * @return string 清理妥善的html文本
477 |      */
478 |     public static function clear_js_code($content)
479 |     {
480 |         ##去除所有JavaScript代码
481 |         $content = preg_replace('/<script(.*?)<\/?script>/is', "", $content);
482 | 
483 |         ##去除所有a标签
484 |         // $content = preg_replace('/<\/?a[^>]>/', '', $content); ##a标签相对危害小一些，依据实际情况取消注释
485 | 
486 |         ## 去除标签内的各种事件属性(以on开头的全部干掉，可能会误杀)，保留非事件属性
487 |         return preg_replace_callback('/<(\w+)\s+([^>]+)>/i', function ($match) {
488 |             // self::dump($match);
489 |             // 匹配出所有的属性对
490 |             $prop = preg_split('/\s+/', trim($match[2]));
491 |             // 去除所有属性中以on开头的属性名和属性值
492 |             foreach ($prop as $key => $value) {
493 |                 if(preg_match('/^on/', $value))
494 |                 {
495 |                     unset($prop[$key]);
496 |                 }
497 |             }
498 |             // self::dump($prop);
499 |             return empty($prop) ? '<'.$match[1].'>' : '<'.$match[1].' '.implode(' ', $prop).'>';
500 |             /**
501 |              * 2017-8-7 Bug
502 |              * 
503 |              * 下面这种方式可以规避清理掉onxx事件，例如：
504 |              * <p onclick="alert("dd")" oonload="ds" nloadonload="ds" ="load">string</p>
505 |              * 
506 |              * $Attribute = trim(preg_replace('/on\w+=.*?\s/is', '', $match[2].' '));
507 |              * return empty($Attribute) ? '<'.$match[1].'>' : '<'.$match[1].' '.$Attribute.'>';
508 |              */
509 |         }, $content);
510 |     }
511 | 
512 |     /**
513 |      * 将相对url转换为绝对完整Url
514 |      * <code>
515 |      *     将某一个Url（当前Url）页面中的超链接不同的写法转换为实际完整的Url
516 |      *     
517 |      *     例如1、当前Url为：
518 |      *         http://blog.jjonline.cn/phptech/172.html，该页面中超链接Url为：/view/173.html
519 |      *         则该超链接Url的实际完整Url为：http://blog.jjonline.cn/view/173.html
520 |      *     例如2、当前Url为：
521 |      *         http://blog.jjonline.cn/phptech/172.html，待转换Url为：./173.html 或 173.html
522 |      *         则待转换Url的实际完整Url为：http://blog.jjonline.cn/phptech/173.html
523 |      *     例如3、当前Url为：
524 |      *         http://blog.jjonline.cn/phptech/172.html，待转换Url为：../view/173.html
525 |      *         则待转换Url的实际完整Url为：http://blog.jjonline.cn/view/173.html
526 |      *     例如4、当前Url为：
527 |      *         http://blog.jjonline.cn/phptech/view/172.html，待转换Url为：./../../173.html
528 |      *         则待转换Url的实际完整Url为：http://blog.jjonline.cn/173.html
529 |      *         
530 |      *     当然第3种和第4种比较变态，但这种Url也是可能存在的
531 |      * </code>
532 |      * @param  string $sUrl    页面中的Url，例如：./../../171.html
533 |      * @param  string $baseUrl 该页面的Url，例如：http://blog.jjonline.cn/sort/php/area/article/173.html
534 |      * @return string
535 |      */
536 |     public static function to_absolute_url($sUrl,$baseUrl) 
537 |     {
538 |         $srcinfo = parse_url($sUrl);
539 |         if(isset($srcinfo['scheme'])) {
540 |             ##完整的Url无需转换
541 |             return $sUrl;
542 |         }
543 | 
544 |         $baseinfo = parse_url($baseUrl);
545 |         $url      = $baseinfo['scheme'].'://'.$baseinfo['host'];##识别出基础的根Url
546 | 
547 |         ##识别出待转换Url中的路径部分
548 |         if(substr($srcinfo['path'], 0, 1) == '/') {
549 |             $path   = $srcinfo['path'];
550 |         }else{
551 |             $path   = dirname($baseinfo['path']).'/'.$srcinfo['path'];
552 |         }
553 |         $rst        = array();##保存待转换Url中的路径部分，索引数组，一个元素是一个文件夹名或.和.. 下方对.和..进行替换
554 |         $path_array = explode('/', $path);
555 |         if(!$path_array[0]) {
556 |             $rst[]  = '';
557 |         }
558 | 
559 |         foreach ($path_array as $key => $dir) {
560 |             if ($dir == '..')
561 |             {
562 |                 if (end($rst) == '..')
563 |                 {
564 |                     $rst[] = '..';
565 |                 }elseif(!array_pop($rst)) {
566 |                     $rst[] = '..';
567 |                 }
568 |             }elseif($dir && $dir != '.') {
569 |                 $rst[]     = $dir;
570 |             }
571 |         }
572 | 
573 |         if(!end($path_array)) {
574 |             $rst[] = '';
575 |         }
576 |         $url .= implode('/', $rst);
577 |         return str_replace('\\', '/', $url);
578 |     }
579 | 
580 |     /**
581 |      * 递归删除非空文件夹
582 |      * @param string $delete_dir 拟删除的文件夹路径---相对入口php文件的相对路径或绝对路径
583 |      */
584 |     public static function rm_dir($delete_dir)
585 |     {
586 |         ## 防止空串参数删根目录
587 |         if(empty($delete_dir))
588 |         {
589 |             return false;
590 |         }
591 |         $delete_dir     = rtrim($delete_dir,'/').'/';
592 |         try {
593 |             $iterator   = new \DirectoryIterator($delete_dir);//路径或文件不存在会抛出UnexpectedValueException异常
594 |             while($iterator->valid()) {
595 |                 if($iterator->isFile()){
596 |                     unlink($delete_dir.$iterator->getFilename());##删除文件
597 |                 }elseif($iterator->isDir() && !$iterator->isDot()) {
598 |                     self::rm_dir($delete_dir.$iterator->getFilename());##递归处理删除子文件夹下的文件
599 |                 }
600 |                 $iterator->next();
601 |             }
602 |             rmdir($delete_dir);##删除参数文件夹
603 |             return true;
604 |         } catch (\Exception $e) {
605 |             return false;
606 |         }
607 |     }
608 | 
609 |     /**
610 |      * 生成36位长度的UUID
611 |      * @param  bool $opt uuid返回值中是否带上大括号，默认false不带
612 |      * @return string
613 |      */
614 |     public static function generate_uuid($opt = false)
615 |     {
616 |         // 获取服务器IP作为uuid一个变量因子
617 |         $server_ip   = isset($_SERVER['HTTP_X_FORWARDED_HOST']) ? $_SERVER['HTTP_X_FORWARDED_HOST'] : (isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : '');
618 |         // PHP7.1下可使用内置生成session_id唯一性相当好的方法生成一个session_id使用
619 |         $session_id  = function_exists('session_create_id') ? session_create_id() : uniqid($server_ip.mt_rand());
620 |         $charid      = md5(uniqid($session_id.mt_rand().$server_ip, true));
621 |         $hyphen      = chr(45); // "-"
622 |         $left_curly  = $opt ? chr(123) : ""; //  "{"
623 |         $right_curly = $opt ? chr(125) : ""; //  "}"
624 |         $uuid        = $left_curly
625 |                      . substr($charid, 0, 8) . $hyphen
626 |                      . substr($charid, 8, 4) . $hyphen
627 |                      . substr($charid, 12, 4) . $hyphen
628 |                      . substr($charid, 16, 4) . $hyphen
629 |                      . substr($charid, 20, 12)
630 |                      . $right_curly;
631 |         return $uuid;
632 |     }
633 | }
634 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     {one line to give the program's name and a brief idea of what it does.}
635 |     Copyright (C) {year}  {name of author}
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <http://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     {project}  Copyright (C) {year}  {fullname}
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <http://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <http://www.gnu.org/philosophy/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------