502647092/MinecraftAccount
1
0
Fork 0
mirror of https://e.coding.net/circlecloud/MinecraftAccount.git synced 2025-11-26 21:46:09 +00:00
Code Releases Activity

首次提交...

Browse Source 
Signed-off-by: j502647092 <jtb1@163.com>
This commit is contained in:
j502647092
2015-11-01 22:25:03 +08:00
commit 2003fda7cb
409 changed files with 77938 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

238
ThinkPHP/Library/Think/Upload/Driver/Bcs.class.php Normal file
View File

@@ -0,0 +1,238 @@
<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK IT ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006-2014 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: Jay <yangweijiester@gmail.com> <http://code-tech.diandian.com>
// +----------------------------------------------------------------------
namespace Think\Upload\Driver;
use Think\Upload\Driver\Bcs\BaiduBcs;
class Bcs {
/**
* 上传文件根目录
* @var string
*/
private $rootPath;
const DEFAULT_URL = 'bcs.duapp.com';
/**
* 上传错误信息
* @var string
*/
private $error = '';
public $config = array(
'AccessKey'=> '',
'SecretKey'=> '', //百度云服务器
'bucket' => '', //空间名称
'rename' => false,
'timeout' => 3600, //超时时间
);
public $bcs = null;
/**
* 构造函数，用于设置上传根路径
* @param array $config FTP配置
*/
public function __construct($config){
/* 默认FTP配置 */
$this->config = array_merge($this->config, $config);
$bcsClass = dirname(__FILE__). "/Bcs/bcs.class.php";
if(is_file($bcsClass))
require_once($bcsClass);
$this->bcs = new BaiduBCS ( $this->config['AccessKey'], $this->config['SecretKey'], self:: DEFAULT_URL );
}
/**
* 检测上传根目录(百度云上传时支持自动创建目录，直接返回)
* @param string $rootpath 根目录
* @return boolean true-检测通过，false-检测失败
*/
public function checkRootPath($rootpath){
/* 设置根目录 */
$this->rootPath = str_replace('./', '/', $rootpath);
return true;
}
/**
* 检测上传目录(百度云上传时支持自动创建目录，直接返回)
* @param string $savepath 上传目录
* @return boolean 检测结果，true-通过，false-失败
*/
public function checkSavePath($savepath){
return true;
}
/**
* 创建文件夹 (百度云上传时支持自动创建目录，直接返回)
* @param string $savepath 目录名称
* @return boolean true-创建成功，false-创建失败
*/
public function mkdir($savepath){
return true;
}
/**
* 保存指定文件
* @param array $file 保存的文件信息
* @param boolean $replace 同名文件是否覆盖
* @return boolean 保存状态，true-成功，false-失败
*/
public function save(&$file,$replace=true) {
$opt = array ();
$opt ['acl'] = BaiduBCS::BCS_SDK_ACL_TYPE_PUBLIC_WRITE;
$opt ['curlopts'] = array (
CURLOPT_CONNECTTIMEOUT => 10,
CURLOPT_TIMEOUT => 1800
);
$object = "/{$file['savepath']}{$file['savename']}";
$response = $this->bcs->create_object ( $this->config['bucket'], $object, $file['tmp_name'], $opt );
$url = $this->download($object);
$file['url'] = $url;
return $response->isOK() ? true : false;
}
public function download($file){
$file = str_replace('./', '/', $file);
$opt = array();
$opt['time'] = mktime('2049-12-31'); //这是最长有效时间!--
$response = $this->bcs->generate_get_object_url ( $this->config['bucket'], $file, $opt );
return $response;
}
/**
* 获取最后一次上传错误信息
* @return string 错误信息
*/
public function getError(){
return $this->error;
}
/**
* 请求百度云服务器
* @param string $path 请求的PATH
* @param string $method 请求方法
* @param array $headers 请求header
* @param resource $body 上传文件资源
* @return boolean
*/
private function request($path, $method, $headers = null, $body = null){
$ch = curl_init($path);
$_headers = array('Expect:');
if (!is_null($headers) && is_array($headers)){
foreach($headers as $k => $v) {
array_push($_headers, "{$k}: {$v}");
}
}
$length = 0;
$date = gmdate('D, d M Y H:i:s \G\M\T');
if (!is_null($body)) {
if(is_resource($body)){
fseek($body, 0, SEEK_END);
$length = ftell($body);
fseek($body, 0);
array_push($_headers, "Content-Length: {$length}");
curl_setopt($ch, CURLOPT_INFILE, $body);
curl_setopt($ch, CURLOPT_INFILESIZE, $length);
} else {
$length = @strlen($body);
array_push($_headers, "Content-Length: {$length}");
curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
}
} else {
array_push($_headers, "Content-Length: {$length}");
}
// array_push($_headers, 'Authorization: ' . $this->sign($method, $uri, $date, $length));
array_push($_headers, "Date: {$date}");
curl_setopt($ch, CURLOPT_HTTPHEADER, $_headers);
curl_setopt($ch, CURLOPT_TIMEOUT, $this->config['timeout']);
curl_setopt($ch, CURLOPT_HEADER, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 0);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
if ($method == 'PUT' || $method == 'POST') {
curl_setopt($ch, CURLOPT_POST, 1);
} else {
curl_setopt($ch, CURLOPT_POST, 0);
}
if ($method == 'HEAD') {
curl_setopt($ch, CURLOPT_NOBODY, true);
}
$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
list($header, $body) = explode("\r\n\r\n", $response, 2);
if ($status == 200) {
if ($method == 'GET') {
return $body;
} else {
$data = $this->response($header);
return count($data) > 0 ? $data : true;
}
} else {
$this->error($header);
return false;
}
}
/**
* 获取响应数据
* @param string $text 响应头字符串
* @return array 响应数据列表
*/
private function response($text){
$items = json_decode($text, true);
return $items;
}
/**
* 生成请求签名
* @return string 请求签名
*/
private function sign($method, $Bucket, $object='/', $size=''){
if(!$size)
$size = $this->config['size'];
$param = array(
'ak'=>$this->config['AccessKey'],
'sk'=>$this->config['SecretKey'],
'size'=>$size,
'bucket'=>$Bucket,
'host'=>self :: DEFAULT_URL,
'date'=>time()+$this->config['timeout'],
'ip'=>'',
'object'=>$object
);
$response = $this->request($this->apiurl.'?'.http_build_query($param), 'POST');
if($response)
$response = json_decode($response, true);
return $response['content'][$method];
}
/**
* 获取请求错误信息
* @param string $header 请求返回头信息
*/
private function error($header) {
list($status, $stash) = explode("\r\n", $header, 2);
list($v, $code, $message) = explode(" ", $status, 3);
$message = is_null($message) ? 'File Not Found' : "[{$status}]:{$message}";
$this->error = $message;
}
}

1318
ThinkPHP/Library/Think/Upload/Driver/Bcs/bcs.class.php Normal file
View File

File diff suppressed because it is too large Load Diff

137
ThinkPHP/Library/Think/Upload/Driver/Bcs/mimetypes.class.php Normal file
View File

@@ -0,0 +1,137 @@
<?php
namespace Think\Upload\Driver\Bcs;
class BCS_MimeTypes {
public static $mime_types = array (
'3gp' => 'video/3gpp', 'ai' => 'application/postscript',
'aif' => 'audio/x-aiff', 'aifc' => 'audio/x-aiff',
'aiff' => 'audio/x-aiff', 'asc' => 'text/plain',
'atom' => 'application/atom+xml', 'au' => 'audio/basic',
'avi' => 'video/x-msvideo', 'bcpio' => 'application/x-bcpio',
'bin' => 'application/octet-stream', 'bmp' => 'image/bmp',
'cdf' => 'application/x-netcdf', 'cgm' => 'image/cgm',
'class' => 'application/octet-stream',
'cpio' => 'application/x-cpio',
'cpt' => 'application/mac-compactpro',
'csh' => 'application/x-csh', 'css' => 'text/css',
'dcr' => 'application/x-director', 'dif' => 'video/x-dv',
'dir' => 'application/x-director', 'djv' => 'image/vnd.djvu',
'djvu' => 'image/vnd.djvu',
'dll' => 'application/octet-stream',
'dmg' => 'application/octet-stream',
'dms' => 'application/octet-stream',
'doc' => 'application/msword', 'dtd' => 'application/xml-dtd',
'dv' => 'video/x-dv', 'dvi' => 'application/x-dvi',
'dxr' => 'application/x-director',
'eps' => 'application/postscript', 'etx' => 'text/x-setext',
'exe' => 'application/octet-stream',
'ez' => 'application/andrew-inset', 'flv' => 'video/x-flv',
'gif' => 'image/gif', 'gram' => 'application/srgs',
'grxml' => 'application/srgs+xml',
'gtar' => 'application/x-gtar', 'gz' => 'application/x-gzip',
'hdf' => 'application/x-hdf',
'hqx' => 'application/mac-binhex40', 'htm' => 'text/html',
'html' => 'text/html', 'ice' => 'x-conference/x-cooltalk',
'ico' => 'image/x-icon', 'ics' => 'text/calendar',
'ief' => 'image/ief', 'ifb' => 'text/calendar',
'iges' => 'model/iges', 'igs' => 'model/iges',
'jnlp' => 'application/x-java-jnlp-file', 'jp2' => 'image/jp2',
'jpe' => 'image/jpeg', 'jpeg' => 'image/jpeg',
'jpg' => 'image/jpeg', 'js' => 'application/x-javascript',
'kar' => 'audio/midi', 'latex' => 'application/x-latex',
'lha' => 'application/octet-stream',
'lzh' => 'application/octet-stream',
'm3u' => 'audio/x-mpegurl', 'm4a' => 'audio/mp4a-latm',
'm4p' => 'audio/mp4a-latm', 'm4u' => 'video/vnd.mpegurl',
'm4v' => 'video/x-m4v', 'mac' => 'image/x-macpaint',
'man' => 'application/x-troff-man',
'mathml' => 'application/mathml+xml',
'me' => 'application/x-troff-me', 'mesh' => 'model/mesh',
'mid' => 'audio/midi', 'midi' => 'audio/midi',
'mif' => 'application/vnd.mif', 'mov' => 'video/quicktime',
'movie' => 'video/x-sgi-movie', 'mp2' => 'audio/mpeg',
'mp3' => 'audio/mpeg', 'mp4' => 'video/mp4',
'mpe' => 'video/mpeg', 'mpeg' => 'video/mpeg',
'mpg' => 'video/mpeg', 'mpga' => 'audio/mpeg',
'ms' => 'application/x-troff-ms', 'msh' => 'model/mesh',
'mxu' => 'video/vnd.mpegurl', 'nc' => 'application/x-netcdf',
'oda' => 'application/oda', 'ogg' => 'application/ogg',
'ogv' => 'video/ogv', 'pbm' => 'image/x-portable-bitmap',
'pct' => 'image/pict', 'pdb' => 'chemical/x-pdb',
'pdf' => 'application/pdf',
'pgm' => 'image/x-portable-graymap',
'pgn' => 'application/x-chess-pgn', 'pic' => 'image/pict',
'pict' => 'image/pict', 'png' => 'image/png',
'pnm' => 'image/x-portable-anymap',
'pnt' => 'image/x-macpaint', 'pntg' => 'image/x-macpaint',
'ppm' => 'image/x-portable-pixmap',
'ppt' => 'application/vnd.ms-powerpoint',
'ps' => 'application/postscript', 'qt' => 'video/quicktime',
'qti' => 'image/x-quicktime', 'qtif' => 'image/x-quicktime',
'ra' => 'audio/x-pn-realaudio',
'ram' => 'audio/x-pn-realaudio', 'ras' => 'image/x-cmu-raster',
'rdf' => 'application/rdf+xml', 'rgb' => 'image/x-rgb',
'rm' => 'application/vnd.rn-realmedia',
'roff' => 'application/x-troff', 'rtf' => 'text/rtf',
'rtx' => 'text/richtext', 'sgm' => 'text/sgml',
'sgml' => 'text/sgml', 'sh' => 'application/x-sh',
'shar' => 'application/x-shar', 'silo' => 'model/mesh',
'sit' => 'application/x-stuffit',
'skd' => 'application/x-koan', 'skm' => 'application/x-koan',
'skp' => 'application/x-koan', 'skt' => 'application/x-koan',
'smi' => 'application/smil', 'smil' => 'application/smil',
'snd' => 'audio/basic', 'so' => 'application/octet-stream',
'spl' => 'application/x-futuresplash',
'src' => 'application/x-wais-source',
'sv4cpio' => 'application/x-sv4cpio',
'sv4crc' => 'application/x-sv4crc', 'svg' => 'image/svg+xml',
'swf' => 'application/x-shockwave-flash',
't' => 'application/x-troff', 'tar' => 'application/x-tar',
'tcl' => 'application/x-tcl', 'tex' => 'application/x-tex',
'texi' => 'application/x-texinfo',
'texinfo' => 'application/x-texinfo', 'tif' => 'image/tiff',
'tiff' => 'image/tiff', 'tr' => 'application/x-troff',
'tsv' => 'text/tab-separated-values', 'txt' => 'text/plain',
'ustar' => 'application/x-ustar',
'vcd' => 'application/x-cdlink', 'vrml' => 'model/vrml',
'vxml' => 'application/voicexml+xml', 'wav' => 'audio/x-wav',
'wbmp' => 'image/vnd.wap.wbmp',
'wbxml' => 'application/vnd.wap.wbxml', 'webm' => 'video/webm',
'wml' => 'text/vnd.wap.wml',
'wmlc' => 'application/vnd.wap.wmlc',
'wmls' => 'text/vnd.wap.wmlscript',
'wmlsc' => 'application/vnd.wap.wmlscriptc',
'wmv' => 'video/x-ms-wmv', 'wrl' => 'model/vrml',
'xbm' => 'image/x-xbitmap', 'xht' => 'application/xhtml+xml',
'xhtml' => 'application/xhtml+xml',
'xls' => 'application/vnd.ms-excel',
'xml' => 'application/xml', 'xpm' => 'image/x-xpixmap',
'xsl' => 'application/xml', 'xslt' => 'application/xslt+xml',
'xul' => 'application/vnd.mozilla.xul+xml',
'xwd' => 'image/x-xwindowdump', 'xyz' => 'chemical/x-xyz',
'zip' => 'application/zip',
//add by zhengkan 20110905
"apk" => "application/vnd.android.package-archive",
"bin" => "application/octet-stream",
"cab" => "application/vnd.ms-cab-compressed",
"gb" => "application/chinese-gb",
"gba" => "application/octet-stream",
"gbc" => "application/octet-stream",
"jad" => "text/vnd.sun.j2me.app-descriptor",
"jar" => "application/java-archive",
"nes" => "application/octet-stream",
"rar" => "application/x-rar-compressed",
"sis" => "application/vnd.symbian.install",
"sisx" => "x-epoc/x-sisx-app",
"smc" => "application/octet-stream",
"smd" => "application/octet-stream",
"swf" => "application/x-shockwave-flash",
"zip" => "application/x-zip-compressed",
"wap" => "text/vnd.wap.wml wml", "mrp" => "application/mrp",
//add by zhengkan 20110914
"wma" => "audio/x-ms-wma",
"lrc" => "application/lrc" );
public static function get_mimetype($ext) {
$ext = strtolower ( $ext );
return (isset ( self::$mime_types [$ext] ) ? self::$mime_types [$ext] : 'application/octet-stream');
}
}

837
ThinkPHP/Library/Think/Upload/Driver/Bcs/requestcore.class.php Normal file
View File

@@ -0,0 +1,837 @@
<?php
namespace Think\Upload\Driver\Bcs;
/**
* Handles all HTTP requests using cURL and manages the responses.
*
* @version 2011.03.01
* @copyright 2006-2011 Ryan Parman
* @copyright 2006-2010 Foleeo Inc.
* @copyright 2010-2011 Amazon.com, Inc. or its affiliates.
* @copyright 2008-2011 Contributors
* @license http://opensource.org/licenses/bsd-license.php Simplified BSD License
*/
class BCS_RequestCore {
/**
* The URL being requested.
*/
public $request_url;
/**
* The headers being sent in the request.
*/
public $request_headers;
/**
* The body being sent in the request.
*/
public $request_body;
/**
* The response returned by the request.
*/
public $response;
/**
* The headers returned by the request.
*/
public $response_headers;
/**
* The body returned by the request.
*/
public $response_body;
/**
* The HTTP status code returned by the request.
*/
public $response_code;
/**
* Additional response data.
*/
public $response_info;
/**
* The handle for the cURL object.
*/
public $curl_handle;
/**
* The method by which the request is being made.
*/
public $method;
/**
* Stores the proxy settings to use for the request.
*/
public $proxy = null;
/**
* The username to use for the request.
*/
public $username = null;
/**
* The password to use for the request.
*/
public $password = null;
/**
* Custom CURLOPT settings.
*/
public $curlopts = null;
/**
* The state of debug mode.
*/
public $debug_mode = false;
/**
* The default class to use for HTTP Requests (defaults to <BCS_RequestCore>).
*/
public $request_class = 'BCS_RequestCore';
/**
* The default class to use for HTTP Responses (defaults to <BCS_ResponseCore>).
*/
public $response_class = 'BCS_ResponseCore';
/**
* Default useragent string to use.
*/
public $useragent = 'BCS_RequestCore/1.4.2';
/**
* File to read from while streaming up.
*/
public $read_file = null;
/**
* The resource to read from while streaming up.
*/
public $read_stream = null;
/**
* The size of the stream to read from.
*/
public $read_stream_size = null;
/**
* The length already read from the stream.
*/
public $read_stream_read = 0;
/**
* File to write to while streaming down.
*/
public $write_file = null;
/**
* The resource to write to while streaming down.
*/
public $write_stream = null;
/**
* Stores the intended starting seek position.
*/
public $seek_position = null;
/**
* The user-defined callback function to call when a stream is read from.
*/
public $registered_streaming_read_callback = null;
/**
* The user-defined callback function to call when a stream is written to.
*/
public $registered_streaming_write_callback = null;
/*%******************************************************************************************%*/
// CONSTANTS
/**
* GET HTTP Method
*/
const HTTP_GET = 'GET';
/**
* POST HTTP Method
*/
const HTTP_POST = 'POST';
/**
* PUT HTTP Method
*/
const HTTP_PUT = 'PUT';
/**
* DELETE HTTP Method
*/
const HTTP_DELETE = 'DELETE';
/**
* HEAD HTTP Method
*/
const HTTP_HEAD = 'HEAD';
/*%******************************************************************************************%*/
// CONSTRUCTOR/DESTRUCTOR
/**
* Constructs a new instance of this class.
*
* @param string $url (Optional) The URL to request or service endpoint to query.
* @param string $proxy (Optional) The faux-url to use for proxy settings. Takes the following format: `proxy://user:pass@hostname:port`
* @param array $helpers (Optional) An associative array of classnames to use for request, and response functionality. Gets passed in automatically by the calling class.
* @return $this A reference to the current instance.
*/
public function __construct($url = null, $proxy = null, $helpers = null) {
// Set some default values.
$this->request_url = $url;
$this->method = self::HTTP_GET;
$this->request_headers = array ();
$this->request_body = '';
// Set a new Request class if one was set.
if (isset ( $helpers ['request'] ) && ! empty ( $helpers ['request'] )) {
$this->request_class = $helpers ['request'];
}
// Set a new Request class if one was set.
if (isset ( $helpers ['response'] ) && ! empty ( $helpers ['response'] )) {
$this->response_class = $helpers ['response'];
}
if ($proxy) {
$this->set_proxy ( $proxy );
}
return $this;
}
/**
* Destructs the instance. Closes opened file handles.
*
* @return $this A reference to the current instance.
*/
public function __destruct() {
if (isset ( $this->read_file ) && isset ( $this->read_stream )) {
fclose ( $this->read_stream );
}
if (isset ( $this->write_file ) && isset ( $this->write_stream )) {
fclose ( $this->write_stream );
}
return $this;
}
/*%******************************************************************************************%*/
// REQUEST METHODS
/**
* Sets the credentials to use for authentication.
*
* @param string $user (Required) The username to authenticate with.
* @param string $pass (Required) The password to authenticate with.
* @return $this A reference to the current instance.
*/
public function set_credentials($user, $pass) {
$this->username = $user;
$this->password = $pass;
return $this;
}
/**
* Adds a custom HTTP header to the cURL request.
*
* @param string $key (Required) The custom HTTP header to set.
* @param mixed $value (Required) The value to assign to the custom HTTP header.
* @return $this A reference to the current instance.
*/
public function add_header($key, $value) {
$this->request_headers [$key] = $value;
return $this;
}
/**
* Removes an HTTP header from the cURL request.
*
* @param string $key (Required) The custom HTTP header to set.
* @return $this A reference to the current instance.
*/
public function remove_header($key) {
if (isset ( $this->request_headers [$key] )) {
unset ( $this->request_headers [$key] );
}
return $this;
}
/**
* Set the method type for the request.
*
* @param string $method (Required) One of the following constants: <HTTP_GET>, <HTTP_POST>, <HTTP_PUT>, <HTTP_HEAD>, <HTTP_DELETE>.
* @return $this A reference to the current instance.
*/
public function set_method($method) {
$this->method = strtoupper ( $method );
return $this;
}
/**
* Sets a custom useragent string for the class.
*
* @param string $ua (Required) The useragent string to use.
* @return $this A reference to the current instance.
*/
public function set_useragent($ua) {
$this->useragent = $ua;
return $this;
}
/**
* Set the body to send in the request.
*
* @param string $body (Required) The textual content to send along in the body of the request.
* @return $this A reference to the current instance.
*/
public function set_body($body) {
$this->request_body = $body;
return $this;
}
/**
* Set the URL to make the request to.
*
* @param string $url (Required) The URL to make the request to.
* @return $this A reference to the current instance.
*/
public function set_request_url($url) {
$this->request_url = $url;
return $this;
}
/**
* Set additional CURLOPT settings. These will merge with the default settings, and override if
* there is a duplicate.
*
* @param array $curlopts (Optional) A set of key-value pairs that set `CURLOPT` options. These will merge with the existing CURLOPTs, and ones passed here will override the defaults. Keys should be the `CURLOPT_*` constants, not strings.
* @return $this A reference to the current instance.
*/
public function set_curlopts($curlopts) {
$this->curlopts = $curlopts;
return $this;
}
/**
* Sets the length in bytes to read from the stream while streaming up.
*
* @param integer $size (Required) The length in bytes to read from the stream.
* @return $this A reference to the current instance.
*/
public function set_read_stream_size($size) {
$this->read_stream_size = $size;
return $this;
}
/**
* Sets the resource to read from while streaming up. Reads the stream from its current position until
* EOF or `$size` bytes have been read. If `$size` is not given it will be determined by <php:fstat()> and
* <php:ftell()>.
*
* @param resource $resource (Required) The readable resource to read from.
* @param integer $size (Optional) The size of the stream to read.
* @return $this A reference to the current instance.
*/
public function set_read_stream($resource, $size = null) {
if (! isset ( $size ) || $size < 0) {
$stats = fstat ( $resource );
if ($stats && $stats ['size'] >= 0) {
$position = ftell ( $resource );
if ($position !== false && $position >= 0) {
$size = $stats ['size'] - $position;
}
}
}
$this->read_stream = $resource;
return $this->set_read_stream_size ( $size );
}
/**
* Sets the file to read from while streaming up.
*
* @param string $location (Required) The readable location to read from.
* @return $this A reference to the current instance.
*/
public function set_read_file($location) {
$this->read_file = $location;
$read_file_handle = fopen ( $location, 'r' );
return $this->set_read_stream ( $read_file_handle );
}
/**
* Sets the resource to write to while streaming down.
*
* @param resource $resource (Required) The writeable resource to write to.
* @return $this A reference to the current instance.
*/
public function set_write_stream($resource) {
$this->write_stream = $resource;
return $this;
}
/**
* Sets the file to write to while streaming down.
*
* @param string $location (Required) The writeable location to write to.
* @return $this A reference to the current instance.
*/
public function set_write_file($location) {
$this->write_file = $location;
$write_file_handle = fopen ( $location, 'w' );
return $this->set_write_stream ( $write_file_handle );
}
/**
* Set the proxy to use for making requests.
*
* @param string $proxy (Required) The faux-url to use for proxy settings. Takes the following format: `proxy://user:pass@hostname:port`
* @return $this A reference to the current instance.
*/
public function set_proxy($proxy) {
$proxy = parse_url ( $proxy );
$proxy ['user'] = isset ( $proxy ['user'] ) ? $proxy ['user'] : null;
$proxy ['pass'] = isset ( $proxy ['pass'] ) ? $proxy ['pass'] : null;
$proxy ['port'] = isset ( $proxy ['port'] ) ? $proxy ['port'] : null;
$this->proxy = $proxy;
return $this;
}
/**
* Set the intended starting seek position.
*
* @param integer $position (Required) The byte-position of the stream to begin reading from.
* @return $this A reference to the current instance.
*/
public function set_seek_position($position) {
$this->seek_position = isset ( $position ) ? ( integer ) $position : null;
return $this;
}
/**
* Register a callback function to execute whenever a data stream is read from using
* <CFRequest::streaming_read_callback()>.
*
* The user-defined callback function should accept three arguments:
*
* <ul>
* <li><code>$curl_handle</code> - <code>resource</code> - Required - The cURL handle resource that represents the in-progress transfer.</li>
* <li><code>$file_handle</code> - <code>resource</code> - Required - The file handle resource that represents the file on the local file system.</li>
* <li><code>$length</code> - <code>integer</code> - Required - The length in kilobytes of the data chunk that was transferred.</li>
* </ul>
*
* @param string|array|function $callback (Required) The callback function is called by <php:call_user_func()>, so you can pass the following values: <ul>
* <li>The name of a global function to execute, passed as a string.</li>
* <li>A method to execute, passed as <code>array('ClassName', 'MethodName')</code>.</li>
* <li>An anonymous function (PHP 5.3+).</li></ul>
* @return $this A reference to the current instance.
*/
public function register_streaming_read_callback($callback) {
$this->registered_streaming_read_callback = $callback;
return $this;
}
/**
* Register a callback function to execute whenever a data stream is written to using
* <CFRequest::streaming_write_callback()>.
*
* The user-defined callback function should accept two arguments:
*
* <ul>
* <li><code>$curl_handle</code> - <code>resource</code> - Required - The cURL handle resource that represents the in-progress transfer.</li>
* <li><code>$length</code> - <code>integer</code> - Required - The length in kilobytes of the data chunk that was transferred.</li>
* </ul>
*
* @param string|array|function $callback (Required) The callback function is called by <php:call_user_func()>, so you can pass the following values: <ul>
* <li>The name of a global function to execute, passed as a string.</li>
* <li>A method to execute, passed as <code>array('ClassName', 'MethodName')</code>.</li>
* <li>An anonymous function (PHP 5.3+).</li></ul>
* @return $this A reference to the current instance.
*/
public function register_streaming_write_callback($callback) {
$this->registered_streaming_write_callback = $callback;
return $this;
}
/*%******************************************************************************************%*/
// PREPARE, SEND, AND PROCESS REQUEST
/**
* A callback function that is invoked by cURL for streaming up.
*
* @param resource $curl_handle (Required) The cURL handle for the request.
* @param resource $file_handle (Required) The open file handle resource.
* @param integer $length (Required) The maximum number of bytes to read.
* @return binary Binary data from a stream.
*/
public function streaming_read_callback($curl_handle, $file_handle, $length) {
// Once we've sent as much as we're supposed to send...
if ($this->read_stream_read >= $this->read_stream_size) {
// Send EOF
return '';
}
// If we're at the beginning of an upload and need to seek...
if ($this->read_stream_read == 0 && isset ( $this->seek_position ) && $this->seek_position !== ftell ( $this->read_stream )) {
if (fseek ( $this->read_stream, $this->seek_position ) !== 0) {
throw new BCS_RequestCore_Exception ( 'The stream does not support seeking and is either not at the requested position or the position is unknown.' );
}
}
$read = fread ( $this->read_stream, min ( $this->read_stream_size - $this->read_stream_read, $length ) ); // Remaining upload data or cURL's requested chunk size
$this->read_stream_read += strlen ( $read );
$out = $read === false ? '' : $read;
// Execute callback function
if ($this->registered_streaming_read_callback) {
call_user_func ( $this->registered_streaming_read_callback, $curl_handle, $file_handle, $out );
}
return $out;
}
/**
* A callback function that is invoked by cURL for streaming down.
*
* @param resource $curl_handle (Required) The cURL handle for the request.
* @param binary $data (Required) The data to write.
* @return integer The number of bytes written.
*/
public function streaming_write_callback($curl_handle, $data) {
$length = strlen ( $data );
$written_total = 0;
$written_last = 0;
while ( $written_total < $length ) {
$written_last = fwrite ( $this->write_stream, substr ( $data, $written_total ) );
if ($written_last === false) {
return $written_total;
}
$written_total += $written_last;
}
// Execute callback function
if ($this->registered_streaming_write_callback) {
call_user_func ( $this->registered_streaming_write_callback, $curl_handle, $written_total );
}
return $written_total;
}
/**
* Prepares and adds the details of the cURL request. This can be passed along to a <php:curl_multi_exec()>
* function.
*
* @return resource The handle for the cURL object.
*/
public function prep_request() {
$curl_handle = curl_init ();
// Set default options.
curl_setopt ( $curl_handle, CURLOPT_URL, $this->request_url );
curl_setopt ( $curl_handle, CURLOPT_FILETIME, true );
curl_setopt ( $curl_handle, CURLOPT_FRESH_CONNECT, false );
curl_setopt ( $curl_handle, CURLOPT_SSL_VERIFYPEER, false );
curl_setopt ( $curl_handle, CURLOPT_SSL_VERIFYHOST, true );
curl_setopt ( $curl_handle, CURLOPT_CLOSEPOLICY, CURLCLOSEPOLICY_LEAST_RECENTLY_USED );
curl_setopt ( $curl_handle, CURLOPT_MAXREDIRS, 5 );
curl_setopt ( $curl_handle, CURLOPT_HEADER, true );
curl_setopt ( $curl_handle, CURLOPT_RETURNTRANSFER, true );
curl_setopt ( $curl_handle, CURLOPT_TIMEOUT, 5184000 );
curl_setopt ( $curl_handle, CURLOPT_CONNECTTIMEOUT, 120 );
curl_setopt ( $curl_handle, CURLOPT_NOSIGNAL, true );
curl_setopt ( $curl_handle, CURLOPT_REFERER, $this->request_url );
curl_setopt ( $curl_handle, CURLOPT_USERAGENT, $this->useragent );
curl_setopt ( $curl_handle, CURLOPT_READFUNCTION, array (
$this,
'streaming_read_callback' ) );
if ($this->debug_mode) {
curl_setopt ( $curl_handle, CURLOPT_VERBOSE, true );
}
//if (! ini_get ( 'safe_mode' )) {
//modify by zhengkan
//curl_setopt($curl_handle, CURLOPT_FOLLOWLOCATION, true);
//}
// Enable a proxy connection if requested.
if ($this->proxy) {
curl_setopt ( $curl_handle, CURLOPT_HTTPPROXYTUNNEL, true );
$host = $this->proxy ['host'];
$host .= ($this->proxy ['port']) ? ':' . $this->proxy ['port'] : '';
curl_setopt ( $curl_handle, CURLOPT_PROXY, $host );
if (isset ( $this->proxy ['user'] ) && isset ( $this->proxy ['pass'] )) {
curl_setopt ( $curl_handle, CURLOPT_PROXYUSERPWD, $this->proxy ['user'] . ':' . $this->proxy ['pass'] );
}
}
// Set credentials for HTTP Basic/Digest Authentication.
if ($this->username && $this->password) {
curl_setopt ( $curl_handle, CURLOPT_HTTPAUTH, CURLAUTH_ANY );
curl_setopt ( $curl_handle, CURLOPT_USERPWD, $this->username . ':' . $this->password );
}
// Handle the encoding if we can.
if (extension_loaded ( 'zlib' )) {
curl_setopt ( $curl_handle, CURLOPT_ENCODING, '' );
}
// Process custom headers
if (isset ( $this->request_headers ) && count ( $this->request_headers )) {
$temp_headers = array ();
foreach ( $this->request_headers as $k => $v ) {
$temp_headers [] = $k . ': ' . $v;
}
curl_setopt ( $curl_handle, CURLOPT_HTTPHEADER, $temp_headers );
}
switch ($this->method) {
case self::HTTP_PUT :
curl_setopt ( $curl_handle, CURLOPT_CUSTOMREQUEST, 'PUT' );
if (isset ( $this->read_stream )) {
if (! isset ( $this->read_stream_size ) || $this->read_stream_size < 0) {
throw new BCS_RequestCore_Exception ( 'The stream size for the streaming upload cannot be determined.' );
}
curl_setopt ( $curl_handle, CURLOPT_INFILESIZE, $this->read_stream_size );
curl_setopt ( $curl_handle, CURLOPT_UPLOAD, true );
} else {
curl_setopt ( $curl_handle, CURLOPT_POSTFIELDS, $this->request_body );
}
break;
case self::HTTP_POST :
curl_setopt ( $curl_handle, CURLOPT_POST, true );
curl_setopt ( $curl_handle, CURLOPT_POSTFIELDS, $this->request_body );
break;
case self::HTTP_HEAD :
curl_setopt ( $curl_handle, CURLOPT_CUSTOMREQUEST, self::HTTP_HEAD );
curl_setopt ( $curl_handle, CURLOPT_NOBODY, 1 );
break;
default : // Assumed GET
curl_setopt ( $curl_handle, CURLOPT_CUSTOMREQUEST, $this->method );
if (isset ( $this->write_stream )) {
curl_setopt ( $curl_handle, CURLOPT_WRITEFUNCTION, array (
$this,
'streaming_write_callback' ) );
curl_setopt ( $curl_handle, CURLOPT_HEADER, false );
} else {
curl_setopt ( $curl_handle, CURLOPT_POSTFIELDS, $this->request_body );
}
break;
}
// Merge in the CURLOPTs
if (isset ( $this->curlopts ) && sizeof ( $this->curlopts ) > 0) {
foreach ( $this->curlopts as $k => $v ) {
curl_setopt ( $curl_handle, $k, $v );
}
}
return $curl_handle;
}
/**
* is the environment BAE?
* @return boolean the result of the answer
*/
private function isBaeEnv() {
if (isset ( $_SERVER ['HTTP_HOST'] )) {
$host = $_SERVER ['HTTP_HOST'];
$pos = strpos ( $host, '.' );
if ($pos !== false) {
$substr = substr ( $host, $pos + 1 );
if ($substr == 'duapp.com') {
return true;
}
}
}
if (isset ( $_SERVER ["HTTP_BAE_LOGID"] )) {
return true;
}
return false;
}
/**
* Take the post-processed cURL data and break it down into useful header/body/info chunks. Uses the
* data stored in the `curl_handle` and `response` properties unless replacement data is passed in via
* parameters.
*
* @param resource $curl_handle (Optional) The reference to the already executed cURL request.
* @param string $response (Optional) The actual response content itself that needs to be parsed.
* @return BCS_ResponseCore A <BCS_ResponseCore> object containing a parsed HTTP response.
*/
public function process_response($curl_handle = null, $response = null) {
// Accept a custom one if it's passed.
if ($curl_handle && $response) {
$this->curl_handle = $curl_handle;
$this->response = $response;
}
// As long as this came back as a valid resource...
if (is_resource ( $this->curl_handle )) {
// Determine what's what.
$header_size = curl_getinfo ( $this->curl_handle, CURLINFO_HEADER_SIZE );
$this->response_headers = substr ( $this->response, 0, $header_size );
$this->response_body = substr ( $this->response, $header_size );
$this->response_code = curl_getinfo ( $this->curl_handle, CURLINFO_HTTP_CODE );
$this->response_info = curl_getinfo ( $this->curl_handle );
// Parse out the headers
$this->response_headers = explode ( "\r\n\r\n", trim ( $this->response_headers ) );
$this->response_headers = array_pop ( $this->response_headers );
$this->response_headers = explode ( "\r\n", $this->response_headers );
array_shift ( $this->response_headers );
// Loop through and split up the headers.
$header_assoc = array ();
foreach ( $this->response_headers as $header ) {
$kv = explode ( ': ', $header );
//$header_assoc [strtolower ( $kv [0] )] = $kv [1];
$header_assoc [$kv [0]] = $kv [1];
}
// Reset the headers to the appropriate property.
$this->response_headers = $header_assoc;
$this->response_headers ['_info'] = $this->response_info;
$this->response_headers ['_info'] ['method'] = $this->method;
if ($curl_handle && $response) {
$class='\Think\Upload\Driver\Bcs\\'. $this->response_class;
return new $class ( $this->response_headers, $this->response_body, $this->response_code, $this->curl_handle );
}
}
// Return false
return false;
}
/**
* Sends the request, calling necessary utility functions to update built-in properties.
*
* @param boolean $parse (Optional) Whether to parse the response with BCS_ResponseCore or not.
* @return string The resulting unparsed data from the request.
*/
public function send_request($parse = false) {
if (false === $this->isBaeEnv ()) {
set_time_limit ( 0 );
}
$curl_handle = $this->prep_request ();
$this->response = curl_exec ( $curl_handle );
if ($this->response === false ||
($this->method === self::HTTP_GET &&
curl_errno($curl_handle) === CURLE_PARTIAL_FILE)) {
throw new BCS_RequestCore_Exception ( 'cURL resource: ' . ( string ) $curl_handle . '; cURL error: ' . curl_error ( $curl_handle ) . ' (' . curl_errno ( $curl_handle ) . ')' );
}
$parsed_response = $this->process_response ( $curl_handle, $this->response );
curl_close ( $curl_handle );
if ($parse) {
return $parsed_response;
}
return $this->response;
}
/**
* Sends the request using <php:curl_multi_exec()>, enabling parallel requests. Uses the "rolling" method.
*
* @param array $handles (Required) An indexed array of cURL handles to process simultaneously.
* @param array $opt (Optional) An associative array of parameters that can have the following keys: <ul>
* <li><code>callback</code> - <code>string|array</code> - Optional - The string name of a function to pass the response data to. If this is a method, pass an array where the <code>[0]</code> index is the class and the <code>[1]</code> index is the method name.</li>
* <li><code>limit</code> - <code>integer</code> - Optional - The number of simultaneous requests to make. This can be useful for scaling around slow server responses. Defaults to trusting cURLs judgement as to how many to use.</li></ul>
* @return array Post-processed cURL responses.
*/
public function send_multi_request($handles, $opt = null) {
if (false === $this->isBaeEnv ()) {
set_time_limit ( 0 );
}
// Skip everything if there are no handles to process.
if (count ( $handles ) === 0)
return array ();
if (! $opt)
$opt = array ();
// Initialize any missing options
$limit = isset ( $opt ['limit'] ) ? $opt ['limit'] : - 1;
// Initialize
$handle_list = $handles;
$http = new $this->request_class ();
$multi_handle = curl_multi_init ();
$handles_post = array ();
$added = count ( $handles );
$last_handle = null;
$count = 0;
$i = 0;
// Loop through the cURL handles and add as many as it set by the limit parameter.
while ( $i < $added ) {
if ($limit > 0 && $i >= $limit)
break;
curl_multi_add_handle ( $multi_handle, array_shift ( $handles ) );
$i ++;
}
do {
$active = false;
// Start executing and wait for a response.
while ( ($status = curl_multi_exec ( $multi_handle, $active )) === CURLM_CALL_MULTI_PERFORM ) {
// Start looking for possible responses immediately when we have to add more handles
if (count ( $handles ) > 0)
break;
}
// Figure out which requests finished.
$to_process = array ();
while ( $done = curl_multi_info_read ( $multi_handle ) ) {
// Since curl_errno() isn't reliable for handles that were in multirequests, we check the 'result' of the info read, which contains the curl error number, (listed here http://curl.haxx.se/libcurl/c/libcurl-errors.html )
if ($done ['result'] > 0) {
throw new BCS_RequestCore_Exception ( 'cURL resource: ' . ( string ) $done ['handle'] . '; cURL error: ' . curl_error ( $done ['handle'] ) . ' (' . $done ['result'] . ')' );
} // Because curl_multi_info_read() might return more than one message about a request, we check to see if this request is already in our array of completed requests
elseif (! isset ( $to_process [( int ) $done ['handle']] )) {
$to_process [( int ) $done ['handle']] = $done;
}
}
// Actually deal with the request
foreach ( $to_process as $pkey => $done ) {
$response = $http->process_response ( $done ['handle'], curl_multi_getcontent ( $done ['handle'] ) );
$key = array_search ( $done ['handle'], $handle_list, true );
$handles_post [$key] = $response;
if (count ( $handles ) > 0) {
curl_multi_add_handle ( $multi_handle, array_shift ( $handles ) );
}
curl_multi_remove_handle ( $multi_handle, $done ['handle'] );
curl_close ( $done ['handle'] );
}
} while ( $active || count ( $handles_post ) < $added );
curl_multi_close ( $multi_handle );
ksort ( $handles_post, SORT_NUMERIC );
return $handles_post;
}
/*%******************************************************************************************%*/
// RESPONSE METHODS
/**
* Get the HTTP response headers from the request.
*
* @param string $header (Optional) A specific header value to return. Defaults to all headers.
* @return string|array All or selected header values.
*/
public function get_response_header($header = null) {
if ($header) {
// return $this->response_headers [strtolower ( $header )];
return $this->response_headers [$header];
}
return $this->response_headers;
}
/**
* Get the HTTP response body from the request.
*
* @return string The response body.
*/
public function get_response_body() {
return $this->response_body;
}
/**
* Get the HTTP response code from the request.
*
* @return string The HTTP response code.
*/
public function get_response_code() {
return $this->response_code;
}
}
/**
* Container for all response-related methods.
*/
class BCS_ResponseCore {
/**
* Stores the HTTP header information.
*/
public $header;
/**
* Stores the SimpleXML response.
*/
public $body;
/**
* Stores the HTTP response code.
*/
public $status;
/**
* Constructs a new instance of this class.
*
* @param array $header (Required) Associative array of HTTP headers (typically returned by <BCS_RequestCore::get_response_header()>).
* @param string $body (Required) XML-formatted response from AWS.
* @param integer $status (Optional) HTTP response status code from the request.
* @return object Contains an <php:array> `header` property (HTTP headers as an associative array), a <php:SimpleXMLElement> or <php:string> `body` property, and an <php:integer> `status` code.
*/
public function __construct($header, $body, $status = null) {
$this->header = $header;
$this->body = $body;
$this->status = $status;
return $this;
}
/**
* Did we receive the status code we expected?
*
* @param integer|array $codes (Optional) The status code(s) to expect. Pass an <php:integer> for a single acceptable value, or an <php:array> of integers for multiple acceptable values.
* @return boolean Whether we received the expected status code or not.
*/
public function isOK($codes = array(200, 201, 204, 206)) {
if (is_array ( $codes )) {
return in_array ( $this->status, $codes );
}
return $this->status === $codes;
}
}
/**
* Default BCS_RequestCore Exception.
*/
class BCS_RequestCore_Exception extends \Exception {
}

163
ThinkPHP/Library/Think/Upload/Driver/Ftp.class.php Normal file
View File

@@ -0,0 +1,163 @@
<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK IT ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006-2014 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: 麦当苗儿 <zuojiazi@vip.qq.com> <http://www.zjzit.cn>
// +----------------------------------------------------------------------
namespace Think\Upload\Driver;
class Ftp {
/**
* 上传文件根目录
* @var string
*/
private $rootPath;
/**
* 本地上传错误信息
* @var string
*/
private $error = ''; //上传错误信息
/**
* FTP连接
* @var resource
*/
private $link;
private $config = array(
'host' => '', //服务器
'port' => 21, //端口
'timeout' => 90, //超时时间
'username' => '', //用户名
'password' => '', //密码
);
/**
* 构造函数，用于设置上传根路径
* @param array $config FTP配置
*/
public function __construct($config){
/* 默认FTP配置 */
$this->config = array_merge($this->config, $config);
/* 登录FTP服务器 */
if(!$this->login()){
E($this->error);
}
}
/**
* 检测上传根目录
* @param string $rootpath 根目录
* @return boolean true-检测通过，false-检测失败
*/
public function checkRootPath($rootpath){
/* 设置根目录 */
$this->rootPath = ftp_pwd($this->link) . '/' . ltrim($rootpath, '/');
if(!@ftp_chdir($this->link, $this->rootPath)){
$this->error = '上传根目录不存在！';
return false;
}
return true;
}
/**
* 检测上传目录
* @param string $savepath 上传目录
* @return boolean 检测结果，true-通过，false-失败
*/
public function checkSavePath($savepath){
/* 检测并创建目录 */
if (!$this->mkdir($savepath)) {
return false;
} else {
//TODO:检测目录是否可写
return true;
}
}
/**
* 保存指定文件
* @param array $file 保存的文件信息
* @param boolean $replace 同名文件是否覆盖
* @return boolean 保存状态，true-成功，false-失败
*/
public function save($file, $replace=true) {
$filename = $this->rootPath . $file['savepath'] . $file['savename'];
/* 不覆盖同名文件 */
// if (!$replace && is_file($filename)) {
// $this->error = '存在同名文件' . $file['savename'];
// return false;
// }
/* 移动文件 */
if (!ftp_put($this->link, $filename, $file['tmp_name'], FTP_BINARY)) {
$this->error = '文件上传保存错误！';
return false;
}
return true;
}
/**
* 创建目录
* @param string $savepath 要创建的目录
* @return boolean 创建状态，true-成功，false-失败
*/
public function mkdir($savepath){
$dir = $this->rootPath . $savepath;
if(ftp_chdir($this->link, $dir)){
return true;
}
if(ftp_mkdir($this->link, $dir)){
return true;
} elseif($this->mkdir(dirname($savepath)) && ftp_mkdir($this->link, $dir)) {
return true;
} else {
$this->error = "目录 {$savepath} 创建失败！";
return false;
}
}
/**
* 获取最后一次上传错误信息
* @return string 错误信息
*/
public function getError(){
return $this->error;
}
/**
* 登录到FTP服务器
* @return boolean true-登录成功，false-登录失败
*/
private function login(){
extract($this->config);
$this->link = ftp_connect($host, $port, $timeout);
if($this->link) {
if (ftp_login($this->link, $username, $password)) {
return true;
} else {
$this->error = "无法登录到FTP服务器：username - {$username}";
}
} else {
$this->error = "无法连接到FTP服务器：{$host}";
}
return false;
}
/**
* 析构方法，用于断开当前FTP连接
*/
public function __destruct() {
ftp_close($this->link);
}
}

118
ThinkPHP/Library/Think/Upload/Driver/Local.class.php Normal file
View File

@@ -0,0 +1,118 @@
<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK IT ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006-2014 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: 麦当苗儿 <zuojiazi@vip.qq.com> <http://www.zjzit.cn>
// +----------------------------------------------------------------------
namespace Think\Upload\Driver;
class Local{
/**
* 上传文件根目录
* @var string
*/
private $rootPath;
/**
* 本地上传错误信息
* @var string
*/
private $error = ''; //上传错误信息
/**
* 构造函数，用于设置上传根路径
*/
public function __construct($config = null){
}
/**
* 检测上传根目录
* @param string $rootpath 根目录
* @return boolean true-检测通过，false-检测失败
*/
public function checkRootPath($rootpath){
if(!(is_dir($rootpath) && is_writable($rootpath))){
$this->error = '上传根目录不存在！请尝试手动创建:'.$rootpath;
return false;
}
$this->rootPath = $rootpath;
return true;
}
/**
* 检测上传目录
* @param string $savepath 上传目录
* @return boolean 检测结果，true-通过，false-失败
*/
public function checkSavePath($savepath){
/* 检测并创建目录 */
if (!$this->mkdir($savepath)) {
return false;
} else {
/* 检测目录是否可写 */
if (!is_writable($this->rootPath . $savepath)) {
$this->error = '上传目录 ' . $savepath . ' 不可写！';
return false;
} else {
return true;
}
}
}
/**
* 保存指定文件
* @param array $file 保存的文件信息
* @param boolean $replace 同名文件是否覆盖
* @return boolean 保存状态，true-成功，false-失败
*/
public function save($file, $replace=true) {
$filename = $this->rootPath . $file['savepath'] . $file['savename'];
/* 不覆盖同名文件 */
if (!$replace && is_file($filename)) {
$this->error = '存在同名文件' . $file['savename'];
return false;
}
/* 移动文件 */
if (!move_uploaded_file($file['tmp_name'], $filename)) {
$this->error = '文件上传保存错误！';
return false;
}
return true;
}
/**
* 创建目录
* @param string $savepath 要创建的穆里
* @return boolean 创建状态，true-成功，false-失败
*/
public function mkdir($savepath){
$dir = $this->rootPath . $savepath;
if(is_dir($dir)){
return true;
}
if(mkdir($dir, 0777, true)){
return true;
} else {
$this->error = "目录 {$savepath} 创建失败！";
return false;
}
}
/**
* 获取最后一次上传错误信息
* @return string 错误信息
*/
public function getError(){
return $this->error;
}
}

102
ThinkPHP/Library/Think/Upload/Driver/Qiniu.class.php Normal file
View File

@@ -0,0 +1,102 @@
<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK IT ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006-2014 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: yangweijie <yangweijiester@gmail.com> <http://www.code-tech.diandian.com>
// +----------------------------------------------------------------------
namespace Think\Upload\Driver;
use Think\Upload\Driver\Qiniu\QiniuStorage;
class Qiniu{
/**
* 上传文件根目录
* @var string
*/
private $rootPath;
/**
* 上传错误信息
* @var string
*/
private $error = '';
private $config = array(
'secretKey' => '', //七牛服务器
'accessKey' => '', //七牛用户
'domain' => '', //七牛密码
'bucket' => '', //空间名称
'timeout' => 300, //超时时间
);
/**
* 构造函数，用于设置上传根路径
* @param array $config FTP配置
*/
public function __construct($config){
$this->config = array_merge($this->config, $config);
/* 设置根目录 */
$this->qiniu = new QiniuStorage($config);
}
/**
* 检测上传根目录(七牛上传时支持自动创建目录，直接返回)
* @param string $rootpath 根目录
* @return boolean true-检测通过，false-检测失败
*/
public function checkRootPath($rootpath){
$this->rootPath = trim($rootpath, './') . '/';
return true;
}
/**
* 检测上传目录(七牛上传时支持自动创建目录，直接返回)
* @param string $savepath 上传目录
* @return boolean 检测结果，true-通过，false-失败
*/
public function checkSavePath($savepath){
return true;
}
/**
* 创建文件夹 (七牛上传时支持自动创建目录，直接返回)
* @param string $savepath 目录名称
* @return boolean true-创建成功，false-创建失败
*/
public function mkdir($savepath){
return true;
}
/**
* 保存指定文件
* @param array $file 保存的文件信息
* @param boolean $replace 同名文件是否覆盖
* @return boolean 保存状态，true-成功，false-失败
*/
public function save(&$file,$replace=true) {
$file['name'] = $file['savepath'] . $file['savename'];
$key = str_replace('/', '_', $file['name']);
$upfile = array(
'name'=>'file',
'fileName'=>$key,
'fileBody'=>file_get_contents($file['tmp_name'])
);
$config = array();
$result = $this->qiniu->upload($config, $upfile);
$url = $this->qiniu->downlink($key);
$file['url'] = $url;
return false ===$result ? false : true;
}
/**
* 获取最后一次上传错误信息
* @return string 错误信息
*/
public function getError(){
return $this->qiniu->errorStr;
}
}

333
ThinkPHP/Library/Think/Upload/Driver/Qiniu/QiniuStorage.class.php Normal file
View File

@@ -0,0 +1,333 @@
<?php
namespace Think\Upload\Driver\Qiniu;
class QiniuStorage {
public $QINIU_RSF_HOST = 'http://rsf.qbox.me';
public $QINIU_RS_HOST = 'http://rs.qbox.me';
public $QINIU_UP_HOST = 'http://up.qiniu.com';
public $timeout = '';
public function __construct($config){
$this->sk = $config['secretKey'];
$this->ak = $config['accessKey'];
$this->domain = $config['domain'];
$this->bucket = $config['bucket'];
$this->timeout = isset($config['timeout'])? $config['timeout'] : 3600;
}
static function sign($sk, $ak, $data){
$sign = hash_hmac('sha1', $data, $sk, true);
return $ak . ':' . self::Qiniu_Encode($sign);
}
static function signWithData($sk, $ak, $data){
$data = self::Qiniu_Encode($data);
return self::sign($sk, $ak, $data) . ':' . $data;
}
public function accessToken($url, $body=''){
$parsed_url = parse_url($url);
$path = $parsed_url['path'];
$access = $path;
if (isset($parsed_url['query'])) {
$access .= "?" . $parsed_url['query'];
}
$access .= "\n";
if($body){
$access .= $body;
}
return self::sign($this->sk, $this->ak, $access);
}
public function UploadToken($sk ,$ak ,$param){
$param['deadline'] = $param['Expires'] == 0? 3600: $param['Expires'];
$param['deadline'] += time();
$data = array('scope'=> $this->bucket, 'deadline'=>$param['deadline']);
if (!empty($param['CallbackUrl'])) {
$data['callbackUrl'] = $param['CallbackUrl'];
}
if (!empty($param['CallbackBody'])) {
$data['callbackBody'] = $param['CallbackBody'];
}
if (!empty($param['ReturnUrl'])) {
$data['returnUrl'] = $param['ReturnUrl'];
}
if (!empty($param['ReturnBody'])) {
$data['returnBody'] = $param['ReturnBody'];
}
if (!empty($param['AsyncOps'])) {
$data['asyncOps'] = $param['AsyncOps'];
}
if (!empty($param['EndUser'])) {
$data['endUser'] = $param['EndUser'];
}
$data = json_encode($data);
return self::SignWithData($sk, $ak, $data);
}
public function upload($config, $file){
$uploadToken = $this->UploadToken($this->sk, $this->ak, $config);
$url = "{$this->QINIU_UP_HOST}";
$mimeBoundary = md5(microtime());
$header = array('Content-Type'=>'multipart/form-data;boundary='.$mimeBoundary);
$data = array();
$fields = array(
'token' => $uploadToken,
'key' => $config['saveName']? : $file['fileName'],
);
if(is_array($config['custom_fields']) && $config['custom_fields'] !== array()){
$fields = array_merge($fields, $config['custom_fields']);
}
foreach ($fields as $name => $val) {
array_push($data, '--' . $mimeBoundary);
array_push($data, "Content-Disposition: form-data; name=\"$name\"");
array_push($data, '');
array_push($data, $val);
}
//文件
array_push($data, '--' . $mimeBoundary);
$name = $file['name'];
$fileName = $file['fileName'];
$fileBody = $file['fileBody'];
$fileName = self::Qiniu_escapeQuotes($fileName);
array_push($data, "Content-Disposition: form-data; name=\"$name\"; filename=\"$fileName\"");
array_push($data, 'Content-Type: application/octet-stream');
array_push($data, '');
array_push($data, $fileBody);
array_push($data, '--' . $mimeBoundary . '--');
array_push($data, '');
$body = implode("\r\n", $data);
$response = $this->request($url, 'POST', $header, $body);
return $response;
}
public function dealWithType($key, $type){
$param = $this->buildUrlParam();
$url = '';
switch($type){
case 'img':
$url = $this->downLink($key);
if($param['imageInfo']){
$url .= '?imageInfo';
}else if($param['exif']){
$url .= '?exif';
}else if($param['imageView']){
$url .= '?imageView/'.$param['mode'];
if($param['w'])
$url .= "/w/{$param['w']}";
if($param['h'])
$url .= "/h/{$param['h']}";
if($param['q'])
$url .= "/q/{$param['q']}";
if($param['format'])
$url .= "/format/{$param['format']}";
}
break;
case 'video': //TODO 视频处理
case 'doc':
$url = $this->downLink($key);
$url .= '?md2html';
if(isset($param['mode']))
$url .= '/'.(int)$param['mode'];
if($param['cssurl'])
$url .= '/'. self::Qiniu_Encode($param['cssurl']);
break;
}
return $url;
}
public function buildUrlParam(){
return $_REQUEST;
}
//获取某个路径下的文件列表
public function getList($query = array(), $path = ''){
$query = array_merge(array('bucket'=>$this->bucket), $query);
$url = "{$this->QINIU_RSF_HOST}/list?".http_build_query($query);
$accessToken = $this->accessToken($url);
$response = $this->request($url, 'POST', array('Authorization'=>"QBox $accessToken"));
return $response;
}
//获取某个文件的信息
public function info($key){
$key = trim($key);
$url = "{$this->QINIU_RS_HOST}/stat/" . self::Qiniu_Encode("{$this->bucket}:{$key}");
$accessToken = $this->accessToken($url);
$response = $this->request($url, 'POST', array(
'Authorization' => "QBox $accessToken",
));
return $response;
}
//获取文件下载资源链接
public function downLink($key){
$key = urlencode($key);
$key = self::Qiniu_escapeQuotes($key);
$url = "http://{$this->domain}/{$key}";
return $url;
}
//重命名单个文件
public function rename($file, $new_file){
$key = trim($file);
$url = "{$this->QINIU_RS_HOST}/move/" . self::Qiniu_Encode("{$this->bucket}:{$key}") .'/'. self::Qiniu_Encode("{$this->bucket}:{$new_file}");
trace($url);
$accessToken = $this->accessToken($url);
$response = $this->request($url, 'POST', array('Authorization'=>"QBox $accessToken"));
return $response;
}
//删除单个文件
public function del($file){
$key = trim($file);
$url = "{$this->QINIU_RS_HOST}/delete/" . self::Qiniu_Encode("{$this->bucket}:{$key}");
$accessToken = $this->accessToken($url);
$response = $this->request($url, 'POST', array('Authorization'=>"QBox $accessToken"));
return $response;
}
//批量删除文件
public function delBatch($files){
$url = $this->QINIU_RS_HOST . '/batch';
$ops = array();
foreach ($files as $file) {
$ops[] = "/delete/". self::Qiniu_Encode("{$this->bucket}:{$file}");
}
$params = 'op=' . implode('&op=', $ops);
$url .= '?'.$params;
trace($url);
$accessToken = $this->accessToken($url);
$response = $this->request($url, 'POST', array('Authorization'=>"QBox $accessToken"));
return $response;
}
static function Qiniu_Encode($str) {// URLSafeBase64Encode
$find = array('+', '/');
$replace = array('-', '_');
return str_replace($find, $replace, base64_encode($str));
}
static function Qiniu_escapeQuotes($str){
$find = array("\\", "\"");
$replace = array("\\\\", "\\\"");
return str_replace($find, $replace, $str);
}
/**
* 请求云服务器
* @param string $path 请求的PATH
* @param string $method 请求方法
* @param array $headers 请求header
* @param resource $body 上传文件资源
* @return boolean
*/
private function request($path, $method, $headers = null, $body = null){
$ch = curl_init($path);
$_headers = array('Expect:');
if (!is_null($headers) && is_array($headers)){
foreach($headers as $k => $v) {
array_push($_headers, "{$k}: {$v}");
}
}
$length = 0;
$date = gmdate('D, d M Y H:i:s \G\M\T');
if (!is_null($body)) {
if(is_resource($body)){
fseek($body, 0, SEEK_END);
$length = ftell($body);
fseek($body, 0);
array_push($_headers, "Content-Length: {$length}");
curl_setopt($ch, CURLOPT_INFILE, $body);
curl_setopt($ch, CURLOPT_INFILESIZE, $length);
} else {
$length = @strlen($body);
array_push($_headers, "Content-Length: {$length}");
curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
}
} else {
array_push($_headers, "Content-Length: {$length}");
}
// array_push($_headers, 'Authorization: ' . $this->sign($method, $uri, $date, $length));
array_push($_headers, "Date: {$date}");
curl_setopt($ch, CURLOPT_HTTPHEADER, $_headers);
curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_HEADER, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 0);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
if ($method == 'PUT' || $method == 'POST') {
curl_setopt($ch, CURLOPT_POST, 1);
} else {
curl_setopt($ch, CURLOPT_POST, 0);
}
if ($method == 'HEAD') {
curl_setopt($ch, CURLOPT_NOBODY, true);
}
$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
list($header, $body) = explode("\r\n\r\n", $response, 2);
if ($status == 200) {
if ($method == 'GET') {
return $body;
} else {
return $this->response($response);
}
} else {
$this->error($header , $body);
return false;
}
}
/**
* 获取响应数据
* @param string $text 响应头字符串
* @return array 响应数据列表
*/
private function response($text){
$headers = explode(PHP_EOL, $text);
$items = array();
foreach($headers as $header) {
$header = trim($header);
if(strpos($header, '{') !== False){
$items = json_decode($header, 1);
break;
}
}
return $items;
}
/**
* 获取请求错误信息
* @param string $header 请求返回头信息
*/
private function error($header, $body) {
list($status, $stash) = explode("\r\n", $header, 2);
list($v, $code, $message) = explode(" ", $status, 3);
$message = is_null($message) ? 'File Not Found' : "[{$status}]:{$message}]";
$this->error = $message;
$this->errorStr = json_decode($body ,1);
$this->errorStr = $this->errorStr['error'];
}
}

106
ThinkPHP/Library/Think/Upload/Driver/Sae.class.php Normal file
View File

@@ -0,0 +1,106 @@
<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK IT ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006-2014 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: luofei614<weibo.com/luofei614>
// +----------------------------------------------------------------------
namespace Think\Upload\Driver;
class Sae{
/**
* Storage的Domain
* @var string
*/
private $domain = '';
private $rootPath = '';
/**
* 本地上传错误信息
* @var string
*/
private $error = '';
/**
* 构造函数，设置storage的domain， 如果有传配置，则domain为配置项，如果没有传domain为第一个路径的目录名称。
* @param mixed $config 上传配置
*/
public function __construct($config = null){
if(is_array($config) && !empty($config['domain'])){
$this->domain = strtolower($config['domain']);
}
}
/**
* 检测上传根目录
* @param string $rootpath 根目录
* @return boolean true-检测通过，false-检测失败
*/
public function checkRootPath($rootpath){
$rootpath = trim($rootpath,'./');
if(!$this->domain){
$rootpath = explode('/', $rootpath);
$this->domain = strtolower(array_shift($rootpath));
$rootpath = implode('/', $rootpath);
}
$this->rootPath = $rootpath;
$st = new \SaeStorage();
if(false===$st->getDomainCapacity($this->domain)){
$this->error = '您好像没有建立Storage的domain['.$this->domain.']';
return false;
}
return true;
}
/**
* 检测上传目录
* @param string $savepath 上传目录
* @return boolean 检测结果，true-通过，false-失败
*/
public function checkSavePath($savepath){
return true;
}
/**
* 保存指定文件
* @param array $file 保存的文件信息
* @param boolean $replace 同名文件是否覆盖
* @return boolean 保存状态，true-成功，false-失败
*/
public function save(&$file, $replace=true) {
$filename = ltrim($this->rootPath .'/'. $file['savepath'] . $file['savename'],'/');
$st = new \SaeStorage();
/* 不覆盖同名文件 */
if (!$replace && $st->fileExists($this->domain,$filename)) {
$this->error = '存在同名文件' . $file['savename'];
return false;
}
/* 移动文件 */
if (!$st->upload($this->domain,$filename,$file['tmp_name'])) {
$this->error = '文件上传保存错误！['.$st->errno().']:'.$st->errmsg();
return false;
}else{
$file['url'] = $st->getUrl($this->domain, $filename);
}
return true;
}
public function mkdir(){
return true;
}
/**
* 获取最后一次上传错误信息
* @return string 错误信息
*/
public function getError(){
return $this->error;
}
}

218
ThinkPHP/Library/Think/Upload/Driver/Upyun.class.php Normal file
View File

@@ -0,0 +1,218 @@
<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK IT ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006-2014 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: 麦当苗儿 <zuojiazi@vip.qq.com> <http://www.zjzit.cn>
// +----------------------------------------------------------------------
namespace Think\Upload\Driver;
class Upyun{
/**
* 上传文件根目录
* @var string
*/
private $rootPath;
/**
* 上传错误信息
* @var string
*/
private $error = '';
private $config = array(
'host' => '', //又拍云服务器
'username' => '', //又拍云用户
'password' => '', //又拍云密码
'bucket' => '', //空间名称
'timeout' => 90, //超时时间
);
/**
* 构造函数，用于设置上传根路径
* @param array $config FTP配置
*/
public function __construct($config){
/* 默认FTP配置 */
$this->config = array_merge($this->config, $config);
$this->config['password'] = md5($this->config['password']);
}
/**
* 检测上传根目录(又拍云上传时支持自动创建目录，直接返回)
* @param string $rootpath 根目录
* @return boolean true-检测通过，false-检测失败
*/
public function checkRootPath($rootpath){
/* 设置根目录 */
$this->rootPath = trim($rootpath, './') . '/';
return true;
}
/**
* 检测上传目录(又拍云上传时支持自动创建目录，直接返回)
* @param string $savepath 上传目录
* @return boolean 检测结果，true-通过，false-失败
*/
public function checkSavePath($savepath){
return true;
}
/**
* 创建文件夹 (又拍云上传时支持自动创建目录，直接返回)
* @param string $savepath 目录名称
* @return boolean true-创建成功，false-创建失败
*/
public function mkdir($savepath){
return true;
}
/**
* 保存指定文件
* @param array $file 保存的文件信息
* @param boolean $replace 同名文件是否覆盖
* @return boolean 保存状态，true-成功，false-失败
*/
public function save($file, $replace = true) {
$header['Content-Type'] = $file['type'];
$header['Content-MD5'] = $file['md5'];
$header['Mkdir'] = 'true';
$resource = fopen($file['tmp_name'], 'r');
$save = $this->rootPath . $file['savepath'] . $file['savename'];
$data = $this->request($save, 'PUT', $header, $resource);
return false === $data ? false : true;
}
/**
* 获取最后一次上传错误信息
* @return string 错误信息
*/
public function getError(){
return $this->error;
}
/**
* 请求又拍云服务器
* @param string $path 请求的PATH
* @param string $method 请求方法
* @param array $headers 请求header
* @param resource $body 上传文件资源
* @return boolean
*/
private function request($path, $method, $headers = null, $body = null){
$uri = "/{$this->config['bucket']}/{$path}";
$ch = curl_init($this->config['host'] . $uri);
$_headers = array('Expect:');
if (!is_null($headers) && is_array($headers)){
foreach($headers as $k => $v) {
array_push($_headers, "{$k}: {$v}");
}
}
$length = 0;
$date = gmdate('D, d M Y H:i:s \G\M\T');
if (!is_null($body)) {
if(is_resource($body)){
fseek($body, 0, SEEK_END);
$length = ftell($body);
fseek($body, 0);
array_push($_headers, "Content-Length: {$length}");
curl_setopt($ch, CURLOPT_INFILE, $body);
curl_setopt($ch, CURLOPT_INFILESIZE, $length);
} else {
$length = @strlen($body);
array_push($_headers, "Content-Length: {$length}");
curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
}
} else {
array_push($_headers, "Content-Length: {$length}");
}
array_push($_headers, 'Authorization: ' . $this->sign($method, $uri, $date, $length));
array_push($_headers, "Date: {$date}");
curl_setopt($ch, CURLOPT_HTTPHEADER, $_headers);
curl_setopt($ch, CURLOPT_TIMEOUT, $this->config['timeout']);
curl_setopt($ch, CURLOPT_HEADER, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 0);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
if ($method == 'PUT' || $method == 'POST') {
curl_setopt($ch, CURLOPT_POST, 1);
} else {
curl_setopt($ch, CURLOPT_POST, 0);
}
if ($method == 'HEAD') {
curl_setopt($ch, CURLOPT_NOBODY, true);
}
$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
list($header, $body) = explode("\r\n\r\n", $response, 2);
if ($status == 200) {
if ($method == 'GET') {
return $body;
} else {
$data = $this->response($header);
return count($data) > 0 ? $data : true;
}
} else {
$this->error($header);
return false;
}
}
/**
* 获取响应数据
* @param string $text 响应头字符串
* @return array 响应数据列表
*/
private function response($text){
$headers = explode("\r\n", $text);
$items = array();
foreach($headers as $header) {
$header = trim($header);
if(strpos($header, 'x-upyun') !== False){
list($k, $v) = explode(':', $header);
$items[trim($k)] = in_array(substr($k,8,5), array('width','heigh','frame')) ? intval($v) : trim($v);
}
}
return $items;
}
/**
* 生成请求签名
* @param string $method 请求方法
* @param string $uri 请求URI
* @param string $date 请求时间
* @param integer $length 请求内容大小
* @return string 请求签名
*/
private function sign($method, $uri, $date, $length){
$sign = "{$method}&{$uri}&{$date}&{$length}&{$this->config['password']}";
return 'UpYun ' . $this->config['username'] . ':' . md5($sign);
}
/**
* 获取请求错误信息
* @param string $header 请求返回头信息
*/
private function error($header) {
list($status, $stash) = explode("\r\n", $header, 2);
list($v, $code, $message) = explode(" ", $status, 3);
$message = is_null($message) ? 'File Not Found' : "[{$status}]:{$message}";
$this->error = $message;
}
}