fix user

* feat(123_open): add `UseDirectLink` option

* feat(123_open): update rate limit rules

* fix(123_open): update api

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Signed-off-by: MadDogOwner <xiaoran@xrgzs.top>

* feat(123_open): enhance direct link functionality with private key and expiration

* refactor(123_open): use UUID for random generation

---------

Signed-off-by: MadDogOwner <xiaoran@xrgzs.top>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.github/workflows/sync_repo.yml

@@ -0,0 +1,38 @@
+name: Sync to Gitee
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    name: Sync GitHub to Gitee
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup SSH
+        run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.GITEE_SSH_PRIVATE_KEY }}" > ~/.ssh/id_rsa
+          chmod 600 ~/.ssh/id_rsa
+          ssh-keyscan gitee.com >> ~/.ssh/known_hosts
+
+      - name: Create single commit and push
+        run: |
+          git config user.name "GitHub Actions"
+          git config user.email "actions@github.com"
+          
+          # Create a new branch
+          git checkout --orphan new-main
+          git add .
+          git commit -m "Sync from GitHub: $(date)"
+
+          # Add Gitee remote and force push
+          git remote add gitee ${{ vars.GITEE_REPO_URL }}
+          git push --force gitee new-main:main

Dockerfile

@@ -14,19 +14,17 @@ FROM openlistteam/openlist-base-image:${BASE_IMAGE_TAG}
 LABEL MAINTAINER="OpenList"
 ARG INSTALL_FFMPEG=false
 ARG INSTALL_ARIA2=false
-ARG USER=openlist
-ARG UID=1001
-ARG GID=1001
 
 WORKDIR /opt/openlist/
 
-COPY --chmod=755 --from=builder /app/bin/openlist ./
+RUN addgroup -g 1001 openlist && \
-COPY --chmod=755 entrypoint.sh /entrypoint.sh
+    adduser -D -u 1001 -G openlist openlist && \
-RUN adduser -u ${UID} -g ${GID} -h /opt/openlist/data -D -s /bin/sh ${USER} \
+    mkdir -p /opt/openlist/data
-    && chown -R ${UID}:${GID} /opt \
-    && chown -R ${UID}:${GID} /entrypoint.sh
 
-USER ${USER}
+COPY --from=builder --chmod=755 --chown=1001:1001 /app/bin/openlist ./
+COPY --chmod=755 --chown=1001:1001 entrypoint.sh /entrypoint.sh
+
+USER openlist
 RUN /entrypoint.sh version
 
 ENV UMASK=022 RUN_ARIA2=${INSTALL_ARIA2}

Dockerfile.ci

@@ -0,0 +1,23 @@
+ARG BASE_IMAGE_TAG=base
+FROM ghcr.io/openlistteam/openlist-base-image:${BASE_IMAGE_TAG}
+LABEL MAINTAINER="OpenList"
+ARG TARGETPLATFORM
+ARG INSTALL_FFMPEG=false
+ARG INSTALL_ARIA2=false
+
+WORKDIR /opt/openlist/
+
+RUN addgroup -g 1001 openlist && \
+    adduser -D -u 1001 -G openlist openlist && \
+    mkdir -p /opt/openlist/data
+
+COPY --chmod=755 --chown=1001:1001 /build/${TARGETPLATFORM}/openlist ./
+COPY --chmod=755 --chown=1001:1001 entrypoint.sh /entrypoint.sh
+
+USER openlist
+RUN /entrypoint.sh version
+
+ENV UMASK=022 RUN_ARIA2=${INSTALL_ARIA2}
+VOLUME /opt/openlist/data/
+EXPOSE 5244 5245
+CMD [ "/entrypoint.sh" ]

buf.gen.yaml

@@ -1,11 +0,0 @@
-version: v1
-plugins:
-  - plugin: buf.build/protocolbuffers/go:v1.36.7
-    out: .
-    opt:
-      - paths=source_relative
-  - plugin: buf.build/grpc/go:v1.5.1
-    out: .
-    opt:
-      - paths=source_relative
-      - require_unimplemented_servers=false

buf.yaml

@@ -1 +0,0 @@
-version: v1

cmd/common.go

@@ -1,42 +1,51 @@
 package cmd
 
 import (
-	"context"
+	"os"
+	"path/filepath"
+	"strconv"
 
-	"github.com/OpenListTeam/OpenList/v5/cmd/flags"
+	"github.com/OpenListTeam/OpenList/v4/internal/bootstrap"
-	"github.com/OpenListTeam/OpenList/v5/internal/bootstrap"
+	"github.com/OpenListTeam/OpenList/v4/internal/bootstrap/data"
-	"github.com/sirupsen/logrus"
+	"github.com/OpenListTeam/OpenList/v4/internal/db"
+	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
+	log "github.com/sirupsen/logrus"
 )
 
-func Init(ctx context.Context) {
+func Init() {
-	if flags.Dev {
-		flags.Debug = true
-	}
-	initLogrus()
 	bootstrap.InitConfig()
-	bootstrap.InitDriverPlugins()
+	bootstrap.Log()
+	bootstrap.InitDB()
+	data.InitData()
+	bootstrap.InitStreamLimit()
+	bootstrap.InitIndex()
+	bootstrap.InitUpgradePatch()
 }
 
 func Release() {
-
+	db.Close()
 }
 
-func initLog(l *logrus.Logger) {
+var pid = -1
-	if flags.Debug {
+var pidFile string
-		l.SetLevel(logrus.DebugLevel)
+
-		l.SetReportCaller(true)
+func initDaemon() {
-	} else {
+	ex, err := os.Executable()
-		l.SetLevel(logrus.InfoLevel)
+	if err != nil {
-		l.SetReportCaller(false)
+		log.Fatal(err)
+	}
+	exPath := filepath.Dir(ex)
+	_ = os.MkdirAll(filepath.Join(exPath, "daemon"), 0700)
+	pidFile = filepath.Join(exPath, "daemon/pid")
+	if utils.Exists(pidFile) {
+		bytes, err := os.ReadFile(pidFile)
+		if err != nil {
+			log.Fatal("failed to read pid file", err)
+		}
+		id, err := strconv.Atoi(string(bytes))
+		if err != nil {
+			log.Fatal("failed to parse pid data", err)
+		}
+		pid = id
 	}
 }
-func initLogrus() {
-	formatter := logrus.TextFormatter{
-		ForceColors:               true,
-		EnvironmentOverrideColors: true,
-		TimestampFormat:           "2006-01-02 15:04:05",
-		FullTimestamp:             true,
-	}
-	logrus.SetFormatter(&formatter)
-	initLog(logrus.StandardLogger())
-}

cmd/flags/config.go

@@ -1,40 +1,10 @@
 package flags
 
-import (
-	"os"
-	"path/filepath"
-
-	"github.com/sirupsen/logrus"
-)
-
 var (
-	ConfigFile  string
+	DataDir     string
 	Debug       bool
 	NoPrefix    bool
 	Dev         bool
 	ForceBinDir bool
 	LogStd      bool
-
-	pwd string
 )
-
-// Program working directory
-func PWD() string {
-	if pwd != "" {
-		return pwd
-	}
-	if ForceBinDir {
-		ex, err := os.Executable()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		pwd = filepath.Dir(ex)
-		return pwd
-	}
-	d, err := os.Getwd()
-	if err != nil {
-		logrus.Fatal(err)
-	}
-	pwd = d
-	return d
-}

cmd/root.go

@@ -4,7 +4,10 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/OpenListTeam/OpenList/v5/cmd/flags"
+	"github.com/OpenListTeam/OpenList/v4/cmd/flags"
+	_ "github.com/OpenListTeam/OpenList/v4/drivers"
+	_ "github.com/OpenListTeam/OpenList/v4/internal/archive"
+	_ "github.com/OpenListTeam/OpenList/v4/internal/offline_download"
 	"github.com/spf13/cobra"
 )
 
@@ -24,10 +27,10 @@ func Execute() {
 }
 
 func init() {
-	RootCmd.PersistentFlags().StringVarP(&flags.ConfigFile, "config", "c", "data/config.json", "config file")
+	RootCmd.PersistentFlags().StringVar(&flags.DataDir, "data", "data", "data folder")
 	RootCmd.PersistentFlags().BoolVar(&flags.Debug, "debug", false, "start with debug mode")
 	RootCmd.PersistentFlags().BoolVar(&flags.NoPrefix, "no-prefix", false, "disable env prefix")
 	RootCmd.PersistentFlags().BoolVar(&flags.Dev, "dev", false, "start with dev mode")
-	RootCmd.PersistentFlags().BoolVarP(&flags.ForceBinDir, "force-bin-dir", "f", false, "force to use the directory where the binary file is located as data directory")
+	RootCmd.PersistentFlags().BoolVar(&flags.ForceBinDir, "force-bin-dir", false, "Force to use the directory where the binary file is located as data directory")
-	RootCmd.PersistentFlags().BoolVar(&flags.LogStd, "log-std", false, "force to log to std")
+	RootCmd.PersistentFlags().BoolVar(&flags.LogStd, "log-std", false, "Force to log to std")
 }

cmd/server.go

@@ -13,9 +13,15 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/OpenListTeam/OpenList/v5/cmd/flags"
+	"github.com/OpenListTeam/OpenList/v4/cmd/flags"
-	"github.com/OpenListTeam/OpenList/v5/internal/conf"
+	"github.com/OpenListTeam/OpenList/v4/internal/bootstrap"
-	"github.com/OpenListTeam/OpenList/v5/server"
+	"github.com/OpenListTeam/OpenList/v4/internal/conf"
+	"github.com/OpenListTeam/OpenList/v4/internal/fs"
+	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
+	"github.com/OpenListTeam/OpenList/v4/server"
+	"github.com/OpenListTeam/OpenList/v4/server/middlewares"
+	"github.com/OpenListTeam/sftpd-openlist"
+	ftpserver "github.com/fclairamb/ftpserverlib"
 	"github.com/gin-gonic/gin"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
@@ -29,127 +35,220 @@ var ServerCmd = &cobra.Command{
 	Short: "Start the server at the specified address",
 	Long: `Start the server at the specified address
 the address is defined in config file`,
-	Run: func(_ *cobra.Command, args []string) {
+	Run: func(cmd *cobra.Command, args []string) {
-		serverCtx, serverCancel := context.WithCancel(context.Background())
+		Init()
-		defer serverCancel()
+		if conf.Conf.DelayedStart != 0 {
-		Init(serverCtx)
+			utils.Log.Infof("delayed start for %d seconds", conf.Conf.DelayedStart)
-
+			time.Sleep(time.Duration(conf.Conf.DelayedStart) * time.Second)
-		if !flags.Debug {
+		}
+		bootstrap.InitOfflineDownloadTools()
+		bootstrap.LoadStorages()
+		bootstrap.InitTaskManager()
+		if !flags.Debug && !flags.Dev {
 			gin.SetMode(gin.ReleaseMode)
 		}
 		r := gin.New()
-		r.Use(gin.LoggerWithWriter(log.StandardLogger().Out))
-		r.Use(gin.RecoveryWithWriter(log.StandardLogger().Out))
-		server.Init(r)
 
+		// gin log
+		if conf.Conf.Log.Filter.Enable {
+			r.Use(middlewares.FilteredLogger())
+		} else {
+			r.Use(gin.LoggerWithWriter(log.StandardLogger().Out))
+		}
+		r.Use(gin.RecoveryWithWriter(log.StandardLogger().Out))
+
+		server.Init(r)
 		var httpHandler http.Handler = r
 		if conf.Conf.Scheme.EnableH2c {
 			httpHandler = h2c.NewHandler(r, &http2.Server{})
 		}
 		var httpSrv, httpsSrv, unixSrv *http.Server
-		if conf.Conf.Scheme.HttpPort > 0 {
+		if conf.Conf.Scheme.HttpPort != -1 {
 			httpBase := fmt.Sprintf("%s:%d", conf.Conf.Scheme.Address, conf.Conf.Scheme.HttpPort)
-			log.Infoln("start HTTP server", "@", httpBase)
+			fmt.Printf("start HTTP server @ %s\n", httpBase)
+			utils.Log.Infof("start HTTP server @ %s", httpBase)
 			httpSrv = &http.Server{Addr: httpBase, Handler: httpHandler}
 			go func() {
 				err := httpSrv.ListenAndServe()
 				if err != nil && !errors.Is(err, http.ErrServerClosed) {
-					log.Errorln("start HTTP server", ":", err)
+					utils.Log.Fatalf("failed to start http: %s", err.Error())
-					serverCancel()
 				}
 			}()
 		}
-		if conf.Conf.Scheme.HttpsPort > 0 {
+		if conf.Conf.Scheme.HttpsPort != -1 {
 			httpsBase := fmt.Sprintf("%s:%d", conf.Conf.Scheme.Address, conf.Conf.Scheme.HttpsPort)
-			log.Infoln("start HTTPS server", "@", httpsBase)
+			fmt.Printf("start HTTPS server @ %s\n", httpsBase)
+			utils.Log.Infof("start HTTPS server @ %s", httpsBase)
 			httpsSrv = &http.Server{Addr: httpsBase, Handler: r}
 			go func() {
 				err := httpsSrv.ListenAndServeTLS(conf.Conf.Scheme.CertFile, conf.Conf.Scheme.KeyFile)
 				if err != nil && !errors.Is(err, http.ErrServerClosed) {
-					log.Errorln("start HTTPS server", ":", err)
+					utils.Log.Fatalf("failed to start https: %s", err.Error())
-					serverCancel()
 				}
 			}()
 		}
 		if conf.Conf.Scheme.UnixFile != "" {
-			log.Infoln("start Unix server", "@", conf.Conf.Scheme.UnixFile)
+			fmt.Printf("start unix server @ %s\n", conf.Conf.Scheme.UnixFile)
+			utils.Log.Infof("start unix server @ %s", conf.Conf.Scheme.UnixFile)
 			unixSrv = &http.Server{Handler: httpHandler}
 			go func() {
 				listener, err := net.Listen("unix", conf.Conf.Scheme.UnixFile)
 				if err != nil {
-					log.Errorln("start Unix server", ":", err)
+					utils.Log.Fatalf("failed to listen unix: %+v", err)
-					serverCancel()
-					return
 				}
-
+				// set socket file permission
 				mode, err := strconv.ParseUint(conf.Conf.Scheme.UnixFilePerm, 8, 32)
 				if err != nil {
-					log.Errorln("parse unix_file_perm", ":", err)
+					utils.Log.Errorf("failed to parse socket file permission: %+v", err)
 				} else {
 					err = os.Chmod(conf.Conf.Scheme.UnixFile, os.FileMode(mode))
 					if err != nil {
-						log.Errorln("chmod socket file", ":", err)
+						utils.Log.Errorf("failed to chmod socket file: %+v", err)
 					}
 				}
-
 				err = unixSrv.Serve(listener)
 				if err != nil && !errors.Is(err, http.ErrServerClosed) {
-					log.Errorln("start Unix server", ":", err)
+					utils.Log.Fatalf("failed to start unix: %s", err.Error())
-					serverCancel()
 				}
 			}()
 		}
-
+		if conf.Conf.S3.Port != -1 && conf.Conf.S3.Enable {
+			s3r := gin.New()
+			s3r.Use(gin.LoggerWithWriter(log.StandardLogger().Out), gin.RecoveryWithWriter(log.StandardLogger().Out))
+			server.InitS3(s3r)
+			s3Base := fmt.Sprintf("%s:%d", conf.Conf.Scheme.Address, conf.Conf.S3.Port)
+			fmt.Printf("start S3 server @ %s\n", s3Base)
+			utils.Log.Infof("start S3 server @ %s", s3Base)
+			go func() {
+				var err error
+				if conf.Conf.S3.SSL {
+					httpsSrv = &http.Server{Addr: s3Base, Handler: s3r}
+					err = httpsSrv.ListenAndServeTLS(conf.Conf.Scheme.CertFile, conf.Conf.Scheme.KeyFile)
+				}
+				if !conf.Conf.S3.SSL {
+					httpSrv = &http.Server{Addr: s3Base, Handler: s3r}
+					err = httpSrv.ListenAndServe()
+				}
+				if err != nil && !errors.Is(err, http.ErrServerClosed) {
+					utils.Log.Fatalf("failed to start s3 server: %s", err.Error())
+				}
+			}()
+		}
+		var ftpDriver *server.FtpMainDriver
+		var ftpServer *ftpserver.FtpServer
+		if conf.Conf.FTP.Listen != "" && conf.Conf.FTP.Enable {
+			var err error
+			ftpDriver, err = server.NewMainDriver()
+			if err != nil {
+				utils.Log.Fatalf("failed to start ftp driver: %s", err.Error())
+			} else {
+				fmt.Printf("start ftp server on %s\n", conf.Conf.FTP.Listen)
+				utils.Log.Infof("start ftp server on %s", conf.Conf.FTP.Listen)
+				go func() {
+					ftpServer = ftpserver.NewFtpServer(ftpDriver)
+					err = ftpServer.ListenAndServe()
+					if err != nil {
+						utils.Log.Fatalf("problem ftp server listening: %s", err.Error())
+					}
+				}()
+			}
+		}
+		var sftpDriver *server.SftpDriver
+		var sftpServer *sftpd.SftpServer
+		if conf.Conf.SFTP.Listen != "" && conf.Conf.SFTP.Enable {
+			var err error
+			sftpDriver, err = server.NewSftpDriver()
+			if err != nil {
+				utils.Log.Fatalf("failed to start sftp driver: %s", err.Error())
+			} else {
+				fmt.Printf("start sftp server on %s", conf.Conf.SFTP.Listen)
+				utils.Log.Infof("start sftp server on %s", conf.Conf.SFTP.Listen)
+				go func() {
+					sftpServer = sftpd.NewSftpServer(sftpDriver)
+					err = sftpServer.RunServer()
+					if err != nil {
+						utils.Log.Fatalf("problem sftp server listening: %s", err.Error())
+					}
+				}()
+			}
+		}
+		// Wait for interrupt signal to gracefully shutdown the server with
+		// a timeout of 1 second.
 		quit := make(chan os.Signal, 1)
 		// kill (no param) default send syscanll.SIGTERM
 		// kill -2 is syscall.SIGINT
 		// kill -9 is syscall. SIGKILL but can"t be catch, so don't need add it
 		signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
-		select {
+		<-quit
-		case <-quit:
+		utils.Log.Println("Shutdown server...")
-		case <-serverCtx.Done():
+		fs.ArchiveContentUploadTaskManager.RemoveAll()
-		}
-
-		log.Println("shutdown server...")
 		Release()
-
+		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-		quitCtx, quitCancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
-		defer quitCancel()
 		var wg sync.WaitGroup
-		if httpSrv != nil {
+		if conf.Conf.Scheme.HttpPort != -1 {
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
-				if err := httpSrv.Shutdown(quitCtx); err != nil {
+				if err := httpSrv.Shutdown(ctx); err != nil {
-					log.Errorln("shutdown HTTP server", ":", err)
+					utils.Log.Fatal("HTTP server shutdown err: ", err)
 				}
 			}()
 		}
-		if httpsSrv != nil {
+		if conf.Conf.Scheme.HttpsPort != -1 {
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
-				if err := httpsSrv.Shutdown(quitCtx); err != nil {
+				if err := httpsSrv.Shutdown(ctx); err != nil {
-					log.Errorln("shutdown HTTPS server", ":", err)
+					utils.Log.Fatal("HTTPS server shutdown err: ", err)
 				}
 			}()
 		}
-		if unixSrv != nil {
+		if conf.Conf.Scheme.UnixFile != "" {
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
-				if err := unixSrv.Shutdown(quitCtx); err != nil {
+				if err := unixSrv.Shutdown(ctx); err != nil {
-					log.Errorln("shutdown Unix server", ":", err)
+					utils.Log.Fatal("Unix server shutdown err: ", err)
+				}
+			}()
+		}
+		if conf.Conf.FTP.Listen != "" && conf.Conf.FTP.Enable && ftpServer != nil && ftpDriver != nil {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				ftpDriver.Stop()
+				if err := ftpServer.Stop(); err != nil {
+					utils.Log.Fatal("FTP server shutdown err: ", err)
+				}
+			}()
+		}
+		if conf.Conf.SFTP.Listen != "" && conf.Conf.SFTP.Enable && sftpServer != nil && sftpDriver != nil {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				if err := sftpServer.Close(); err != nil {
+					utils.Log.Fatal("SFTP server shutdown err: ", err)
 				}
 			}()
 		}
 		wg.Wait()
-		log.Println("server exit")
+		utils.Log.Println("Server exit")
 	},
 }
 
 func init() {
 	RootCmd.AddCommand(ServerCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// serverCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// serverCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
 }
 
 // OutOpenListInit 暴露用于外部启动server的函数

docker-compose.yml

@@ -6,10 +6,9 @@ services:
     ports:
       - '5244:5244'
       - '5245:5245'
+    user: '0:0'
     environment:
-      - PUID=0
-      - PGID=0
       - UMASK=022
-      - TZ=UTC
+      - TZ=Asia/Shanghai
     container_name: openlist
     image: 'openlistteam/openlist:latest'

drivers/123_open/driver.go

@@ -69,13 +69,45 @@ func (d *Open123) List(ctx context.Context, dir model.Obj, args model.ListArgs)
 func (d *Open123) Link(ctx context.Context, file model.Obj, args model.LinkArgs) (*model.Link, error) {
 	fileId, _ := strconv.ParseInt(file.GetID(), 10, 64)
 
+	if d.DirectLink {
+		res, err := d.getDirectLink(fileId)
+		if err != nil {
+			return nil, err
+		}
+
+		if d.DirectLinkPrivateKey == "" {
+			duration := 365 * 24 * time.Hour // 缓存1年
+			return &model.Link{
+				URL:        res.Data.URL,
+				Expiration: &duration,
+			}, nil
+		}
+
+		u, err := d.getUserInfo()
+		if err != nil {
+			return nil, err
+		}
+
+		duration := time.Duration(d.DirectLinkValidDuration) * time.Minute
+
+		newURL, err := d.SignURL(res.Data.URL, d.DirectLinkPrivateKey,
+			u.Data.UID, duration)
+		if err != nil {
+			return nil, err
+		}
+
+		return &model.Link{
+			URL:        newURL,
+			Expiration: &duration,
+		}, nil
+	}
+
 	res, err := d.getDownloadInfo(fileId)
 	if err != nil {
 		return nil, err
 	}
 
-	link := model.Link{URL: res.Data.DownloadUrl}
+	return &model.Link{URL: res.Data.DownloadUrl}, nil
-	return &link, nil
 }
 
 func (d *Open123) MakeDir(ctx context.Context, parentDir model.Obj, dirName string) error {

drivers/123_open/meta.go

@@ -23,6 +23,11 @@ type Addition struct {
 	//  上传线程数
 	UploadThread int `json:"UploadThread" type:"number" default:"3" help:"the threads of upload"`
 
+	//  使用直链
+	DirectLink              bool   `json:"DirectLink" type:"boolean" default:"false" required:"false" help:"use direct link when download file"`
+	DirectLinkPrivateKey    string `json:"DirectLinkPrivateKey" required:"false" help:"private key for direct link, if URL authentication is enabled"`
+	DirectLinkValidDuration int64  `json:"DirectLinkValidDuration" type:"number" default:"30" required:"false" help:"minutes, if URL authentication is enabled"`
+
 	driver.RootID
 }
 

drivers/123_open/types.go

@@ -127,7 +127,7 @@ type RefreshTokenResp struct {
 type UserInfoResp struct {
 	BaseResp
 	Data struct {
-		UID            int64  `json:"uid"`
+		UID            uint64 `json:"uid"`
 		Username       string `json:"username"`
 		DisplayName    string `json:"displayName"`
 		HeadImage      string `json:"headImage"`
@@ -158,6 +158,13 @@ type DownloadInfoResp struct {
 	} `json:"data"`
 }
 
+type DirectLinkResp struct {
+	BaseResp
+	Data struct {
+		URL string `json:"url"`
+	} `json:"data"`
+}
+
 // 创建文件V2返回
 type UploadCreateResp struct {
 	BaseResp

drivers/123_open/upload.go

@@ -70,6 +70,8 @@ func (d *Open123) Upload(ctx context.Context, file model.FileStreamer, createRes
 		var reader *stream.SectionReader
 		var rateLimitedRd io.Reader
 		sliceMD5 := ""
+		// 表单
+		b := bytes.NewBuffer(make([]byte, 0, 2048))
 		threadG.GoWithLifecycle(errgroup.Lifecycle{
 			Before: func(ctx context.Context) error {
 				if reader == nil {
@@ -84,7 +86,6 @@ func (d *Open123) Upload(ctx context.Context, file model.FileStreamer, createRes
 					if err != nil {
 						return err
 					}
-					rateLimitedRd = driver.NewLimitedUploadStream(ctx, reader)
 				}
 				return nil
 			},
@@ -92,9 +93,8 @@ func (d *Open123) Upload(ctx context.Context, file model.FileStreamer, createRes
 				// 重置分片reader位置，因为HashReader、上一次失败已经读取到分片EOF
 				reader.Seek(0, io.SeekStart)
 
-				// 创建表单数据
+				b.Reset()
-				var b bytes.Buffer
+				w := multipart.NewWriter(b)
-				w := multipart.NewWriter(&b)
 				// 添加表单字段
 				err = w.WriteField("preuploadID", createResp.Data.PreuploadID)
 				if err != nil {
@@ -109,21 +109,20 @@ func (d *Open123) Upload(ctx context.Context, file model.FileStreamer, createRes
 					return err
 				}
 				// 写入文件内容
-				fw, err := w.CreateFormFile("slice", fmt.Sprintf("%s.part%d", file.GetName(), partNumber))
+				_, err = w.CreateFormFile("slice", fmt.Sprintf("%s.part%d", file.GetName(), partNumber))
-				if err != nil {
-					return err
-				}
-				_, err = utils.CopyWithBuffer(fw, rateLimitedRd)
 				if err != nil {
 					return err
 				}
+				headSize := b.Len()
 				err = w.Close()
 				if err != nil {
 					return err
 				}
-
+				head := bytes.NewReader(b.Bytes()[:headSize])
+				tail := bytes.NewReader(b.Bytes()[headSize:])
+				rateLimitedRd = driver.NewLimitedUploadStream(ctx, io.MultiReader(head, reader, tail))
 				// 创建请求并设置header
-				req, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadDomain+"/upload/v2/file/slice", &b)
+				req, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadDomain+"/upload/v2/file/slice", rateLimitedRd)
 				if err != nil {
 					return err
 				}

drivers/123_open/util.go

@@ -1,15 +1,20 @@
 package _123_open
 
 import (
+	"crypto/md5"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"net/http"
+	"net/url"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/OpenListTeam/OpenList/v4/drivers/base"
 	"github.com/OpenListTeam/OpenList/v4/internal/op"
 	"github.com/go-resty/resty/v2"
+	"github.com/google/uuid"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -20,7 +25,8 @@ var ( //不同情况下获取的AccessTokenQPS限制不同 如下模块化易于
 	RefreshToken   = InitApiInfo(Api+"/api/v1/oauth2/access_token", 1)
 	UserInfo       = InitApiInfo(Api+"/api/v1/user/info", 1)
 	FileList       = InitApiInfo(Api+"/api/v2/file/list", 3)
-	DownloadInfo   = InitApiInfo(Api+"/api/v1/file/download_info", 0)
+	DownloadInfo   = InitApiInfo(Api+"/api/v1/file/download_info", 5)
+	DirectLink     = InitApiInfo(Api+"/api/v1/direct-link/url", 5)
 	Mkdir          = InitApiInfo(Api+"/upload/v1/file/mkdir", 2)
 	Move           = InitApiInfo(Api+"/api/v1/file/move", 1)
 	Rename         = InitApiInfo(Api+"/api/v1/file/name", 1)
@@ -112,6 +118,33 @@ func (d *Open123) flushAccessToken() error {
 	return nil
 }
 
+func (d *Open123) SignURL(originURL, privateKey string, uid uint64, validDuration time.Duration) (newURL string, err error) {
+	// 生成Unix时间戳
+	ts := time.Now().Add(validDuration).Unix()
+
+	// 生成随机数（建议使用UUID，不能包含中划线（-））
+	rand := strings.ReplaceAll(uuid.New().String(), "-", "")
+
+	// 解析URL
+	objURL, err := url.Parse(originURL)
+	if err != nil {
+		return "", err
+	}
+
+	// 待签名字符串，格式：path-timestamp-rand-uid-privateKey
+	unsignedStr := fmt.Sprintf("%s-%d-%s-%d-%s", objURL.Path, ts, rand, uid, privateKey)
+	md5Hash := md5.Sum([]byte(unsignedStr))
+	// 生成鉴权参数，格式：timestamp-rand-uid-md5hash
+	authKey := fmt.Sprintf("%d-%s-%d-%x", ts, rand, uid, md5Hash)
+
+	// 添加鉴权参数到URL查询参数
+	v := objURL.Query()
+	v.Add("auth_key", authKey)
+	objURL.RawQuery = v.Encode()
+
+	return objURL.String(), nil
+}
+
 func (d *Open123) getUserInfo() (*UserInfoResp, error) {
 	var resp UserInfoResp
 
@@ -159,6 +192,21 @@ func (d *Open123) getDownloadInfo(fileId int64) (*DownloadInfoResp, error) {
 	return &resp, nil
 }
 
+func (d *Open123) getDirectLink(fileId int64) (*DirectLinkResp, error) {
+	var resp DirectLinkResp
+
+	_, err := d.Request(DirectLink, http.MethodGet, func(req *resty.Request) {
+		req.SetQueryParams(map[string]string{
+			"fileId": strconv.FormatInt(fileId, 10),
+		})
+	}, &resp)
+	if err != nil {
+		return nil, err
+	}
+
+	return &resp, nil
+}
+
 func (d *Open123) mkdir(parentID int64, name string) error {
 	_, err := d.Request(Mkdir, http.MethodPost, func(req *resty.Request) {
 		req.SetBody(base.Json{