🎇 feat: pikpak support

README.md

@@ -1,6 +1,6 @@
 <div align="center">
   <h3><a href="https://alist.nn.ci">Alist</a></h3>
-  <p><em>A file list program that supports multiple storage, powered by gin and React.</em></p>
+  <p><em>🗂️Another file list program that supports multiple storage, powered by Gin and React.</em></p>
   <a href="https://github.com/Xhofe/alist/releases"><img src="https://img.shields.io/github/release/Xhofe/alist?style=flat-square" alt="latest version"></a>
   <a href="https://github.com/Xhofe/alist/discussions"><img src="https://img.shields.io/github/discussions/Xhofe/alist?color=%23ED8936&style=flat-square" alt="discussions"></a>
   <a href="https://github.com/Xhofe/alist/actions?query=workflow%3ABuild"><img src="https://img.shields.io/github/workflow/status/Xhofe/alist/build?style=flat-square" alt="Build status"></a>
@@ -26,6 +26,9 @@ English | [中文](./README_cn.md)
   - [x] [GoogleDrive](https://drive.google.com/)
   - [x] [123pan](https://www.123pan.com/)
   - [x] [lanzou](https://pc.woozooo.com/)
+  - [x] [Alist](https://github.com/Xhofe/alist)
+  - [x] FTP
+  - [x] [PikPak](https://www.mypikpak.com/)
 - [x] File preview (PDF, markdown, code, plain text, ...)
 - [x] Image preview in gallery mode
 - [x] Video and audio preview (mp4, mp3, ...)
@@ -37,6 +40,7 @@ English | [中文](./README_cn.md)
 - [x] Protected routes (password protection and authentication) 
 - [x] WebDav (readonly)
 - [x] [Docker Deploy](https://hub.docker.com/r/xhofe/alist)
+- [x] Cloudflare workers proxy
 
 ## Discussion
 

README_cn.md

@@ -1,6 +1,6 @@
 <div align="center">
   <h3><a href="https://alist.nn.ci">Alist</a></h3>
-  <p><em>一个支持多存储的文件列表程序，使用 gin 和 React 。</em></p>
+  <p><em>🗂️一个支持多存储的文件列表程序，使用 Gin 和 React 。</em></p>
   <a href="https://github.com/Xhofe/alist/releases"><img src="https://img.shields.io/github/release/Xhofe/alist?style=flat-square" alt="latest version"></a>
   <a href="https://github.com/Xhofe/alist/discussions"><img src="https://img.shields.io/github/discussions/Xhofe/alist?color=%23ED8936&style=flat-square" alt="discussions"></a>
   <a href="https://github.com/Xhofe/alist/actions?query=workflow%3ABuild"><img src="https://img.shields.io/github/workflow/status/Xhofe/alist/build?style=flat-square" alt="Build status"></a>
@@ -25,6 +25,9 @@
   - [x] [GoogleDrive](https://drive.google.com/)
   - [x] [123云盘](https://www.123pan.com/)
   - [x] [蓝奏云](https://pc.woozooo.com/)
+  - [x] [Alist](https://github.com/Xhofe/alist)
+  - [x] FTP
+  - [x] [PikPak](https://www.mypikpak.com/)
 - [x] 文件预览（PDF、markdown、代码、纯文本……）
 - [x] 画廊模式下的图像预览
 - [x] 视频和音频预览（mp4、mp3 等）
@@ -36,6 +39,7 @@
 - [x] 受保护的路由（密码保护和身份验证）
 - [x] WebDav（只读）
 - [x] [Docker 部署](https://hub.docker.com/r/xhofe/alist)
+- [x] Cloudflare workers 中转
 
 ## 讨论
 

alist-proxy.js

@@ -12,7 +12,7 @@ const corsHeaders = {
 async function handleRequest(request) {
     const origin = request.headers.get("origin");
     const url = new URL(request.url);
-    const path = url.pathname;
+    const path = decodeURI(url.pathname);
     const sign = url.searchParams.get("sign");
     const name = path.split("/").pop();
     const right = md5(`alist-${TOKEN}-${name}`).slice(8, 24);
@@ -39,7 +39,7 @@ async function handleRequest(request) {
             Authorization: TOKEN,
         },
         body: JSON.stringify({
-            path: decodeURI(path),
+            path: path,
         }),
     });
     let res = await resp.json();

drivers/123/123.go

@@ -1,12 +1,17 @@
 package _23
 
 import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"errors"
 	"fmt"
 	"github.com/Xhofe/alist/conf"
 	"github.com/Xhofe/alist/drivers/base"
 	"github.com/Xhofe/alist/model"
 	"github.com/Xhofe/alist/utils"
 	"github.com/go-resty/resty/v2"
+	jsoniter "github.com/json-iterator/go"
+	"math/rand"
 	"path/filepath"
 	"strconv"
 	"time"
@@ -122,6 +127,20 @@ func (driver Pan123) GetFiles(parentId string, account *model.Account) ([]Pan123
 	return res, nil
 }
 
+func (driver Pan123) Post(url string, data base.Json, account *model.Account) ([]byte, error) {
+	res, err := pan123Client.R().
+		SetHeader("authorization", "Bearer "+account.AccessToken).
+		SetBody(data).Post(url)
+	if err != nil {
+		return nil, err
+	}
+	body := res.Body()
+	if jsoniter.Get(body, "code").ToInt() != 0 {
+		return nil, errors.New(jsoniter.Get(body, "message").ToString())
+	}
+	return body, nil
+}
+
 func (driver Pan123) GetFile(path string, account *model.Account) (*Pan123File, error) {
 	dir, name := filepath.Split(path)
 	dir = utils.ParsePath(dir)
@@ -143,6 +162,28 @@ func (driver Pan123) GetFile(path string, account *model.Account) (*Pan123File,
 	return nil, base.ErrPathNotFound
 }
 
+func RandStr(length int) string {
+	str := "123456789abcdefghijklmnopqrstuvwxyz"
+	bytes := []byte(str)
+	var result []byte
+	rand.Seed(time.Now().UnixNano()+ int64(rand.Intn(100)))
+	for i := 0; i < length; i++ {
+		result = append(result, bytes[rand.Intn(len(bytes))])
+	}
+	return string(result)
+}
+
+func HMAC(message string, secret string) string {
+	key := []byte(secret)
+	h := hmac.New(sha256.New, key)
+	h.Write([]byte(message))
+	//	fmt.Println(h.Sum(nil))
+	//sha := hex.EncodeToString(h.Sum(nil))
+	//	fmt.Println(sha)
+	//return sha
+	return string(h.Sum(nil))
+}
+
 func init() {
 	base.RegisterDriver(&Pan123{})
 	pan123Client.SetRetryCount(3)

drivers/123/driver.go

@@ -1,15 +1,21 @@
 package _23
 
 import (
+	"encoding/hex"
+	"encoding/xml"
 	"fmt"
 	"github.com/Xhofe/alist/conf"
 	"github.com/Xhofe/alist/drivers/base"
 	"github.com/Xhofe/alist/model"
 	"github.com/Xhofe/alist/utils"
 	"github.com/gin-gonic/gin"
+	jsoniter "github.com/json-iterator/go"
 	log "github.com/sirupsen/logrus"
 	url "net/url"
 	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
 )
 
 type Pan123 struct{}
@@ -161,7 +167,7 @@ func (driver Pan123) Link(path string, account *model.Account) (*base.Link, erro
 	link := base.Link{}
 	if res.StatusCode() == 302 {
 		link.Url = res.Header().Get("location")
-	}else {
+	} else {
 		link.Url = resp.Data.DownloadUrl
 	}
 	return &link, nil
@@ -198,22 +204,145 @@ func (driver Pan123) Preview(path string, account *model.Account) (interface{},
 }
 
 func (driver Pan123) MakeDir(path string, account *model.Account) error {
-	return base.ErrNotImplement
+	dir, name := filepath.Split(path)
+	parentFile, err := driver.File(dir, account)
+	if err != nil {
+		return err
+	}
+	if !parentFile.IsDir() {
+		return base.ErrNotFolder
+	}
+	parentFileId, _ := strconv.Atoi(parentFile.Id)
+	data := base.Json{
+		"driveId":      0,
+		"etag":         "",
+		"fileName":     name,
+		"parentFileId": parentFileId,
+		"size":         0,
+		"type":         1,
+	}
+	_, err = driver.Post("https://www.123pan.com/api/file/upload_request", data, account)
+	if err == nil {
+		_ = base.DeleteCache(dir, account)
+	}
+	return err
 }
 
 func (driver Pan123) Move(src string, dst string, account *model.Account) error {
-	return base.ErrNotImplement
+	srcDir, _ := filepath.Split(src)
+	dstDir, dstName := filepath.Split(dst)
+	srcFile, err := driver.File(src, account)
+	if err != nil {
+		return err
+	}
+	fileId, _ := strconv.Atoi(srcFile.Id)
+	// rename
+	if srcDir == dstDir {
+		data := base.Json{
+			"driveId":  0,
+			"fileId":   fileId,
+			"fileName": dstName,
+		}
+		_, err = driver.Post("https://www.123pan.com/api/file/rename", data, account)
+	} else {
+		// move
+		dstDirFile, err := driver.File(dstDir, account)
+		if err != nil {
+			return err
+		}
+		parentFileId, _ := strconv.Atoi(dstDirFile.Id)
+		data := base.Json{
+			"fileId":       fileId,
+			"parentFileId": parentFileId,
+		}
+		_, err = driver.Post("https://www.123pan.com/api/file/mod_pid", data, account)
+	}
+	if err != nil {
+		_ = base.DeleteCache(srcDir, account)
+		_ = base.DeleteCache(dstDir, account)
+	}
+	return err
 }
 
 func (driver Pan123) Copy(src string, dst string, account *model.Account) error {
-	return base.ErrNotImplement
+	return base.ErrNotSupport
 }
 
 func (driver Pan123) Delete(path string, account *model.Account) error {
-	return base.ErrNotImplement
+	file, err := driver.GetFile(path, account)
+	if err != nil {
+		return err
+	}
+	data := base.Json{
+		"driveId":           0,
+		"operation":         true,
+		"fileTrashInfoList": file,
+	}
+	_, err = driver.Post("https://www.123pan.com/api/file/trash", data, account)
+	if err == nil {
+		_ = base.DeleteCache(utils.Dir(path), account)
+	}
+	return err
 }
 
+type UploadResp struct {
+	XMLName  xml.Name `xml:"InitiateMultipartUploadResult"`
+	Bucket   string   `xml:"Bucket"`
+	Key      string   `xml:"Key"`
+	UploadId string   `xml:"UploadId"`
+}
+
+// TODO unfinished
 func (driver Pan123) Upload(file *model.FileStream, account *model.Account) error {
+	parentFile, err := driver.File(file.ParentPath, account)
+	if err != nil {
+		return err
+	}
+	if !parentFile.IsDir() {
+		return base.ErrNotFolder
+	}
+	parentFileId, _ := strconv.Atoi(parentFile.Id)
+	data := base.Json{
+		"driveId":      0,
+		"duplicate":    true,
+		"etag":         RandStr(32), //maybe file's md5
+		"fileName":     file.GetFileName(),
+		"parentFileId": parentFileId,
+		"size":         file.GetSize(),
+		"type":         0,
+	}
+	res, err := driver.Post("https://www.123pan.com/api/file/upload_request", data, account)
+	if err != nil {
+		return err
+	}
+	baseUrl := fmt.Sprintf("https://file.123pan.com/%s/%s", jsoniter.Get(res, "data.Bucket").ToString(), jsoniter.Get(res, "data.Key").ToString())
+	var resp UploadResp
+	kSecret := jsoniter.Get(res, "data.SecretAccessKey").ToString()
+	nowTimeStr := time.Now().String()
+	Date := strings.ReplaceAll(strings.Split(nowTimeStr, "T")[0],"-","")
+
+	StringToSign := fmt.Sprintf("%s\n%s\n%s\n%s",
+		"AWS4-HMAC-SHA256",
+		nowTimeStr,
+		fmt.Sprintf("%s/us-east-1/s3/aws4_request", Date),
+		)
+
+	kDate := HMAC("AWS4"+kSecret, Date)
+	kRegion := HMAC(kDate, "us-east-1")
+	kService := HMAC(kRegion, "s3")
+	kSigning := HMAC(kService, "aws4_request")
+	_, err = pan123Client.R().SetResult(&resp).SetHeaders(map[string]string{
+		"Authorization": fmt.Sprintf("AWS4-HMAC-SHA256 Credential=%s/%s/us-east-1/s3/aws4_request, SignedHeaders=host;x-amz-content-sha256;x-amz-date;x-amz-security-token;x-amz-user-agent, Signature=%s",
+			jsoniter.Get(res, "data.AccessKeyId"),
+			Date,
+			hex.EncodeToString([]byte(HMAC(StringToSign, kSigning)))),
+		"X-Amz-Content-Sha256": "UNSIGNED-PAYLOAD",
+		"X-Amz-Date":           nowTimeStr,
+		"x-amz-security-token": jsoniter.Get(res, "data.SessionToken").ToString(),
+	}).Post(fmt.Sprintf("%s?uploads", baseUrl))
+	if err != nil {
+		return err
+	}
 	return base.ErrNotImplement
 }
 

drivers/189/189.go

@@ -1,20 +1,28 @@
 package _89
 
 import (
+	"crypto/aes"
+	"crypto/hmac"
+	"crypto/md5"
 	"crypto/rand"
 	"crypto/rsa"
+	"crypto/sha1"
 	"crypto/x509"
 	"encoding/base64"
+	"encoding/hex"
 	"encoding/json"
 	"encoding/pem"
+	"errors"
 	"fmt"
 	"github.com/Xhofe/alist/conf"
 	"github.com/Xhofe/alist/drivers/base"
 	"github.com/Xhofe/alist/model"
 	"github.com/Xhofe/alist/utils"
 	"github.com/go-resty/resty/v2"
+	jsoniter "github.com/json-iterator/go"
 	log "github.com/sirupsen/logrus"
 	mathRand "math/rand"
+	"net/url"
 	"path/filepath"
 	"regexp"
 	"strconv"
@@ -22,7 +30,6 @@ import (
 	"time"
 )
 
-
 var client189Map map[string]*resty.Client
 
 func (driver Cloud189) FormatFile(file *Cloud189File) *model.File {
@@ -90,6 +97,7 @@ func (driver Cloud189) Login(account *model.Account) error {
 		client = resty.New()
 		//client.SetCookieJar(cookieJar)
 		client.SetRetryCount(3)
+		client.SetHeader("Referer", "https://cloud.189.cn/")
 	}
 	url := "https://cloud.189.cn/api/portal/loginUrl.action?redirectURL=https%3A%2F%2Fcloud.189.cn%2Fmain.action"
 	b := ""
@@ -254,6 +262,102 @@ func (driver Cloud189) GetFiles(fileId string, account *model.Account) ([]Cloud1
 	return res, nil
 }
 
+func (driver Cloud189) Request(url string, method string, form map[string]string, headers map[string]string, account *model.Account) ([]byte, error) {
+	client, ok := client189Map[account.Name]
+	if !ok {
+		return nil, fmt.Errorf("can't find [%s] client", account.Name)
+	}
+	//var resp base.Json
+	var e Cloud189Error
+	req := client.R().SetError(&e).
+		SetHeader("Accept", "application/json;charset=UTF-8").
+		SetQueryParams(map[string]string{
+			"noCache": random(),
+		})
+	if form != nil {
+		req = req.SetFormData(form)
+	}
+	if headers != nil {
+		req = req.SetHeaders(headers)
+	}
+	var err error
+	var res *resty.Response
+	if strings.ToUpper(method) == "GET" {
+		res, err = req.Get(url)
+	} else {
+		res, err = req.Post(url)
+	}
+	if err != nil {
+		return nil, err
+	}
+	if e.ErrorCode != "" {
+		if e.ErrorCode == "InvalidSessionKey" {
+			err = driver.Login(account)
+			if err != nil {
+				return nil, err
+			}
+			return driver.Request(url, method, form, nil, account)
+		}
+	}
+	//log.Debug(res, jsoniter.Get(res.Body(),"res_code").ToInt())
+	if jsoniter.Get(res.Body(),"res_code").ToInt() != 0 {
+		err = errors.New(jsoniter.Get(res.Body(),"res_message").ToString())
+	}
+	return res.Body(), err
+}
+
+func (driver Cloud189) GetSessionKey(account *model.Account) (string, error) {
+	resp, err := driver.Request("https://cloud.189.cn/v2/getUserBriefInfo.action", "GET", nil, nil, account)
+	if err != nil {
+		return "", err
+	}
+	return jsoniter.Get(resp, "sessionKey").ToString(), nil
+}
+
+func (driver Cloud189) GetResKey(account *model.Account) (string, string, error) {
+	resp, err := driver.Request("https://cloud.189.cn/api/security/generateRsaKey.action", "GET", nil, nil, account)
+	if err != nil {
+		return "", "", err
+	}
+	return jsoniter.Get(resp, "pubKey").ToString(), jsoniter.Get(resp, "pkId").ToString(), nil
+}
+
+func (driver Cloud189) UploadRequest(url string, form map[string]string, account *model.Account) ([]byte, error) {
+	sessionKey, err := driver.GetSessionKey(account)
+	if err != nil {
+		return nil, err
+	}
+	pubKey, pkId, err := driver.GetResKey(account)
+	if err != nil {
+		return nil, err
+	}
+	xRId := "e007e99a-370c-4a14-a143-1b1541972fcf"
+	pkey := strings.ReplaceAll(xRId, "-", "")
+	params := aesEncrypt(qs(form), pkey[:16])
+	date := strconv.FormatInt(time.Now().Unix(), 10)
+	signature := hmacSha1(fmt.Sprintf("SessionKey=%s&Operate=GET&RequestURI=%s&Date=%s&params=%s", sessionKey, url, date, params), pkey)
+	encryptionText := RsaEncode([]byte(pkey), pubKey)
+	res, err := base.RestyClient.R().SetHeaders(map[string]string{
+		"signature":      signature,
+		"sessionKey":     sessionKey,
+		"encryptionText": encryptionText,
+		"pkId":           pkId,
+		"x-request-id":   xRId,
+		"x-request-date": date,
+		"origin":         "https://cloud.189.cn",
+		"referer":        "https://cloud.189.cn/",
+	}).SetQueryParam("params", params).Get("https://upload.cloud.189.cn" + url)
+	if err != nil {
+		return nil, err
+	}
+	log.Debug(res.String())
+	data := res.Body()
+	if jsoniter.Get(data, "code").ToString() != "SUCCESS" {
+		return nil, errors.New(jsoniter.Get(data, "msg").ToString())
+	}
+	return data, nil
+}
+
 func random() string {
 	return fmt.Sprintf("0.%17v", mathRand.New(mathRand.NewSource(time.Now().UnixNano())).Int63n(100000000000000000))
 }
@@ -312,6 +416,75 @@ func b64tohex(a string) string {
 	return d
 }
 
+func qs(form map[string]string) string {
+	strList := make([]string, 0)
+	for k, v := range form {
+		strList = append(strList, fmt.Sprintf("%s=%s", k, url.QueryEscape(v)))
+	}
+	return strings.Join(strList, "&")
+}
+
+func aesEncrypt(data, key string) string {
+	encrypted := AesEncryptECB([]byte(data), []byte(key))
+	//return string(encrypted)
+	return hex.EncodeToString(encrypted)
+}
+
+func hmacSha1(data string, secret string) string {
+	h := hmac.New(sha1.New, []byte(secret))
+	h.Write([]byte(data))
+	return hex.EncodeToString(h.Sum(nil))
+}
+
+func AesEncryptECB(origData []byte, key []byte) (encrypted []byte) {
+	cipher, _ := aes.NewCipher(generateKey(key))
+	length := (len(origData) + aes.BlockSize) / aes.BlockSize
+	plain := make([]byte, length*aes.BlockSize)
+	copy(plain, origData)
+	pad := byte(len(plain) - len(origData))
+	for i := len(origData); i < len(plain); i++ {
+		plain[i] = pad
+	}
+	encrypted = make([]byte, len(plain))
+	// 分组分块加密
+	for bs, be := 0, cipher.BlockSize(); bs <= len(origData); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
+		cipher.Encrypt(encrypted[bs:be], plain[bs:be])
+	}
+
+	return encrypted
+}
+func AesDecryptECB(encrypted []byte, key []byte) (decrypted []byte) {
+	cipher, _ := aes.NewCipher(generateKey(key))
+	decrypted = make([]byte, len(encrypted))
+	//
+	for bs, be := 0, cipher.BlockSize(); bs < len(encrypted); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
+		cipher.Decrypt(decrypted[bs:be], encrypted[bs:be])
+	}
+
+	trim := 0
+	if len(decrypted) > 0 {
+		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
+	}
+
+	return decrypted[:trim]
+}
+func generateKey(key []byte) (genKey []byte) {
+	genKey = make([]byte, 16)
+	copy(genKey, key)
+	for i := 16; i < len(key); {
+		for j := 0; j < 16 && i < len(key); j, i = j+1, i+1 {
+			genKey[j] ^= key[i]
+		}
+	}
+	return genKey
+}
+
+func getMd5(data []byte) []byte {
+	h := md5.New()
+	h.Write(data)
+	return h.Sum(nil)
+}
+
 func init() {
 	base.RegisterDriver(&Cloud189{})
 	client189Map = make(map[string]*resty.Client, 0)

drivers/189/driver.go

@@ -1,17 +1,28 @@
 package _89
 
 import (
+	"bytes"
+	"crypto/md5"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	"github.com/Xhofe/alist/conf"
 	"github.com/Xhofe/alist/drivers/base"
 	"github.com/Xhofe/alist/model"
 	"github.com/Xhofe/alist/utils"
 	"github.com/gin-gonic/gin"
+	jsoniter "github.com/json-iterator/go"
 	log "github.com/sirupsen/logrus"
+	"io"
+	"math"
+	"net/http"
 	"path/filepath"
+	"strconv"
+	"strings"
 )
 
-type Cloud189 struct {}
+type Cloud189 struct{}
 
 func (driver Cloud189) Config() base.DriverConfig {
 	return base.DriverConfig{
@@ -169,7 +180,7 @@ func (driver Cloud189) Link(path string, account *model.Account) (*base.Link, er
 	link := base.Link{}
 	if res.StatusCode() == 302 {
 		link.Url = res.Header().Get("location")
-	}else {
+	} else {
 		link.Url = resp.FileDownloadUrl
 	}
 	return &link, nil
@@ -205,25 +216,232 @@ func (driver Cloud189) Preview(path string, account *model.Account) (interface{}
 	return nil, base.ErrNotSupport
 }
 
-
 func (driver Cloud189) MakeDir(path string, account *model.Account) error {
-	return base.ErrNotImplement
+	dir, name := filepath.Split(path)
+	parent, err := driver.File(dir, account)
+	if err != nil {
+		return err
+	}
+	if !parent.IsDir() {
+		return base.ErrNotFolder
+	}
+	form := map[string]string{
+		"parentFolderId": parent.Id,
+		"folderName":     name,
+	}
+	_, err = driver.Request("https://cloud.189.cn/api/open/file/createFolder.action", "POST", form,nil, account)
+	if err == nil {
+		_ = base.DeleteCache(dir, account)
+	}
+	return err
 }
 
 func (driver Cloud189) Move(src string, dst string, account *model.Account) error {
-	return base.ErrNotImplement
+	srcDir, _ := filepath.Split(src)
+	dstDir, dstName := filepath.Split(dst)
+	srcFile, err := driver.File(src, account)
+	if err != nil {
+		return err
+	}
+	// rename
+	if srcDir == dstDir {
+		url := "https://cloud.189.cn/api/open/file/renameFile.action"
+		idKey := "fileId"
+		nameKey := "destFileName"
+		if srcFile.IsDir() {
+			url = "https://cloud.189.cn/api/open/file/renameFolder.action"
+			idKey = "folderId"
+			nameKey = "destFolderName"
+		}
+		form := map[string]string{
+			idKey:   srcFile.Id,
+			nameKey: dstName,
+		}
+		_, err = driver.Request(url, "POST", form,nil, account)
+	} else {
+		// move
+		dstDirFile, err := driver.File(dstDir, account)
+		if err != nil {
+			return err
+		}
+		isFolder := 0
+		if srcFile.IsDir() {
+			isFolder = 1
+		}
+		taskInfos := []base.Json{
+			{
+				"fileId":   srcFile.Id,
+				"fileName": dstName,
+				"isFolder": isFolder,
+			},
+		}
+		taskInfosBytes, err := json.Marshal(taskInfos)
+		if err != nil {
+			return err
+		}
+		form := map[string]string{
+			"type":           "MOVE",
+			"targetFolderId": dstDirFile.Id,
+			"taskInfos":      string(taskInfosBytes),
+		}
+		_, err = driver.Request("https://cloud.189.cn/api/open/batch/createBatchTask.action", "POST", form,nil, account)
+	}
+	if err == nil {
+		_ = base.DeleteCache(srcDir, account)
+		_ = base.DeleteCache(dstDir, account)
+	}
+	return err
 }
 
 func (driver Cloud189) Copy(src string, dst string, account *model.Account) error {
-	return base.ErrNotImplement
+	dstDir, dstName := filepath.Split(dst)
+	srcFile, err := driver.File(src, account)
+	if err != nil {
+		return err
+	}
+	dstDirFile, err := driver.File(dstDir, account)
+	if err != nil {
+		return err
+	}
+	isFolder := 0
+	if srcFile.IsDir() {
+		isFolder = 1
+	}
+	taskInfos := []base.Json{
+		{
+			"fileId":   srcFile.Id,
+			"fileName": dstName,
+			"isFolder": isFolder,
+		},
+	}
+	taskInfosBytes, err := json.Marshal(taskInfos)
+	if err != nil {
+		return err
+	}
+	form := map[string]string{
+		"type":           "COPY",
+		"targetFolderId": dstDirFile.Id,
+		"taskInfos":      string(taskInfosBytes),
+	}
+	_, err = driver.Request("https://cloud.189.cn/api/open/batch/createBatchTask.action", "POST", form,nil, account)
+	if err == nil {
+		_ = base.DeleteCache(dstDir, account)
+	}
+	return err
 }
 
 func (driver Cloud189) Delete(path string, account *model.Account) error {
-	return base.ErrNotImplement
+	path = utils.ParsePath(path)
+	file, err := driver.File(path, account)
+	if err != nil {
+		return err
+	}
+	isFolder := 0
+	if file.IsDir() {
+		isFolder = 1
+	}
+	taskInfos := []base.Json{
+		{
+			"fileId":   file.Id,
+			"fileName": file.Name,
+			"isFolder": isFolder,
+		},
+	}
+	taskInfosBytes, err := json.Marshal(taskInfos)
+	if err != nil {
+		return err
+	}
+	form := map[string]string{
+		"type":           "DELETE",
+		"targetFolderId": "",
+		"taskInfos":      string(taskInfosBytes),
+	}
+	_, err = driver.Request("https://cloud.189.cn/api/open/batch/createBatchTask.action", "POST", form,nil, account)
+	if err == nil {
+		_ = base.DeleteCache(utils.Dir(path), account)
+	}
+	return err
 }
 
+// Upload Error: decrypt encryptionText failed
 func (driver Cloud189) Upload(file *model.FileStream, account *model.Account) error {
-	return base.ErrNotImplement
+	const DEFAULT uint64 = 10485760
+	var count = int64(math.Ceil(float64(file.GetSize()) / float64(DEFAULT)))
+	var finish uint64 = 0
+	parentFile, err := driver.File(file.ParentPath, account)
+	if err != nil {
+		return err
+	}
+	if !parentFile.IsDir() {
+		return base.ErrNotFolder
+	}
+	res, err := driver.UploadRequest("/person/initMultiUpload", map[string]string{
+		"parentFolderId": parentFile.Id,
+		"fileName": file.Name,
+		"fileSize": strconv.FormatInt(int64(file.Size),10),
+		"sliceSize": strconv.FormatInt(int64(DEFAULT),10),
+		"lazyCheck": "1",
+	},account)
+	if err != nil {
+		return err
+	}
+	uploadFileId := jsoniter.Get(res, "data.uploadFileId").ToString()
+	var i int64
+	var byteSize uint64
+	md5s := make([]string, 0)
+	md5Sum := md5.New()
+	for i = 1; i <= count; i++ {
+		byteSize = file.GetSize() - finish
+		if DEFAULT < byteSize {
+			byteSize = DEFAULT
+		}
+		log.Debugf("%d,%d", byteSize, finish)
+		byteData := make([]byte, byteSize)
+		n, err := io.ReadFull(file, byteData)
+		log.Debug(err, n)
+		if err != nil {
+			return err
+		}
+		finish += uint64(n)
+		md5Bytes := getMd5(byteData)
+		md5Str := hex.EncodeToString(md5Bytes)
+		md5Base64 := base64.StdEncoding.EncodeToString(md5Bytes)
+		md5s = append(md5s, md5Str)
+		md5Sum.Write(byteData)
+		res, err = driver.UploadRequest("/person/getMultiUploadUrls", map[string]string{
+			"partInfo": fmt.Sprintf("%s-%s",strconv.FormatInt(i,10),md5Base64),
+			"uploadFileId": uploadFileId,
+		},account)
+		if err != nil {
+			return err
+		}
+		uploadData := jsoniter.Get(res,"uploadUrls.partNumber_"+strconv.FormatInt(i,10))
+		headers := strings.Split(uploadData.Get("requestHeader").ToString(),"&")
+		req, err := http.NewRequest("PUT", uploadData.Get("requestURL").ToString(), bytes.NewBuffer(byteData))
+		if err != nil {
+			return err
+		}
+		for _,header := range headers{
+			kv := strings.Split(header, "=")
+			req.Header.Set(kv[0],strings.Join(kv[1:],"="))
+		}
+		res, err := base.HttpClient.Do(req)
+		if err != nil {
+			return err
+		}
+		log.Debugf("%+v", res)
+	}
+	id := md5Sum.Sum(nil)
+	res,err = driver.UploadRequest("/person/commitMultiUploadFile", map[string]string{
+		"uploadFileId": uploadFileId,
+		"fileMd5": hex.EncodeToString(id),
+		"sliceMd5": utils.GetMD5Encode(strings.Join(md5s,"\n")),
+		"lazyCheck":"1",
+	},account)
+	if err == nil {
+		_ = base.DeleteCache(file.ParentPath, account)
+	}
+	return err
 }
 
 var _ base.Driver = (*Cloud189)(nil)

drivers/alidrive/driver.go

@@ -377,6 +377,9 @@ func (driver AliDrive) Upload(file *model.FileStream, account *model.Account) er
 	if err != nil {
 		return err
 	}
+	if !parentFile.IsDir() {
+		return base.ErrNotFolder
+	}
 	var resp UploadResp
 	var e AliRespError
 	partInfoList := make([]base.Json, 0)
@@ -471,6 +474,7 @@ func (driver AliDrive) Upload(file *model.FileStream, account *model.Account) er
 		return fmt.Errorf("%s", e.Message)
 	}
 	if resp2["file_id"] == resp.FileId {
+		_ = base.DeleteCache(file.ParentPath, account)
 		return nil
 	}
 	return fmt.Errorf("%+v", resp2)

drivers/alist/driver.go

@@ -91,7 +91,7 @@ func (driver Alist) File(path string, account *model.Account) (*model.File, erro
 
 func (driver Alist) Files(path string, account *model.Account) ([]model.File, error) {
 	//return nil, base.ErrNotImplement
-	_, files, err := driver.Path(utils.Dir(path), account)
+	_, files, err := driver.Path(path, account)
 	if err != nil {
 		return nil, err
 	}
@@ -115,6 +115,8 @@ func (driver Alist) Link(path string, account *model.Account) (*base.Link, error
 
 func (driver Alist) Path(path string, account *model.Account) (*model.File, []model.File, error) {
 	path = utils.ParsePath(path)
+	path = filepath.Join(account.RootFolder, path)
+	path = strings.ReplaceAll(path, "\\", "/")
 	cache, err := base.GetCache(path, account)
 	if err == nil {
 		files := cache.([]model.File)

drivers/all.go

@@ -5,8 +5,10 @@ import (
 	_ "github.com/Xhofe/alist/drivers/189"
 	_ "github.com/Xhofe/alist/drivers/alidrive"
 	_ "github.com/Xhofe/alist/drivers/alist"
+	_ "github.com/Xhofe/alist/drivers/ftp"
 	_ "github.com/Xhofe/alist/drivers/google"
 	_ "github.com/Xhofe/alist/drivers/lanzou"
 	_ "github.com/Xhofe/alist/drivers/native"
 	_ "github.com/Xhofe/alist/drivers/onedrive"
+	_ "github.com/Xhofe/alist/drivers/pikpak"
 )

drivers/base/cache.go

@@ -5,6 +5,7 @@ import (
 	"github.com/Xhofe/alist/conf"
 	"github.com/Xhofe/alist/model"
 	"github.com/Xhofe/alist/utils"
+	log "github.com/sirupsen/logrus"
 )
 
 func KeyCache(path string, account *model.Account) string {
@@ -21,5 +22,7 @@ func GetCache(path string, account *model.Account) (interface{}, error) {
 }
 
 func DeleteCache(path string, account *model.Account) error {
-	return conf.Cache.Delete(conf.Ctx, KeyCache(path, account))
+	err := conf.Cache.Delete(conf.Ctx, KeyCache(path, account))
+	log.Debugf("delete cache %s: %+v", path, err)
+	return err
 }

drivers/base/driver.go

@@ -84,8 +84,6 @@ func GetDrivers() map[string][]Item {
 				},
 			}, v.Items()...)
 		}
-		// 不支持给本地文件添加中转
-		if v.Config().Name != "Native" {
 		res[k] = append(res[k], Item{
 			Name:        "proxy_url",
 			Label:       "proxy_url",
@@ -94,7 +92,6 @@ func GetDrivers() map[string][]Item {
 			Description: "proxy url",
 		})
 	}
-	}
 	return res
 }
 
@@ -109,4 +106,5 @@ func init() {
 		}),
 	)
 	NoRedirectClient.SetHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36")
+	RestyClient.SetHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36")
 }

drivers/base/types.go

@@ -19,6 +19,14 @@ const (
 	TypeNumber = "number"
 )
 
+const (
+	Get = iota
+	Post
+	Put
+	Delete
+	Patch
+)
+
 type Json map[string]interface{}
 
 type TokenResp struct {
@@ -34,4 +42,5 @@ type Header struct{
 type Link struct {
 	Url string `json:"url"`
 	Headers []Header `json:"headers"`
+	Data []byte
 }

drivers/ftp/driver.go

@@ -0,0 +1,264 @@
+package ftp
+
+import (
+	"github.com/Xhofe/alist/conf"
+	"github.com/Xhofe/alist/drivers/base"
+	"github.com/Xhofe/alist/model"
+	"github.com/Xhofe/alist/utils"
+	"github.com/gin-gonic/gin"
+	"github.com/jlaffaye/ftp"
+	log "github.com/sirupsen/logrus"
+	"io/ioutil"
+	"path/filepath"
+)
+
+type FTP struct{}
+
+func (driver FTP) Config() base.DriverConfig {
+	return base.DriverConfig{
+		Name:      "FTP",
+		OnlyProxy: true,
+		NoLink:    true,
+	}
+}
+
+func (driver FTP) Items() []base.Item {
+	return []base.Item{
+		{
+			Name:     "site_url",
+			Label:    "ftp host url",
+			Type:     base.TypeString,
+			Required: true,
+		},
+		{
+			Name:     "username",
+			Label:    "username",
+			Type:     base.TypeString,
+			Required: true,
+		},
+		{
+			Name:     "password",
+			Label:    "password",
+			Type:     base.TypeString,
+			Required: true,
+		},
+		{
+			Name:     "root_folder",
+			Label:    "root folder path",
+			Type:     base.TypeString,
+			Required: false,
+		},
+		{
+			Name:     "order_by",
+			Label:    "order_by",
+			Type:     base.TypeSelect,
+			Values:   "name,size,updated_at",
+			Required: false,
+		},
+		{
+			Name:     "order_direction",
+			Label:    "order_direction",
+			Type:     base.TypeSelect,
+			Values:   "ASC,DESC",
+			Required: false,
+		},
+	}
+}
+
+func (driver FTP) Save(account *model.Account, old *model.Account) error {
+	if account.RootFolder == "" {
+		account.RootFolder = "/"
+	}
+	conn, err := driver.Login(account)
+	if err != nil {
+		account.Status = err.Error()
+	} else {
+		account.Status = "work"
+		_ = conn.Quit()
+	}
+	_ = model.SaveAccount(account)
+	return err
+}
+
+func (driver FTP) File(path string, account *model.Account) (*model.File, error) {
+	log.Debugf("file: %s", path)
+	path = utils.ParsePath(path)
+	if path == "/" {
+		return &model.File{
+			Id:        account.RootFolder,
+			Name:      account.Name,
+			Size:      0,
+			Type:      conf.FOLDER,
+			Driver:    driver.Config().Name,
+			UpdatedAt: account.UpdatedAt,
+		}, nil
+	}
+	dir, name := filepath.Split(path)
+	files, err := driver.Files(dir, account)
+	if err != nil {
+		return nil, err
+	}
+	for _, file := range files {
+		if file.Name == name {
+			return &file, nil
+		}
+	}
+	return nil, base.ErrPathNotFound
+}
+
+func (driver FTP) Files(path string, account *model.Account) ([]model.File, error) {
+	log.Debugf("files: %s", path)
+	path = utils.ParsePath(path)
+	cache, err := base.GetCache(path, account)
+	if err == nil {
+		files, _ := cache.([]model.File)
+		return files, nil
+	}
+	realPath := utils.Join(account.RootFolder, path)
+	conn, err := driver.Login(account)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = conn.Quit() }()
+	entries, err := conn.List(realPath)
+	if err != nil {
+		return nil, err
+	}
+	res := make([]model.File, 0)
+	for i, _ := range entries {
+		entry := entries[i]
+		f := model.File{
+			Name:      entry.Name,
+			Size:      int64(entry.Size),
+			UpdatedAt: &entry.Time,
+			Driver:    driver.Config().Name,
+		}
+		if entry.Type == ftp.EntryTypeFolder {
+			f.Type = conf.FOLDER
+		} else {
+			f.Type = utils.GetFileType(filepath.Ext(entry.Name))
+		}
+		res = append(res, f)
+	}
+	if len(res) > 0 {
+		_ = base.SetCache(path, res, account)
+	}
+	return res, nil
+}
+
+func (driver FTP) Link(path string, account *model.Account) (*base.Link, error) {
+	path = utils.ParsePath(path)
+	realPath := utils.Join(account.RootFolder, path)
+	conn, err := driver.Login(account)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = conn.Quit() }()
+	resp, err := conn.Retr(realPath)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = resp.Close() }()
+	data, err := ioutil.ReadAll(resp)
+	if err != nil {
+		return nil, err
+	}
+	return &base.Link{
+		Data: data,
+	}, nil
+}
+
+func (driver FTP) Path(path string, account *model.Account) (*model.File, []model.File, error) {
+	log.Debugf("ftp path: %s", path)
+	file, err := driver.File(path, account)
+	if err != nil {
+		return nil, nil, err
+	}
+	if !file.IsDir() {
+		//file.Url, _ = driver.Link(path, account)
+		return file, nil, nil
+	}
+	files, err := driver.Files(path, account)
+	if err != nil {
+		return nil, nil, err
+	}
+	model.SortFiles(files, account)
+	return nil, files, nil
+}
+
+func (driver FTP) Proxy(c *gin.Context, account *model.Account) {
+
+}
+
+func (driver FTP) Preview(path string, account *model.Account) (interface{}, error) {
+	return nil, base.ErrNotSupport
+}
+
+func (driver FTP) MakeDir(path string, account *model.Account) error {
+	path = utils.ParsePath(path)
+	realPath := utils.Join(account.RootFolder, path)
+	conn, err := driver.Login(account)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = conn.Quit() }()
+	err = conn.MakeDir(realPath)
+	if err == nil {
+		_ = base.DeleteCache(utils.Dir(path), account)
+	}
+	return err
+}
+
+func (driver FTP) Move(src string, dst string, account *model.Account) error {
+	//if utils.Dir(src) != utils.Dir(dst) {
+	//	return base.ErrNotSupport
+	//}
+	realSrc := utils.Join(account.RootFolder, src)
+	realDst := utils.Join(account.RootFolder, dst)
+	conn, err := driver.Login(account)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = conn.Quit() }()
+	err = conn.Rename(realSrc, realDst)
+	if err != nil {
+		_ = base.DeleteCache(utils.Dir(src), account)
+		_ = base.DeleteCache(utils.Dir(dst), account)
+	}
+	return err
+}
+
+func (driver FTP) Copy(src string, dst string, account *model.Account) error {
+	return base.ErrNotSupport
+}
+
+func (driver FTP) Delete(path string, account *model.Account) error {
+	path = utils.ParsePath(path)
+	realPath := utils.Join(account.RootFolder, path)
+	conn, err := driver.Login(account)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = conn.Quit() }()
+	err = conn.Delete(realPath)
+	if err == nil {
+		_ = base.DeleteCache(utils.Dir(path), account)
+	}
+	return err
+}
+
+func (driver FTP) Upload(file *model.FileStream, account *model.Account) error {
+	realPath := utils.Join(account.RootFolder, file.ParentPath, file.Name)
+	conn, err := driver.Login(account)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = conn.Quit() }()
+	err = conn.Stor(realPath, file)
+	if err == nil {
+		_ = base.DeleteCache(utils.Dir(file.ParentPath), account)
+	}
+	return err
+}
+
+var _ base.Driver = (*FTP)(nil)

drivers/ftp/ftp.go

@@ -0,0 +1,23 @@
+package ftp
+
+import (
+	"github.com/Xhofe/alist/drivers/base"
+	"github.com/Xhofe/alist/model"
+	"github.com/jlaffaye/ftp"
+)
+
+func (driver FTP) Login(account *model.Account) (*ftp.ServerConn, error) {
+	conn, err := ftp.Connect(account.SiteUrl)
+	if err != nil {
+		return nil, err
+	}
+	err = conn.Login(account.Username, account.Password)
+	if err != nil {
+		return nil, err
+	}
+	return conn, nil
+}
+
+func init() {
+	base.RegisterDriver(&FTP{})
+}

drivers/lanzou/driver.go

@@ -22,7 +22,7 @@ func (driver Lanzou) Config() base.DriverConfig {
 func (driver Lanzou) Items() []base.Item {
 	return []base.Item{
 		{
-			Name:     "onedrive_type",
+			Name:     "internal_type",
 			Label:    "lanzou type",
 			Type:     base.TypeSelect,
 			Required: true,
@@ -53,7 +53,7 @@ func (driver Lanzou) Items() []base.Item {
 }
 
 func (driver Lanzou) Save(account *model.Account, old *model.Account) error {
-	if account.OnedriveType == "cookie" {
+	if account.InternalType == "cookie" {
 		if account.RootFolder == "" {
 			account.RootFolder = "-1"
 		}
@@ -121,7 +121,7 @@ func (driver Lanzou) Link(path string, account *model.Account) (*base.Link, erro
 	}
 	log.Debugf("down file: %+v", file)
 	downId := file.Id
-	if account.OnedriveType == "cookie" {
+	if account.InternalType == "cookie" {
 		downId, err = driver.GetDownPageId(file.Id, account)
 		if err != nil {
 			return nil, err

drivers/lanzou/lanzou.go

@@ -53,7 +53,7 @@ type LanZouFilesResp struct {
 }
 
 func (driver *Lanzou) GetFiles(folderId string, account *model.Account) ([]LanZouFile, error) {
-	if account.OnedriveType == "cookie" {
+	if account.InternalType == "cookie" {
 		files := make([]LanZouFile, 0)
 		var resp LanZouFilesResp
 		// folders

drivers/onedrive/driver.go

@@ -33,7 +33,7 @@ func (driver Onedrive) Items() []base.Item {
 			Description: "",
 		},
 		{
-			Name:     "onedrive_type",
+			Name:     "internal_type",
 			Label:    "onedrive type",
 			Type:     base.TypeSelect,
 			Required: true,

drivers/onedrive/onedrive.go

@@ -1,6 +1,7 @@
 package onedrive
 
 import (
+	"errors"
 	"fmt"
 	"github.com/Xhofe/alist/conf"
 	"github.com/Xhofe/alist/drivers/base"
@@ -45,7 +46,7 @@ func (driver Onedrive) GetMetaUrl(account *model.Account, auth bool, path string
 	if auth {
 		return host.Oauth
 	}
-	switch account.OnedriveType {
+	switch account.InternalType {
 	case "onedrive":
 		{
 			if path == "/" || path == "\\" {
@@ -73,6 +74,14 @@ type OneTokenErr struct {
 }
 
 func (driver Onedrive) RefreshToken(account *model.Account) error {
+	err := driver.refreshToken(account)
+	if err != nil && err.Error() == "empty refresh_token" {
+		return driver.refreshToken(account)
+	}
+	return err
+}
+
+func (driver Onedrive) refreshToken(account *model.Account) error {
 	url := driver.GetMetaUrl(account, true, "") + "/common/oauth2/v2.0/token"
 	var resp base.TokenResp
 	var e OneTokenErr
@@ -93,6 +102,10 @@ func (driver Onedrive) RefreshToken(account *model.Account) error {
 	} else {
 		account.Status = "work"
 	}
+	if resp.RefreshToken == "" {
+		account.Status = "empty refresh_token"
+		return errors.New("empty refresh_token")
+	}
 	account.RefreshToken, account.AccessToken = resp.RefreshToken, resp.AccessToken
 	return nil
 }

drivers/pikpak/driver.go

@@ -0,0 +1,240 @@
+package pikpak
+
+import (
+	"fmt"
+	"github.com/Xhofe/alist/conf"
+	"github.com/Xhofe/alist/drivers/base"
+	"github.com/Xhofe/alist/model"
+	"github.com/Xhofe/alist/utils"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"path/filepath"
+)
+
+type PikPak struct{}
+
+func (driver PikPak) Config() base.DriverConfig {
+	return base.DriverConfig{
+		Name: "PikPak",
+	}
+}
+
+func (driver PikPak) Items() []base.Item {
+	return []base.Item{
+		{
+			Name:     "username",
+			Label:    "username",
+			Type:     base.TypeString,
+			Required: true,
+		},
+		{
+			Name:     "password",
+			Label:    "password",
+			Type:     base.TypeString,
+			Required: true,
+		},
+		{
+			Name:     "root_folder",
+			Label:    "root folder id",
+			Type:     base.TypeString,
+			Required: false,
+		},
+	}
+}
+
+func (driver PikPak) Save(account *model.Account, old *model.Account) error {
+	err := driver.Login(account)
+	_ = model.SaveAccount(account)
+	return err
+}
+
+func (driver PikPak) File(path string, account *model.Account) (*model.File, error) {
+	path = utils.ParsePath(path)
+	if path == "/" {
+		return &model.File{
+			Id:        account.RootFolder,
+			Name:      account.Name,
+			Size:      0,
+			Type:      conf.FOLDER,
+			Driver:    driver.Config().Name,
+			UpdatedAt: account.UpdatedAt,
+		}, nil
+	}
+	dir, name := filepath.Split(path)
+	files, err := driver.Files(dir, account)
+	if err != nil {
+		return nil, err
+	}
+	for _, file := range files {
+		if file.Name == name {
+			return &file, nil
+		}
+	}
+	return nil, base.ErrPathNotFound
+}
+
+func (driver PikPak) Files(path string, account *model.Account) ([]model.File, error) {
+	path = utils.ParsePath(path)
+	var files []model.File
+	cache, err := base.GetCache(path, account)
+	if err == nil {
+		files, _ = cache.([]model.File)
+	} else {
+		file, err := driver.File(path, account)
+		if err != nil {
+			return nil, err
+		}
+		rawFiles, err := driver.GetFiles(file.Id, account)
+		if err != nil {
+			return nil, err
+		}
+		files = make([]model.File, 0)
+		for _, file := range rawFiles {
+			files = append(files, *driver.FormatFile(&file))
+		}
+		if len(files) > 0 {
+			_ = base.SetCache(path, files, account)
+		}
+	}
+	return files, nil
+}
+
+func (driver PikPak) Link(path string, account *model.Account) (*base.Link, error) {
+	file, err := driver.File(path, account)
+	if err != nil {
+		return nil, err
+	}
+	var resp File
+	_, err = driver.Request(fmt.Sprintf("https://api-drive.mypikpak.com/drive/v1/files/%s?_magic=2021&thumbnail_size=SIZE_LARGE", file.Id),
+		base.Get, nil, nil, &resp, account)
+	if err != nil {
+		return nil, err
+	}
+	return &base.Link{
+		Url: resp.WebContentLink,
+	}, nil
+}
+
+func (driver PikPak) Path(path string, account *model.Account) (*model.File, []model.File, error) {
+	path = utils.ParsePath(path)
+	log.Debugf("pikpak path: %s", path)
+	file, err := driver.File(path, account)
+	if err != nil {
+		return nil, nil, err
+	}
+	if !file.IsDir() {
+		link, err := driver.Link(path, account)
+		if err != nil {
+			return nil, nil, err
+		}
+		file.Url = link.Url
+		return file, nil, nil
+	}
+	files, err := driver.Files(path, account)
+	if err != nil {
+		return nil, nil, err
+	}
+	return nil, files, nil
+}
+
+func (driver PikPak) Proxy(c *gin.Context, account *model.Account) {
+
+}
+
+func (driver PikPak) Preview(path string, account *model.Account) (interface{}, error) {
+	return nil, base.ErrNotSupport
+}
+
+func (driver PikPak) MakeDir(path string, account *model.Account) error {
+	path = utils.ParsePath(path)
+	dir, name := filepath.Split(path)
+	parentFile, err := driver.File(dir, account)
+	if err != nil {
+		return err
+	}
+	if !parentFile.IsDir() {
+		return base.ErrNotFolder
+	}
+	_, err = driver.Request("https://api-drive.mypikpak.com/drive/v1/files", base.Post, nil, &base.Json{
+		"kind":      "drive#folder",
+		"parent_id": parentFile.Id,
+		"name":      name,
+	}, nil, account)
+	if err == nil {
+		_ = base.DeleteCache(dir, account)
+	}
+	return err
+}
+
+func (driver PikPak) Move(src string, dst string, account *model.Account) error {
+	srcDir, _ := filepath.Split(src)
+	dstDir, dstName := filepath.Split(dst)
+	srcFile, err := driver.File(src, account)
+	if err != nil {
+		return err
+	}
+	// rename
+	if srcDir == dstDir {
+		_, err = driver.Request("https://api-drive.mypikpak.com/drive/v1/files/"+srcFile.Id, base.Patch, nil, &base.Json{
+			"name": dstName,
+		}, nil, account)
+	} else {
+		// move
+		dstDirFile, err := driver.File(dstDir, account)
+		if err != nil {
+			return err
+		}
+		_, err = driver.Request("https://api-drive.mypikpak.com/drive/v1/files:batchMove", base.Post, nil, &base.Json{
+			"ids": []string{srcFile.Id},
+			"to": base.Json{
+				"parent_id": dstDirFile.Id,
+			},
+		}, nil, account)
+	}
+	if err == nil {
+		_ = base.DeleteCache(srcDir, account)
+		_ = base.DeleteCache(dstDir, account)
+	}
+	return err
+}
+
+func (driver PikPak) Copy(src string, dst string, account *model.Account) error {
+	srcFile, err := driver.File(src, account)
+	if err != nil {
+		return err
+	}
+	dstDirFile, err := driver.File(utils.Dir(dst), account)
+	if err != nil {
+		return err
+	}
+	_, err = driver.Request("https://api-drive.mypikpak.com/drive/v1/files:batchCopy", base.Post, nil, &base.Json{
+		"ids": []string{srcFile.Id},
+		"to": base.Json{
+			"parent_id": dstDirFile.Id,
+		},
+	}, nil, account)
+	if err == nil {
+		_ = base.DeleteCache(utils.Dir(dst), account)
+	}
+	return err
+}
+
+func (driver PikPak) Delete(path string, account *model.Account) error {
+	file, err := driver.File(path, account)
+	if err != nil {
+		return err
+	}
+	_, err = driver.Request("https://api-drive.mypikpak.com/drive/v1/files:batchTrash", base.Post, nil, &base.Json{
+		"ids": []string{file.Id},
+	}, nil, account)
+	if err == nil {
+		_ = base.DeleteCache(utils.Dir(path), account)
+	}
+	return err
+}
+
+func (driver PikPak) Upload(file *model.FileStream, account *model.Account) error {
+	return base.ErrNotImplement
+}
+
+var _ base.Driver = (*PikPak)(nil)

drivers/pikpak/pikpak.go

@@ -0,0 +1,178 @@
+package pikpak
+
+import (
+	"errors"
+	"github.com/Xhofe/alist/conf"
+	"github.com/Xhofe/alist/drivers/base"
+	"github.com/Xhofe/alist/model"
+	"github.com/Xhofe/alist/utils"
+	"github.com/go-resty/resty/v2"
+	jsoniter "github.com/json-iterator/go"
+	log "github.com/sirupsen/logrus"
+	"path/filepath"
+	"strconv"
+	"time"
+)
+
+type RespErr struct {
+	ErrorCode int    `json:"error_code"`
+	Error     string `json:"error"`
+}
+
+func (driver PikPak) Login(account *model.Account) error {
+	var e RespErr
+	res, err := base.RestyClient.R().SetError(&e).SetBody(base.Json{
+		"captcha_token": "",
+		"client_id":     "YNxT9w7GMdWvEOKa",
+		"client_secret": "dbw2OtmVEeuUvIptb1Coyg",
+		"username":      account.Username,
+		"password":      account.Password,
+	}).Post("https://user.mypikpak.com/v1/auth/signin")
+	if err != nil {
+		account.Status = err.Error()
+		return err
+	}
+	if e.ErrorCode != 0 {
+		account.Status = e.Error
+		return errors.New(e.Error)
+	}
+	data := res.Body()
+	account.Status = "work"
+	account.RefreshToken = jsoniter.Get(data, "refresh_token").ToString()
+	account.AccessToken = jsoniter.Get(data, "access_token").ToString()
+	return nil
+}
+
+func (driver PikPak) RefreshToken(account *model.Account) error {
+	var e RespErr
+	res, err := base.RestyClient.R().SetError(&e).SetBody(base.Json{
+		"client_id":     "YNxT9w7GMdWvEOKa",
+		"client_secret": "dbw2OtmVEeuUvIptb1Coyg",
+		"grant_type":    "refresh_token",
+		"refresh_token": account.RefreshToken,
+	}).Post("https://user.mypikpak.com/v1/auth/token")
+	if err != nil {
+		account.Status = err.Error()
+		return err
+	}
+	if e.ErrorCode != 0 {
+		if e.ErrorCode == 4126 {
+			// refresh_token 失效，重新登陆
+			return driver.Login(account)
+		}
+	}
+	data := res.Body()
+	account.Status = "work"
+	account.RefreshToken = jsoniter.Get(data, "refresh_token").ToString()
+	account.AccessToken = jsoniter.Get(data, "access_token").ToString()
+	return nil
+}
+
+func (driver PikPak) Request(url string, method int, query map[string]string, data *base.Json, resp interface{}, account *model.Account) ([]byte, error) {
+	req := base.RestyClient.R()
+	req.SetHeader("Authorization", "Bearer "+account.AccessToken)
+	if query != nil {
+		req.SetQueryParams(query)
+	}
+	if data != nil {
+		req.SetBody(data)
+	}
+	if resp != nil {
+		req.SetResult(resp)
+	}
+	var e RespErr
+	req.SetError(&e)
+	var res *resty.Response
+	var err error
+	switch method {
+	case base.Get:
+		res, err = req.Get(url)
+	case base.Post:
+		res, err = req.Post(url)
+	case base.Patch:
+		res, err = req.Patch(url)
+	default:
+		return nil, base.ErrNotSupport
+	}
+	if err != nil {
+		return nil, err
+	}
+	if e.ErrorCode != 0 {
+		if e.ErrorCode == 16 {
+			// login / refresh token
+			err = driver.RefreshToken(account)
+			if err != nil {
+				return nil, err
+			}
+			_ = model.SaveAccount(account)
+			return driver.Request(url, method, query, data, resp, account)
+		} else {
+			return nil, errors.New(e.Error)
+		}
+	}
+	return res.Body(), nil
+}
+
+type File struct {
+	Id             string     `json:"id"`
+	Kind           string     `json:"kind"`
+	Name           string     `json:"name"`
+	ModifiedTime   *time.Time `json:"modified_time"`
+	Size           string     `json:"size"`
+	ThumbnailLink  string     `json:"thumbnail_link"`
+	WebContentLink string     `json:"web_content_link"`
+}
+
+func (driver PikPak) FormatFile(file *File) *model.File {
+	size, _ := strconv.ParseInt(file.Size, 10, 64)
+	f := &model.File{
+		Id:        file.Id,
+		Name:      file.Name,
+		Size:      size,
+		Driver:    driver.Config().Name,
+		UpdatedAt: file.ModifiedTime,
+		Thumbnail: file.ThumbnailLink,
+	}
+	if file.Kind == "drive#folder" {
+		f.Type = conf.FOLDER
+	} else {
+		f.Type = utils.GetFileType(filepath.Ext(file.Name))
+	}
+	return f
+}
+
+type Files struct {
+	Files         []File `json:"files"`
+	NextPageToken string `json:"next_page_token"`
+}
+
+func (driver PikPak) GetFiles(id string, account *model.Account) ([]File, error) {
+	res := make([]File, 0)
+	pageToken := "first"
+	for pageToken != "" {
+		if pageToken == "first" {
+			pageToken = ""
+		}
+		query := map[string]string{
+			"parent_id":      id,
+			"thumbnail_size": "SIZE_LARGE",
+			"with_audit":     "true",
+			"limit":          "100",
+			"filters":        `{"phase":{"eq":"PHASE_TYPE_COMPLETE"},"trashed":{"eq":false}}`,
+			"page_token":     pageToken,
+		}
+		var resp Files
+		_, err := driver.Request("https://api-drive.mypikpak.com/drive/v1/files", base.Get, query, nil, &resp, account)
+		if err != nil {
+			return nil, err
+		}
+		log.Debugf("%+v", resp)
+		pageToken = resp.NextPageToken
+		res = append(res, resp.Files...)
+	}
+	return res, nil
+}
+
+func init() {
+	base.RegisterDriver(&PikPak{})
+}

go.mod

@@ -40,6 +40,7 @@ require (
 	github.com/jackc/pgx/v4 v4.13.0 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.2 // indirect
+	github.com/jlaffaye/ftp v0.0.0-20211117213618-11820403398b // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/leodido/go-urn v1.2.1 // indirect
 	github.com/mattn/go-isatty v0.0.14 // indirect

go.sum

@@ -266,6 +266,8 @@ github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.2 h1:eVKgfIdy9b6zbWBMgFpfDPoAMifwSZagU9HmEU6zgiI=
 github.com/jinzhu/now v1.1.2/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/jlaffaye/ftp v0.0.0-20211117213618-11820403398b h1:Ur6QAxsHCK99Quj9PaWafoV4unb0DO/HWiKExD+TN5g=
+github.com/jlaffaye/ftp v0.0.0-20211117213618-11820403398b/go.mod h1:2lmrmq866uF2tnje75wQHzmPXhmSWUt7Gyx2vgK1RCU=
 github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=

model/account.go

@@ -30,7 +30,7 @@ type Account struct {
 	RedirectUri    string     `json:"redirect_uri"`
 	SiteUrl        string     `json:"site_url"`
 	SiteId         string     `json:"site_id"`
-	OnedriveType   string     `json:"onedrive_type"`
+	InternalType   string     `json:"internal_type"`
 	WebdavProxy    bool       `json:"webdav_proxy"`
 	Proxy          bool       `json:"proxy"`       // 是否中转
 	//AllowProxy     bool       `json:"allow_proxy"` // 是否允许中转下载

server/controllers/down.go

@@ -56,8 +56,8 @@ func Proxy(c *gin.Context) {
 		common.ErrorResp(c, fmt.Errorf("[%s] not allowed proxy", account.Name), 403)
 		return
 	}
-	// 中转时有中转机器使用中转机器
+	// 中转时有中转机器使用中转机器，若携带标志位则表明不能再走中转机器了
-	if account.ProxyUrl != "" {
+	if account.ProxyUrl != "" && c.Param("d") != "1" {
 		name := utils.Base(rawPath)
 		link := fmt.Sprintf("%s%s?sign=%s", account.ProxyUrl, rawPath, utils.SignWithToken(name, conf.Token))
 		c.Redirect(302, link)
@@ -68,6 +68,10 @@ func Proxy(c *gin.Context) {
 		common.ErrorResp(c, err, 500)
 		return
 	}
+	// 本机读取数据
+	if account.Type == "FTP" {
+		c.Data(http.StatusOK, "application/octet-stream", link.Data)
+	}
 	// 本机文件直接返回文件
 	if account.Type == "Native" {
 		// 对于名称为index.html的文件需要特殊处理

server/controllers/path.go

@@ -88,20 +88,20 @@ func Link(c *gin.Context) {
 		common.ErrorResp(c, err, 500)
 		return
 	}
+	if driver.Config().NoLink {
+		common.SuccessResp(c, base.Link{
+			Url: fmt.Sprintf("//%s/d%s?d=1&sign=%s", c.Request.Host, req.Path, utils.SignWithToken(utils.Base(rawPath), conf.Token)),
+		})
+		return
+	}
 	link, err := driver.Link(path, account)
 	if err != nil {
 		common.ErrorResp(c, err, 500)
 		return
 	}
-	if driver.Config().NoLink {
-		common.SuccessResp(c, base.Link{
-			Url: fmt.Sprintf("//%s/d%s?sign=%s", c.Request.Host, req.Path, utils.SignWithToken(utils.Base(rawPath), conf.Token)),
-		})
-		return
-	} else {
 	common.SuccessResp(c, link)
 	return
-	}
+
 }
 
 func Preview(c *gin.Context) {

server/webdav/file.go

@@ -203,6 +203,7 @@ func slashClean(name string) string {
 func moveFiles(ctx context.Context, fs *FileSystem, src string, dst string, overwrite bool) (status int, err error) {
 	src = utils.ParsePath(src)
 	dst = utils.ParsePath(dst)
+	log.Debugf("move %s -> %s", src, dst)
 	if src == dst {
 		return http.StatusMethodNotAllowed, errDestinationEqualsSource
 	}
@@ -219,6 +220,7 @@ func moveFiles(ctx context.Context, fs *FileSystem, src string, dst string, over
 	}
 	err = driver.Move(srcPath,dstPath,srcAccount)
 	if err != nil {
+		log.Debug(err)
 		return http.StatusInternalServerError, err
 	}
 	return http.StatusNoContent, nil
@@ -230,6 +232,7 @@ func moveFiles(ctx context.Context, fs *FileSystem, src string, dst string, over
 func copyFiles(ctx context.Context, fs *FileSystem, src string, dst string, overwrite bool, depth int, recursion int) (status int, err error) {
 	src = utils.ParsePath(src)
 	dst = utils.ParsePath(dst)
+	log.Debugf("move %s -> %s", src, dst)
 	if src == dst {
 		return http.StatusMethodNotAllowed, errDestinationEqualsSource
 	}

server/webdav/webdav.go

@@ -46,6 +46,7 @@ func (h *Handler) stripPrefix(p string) (string, int, error) {
 func isPathExist(ctx context.Context, fs *FileSystem, path string) (bool, FileInfo) {
 	file, err := fs.File(path)
 	if err != nil {
+		log.Debug(err)
 		return false, nil
 	}
 	return true, file

utils/file.go

@@ -114,3 +114,11 @@ func Base(path string) string {
 	}
 	return path[idx+1:]
 }
+
+func Join(elem ...string) string {
+	res := filepath.Join(elem...)
+	if res == "\\" {
+		res = "/"
+	}
+	return res
+}