🎇 resolved #160

.github/workflows/docker.yml

@@ -45,4 +45,4 @@ jobs:
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
-          platforms: linux/amd64,linux/arm64,linux/arm/v7,linux/386,linux/arm/v6,linux/ppc64le,linux/s390x
+          platforms: linux/amd64,linux/arm64,linux/arm/v7,linux/386,linux/arm/v6,linux/s390x

README.md

@@ -32,6 +32,9 @@
 - 本地存储
 - 阿里云盘
 - Onedrive/世纪互联
+- 天翼云盘
+- GoogleDrive
+- 123pan
 - ...
 
 ### 如何使用

alist.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"github.com/Xhofe/alist/bootstrap"
 	"github.com/Xhofe/alist/conf"
+	"github.com/Xhofe/alist/model"
 	"github.com/Xhofe/alist/server"
 	"github.com/gin-gonic/gin"
 	log "github.com/sirupsen/logrus"
@@ -14,15 +15,28 @@ func init() {
 	flag.StringVar(&conf.ConfigFile, "conf", "data/config.json", "config file")
 	flag.BoolVar(&conf.Debug, "debug", false, "start with debug mode")
 	flag.BoolVar(&conf.Version, "version", false, "print version info")
+	flag.BoolVar(&conf.Password, "password", false, "print current password")
 	flag.Parse()
 }
 
-func Init() {
+func Init() bool {
 	bootstrap.InitLog()
 	bootstrap.InitConf()
 	bootstrap.InitCron()
 	bootstrap.InitModel()
+	if conf.Password {
+		pass, err := model.GetSettingByKey("password")
+		if err != nil {
+			log.Errorf(err.Error())
+			return false
+		}
+		log.Infof("current password: %s", pass.Value)
+		return false
+	}
+	bootstrap.InitSettings()
+	bootstrap.InitAccounts()
 	bootstrap.InitCache()
+	return true
 }
 
 func main() {
@@ -30,7 +44,9 @@ func main() {
 		fmt.Printf("Built At: %s\nGo Version: %s\nAuthor: %s\nCommit ID: %s\nVersion: %s\n", conf.BuiltAt, conf.GoVersion, conf.GitAuthor, conf.GitCommit, conf.GitTag)
 		return
 	}
-	Init()
+	if !Init() {
+		return
+	}
 	if !conf.Debug {
 		gin.SetMode(gin.ReleaseMode)
 	}

bootstrap/account.go

@@ -0,0 +1,30 @@
+package bootstrap
+
+import (
+	"github.com/Xhofe/alist/conf"
+	"github.com/Xhofe/alist/drivers"
+	"github.com/Xhofe/alist/model"
+	log "github.com/sirupsen/logrus"
+)
+
+func InitAccounts() {
+	log.Infof("init accounts...")
+	var accounts []model.Account
+	if err := conf.DB.Find(&accounts).Error; err != nil {
+		log.Fatalf("failed sync init accounts")
+	}
+	for i, account := range accounts {
+		model.RegisterAccount(account)
+		driver, ok := drivers.GetDriver(account.Type)
+		if !ok {
+			log.Errorf("no [%s] driver", driver)
+		} else {
+			err := driver.Save(&accounts[i], nil)
+			if err != nil {
+				log.Errorf("init account [%s] error:[%s]", account.Name, err.Error())
+			} else {
+				log.Infof("success init account: %s, type: %s", account.Name, account.Type)
+			}
+		}
+	}
+}

bootstrap/model.go

@@ -3,7 +3,6 @@ package bootstrap
 import (
 	"fmt"
 	"github.com/Xhofe/alist/conf"
-	"github.com/Xhofe/alist/drivers"
 	"github.com/Xhofe/alist/model"
 	log "github.com/sirupsen/logrus"
 	"gorm.io/driver/mysql"
@@ -77,156 +76,5 @@ func InitModel() {
 	if err != nil {
 		log.Fatalf("failed to auto migrate")
 	}
-
-	// TODO init filetype
-	initAccounts()
-	initSettings()
 }
 
-func initAccounts() {
-	log.Infof("init accounts...")
-	var accounts []model.Account
-	if err := conf.DB.Find(&accounts).Error; err != nil {
-		log.Fatalf("failed sync init accounts")
-	}
-	for _, account := range accounts {
-		model.RegisterAccount(account)
-		driver, ok := drivers.GetDriver(account.Type)
-		if !ok {
-			log.Errorf("no [%s] driver", driver)
-		} else {
-			err := driver.Save(&account, nil)
-			if err != nil {
-				log.Errorf("init account [%s] error:[%s]", account.Name, err.Error())
-			}
-		}
-	}
-}
-
-func initSettings() {
-	log.Infof("init settings...")
-	version := model.SettingItem{
-		Key:         "version",
-		Value:       conf.GitTag,
-		Description: "version",
-		Type:        "string",
-		Group:       model.CONST,
-	}
-
-	_ = model.SaveSetting(version)
-
-	settings := []model.SettingItem{
-		{
-			Key:         "title",
-			Value:       "Alist",
-			Description: "title",
-			Type:        "string",
-			Group:       model.PUBLIC,
-		},
-		{
-			Key:         "password",
-			Value:       "alist",
-			Description: "password",
-			Type:        "string",
-			Group:       model.PRIVATE,
-		},
-		{
-			Key:         "logo",
-			Value:       "https://store.heytapimage.com/cdo-portal/feedback/202110/30/d43c41c5d257c9bc36366e310374fb19.png",
-			Description: "logo",
-			Type:        "string",
-			Group:       model.PUBLIC,
-		},
-		{
-			Key:         "favicon",
-			Value:       "https://store.heytapimage.com/cdo-portal/feedback/202110/30/d43c41c5d257c9bc36366e310374fb19.png",
-			Description: "favicon",
-			Type:        "string",
-			Group:       model.PUBLIC,
-		},
-		{
-			Key:         "icon color",
-			Value:       "teal.300",
-			Description: "icon's color",
-			Type:        "string",
-			Group:       model.PUBLIC,
-		},
-		{
-			Key:         "text types",
-			Value:       "txt,htm,html,xml,java,properties,sql,js,md,json,conf,ini,vue,php,py,bat,gitignore,yml,go,sh,c,cpp,h,hpp",
-			Type:        "string",
-			Description: "text type extensions",
-		},
-		{
-			Key:         "hide readme file",
-			Value:       "true",
-			Type:        "bool",
-			Description: "hide readme file? ",
-		},
-		{
-			Key:         "music cover",
-			Value:       "https://store.heytapimage.com/cdo-portal/feedback/202110/30/d43c41c5d257c9bc36366e310374fb19.png",
-			Description: "music cover image",
-			Type:        "string",
-			Group:       model.PUBLIC,
-		},
-		{
-			Key:         "site beian",
-			Description: "chinese beian info",
-			Type:        "string",
-			Group:       model.PUBLIC,
-		},
-		{
-			Key:         "home readme url",
-			Description: "when have multiple, the readme file to show",
-			Type:        "string",
-			Group:       model.PUBLIC,
-		},
-		{
-			Key:         "markdown theme",
-			Value:       "vuepress",
-			Description: "default | github | vuepress",
-			Group:       model.PUBLIC,
-			Type:        "select",
-			Values:      "default,github,vuepress",
-		},
-		{
-			Key:   "autoplay video",
-			Value: "false",
-			Type:  "bool",
-		},
-		{
-			Key:   "autoplay audio",
-			Value: "false",
-			Type:  "bool",
-		},
-		{
-			Key:         "check parent folder",
-			Value:       "false",
-			Type:        "bool",
-			Description: "check parent folder password",
-		},
-		{
-			Key: "customize style",
-			Value: "",
-			Type: "text",
-			Description: "customize style, don't need add <style></style>",
-		},
-		{
-			Key: "customize script",
-			Value: "",
-			Type: "text",
-			Description: "customize script, don't need add <script></script>",
-		},
-	}
-	for _, v := range settings {
-		_, err := model.GetSettingByKey(v.Key)
-		if err == gorm.ErrRecordNotFound {
-			err = model.SaveSetting(v)
-			if err != nil {
-				log.Fatalf("failed write setting: %s", err.Error())
-			}
-		}
-	}
-	model.LoadSettings()
-}

bootstrap/setting.go

@@ -0,0 +1,155 @@
+package bootstrap
+
+import (
+	"github.com/Xhofe/alist/conf"
+	"github.com/Xhofe/alist/model"
+	log "github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+)
+
+func InitSettings() {
+	log.Infof("init settings...")
+	version := model.SettingItem{
+		Key:         "version",
+		Value:       conf.GitTag,
+		Description: "version",
+		Type:        "string",
+		Group:       model.CONST,
+	}
+
+	_ = model.SaveSetting(version)
+
+	settings := []model.SettingItem{
+		{
+			Key:         "title",
+			Value:       "Alist",
+			Description: "title",
+			Type:        "string",
+			Group:       model.PUBLIC,
+		},
+		{
+			Key:         "password",
+			Value:       "alist",
+			Description: "password",
+			Type:        "string",
+			Group:       model.PRIVATE,
+		},
+		{
+			Key:         "logo",
+			Value:       "https://store.heytapimage.com/cdo-portal/feedback/202110/30/d43c41c5d257c9bc36366e310374fb19.png",
+			Description: "logo",
+			Type:        "string",
+			Group:       model.PUBLIC,
+		},
+		{
+			Key:         "favicon",
+			Value:       "https://store.heytapimage.com/cdo-portal/feedback/202110/30/d43c41c5d257c9bc36366e310374fb19.png",
+			Description: "favicon",
+			Type:        "string",
+			Group:       model.PUBLIC,
+		},
+		{
+			Key:         "icon color",
+			Value:       "teal.300",
+			Description: "icon's color",
+			Type:        "string",
+			Group:       model.PUBLIC,
+		},
+		{
+			Key:         "text types",
+			Value:       "txt,htm,html,xml,java,properties,sql,js,md,json,conf,ini,vue,php,py,bat,gitignore,yml,go,sh,c,cpp,h,hpp,tsx",
+			Type:        "string",
+			Description: "text type extensions",
+		},
+		{
+			Key:         "hide readme file",
+			Value:       "true",
+			Type:        "bool",
+			Description: "hide readme file? ",
+		},
+		{
+			Key:         "music cover",
+			Value:       "https://store.heytapimage.com/cdo-portal/feedback/202110/30/d43c41c5d257c9bc36366e310374fb19.png",
+			Description: "music cover image",
+			Type:        "string",
+			Group:       model.PUBLIC,
+		},
+		{
+			Key:         "site beian",
+			Description: "chinese beian info",
+			Type:        "string",
+			Group:       model.PUBLIC,
+		},
+		{
+			Key:         "home readme url",
+			Description: "when have multiple, the readme file to show",
+			Type:        "string",
+			Group:       model.PUBLIC,
+		},
+		{
+			Key:         "markdown theme",
+			Value:       "vuepress",
+			Description: "default | github | vuepress",
+			Group:       model.PUBLIC,
+			Type:        "select",
+			Values:      "default,github,vuepress",
+		},
+		{
+			Key:   "autoplay video",
+			Value: "false",
+			Type:  "bool",
+			Group: model.PUBLIC,
+		},
+		{
+			Key:   "autoplay audio",
+			Value: "false",
+			Type:  "bool",
+			Group: model.PUBLIC,
+		},
+		{
+			Key:         "check parent folder",
+			Value:       "false",
+			Type:        "bool",
+			Description: "check parent folder password",
+			Group:       model.PRIVATE,
+		},
+		{
+			Key:         "customize style",
+			Value:       "",
+			Type:        "text",
+			Description: "customize style, don't need add <style></style>",
+			Group:       model.PRIVATE,
+		},
+		{
+			Key:         "customize script",
+			Value:       "",
+			Type:        "text",
+			Description: "customize script, don't need add <script></script>",
+			Group:       model.PRIVATE,
+		},
+		{
+			Key:         "animation",
+			Value:       "true",
+			Type:        "bool",
+			Description: "when there are a lot of files, the animation will freeze when opening",
+			Group:       model.PUBLIC,
+		},
+		{
+			Key:         "check down link",
+			Value:       "false",
+			Type:        "bool",
+			Description: "check down link password, your link will be 'https://alist.com/d/filename?pw=xxx'",
+			Group:       model.PUBLIC,
+		},
+	}
+	for _, v := range settings {
+		_, err := model.GetSettingByKey(v.Key)
+		if err == gorm.ErrRecordNotFound {
+			err = model.SaveSetting(v)
+			if err != nil {
+				log.Fatalf("failed write setting: %s", err.Error())
+			}
+		}
+	}
+	model.LoadSettings()
+}

conf/var.go

@@ -20,6 +20,7 @@ var (
 	Conf       *Config
 	Debug      bool
 	Version    bool
+	Password   bool
 
 	DB    *gorm.DB
 	Cache *cache.Cache
@@ -43,4 +44,5 @@ var (
 	//CustomizeStyle  string
 	//CustomizeScript string
 	//Favicon         string
+	CheckDown bool
 )

drivers/123pan.go

@@ -0,0 +1,310 @@
+package drivers
+
+import (
+	"fmt"
+	"github.com/Xhofe/alist/conf"
+	"github.com/Xhofe/alist/model"
+	"github.com/Xhofe/alist/utils"
+	"github.com/gin-gonic/gin"
+	"github.com/go-resty/resty/v2"
+	log "github.com/sirupsen/logrus"
+	"path/filepath"
+	"strconv"
+	"time"
+)
+
+type Pan123 struct {
+}
+
+var pan123Client = resty.New()
+
+func (p Pan123) Items() []Item {
+	return []Item{
+		{
+			Name:        "proxy",
+			Label:       "proxy",
+			Type:        "bool",
+			Required:    true,
+			Description: "allow proxy",
+		},
+		{
+			Name:        "username",
+			Label:       "username",
+			Type:        "string",
+			Required:    true,
+			Description: "account username/phone number",
+		},
+		{
+			Name:        "password",
+			Label:       "password",
+			Type:        "string",
+			Required:    true,
+			Description: "account password",
+		},
+		{
+			Name:     "root_folder",
+			Label:    "root folder file_id",
+			Type:     "string",
+			Required: false,
+		},
+		{
+			Name:     "order_by",
+			Label:    "order_by",
+			Type:     "select",
+			Values:   "name,fileId,updateAt,createAt",
+			Required: true,
+		},
+		{
+			Name:     "order_direction",
+			Label:    "order_direction",
+			Type:     "select",
+			Values:   "asc,desc",
+			Required: true,
+		},
+	}
+}
+
+type Pan123TokenResp struct {
+	Code int `json:"code"`
+	Data struct {
+		Token string `json:"token"`
+	} `json:"data"`
+	Message string `json:"message"`
+}
+
+func (p Pan123) Login(account *model.Account) error {
+	var resp Pan123TokenResp
+	_, err := pan123Client.R().
+		SetResult(&resp).
+		SetBody(Json{
+			"passport": account.Username,
+			"password": account.Password,
+		}).Post("https://www.123pan.com/api/user/sign_in")
+	if err != nil {
+		return err
+	}
+	if resp.Code != 200 {
+		err = fmt.Errorf(resp.Message)
+		account.Status = resp.Message
+	} else {
+		account.Status = "work"
+		account.AccessToken = resp.Data.Token
+	}
+	_ = model.SaveAccount(account)
+	return err
+}
+
+func (p Pan123) Save(account *model.Account, old *model.Account) error {
+	if account.RootFolder == "" {
+		account.RootFolder = "0"
+	}
+	err := p.Login(account)
+	return err
+}
+
+type Pan123File struct {
+	FileName  string     `json:"FileName"`
+	Size      int64      `json:"Size"`
+	UpdateAt  *time.Time `json:"UpdateAt"`
+	FileId    int64      `json:"FileId"`
+	Type      int        `json:"Type"`
+	Etag      string     `json:"Etag"`
+	S3KeyFlag string     `json:"S3KeyFlag"`
+}
+
+func (p Pan123) FormatFile(file *Pan123File) *model.File {
+	f := &model.File{
+		Name:      file.FileName,
+		Size:      file.Size,
+		Driver:    "123Pan",
+		UpdatedAt: file.UpdateAt,
+	}
+	if file.Type == 1 {
+		f.Type = conf.FOLDER
+	} else {
+		f.Type = utils.GetFileType(filepath.Ext(file.FileName))
+	}
+	return f
+}
+
+type Pan123Files struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	Data    struct {
+		InfoList []Pan123File `json:"InfoList"`
+		Next     string       `json:"Next"`
+	} `json:"data"`
+}
+
+func (p Pan123) GetFiles(parentId string, account *model.Account) ([]Pan123File, error) {
+	next := "0"
+	res := make([]Pan123File, 0)
+	for next != "-1" {
+		var resp Pan123Files
+		_, err := pan123Client.R().SetResult(&resp).
+			SetHeader("authorization", "Bearer "+account.AccessToken).
+			SetQueryParams(map[string]string{
+				"driveId":        "0",
+				"limit":          "100",
+				"next":           next,
+				"orderBy":        account.OrderBy,
+				"orderDirection": account.OrderDirection,
+				"parentFileId":   parentId,
+				"trashed":        "false",
+			}).Get("https://www.123pan.com/api/file/list")
+		if err != nil {
+			return nil, err
+		}
+		log.Debugf("%+v", resp)
+		if resp.Code != 0 {
+			if resp.Code == 401 {
+				err := p.Login(account)
+				if err != nil {
+					return nil, err
+				}
+				return p.GetFiles(parentId, account)
+			}
+			return nil, fmt.Errorf(resp.Message)
+		}
+		next = resp.Data.Next
+		res = append(res, resp.Data.InfoList...)
+	}
+	return res, nil
+}
+
+func (p Pan123) Path(path string, account *model.Account) (*model.File, []*model.File, error) {
+	path = utils.ParsePath(path)
+	log.Debugf("pan123 path: %s", path)
+	cache, err := conf.Cache.Get(conf.Ctx, fmt.Sprintf("%s%s", account.Name, path))
+	if err == nil {
+		files, _ := cache.([]Pan123File)
+		if len(files) != 0 {
+			res := make([]*model.File, 0)
+			for _, file := range files {
+				res = append(res, p.FormatFile(&file))
+			}
+			return nil, res, nil
+		}
+	}
+	// no cache or len(files) == 0
+	fileId := account.RootFolder
+	if path != "/" {
+		dir, name := filepath.Split(path)
+		dir = utils.ParsePath(dir)
+		_, _, err = p.Path(dir, account)
+		if err != nil {
+			return nil, nil, err
+		}
+		parentFiles_, _ := conf.Cache.Get(conf.Ctx, fmt.Sprintf("%s%s", account.Name, dir))
+		parentFiles, _ := parentFiles_.([]Pan123File)
+		found := false
+		for _, file := range parentFiles {
+			if file.FileName == name {
+				found = true
+				if file.Type != 1 {
+					url, err := p.Link(path, account)
+					if err != nil {
+						return nil, nil, err
+					}
+
+					f := p.FormatFile(&file)
+					f.Url = url
+					return f, nil, nil
+				} else {
+					fileId = strconv.FormatInt(file.FileId, 10)
+					break
+				}
+			}
+		}
+		if !found {
+			return nil, nil, fmt.Errorf("path not found")
+		}
+	}
+	files, err := p.GetFiles(fileId, account)
+	if err != nil {
+		return nil, nil, err
+	}
+	log.Debugf("%+v", files)
+	_ = conf.Cache.Set(conf.Ctx, fmt.Sprintf("%s%s", account.Name, path), files, nil)
+	res := make([]*model.File, 0)
+	for _, file := range files {
+		res = append(res, p.FormatFile(&file))
+	}
+	return nil, res, nil
+}
+
+func (p Pan123) GetFile(path string, account *model.Account) (*Pan123File, error) {
+	dir, name := filepath.Split(path)
+	dir = utils.ParsePath(dir)
+	_, _, err := p.Path(dir, account)
+	if err != nil {
+		return nil, err
+	}
+	parentFiles_, _ := conf.Cache.Get(conf.Ctx, fmt.Sprintf("%s%s", account.Name, dir))
+	parentFiles, _ := parentFiles_.([]Pan123File)
+	for _, file := range parentFiles {
+		if file.FileName == name {
+			if file.Type != 1 {
+				return &file, err
+			} else {
+				return nil, fmt.Errorf("not file")
+			}
+		}
+	}
+	return nil, fmt.Errorf("path not found")
+}
+
+type Pan123DownResp struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	Data    struct {
+		DownloadUrl string `json:"DownloadUrl"`
+	} `json:"data"`
+}
+
+func (p Pan123) Link(path string, account *model.Account) (string, error) {
+	file, err := p.GetFile(utils.ParsePath(path), account)
+	if err != nil {
+		return "", err
+	}
+	var resp Pan123DownResp
+	_, err = pan123Client.R().SetResult(&resp).SetHeader("authorization", "Bearer "+account.AccessToken).
+		SetBody(Json{
+			"driveId":   0,
+			"etag":      file.Etag,
+			"fileId":    file.FileId,
+			"fileName":  file.FileName,
+			"s3keyFlag": file.S3KeyFlag,
+			"size":      file.Size,
+			"type":      file.Type,
+		}).Post("https://www.123pan.com/api/file/download_info")
+	if err != nil {
+		return "", err
+	}
+	if resp.Code != 0 {
+		if resp.Code == 401 {
+			err := p.Login(account)
+			if err != nil {
+				return "", err
+			}
+			return p.Link(path, account)
+		}
+		return "", fmt.Errorf(resp.Message)
+	}
+	return resp.Data.DownloadUrl, nil
+}
+
+func (p Pan123) Proxy(c *gin.Context, account *model.Account) {
+	c.Request.Header.Del("origin")
+}
+
+func (p Pan123) Preview(path string, account *model.Account) (interface{}, error) {
+	return nil, nil
+}
+
+var _ Driver = (*Pan123)(nil)
+
+func init() {
+	RegisterDriver("123Pan", &Pan123{})
+	pan123Client.SetRetryCount(3)
+}

drivers/189.go

@@ -0,0 +1,485 @@
+package drivers
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/json"
+	"encoding/pem"
+	"fmt"
+	"github.com/Xhofe/alist/conf"
+	"github.com/Xhofe/alist/model"
+	"github.com/Xhofe/alist/utils"
+	"github.com/gin-gonic/gin"
+	"github.com/go-resty/resty/v2"
+	log "github.com/sirupsen/logrus"
+	mathRand "math/rand"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type Cloud189 struct {
+}
+
+var client189Map map[string]*resty.Client
+
+func (c Cloud189) Items() []Item {
+	return []Item{
+		{
+			Name:        "proxy",
+			Label:       "proxy",
+			Type:        "bool",
+			Required:    true,
+			Description: "allow proxy",
+		},
+		{
+			Name:        "username",
+			Label:       "username",
+			Type:        "string",
+			Required:    true,
+			Description: "account username/phone number",
+		},
+		{
+			Name:        "password",
+			Label:       "password",
+			Type:        "string",
+			Required:    true,
+			Description: "account password",
+		},
+		{
+			Name:     "root_folder",
+			Label:    "root folder file_id",
+			Type:     "string",
+			Required: true,
+		},
+		{
+			Name:     "order_by",
+			Label:    "order_by",
+			Type:     "select",
+			Values:   "name,size,lastOpTime,createdDate",
+			Required: true,
+		},
+		{
+			Name:     "order_direction",
+			Label:    "desc",
+			Type:     "select",
+			Values:   "true,false",
+			Required: true,
+		},
+	}
+}
+
+func (c Cloud189) Save(account *model.Account, old *model.Account) error {
+	if old != nil && old.Name != account.Name {
+		delete(client189Map, old.Name)
+	}
+	if err := c.Login(account); err != nil {
+		account.Status = err.Error()
+		_ = model.SaveAccount(account)
+		return err
+	}
+	account.Status = "work"
+	err := model.SaveAccount(account)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c Cloud189) FormatFile(file *Cloud189File) *model.File {
+	f := &model.File{
+		Name:      file.Name,
+		Size:      file.Size,
+		Driver:    "189Cloud",
+		UpdatedAt: nil,
+		Thumbnail: file.Icon.SmallUrl,
+		Url:       file.Url,
+	}
+	loc, _ := time.LoadLocation("Local")
+	lastOpTime, err := time.ParseInLocation("2006-01-02 15:04:05", file.LastOpTime, loc)
+	if err == nil {
+		f.UpdatedAt = &lastOpTime
+	}
+	if file.Size == -1 {
+		f.Type = conf.FOLDER
+		f.Size = 0
+	} else {
+		f.Type = utils.GetFileType(filepath.Ext(file.Name))
+	}
+	return f
+}
+
+func (c Cloud189) Path(path string, account *model.Account) (*model.File, []*model.File, error) {
+	path = utils.ParsePath(path)
+	log.Debugf("189 path: %s", path)
+	cache, err := conf.Cache.Get(conf.Ctx, fmt.Sprintf("%s%s", account.Name, path))
+	if err == nil {
+		files, _ := cache.([]Cloud189File)
+		if len(files) != 0 {
+			res := make([]*model.File, 0)
+			for _, file := range files {
+				res = append(res, c.FormatFile(&file))
+			}
+			return nil, res, nil
+		}
+	}
+	// no cache or len(files) == 0
+	fileId := account.RootFolder
+	if path != "/" {
+		dir, name := filepath.Split(path)
+		dir = utils.ParsePath(dir)
+		_, _, err = c.Path(dir, account)
+		if err != nil {
+			return nil, nil, err
+		}
+		parentFiles_, _ := conf.Cache.Get(conf.Ctx, fmt.Sprintf("%s%s", account.Name, dir))
+		parentFiles, _ := parentFiles_.([]Cloud189File)
+		found := false
+		for _, file := range parentFiles {
+			if file.Name == name {
+				found = true
+				if file.Size != -1 {
+					url, err := c.Link(path, account)
+					if err != nil {
+						return nil, nil, err
+					}
+					file.Url = url
+					return c.FormatFile(&file), nil, nil
+				} else {
+					fileId = strconv.FormatInt(file.Id, 10)
+					break
+				}
+			}
+		}
+		if !found {
+			return nil, nil, fmt.Errorf("path not found")
+		}
+	}
+	files, err := c.GetFiles(fileId, account)
+	if err != nil {
+		return nil, nil, err
+	}
+	_ = conf.Cache.Set(conf.Ctx, fmt.Sprintf("%s%s", account.Name, path), files, nil)
+	res := make([]*model.File, 0)
+	for _, file := range files {
+		res = append(res, c.FormatFile(&file))
+	}
+	return nil, res, nil
+}
+
+func (c Cloud189) GetFile(path string, account *model.Account) (*Cloud189File, error) {
+	dir, name := filepath.Split(path)
+	dir = utils.ParsePath(dir)
+	_, _, err := c.Path(dir, account)
+	if err != nil {
+		return nil, err
+	}
+	parentFiles_, _ := conf.Cache.Get(conf.Ctx, fmt.Sprintf("%s%s", account.Name, dir))
+	parentFiles, _ := parentFiles_.([]Cloud189File)
+	for _, file := range parentFiles {
+		if file.Name == name {
+			if file.Size != -1 {
+				return &file, err
+			} else {
+				return nil, fmt.Errorf("not file")
+			}
+		}
+	}
+	return nil, fmt.Errorf("path not found")
+}
+
+type Cloud189Down struct {
+	ResCode         int    `json:"res_code"`
+	ResMessage      string `json:"res_message"`
+	FileDownloadUrl string `json:"fileDownloadUrl"`
+}
+
+func (c Cloud189) Link(path string, account *model.Account) (string, error) {
+	file, err := c.GetFile(utils.ParsePath(path), account)
+	if err != nil {
+		return "", err
+	}
+	client, ok := client189Map[account.Name]
+	if !ok {
+		return "", fmt.Errorf("can't find [%s] client", account.Name)
+	}
+	var e Cloud189Error
+	var resp Cloud189Down
+	_, err = client.R().SetResult(&resp).SetError(&e).
+		SetHeader("Accept", "application/json;charset=UTF-8").
+		SetQueryParams(map[string]string{
+			"noCache": random(),
+			"fileId":  strconv.FormatInt(file.Id, 10),
+		}).Get("https://cloud.189.cn/api/open/file/getFileDownloadUrl.action")
+	if err != nil {
+		return "", err
+	}
+	if e.ErrorCode != "" {
+		if e.ErrorCode == "InvalidSessionKey" {
+			err = c.Login(account)
+			if err != nil {
+				return "", err
+			}
+			return c.Link(path, account)
+		}
+	}
+	if resp.ResCode != 0 {
+		return "", fmt.Errorf(resp.ResMessage)
+	}
+	res, err := noRedirectClient.R().Get(resp.FileDownloadUrl)
+	if err != nil {
+		return "", err
+	}
+	if res.StatusCode() == 302 {
+		return res.Header().Get("location"), nil
+	}
+	return resp.FileDownloadUrl, nil
+}
+
+func (c Cloud189) Proxy(ctx *gin.Context, account *model.Account) {
+	ctx.Request.Header.Del("Origin")
+}
+
+func (c Cloud189) Preview(path string, account *model.Account) (interface{}, error) {
+	return nil, nil
+}
+
+var _ Driver = (*Cloud189)(nil)
+
+func init() {
+	RegisterDriver("189Cloud", &Cloud189{})
+	client189Map = make(map[string]*resty.Client, 0)
+}
+
+type LoginResp struct {
+	Msg    string `json:"msg"`
+	Result int    `json:"result"`
+	ToUrl  string `json:"toUrl"`
+}
+
+// Login refer to PanIndex
+func (c Cloud189) Login(account *model.Account) error {
+	client, ok := client189Map[account.Name]
+	if !ok {
+		//cookieJar, _ := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+		client = resty.New()
+		//client.SetCookieJar(cookieJar)
+		client.SetRetryCount(3)
+	}
+	url := "https://cloud.189.cn/api/portal/loginUrl.action?redirectURL=https%3A%2F%2Fcloud.189.cn%2Fmain.action"
+	res, err := client.R().Get(url)
+	if err != nil {
+		return err
+	}
+	b := res.String()
+	lt := ""
+	ltText := regexp.MustCompile(`lt = "(.+?)"`)
+	ltTextArr := ltText.FindStringSubmatch(b)
+	if len(ltTextArr) > 0 {
+		lt = ltTextArr[1]
+	} else {
+		return fmt.Errorf("ltTextArr = 0")
+	}
+	captchaToken := regexp.MustCompile(`captchaToken' value='(.+?)'`).FindStringSubmatch(b)[1]
+	returnUrl := regexp.MustCompile(`returnUrl = '(.+?)'`).FindStringSubmatch(b)[1]
+	paramId := regexp.MustCompile(`paramId = "(.+?)"`).FindStringSubmatch(b)[1]
+	//reqId := regexp.MustCompile(`reqId = "(.+?)"`).FindStringSubmatch(b)[1]
+	jRsakey := regexp.MustCompile(`j_rsaKey" value="(\S+)"`).FindStringSubmatch(b)[1]
+	vCodeID := regexp.MustCompile(`picCaptcha\.do\?token\=([A-Za-z0-9\&\=]+)`).FindStringSubmatch(b)[1]
+	vCodeRS := ""
+	if vCodeID != "" {
+		// need ValidateCode
+	}
+	userRsa := RsaEncode([]byte(account.Username), jRsakey)
+	passwordRsa := RsaEncode([]byte(account.Password), jRsakey)
+	url = "https://open.e.189.cn/api/logbox/oauth2/loginSubmit.do"
+	var loginResp LoginResp
+	res, err = client.R().
+		SetHeaders(map[string]string{
+			"lt":         lt,
+			"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",
+			"Referer":    "https://open.e.189.cn/",
+			"accept":     "application/json;charset=UTF-8",
+		}).SetFormData(map[string]string{
+		"appKey":       "cloud",
+		"accountType":  "01",
+		"userName":     "{RSA}" + userRsa,
+		"password":     "{RSA}" + passwordRsa,
+		"validateCode": vCodeRS,
+		"captchaToken": captchaToken,
+		"returnUrl":    returnUrl,
+		"mailSuffix":   "@pan.cn",
+		"paramId":      paramId,
+		"clientType":   "10010",
+		"dynamicCheck": "FALSE",
+		"cb_SaveName":  "1",
+		"isOauth2":     "false",
+	}).Post(url)
+	if err != nil {
+		return err
+	}
+	err = json.Unmarshal(res.Body(), &loginResp)
+	if err != nil {
+		log.Error(err.Error())
+		return err
+	}
+	if loginResp.Result != 0 {
+		return fmt.Errorf(loginResp.Msg)
+	}
+	_, err = client.R().Get(loginResp.ToUrl)
+	if err != nil {
+		log.Errorf(err.Error())
+		return err
+	}
+	client189Map[account.Name] = client
+	return nil
+}
+
+type Cloud189Error struct {
+	ErrorCode string `json:"errorCode"`
+	ErrorMsg  string `json:"errorMsg"`
+}
+
+type Cloud189File struct {
+	Id         int64  `json:"id"`
+	LastOpTime string `json:"lastOpTime"`
+	Name       string `json:"name"`
+	Size       int64  `json:"size"`
+	Icon       struct {
+		SmallUrl string `json:"smallUrl"`
+		//LargeUrl string `json:"largeUrl"`
+	} `json:"icon"`
+	Url string `json:"url"`
+}
+
+type Cloud189Folder struct {
+	Id         int64  `json:"id"`
+	LastOpTime string `json:"lastOpTime"`
+	Name       string `json:"name"`
+}
+
+type Cloud189Files struct {
+	ResCode    int    `json:"res_code"`
+	ResMessage string `json:"res_message"`
+	FileListAO struct {
+		Count      int              `json:"count"`
+		FileList   []Cloud189File   `json:"fileList"`
+		FolderList []Cloud189Folder `json:"folderList"`
+	} `json:"fileListAO"`
+}
+
+func (c Cloud189) GetFiles(fileId string, account *model.Account) ([]Cloud189File, error) {
+	client, ok := client189Map[account.Name]
+	if !ok {
+		return nil, fmt.Errorf("can't find [%s] client", account.Name)
+	}
+	res := make([]Cloud189File, 0)
+	pageNum := 1
+	for {
+		var e Cloud189Error
+		var resp Cloud189Files
+		_, err := client.R().SetResult(&resp).SetError(&e).
+			SetHeader("Accept", "application/json;charset=UTF-8").
+			SetQueryParams(map[string]string{
+				"noCache":    random(),
+				"pageSize":   "60",
+				"pageNum":    strconv.Itoa(pageNum),
+				"mediaType":  "0",
+				"folderId":   fileId,
+				"iconOption": "5",
+				"orderBy":    account.OrderBy,
+				"descending": account.OrderDirection,
+			}).Get("https://cloud.189.cn/api/open/file/listFiles.action")
+		if err != nil {
+			return nil, err
+		}
+		if e.ErrorCode != "" {
+			if e.ErrorCode == "InvalidSessionKey" {
+				err = c.Login(account)
+				if err != nil {
+					return nil, err
+				}
+				return c.GetFiles(fileId, account)
+			}
+		}
+		if resp.ResCode != 0 {
+			return nil, fmt.Errorf(resp.ResMessage)
+		}
+		if resp.FileListAO.Count == 0 {
+			break
+		}
+		res = append(res, resp.FileListAO.FileList...)
+		for _, folder := range resp.FileListAO.FolderList {
+			res = append(res, Cloud189File{
+				Id:         folder.Id,
+				LastOpTime: folder.LastOpTime,
+				Name:       folder.Name,
+				Size:       -1,
+			})
+		}
+		pageNum++
+	}
+	return res, nil
+}
+
+func random() string {
+	return fmt.Sprintf("0.%17v", mathRand.New(mathRand.NewSource(time.Now().UnixNano())).Int63n(100000000000000000))
+}
+
+func RsaEncode(origData []byte, j_rsakey string) string {
+	publicKey := []byte("-----BEGIN PUBLIC KEY-----\n" + j_rsakey + "\n-----END PUBLIC KEY-----")
+	block, _ := pem.Decode(publicKey)
+	pubInterface, _ := x509.ParsePKIXPublicKey(block.Bytes)
+	pub := pubInterface.(*rsa.PublicKey)
+	b, err := rsa.EncryptPKCS1v15(rand.Reader, pub, origData)
+	if err != nil {
+		log.Errorf("err: %s", err.Error())
+	}
+	return b64tohex(base64.StdEncoding.EncodeToString(b))
+}
+
+var b64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+
+var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz"
+
+func int2char(a int) string {
+	return strings.Split(BI_RM, "")[a]
+}
+
+func b64tohex(a string) string {
+	d := ""
+	e := 0
+	c := 0
+	for i := 0; i < len(a); i++ {
+		m := strings.Split(a, "")[i]
+		if m != "=" {
+			v := strings.Index(b64map, m)
+			if 0 == e {
+				e = 1
+				d += int2char(v >> 2)
+				c = 3 & v
+			} else if 1 == e {
+				e = 2
+				d += int2char(c<<2 | v>>4)
+				c = 15 & v
+			} else if 2 == e {
+				e = 3
+				d += int2char(c)
+				d += int2char(v >> 2)
+				c = 3 & v
+			} else {
+				e = 0
+				d += int2char(c<<2 | v>>4)
+				d += int2char(15 & v)
+			}
+		}
+	}
+	if e == 1 {
+		d += int2char(c << 2)
+	}
+	return d
+}

drivers/alidrive.go

@@ -67,6 +67,13 @@ func (a AliDrive) Preview(path string, account *model.Account) (interface{}, err
 
 func (a AliDrive) Items() []Item {
 	return []Item{
+		{
+			Name:        "proxy",
+			Label:       "proxy",
+			Type:        "bool",
+			Required:    true,
+			Description: "allow proxy",
+		},
 		{
 			Name: "order_by",
 			Label: "order_by",
@@ -103,7 +110,7 @@ func (a AliDrive) Items() []Item {
 	}
 }
 
-func (a AliDrive) Proxy(c *gin.Context) {
+func (a AliDrive) Proxy(c *gin.Context, account *model.Account) {
 	c.Request.Header.Del("Origin")
 	c.Request.Header.Set("Referer", "https://www.aliyundrive.com/")
 }
@@ -230,20 +237,15 @@ func (a AliDrive) Path(path string, account *model.Account) (*model.File, []*mod
 	log.Debugf("ali path: %s", path)
 	cache, err := conf.Cache.Get(conf.Ctx, fmt.Sprintf("%s%s", account.Name, path))
 	if err == nil {
-		file, ok := cache.(AliFile)
-		if ok {
-			return a.FormatFile(&file), nil, nil
-		} else {
 		files, _ := cache.([]AliFile)
 		if len(files) != 0 {
 			res := make([]*model.File, 0)
-				for _, file = range files {
+			for _, file := range files {
 				res = append(res, a.FormatFile(&file))
 			}
 			return nil, res, nil
 		}
 	}
-	}
 	// no cache or len(files) == 0
 	fileId := account.RootFolder
 	if path != "/" {
@@ -339,6 +341,8 @@ func (a AliDrive) RefreshToken(account *model.Account) error {
 	if e.Code != "" {
 		account.Status = e.Message
 		return fmt.Errorf("failed to refresh token: %s", e.Message)
+	}else {
+		account.Status = "work"
 	}
 	account.RefreshToken, account.AccessToken = resp.RefreshToken, resp.AccessToken
 	return nil
@@ -367,7 +371,9 @@ func (a AliDrive) Save(account *model.Account, old *model.Account) error {
 	account.DriveId = resp["default_drive_id"].(string)
 	cronId, err := conf.Cron.AddFunc("@every 2h", func() {
 		name := account.Name
+		log.Debugf("ali account name: %s", name)
 		newAccount, ok := model.GetAccount(name)
+		log.Debugf("ali account: %+v", newAccount)
 		if !ok {
 			return
 		}

drivers/driver.go

@@ -3,16 +3,19 @@ package drivers
 import (
 	"github.com/Xhofe/alist/model"
 	"github.com/gin-gonic/gin"
+	"github.com/go-resty/resty/v2"
+	"net/http"
 )
 
 type Driver interface {
 	Items() []Item
+	Save(account *model.Account, old *model.Account) error
 	Path(path string, account *model.Account) (*model.File, []*model.File, error)
 	Link(path string, account *model.Account) (string, error)
-	Save(account *model.Account, old *model.Account) error
-	Proxy(c *gin.Context)
+	Proxy(c *gin.Context, account *model.Account)
 	Preview(path string, account *model.Account) (interface{}, error)
 	// TODO
+	//Search(path string, keyword string, account *model.Account) ([]*model.File, error)
 	//MakeDir(path string, account *model.Account) error
 	//Move(src string, des string, account *model.Account) error
 	//Delete(path string) error
@@ -53,3 +56,13 @@ func GetDrivers() map[string][]Item {
 }
 
 type Json map[string]interface{}
+
+var noRedirectClient *resty.Client
+
+func init() {
+	noRedirectClient = resty.New().SetRedirectPolicy(
+		resty.RedirectPolicyFunc(func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		}),
+	)
+}

drivers/googledrive.go

@@ -0,0 +1,290 @@
+package drivers
+
+import (
+	"fmt"
+	"github.com/Xhofe/alist/conf"
+	"github.com/Xhofe/alist/model"
+	"github.com/Xhofe/alist/utils"
+	"github.com/gin-gonic/gin"
+	"github.com/go-resty/resty/v2"
+	log "github.com/sirupsen/logrus"
+	"path/filepath"
+	"strconv"
+	"time"
+)
+
+type GoogleDrive struct {
+}
+
+var googleClient = resty.New()
+
+func (g GoogleDrive) Items() []Item {
+	return []Item{
+		{
+			Name:     "client_id",
+			Label:    "client id",
+			Type:     "string",
+			Required: true,
+		},
+		{
+			Name:     "client_secret",
+			Label:    "client secret",
+			Type:     "string",
+			Required: true,
+		},
+		{
+			Name:     "refresh_token",
+			Label:    "refresh token",
+			Type:     "string",
+			Required: true,
+		},
+		{
+			Name:     "root_folder",
+			Label:    "root folder path",
+			Type:     "string",
+			Required: true,
+		},
+	}
+}
+
+type GoogleTokenError struct {
+	Error            string `json:"error"`
+	ErrorDescription string `json:"error_description"`
+}
+
+func (g GoogleDrive) RefreshToken(account *model.Account) error {
+	url := "https://www.googleapis.com/oauth2/v4/token"
+	var resp TokenResp
+	var e GoogleTokenError
+	_, err := googleClient.R().SetResult(&resp).SetError(&e).
+		SetFormData(map[string]string{
+			"client_id":     account.ClientId,
+			"client_secret": account.ClientSecret,
+			"refresh_token": account.RefreshToken,
+			"grant_type":    "refresh_token",
+		}).Post(url)
+	if err != nil {
+		return err
+	}
+	if e.Error != "" {
+		return fmt.Errorf(e.Error)
+	}
+	account.AccessToken = resp.AccessToken
+	account.Status = "work"
+	return nil
+}
+
+func (g GoogleDrive) Save(account *model.Account, old *model.Account) error {
+	account.Proxy = true
+	err := g.RefreshToken(account)
+	if err != nil {
+		account.Status = err.Error()
+		_ = model.SaveAccount(account)
+		return err
+	}
+	account.Status = "work"
+	_ = model.SaveAccount(account)
+	return nil
+}
+
+type GoogleFile struct {
+	Id           string     `json:"id"`
+	Name         string     `json:"name"`
+	MimeType     string     `json:"mimeType"`
+	ModifiedTime *time.Time `json:"modifiedTime"`
+	Size         string     `json:"size"`
+}
+
+func (g GoogleDrive) IsDir(mimeType string) bool {
+	return mimeType == "application/vnd.google-apps.folder" || mimeType == "application/vnd.google-apps.shortcut"
+}
+
+func (g GoogleDrive) FormatFile(file *GoogleFile) *model.File {
+	f := &model.File{
+		Name:      file.Name,
+		Driver:    "GoogleDrive",
+		UpdatedAt: file.ModifiedTime,
+		Thumbnail: "",
+		Url:       "",
+	}
+	if g.IsDir(file.MimeType) {
+		f.Type = conf.FOLDER
+	} else {
+		size, _ := strconv.ParseInt(file.Size, 10, 64)
+		f.Size = size
+		f.Type = utils.GetFileType(filepath.Ext(file.Name))
+	}
+	return f
+}
+
+type GoogleFiles struct {
+	NextPageToken string       `json:"nextPageToken"`
+	Files         []GoogleFile `json:"files"`
+}
+
+type GoogleError struct {
+	Error struct {
+		Errors []struct {
+			Domain       string `json:"domain"`
+			Reason       string `json:"reason"`
+			Message      string `json:"message"`
+			LocationType string `json:"location_type"`
+			Location     string `json:"location"`
+		}
+		Code    int    `json:"code"`
+		Message string `json:"message"`
+	} `json:"error"`
+}
+
+func (g GoogleDrive) GetFiles(id string, account *model.Account) ([]GoogleFile, error) {
+	pageToken := "first"
+	res := make([]GoogleFile, 0)
+	for pageToken != "" {
+		if pageToken == "first" {
+			pageToken = ""
+		}
+		var resp GoogleFiles
+		var e GoogleError
+		_, err := googleClient.R().SetResult(&resp).SetError(&e).
+			SetHeader("Authorization", "Bearer "+account.AccessToken).
+			SetQueryParams(map[string]string{
+				"orderBy":                   "folder,name,modifiedTime desc",
+				"fields":                    "files(id,name,mimeType,size,modifiedTime),nextPageToken",
+				"pageSize":                  "1000",
+				"q":                         fmt.Sprintf("'%s' in parents and trashed = false", id),
+				"includeItemsFromAllDrives": "true",
+				"supportsAllDrives":         "true",
+				"pageToken":                 pageToken,
+			}).Get("https://www.googleapis.com/drive/v3/files")
+		if err != nil {
+			return nil, err
+		}
+		if e.Error.Code != 0 {
+			if e.Error.Code == 401 {
+				err = g.RefreshToken(account)
+				if err != nil {
+					_ = model.SaveAccount(account)
+					return nil, err
+				}
+				return g.GetFiles(id, account)
+			}
+			return nil, fmt.Errorf("%s: %v", e.Error.Message, e.Error.Errors)
+		}
+		pageToken = resp.NextPageToken
+		res = append(res, resp.Files...)
+	}
+	return res, nil
+}
+
+func (g GoogleDrive) GetFile(path string, account *model.Account) (*GoogleFile, error) {
+	dir, name := filepath.Split(path)
+	dir = utils.ParsePath(dir)
+	_, _, err := g.Path(dir, account)
+	if err != nil {
+		return nil, err
+	}
+	parentFiles_, _ := conf.Cache.Get(conf.Ctx, fmt.Sprintf("%s%s", account.Name, dir))
+	parentFiles, _ := parentFiles_.([]GoogleFile)
+	for _, file := range parentFiles {
+		if file.Name == name {
+			if !g.IsDir(file.MimeType) {
+				return &file, err
+			} else {
+				return nil, fmt.Errorf("not file")
+			}
+		}
+	}
+	return nil, fmt.Errorf("path not found")
+}
+
+func (g GoogleDrive) Path(path string, account *model.Account) (*model.File, []*model.File, error) {
+	path = utils.ParsePath(path)
+	log.Debugf("google path: %s", path)
+	cache, err := conf.Cache.Get(conf.Ctx, fmt.Sprintf("%s%s", account.Name, path))
+	if err == nil {
+		files, _ := cache.([]GoogleFile)
+		if len(files) != 0 {
+			res := make([]*model.File, 0)
+			for _, file := range files {
+				res = append(res, g.FormatFile(&file))
+			}
+			return nil, res, nil
+		}
+	}
+	// no cache or len(files) == 0
+	fileId := account.RootFolder
+	if path != "/" {
+		dir, name := filepath.Split(path)
+		dir = utils.ParsePath(dir)
+		_, _, err = g.Path(dir, account)
+		if err != nil {
+			return nil, nil, err
+		}
+		parentFiles_, _ := conf.Cache.Get(conf.Ctx, fmt.Sprintf("%s%s", account.Name, dir))
+		parentFiles, _ := parentFiles_.([]GoogleFile)
+		found := false
+		for _, file := range parentFiles {
+			if file.Name == name {
+				found = true
+				if !g.IsDir(file.MimeType) {
+					return g.FormatFile(&file), nil, nil
+				} else {
+					fileId = file.Id
+					break
+				}
+			}
+		}
+		if !found {
+			return nil, nil, fmt.Errorf("path not found")
+		}
+	}
+	files, err := g.GetFiles(fileId, account)
+	if err != nil {
+		return nil, nil, err
+	}
+	_ = conf.Cache.Set(conf.Ctx, fmt.Sprintf("%s%s", account.Name, path), files, nil)
+	res := make([]*model.File, 0)
+	for _, file := range files {
+		res = append(res, g.FormatFile(&file))
+	}
+	return nil, res, nil
+}
+
+func (g GoogleDrive) Link(path string, account *model.Account) (string, error) {
+	file, err := g.GetFile(utils.ParsePath(path), account)
+	if err != nil {
+		return "", err
+	}
+	link := fmt.Sprintf("https://www.googleapis.com/drive/v3/files/%s?includeItemsFromAllDrives=true&supportsAllDrives=true", file.Id)
+	var e GoogleError
+	_, _ = googleClient.R().SetError(&e).
+		SetHeader("Authorization", "Bearer "+account.AccessToken).
+		Get(link)
+	if e.Error.Code != 0 {
+		if e.Error.Code == 401 {
+			err = g.RefreshToken(account)
+			if err != nil {
+				_ = model.SaveAccount(account)
+				return "", err
+			}
+			return g.Link(path, account)
+		}
+		return "", fmt.Errorf("%s: %v", e.Error.Message, e.Error.Errors)
+	}
+	return link + "&alt=media", nil
+}
+
+func (g GoogleDrive) Proxy(c *gin.Context, account *model.Account) {
+	c.Request.Header.Add("Authorization", "Bearer "+account.AccessToken)
+}
+
+func (g GoogleDrive) Preview(path string, account *model.Account) (interface{}, error) {
+	return nil, nil
+}
+
+var _ Driver = (*GoogleDrive)(nil)
+
+func init() {
+	RegisterDriver("GoogleDrive", &GoogleDrive{})
+	googleClient.SetRetryCount(3)
+}

drivers/native.go

@@ -31,15 +31,23 @@ func (n Native) Items() []Item {
 	}
 }
 
-func (n Native) Proxy(c *gin.Context) {
+func (n Native) Proxy(c *gin.Context, account *model.Account) {
 	// unnecessary
 }
 
 func (n Native) Save(account *model.Account, old *model.Account) error {
 	log.Debugf("save a account: [%s]", account.Name)
 	if !utils.Exists(account.RootFolder) {
+		account.Status = fmt.Sprintf("[%s] not exist", account.RootFolder)
+		_ = model.SaveAccount(account)
 		return fmt.Errorf("[%s] not exist", account.RootFolder)
 	}
+	account.Status = "work"
+	account.Proxy = true
+	err := model.SaveAccount(account)
+	if err != nil {
+		return err
+	}
 	return nil
 }
 

drivers/onedrive.go

@@ -8,6 +8,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/go-resty/resty/v2"
 	"github.com/robfig/cron/v3"
+	log "github.com/sirupsen/logrus"
 	"path/filepath"
 	"time"
 )
@@ -47,6 +48,7 @@ func init() {
 
 func (o Onedrive) GetMetaUrl(account *model.Account, auth bool, path string) string {
 	path = filepath.Join(account.RootFolder, path)
+	log.Debugf(path)
 	host, _ := onedriveHostMap[account.Zone]
 	if auth {
 		return host.Oauth
@@ -54,7 +56,7 @@ func (o Onedrive) GetMetaUrl(account *model.Account, auth bool, path string) str
 	switch account.OnedriveType {
 	case "onedrive":
 		{
-			if path == "/" {
+			if path == "/" || path == "\\" {
 				return fmt.Sprintf("%s/v1.0/me/drive/root", host.Api)
 			} else {
 				return fmt.Sprintf("%s/v1.0/me/drive/root:%s:", host.Api, path)
@@ -75,6 +77,13 @@ func (o Onedrive) GetMetaUrl(account *model.Account, auth bool, path string) str
 
 func (o Onedrive) Items() []Item {
 	return []Item{
+		{
+			Name:        "proxy",
+			Label:       "proxy",
+			Type:        "bool",
+			Required:    true,
+			Description: "allow proxy",
+		},
 		{
 			Name:        "zone",
 			Label:       "zone",
@@ -152,6 +161,8 @@ func (o Onedrive) RefreshToken(account *model.Account) error {
 	if e.Error != "" {
 		account.Status = e.ErrorDescription
 		return fmt.Errorf("%s", e.ErrorDescription)
+	}else {
+		account.Status = "work"
 	}
 	account.RefreshToken, account.AccessToken = resp.RefreshToken, resp.AccessToken
 	return nil
@@ -277,7 +288,9 @@ func (o Onedrive) Save(account *model.Account, old *model.Account) error {
 	}
 	cronId, err := conf.Cron.AddFunc("@every 1h", func() {
 		name := account.Name
+		log.Debugf("onedrive account name: %s", name)
 		newAccount, ok := model.GetAccount(name)
+		log.Debugf("onedrive account: %+v", newAccount)
 		if !ok {
 			return
 		}
@@ -295,7 +308,7 @@ func (o Onedrive) Save(account *model.Account, old *model.Account) error {
 	return nil
 }
 
-func (o Onedrive) Proxy(c *gin.Context) {
+func (o Onedrive) Proxy(c *gin.Context, account *model.Account) {
 	c.Request.Header.Del("Origin")
 }
 

model/account.go

@@ -68,6 +68,10 @@ func DeleteAccount(id uint) error {
 	return nil
 }
 
+func DeleteAccountFromMap(name string) {
+	delete(accountsMap, name)
+}
+
 func AccountsCount() int {
 	return len(accountsMap)
 }
@@ -86,6 +90,15 @@ func GetAccount(name string) (Account, bool) {
 	return account, ok
 }
 
+func GetAccountById(id uint) (*Account, error) {
+	var account Account
+	account.ID = id
+	if err := conf.DB.First(&account).Error; err != nil {
+		return nil, err
+	}
+	return &account, nil
+}
+
 func GetAccountFiles() ([]*File, error) {
 	files := make([]*File, 0)
 	var accounts []Account

model/setting.go

@@ -61,11 +61,20 @@ func LoadSettings() {
 	if err == nil {
 		conf.CheckParent = checkParent.Value == "true"
 	}
+	checkDown,err := GetSettingByKey("check down link")
+	if err == nil {
+		conf.CheckDown = checkDown.Value == "true"
+	}
 	favicon, err := GetSettingByKey("favicon")
 	if err == nil {
 		//conf.Favicon = favicon.Value
 		conf.IndexHtml = strings.Replace(conf.RawIndexHtml, "https://store.heytapimage.com/cdo-portal/feedback/202110/30/d43c41c5d257c9bc36366e310374fb19.png", favicon.Value, 1)
 	}
+	title, err := GetSettingByKey("title")
+	if err == nil {
+		//conf.CustomizeStyle = customizeStyle.Value
+		conf.IndexHtml = strings.Replace(conf.IndexHtml, "Loading...", title.Value, 1)
+	}
 	customizeStyle, err := GetSettingByKey("customize style")
 	if err == nil {
 		//conf.CustomizeStyle = customizeStyle.Value

server/account.go

@@ -56,18 +56,21 @@ func SaveAccount(c *gin.Context) {
 		ErrorResp(c, fmt.Errorf("no [%s] driver", req.Type), 400)
 		return
 	}
-	old, ok := model.GetAccount(req.Name)
+	old, err := model.GetAccountById(req.ID)
+	if err != nil {
+		ErrorResp(c, err, 400)
+		return
+	}
 	now := time.Now()
 	req.UpdatedAt = &now
+	if old.Name != req.Name {
+		model.DeleteAccountFromMap(old.Name)
+	}
 	if err := model.SaveAccount(&req); err != nil {
 		ErrorResp(c, err, 500)
 	} else {
 		log.Debugf("save account: %+v", req)
-		if ok {
-			err = driver.Save(&req, &old)
-		} else {
-			err = driver.Save(&req, nil)
-		}
+		err = driver.Save(&req, old)
 		if err != nil {
 			ErrorResp(c, err, 500)
 			return

server/check.go

@@ -2,9 +2,11 @@ package server
 
 import (
 	"fmt"
+	"github.com/Xhofe/alist/conf"
 	"github.com/Xhofe/alist/model"
 	"github.com/Xhofe/alist/utils"
 	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
 	"gorm.io/gorm"
 	"path/filepath"
 )
@@ -53,3 +55,26 @@ func CheckParent(path string, password string) bool {
 		return CheckParent(filepath.Dir(path), password)
 	}
 }
+
+func CheckDownLink(path string, passwordMd5 string) bool {
+	if !conf.CheckDown {
+		return true
+	}
+	meta, err := model.GetMetaByPath(path)
+	log.Debugf("check down path: %s", path)
+	if err == nil {
+		log.Debugf("check down link: %s,%s", meta.Password, passwordMd5)
+		if meta.Password != "" && utils.Get16MD5Encode(meta.Password) != passwordMd5 {
+			return false
+		}
+		return true
+	} else {
+		if !conf.CheckParent {
+			return true
+		}
+		if path == "/" {
+			return true
+		}
+		return CheckDownLink(filepath.Dir(path), passwordMd5)
+	}
+}

server/common.go

@@ -5,6 +5,7 @@ import (
 	"github.com/Xhofe/alist/drivers"
 	"github.com/Xhofe/alist/model"
 	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
 	"strings"
 )
 
@@ -39,6 +40,7 @@ func ParsePath(rawPath string) (*model.Account, string, drivers.Driver, error) {
 }
 
 func ErrorResp(c *gin.Context, err error, code int) {
+	log.Error(err.Error())
 	c.JSON(200, Resp{
 		Code:    code,
 		Message: err.Error(),

server/down.go

@@ -5,6 +5,7 @@ import (
 	"github.com/Xhofe/alist/conf"
 	"github.com/Xhofe/alist/utils"
 	"github.com/gin-gonic/gin"
+	"github.com/go-resty/resty/v2"
 	log "github.com/sirupsen/logrus"
 	"net/http/httputil"
 	"net/url"
@@ -20,11 +21,20 @@ func Down(c *gin.Context) {
 	}
 	rawPath = utils.ParsePath(rawPath)
 	log.Debugf("down: %s", rawPath)
+	pw := c.Query("pw")
+	if !CheckDownLink(filepath.Dir(rawPath), pw) {
+		ErrorResp(c, fmt.Errorf("wrong password"), 401)
+		return
+	}
 	account, path, driver, err := ParsePath(rawPath)
 	if err != nil {
 		ErrorResp(c, err, 500)
 		return
 	}
+	if account.Type == "GoogleDrive" {
+		Proxy(c)
+		return
+	}
 	link, err := driver.Link(path, account)
 	if err != nil {
 		ErrorResp(c, err, 500)
@@ -47,6 +57,11 @@ func Proxy(c *gin.Context) {
 	}
 	rawPath = utils.ParsePath(rawPath)
 	log.Debugf("proxy: %s", rawPath)
+	pw := c.Query("pw")
+	if !CheckDownLink(filepath.Dir(rawPath), pw) {
+		ErrorResp(c, fmt.Errorf("wrong password"), 401)
+		return
+	}
 	account, path, driver, err := ParsePath(rawPath)
 	if err != nil {
 		ErrorResp(c, err, 500)
@@ -65,7 +80,11 @@ func Proxy(c *gin.Context) {
 		c.File(link)
 		return
 	} else {
-		driver.Proxy(c)
+		if utils.GetFileType(filepath.Ext(rawPath)) == conf.TEXT {
+			Text(c, link)
+			return
+		}
+		driver.Proxy(c, account)
 		r := c.Request
 		w := c.Writer
 		target, err := url.Parse(link)
@@ -84,3 +103,30 @@ func Proxy(c *gin.Context) {
 		proxy.ServeHTTP(w, r)
 	}
 }
+
+var client *resty.Client
+
+func init() {
+	client = resty.New()
+	client.SetRetryCount(3)
+}
+
+func Text(c *gin.Context, link string) {
+	res, err := client.R().Get(link)
+	if err != nil {
+		ErrorResp(c, err, 500)
+		return
+	}
+	text := res.String()
+	t := utils.GetStrCoding(res.Body())
+	log.Debugf("text type: %s", t)
+	if t != utils.UTF8 {
+		body, err := utils.GbkToUtf8(res.Body())
+		if err != nil {
+			ErrorResp(c, err, 500)
+			return
+		}
+		text = string(body)
+	}
+	c.String(200, text)
+}

server/static.go

@@ -12,7 +12,11 @@ import (
 
 
 func init() {
-	index, _ := public.Public.Open("index.html")
+	index, err := public.Public.Open("index.html")
+	if err != nil {
+		log.Errorf(err.Error())
+		return
+	}
 	data, _ := ioutil.ReadAll(index)
 	conf.RawIndexHtml = string(data)
 }

utils/code.go

@@ -0,0 +1,59 @@
+package utils
+
+import (
+	"bytes"
+	"golang.org/x/text/encoding/simplifiedchinese"
+	"golang.org/x/text/transform"
+	"io/ioutil"
+	"unicode/utf8"
+)
+
+func IsGBK(data []byte) bool {
+	length := len(data)
+	var i = 0
+	for i < length {
+		if data[i] <= 0x7f {
+			//编码0~127,只有一个字节的编码，兼容ASCII码
+			i++
+			continue
+		} else {
+			//大于127的使用双字节编码，落在gbk编码范围内的字符
+			if data[i] >= 0x81 &&
+				data[i] <= 0xfe &&
+				data[i+1] >= 0x40 &&
+				data[i+1] <= 0xfe &&
+				data[i+1] != 0xf7 {
+				i += 2
+				continue
+			} else {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+const (
+	GBK     string = "GBK"
+	UTF8    string = "UTF8"
+	UNKNOWN string = "UNKNOWN"
+)
+
+func GetStrCoding(data []byte) string {
+	if utf8.Valid(data) {
+		return UTF8
+	} else if IsGBK(data) {
+		return GBK
+	} else {
+		return UNKNOWN
+	}
+}
+
+func GbkToUtf8(s []byte) ([]byte, error) {
+	reader := transform.NewReader(bytes.NewReader(s), simplifiedchinese.GBK.NewDecoder())
+	d, e := ioutil.ReadAll(reader)
+	if e != nil {
+		return nil, e
+	}
+	return d, nil
+}

utils/file.go

@@ -88,3 +88,4 @@ func ParsePath(path string) string {
 	}
 	return path
 }
+