Skip to content

PasteFerry (隔空贴): clipboard and file sync across macOS, Windows and Linux. Direct-first, end-to-end encrypted. Optional official access: no server to host. Independent self-hosting remains available.

Windows 后台服务:剪贴板、文件名、进程管理、私钥加密

baiyuzeaa6c63248014
diff --git a/client-core/cmd/copysyncd/logfile.go b/client-core/cmd/copysyncd/logfile.go
new file mode 100644
index 0000000..ffb22e8
--- /dev/null
+++ b/client-core/cmd/copysyncd/logfile.go
@@ -0,0 +1,76 @@
+package main
+
+import (
+ "os"
+ "path/filepath"
+ "sync"
+)
+
+// rotatingFile 是按大小轮转的日志文件:超过上限就把当前文件改名为 .1(覆盖更早的),
+// 再从头写一个新的。最多占用两倍上限的空间。
+//
+// Mac 上日志由 launchd 重定向到文件,用不到它;Windows 上后台服务没有控制台,
+// 日志只能自己写。
+type rotatingFile struct {
+ mu sync.Mutex
+ path string
+ max int64
+ f *os.File
+ size int64
+}
+
+func openRotating(path string, max int64) (*rotatingFile, error) {
+ if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+ return nil, err
+ }
+ r := &rotatingFile{path: path, max: max}
+ if err := r.open(); err != nil {
+ return nil, err
+ }
+ if r.size > max {
+ r.rotate()
+ }
+ return r, nil
+}
+
+func (r *rotatingFile) open() error {
+ f, err := os.OpenFile(r.path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o600)
+ if err != nil {
+ return err
+ }
+ r.f = f
+ r.size = 0
+ if info, err := f.Stat(); err == nil {
+ r.size = info.Size()
+ }
+ return nil
+}
+
+func (r *rotatingFile) Write(p []byte) (int, error) {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+ if r.size+int64(len(p)) > r.max {
+ r.rotate()
+ }
+ n, err := r.f.Write(p)
+ r.size += int64(n)
+ return n, err
+}
+
+// rotate 换一个新文件。改名失败(比如正被别的程序以独占方式打开)就接着往原文件写,
+// 下次再试:日志写不进去比日志过大更糟。
+func (r *rotatingFile) rotate() {
+ r.f.Close()
+ _ = os.Remove(r.path + ".1")
+ _ = os.Rename(r.path, r.path+".1")
+ if err := r.open(); err != nil {
+ // 连新文件都开不了,只能丢弃后续日志
+ r.f, _ = os.OpenFile(os.DevNull, os.O_WRONLY, 0)
+ }
+}
+
+func (r *rotatingFile) Close() error {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+ return r.f.Close()
+}
diff --git a/client-core/cmd/copysyncd/logfile_test.go b/client-core/cmd/copysyncd/logfile_test.go
new file mode 100644
index 0000000..f2df917
--- /dev/null
+++ b/client-core/cmd/copysyncd/logfile_test.go
@@ -0,0 +1,39 @@
+package main
+
+import (
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+)
+
+func TestRotatingFile(t *testing.T) {
+ path := filepath.Join(t.TempDir(), "logs", "daemon.log")
+ r, err := openRotating(path, 100)
+ if err != nil {
+ t.Fatal(err)
+ }
+ line := strings.Repeat("x", 39) + "\n" // 40 字节
+ for range 5 {
+ if _, err := r.Write([]byte(line)); err != nil {
+ t.Fatal(err)
+ }
+ }
+ r.Close()
+
+ cur, _ := os.ReadFile(path)
+ old, _ := os.ReadFile(path + ".1")
+ // 写到第 3 行时超出 100 字节,前两行转到 .1;第 5 行时再转一次
+ if len(cur) != 40 || len(old) != 80 {
+ t.Errorf("当前 %d 字节、上一份 %d 字节,应为 40、80", len(cur), len(old))
+ }
+
+ // 重新打开时接着已有的大小算
+ r, _ = openRotating(path, 100)
+ r.Write([]byte(line))
+ r.Write([]byte(line))
+ r.Close()
+ if cur, _ := os.ReadFile(path); len(cur) != 40 {
+ t.Errorf("重新打开后当前文件 %d 字节,应已轮转为 40", len(cur))
+ }
+}
diff --git a/client-core/cmd/copysyncd/main.go b/client-core/cmd/copysyncd/main.go
index 6121dba..736296f 100644
--- a/client-core/cmd/copysyncd/main.go
+++ b/client-core/cmd/copysyncd/main.go
@@ -7,6 +7,7 @@ package main
import (
"context"
+ "errors"
"flag"
"fmt"
"log/slog"
@@ -47,14 +48,24 @@ func main() {
verbose = flag.Bool("v", false, "输出调试日志")
probe = flag.Bool("probe-clipboard", false,
"诊断用:在主线程直接读一次剪贴板并打印结果后退出")
+ supervise = flag.Bool("supervise", false,
+ "守护模式:拉起后台服务,异常退出时自动重启(Windows 开机自启用)")
)
flag.Parse()
+ if *supervise {
+ os.Exit(runSupervisor(*dataDir))
+ }
+
level := slog.LevelInfo
if *verbose {
level = slog.LevelDebug
}
- slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: level})))
+ logOut := logOutput(*dataDir)
+ if *probe {
+ logOut = os.Stderr
+ }
+ slog.SetDefault(slog.New(slog.NewTextHandler(logOut, &slog.HandlerOptions{Level: level})))
if *probe {
probeClipboard()
@@ -62,11 +73,20 @@ func main() {
}
if err := run(*dataDir); err != nil {
+ if errors.Is(err, errAlreadyRunning) {
+ slog.Info("已有后台服务在运行,本进程退出")
+ os.Exit(exitAlreadyRunning)
+ }
slog.Error("daemon 退出", "err", err)
os.Exit(1)
}
}
+// exitAlreadyRunning 是「已有实例在运行」的退出码。Windows 的守护进程见到它就不再重启。
+const exitAlreadyRunning = 3
+
+var errAlreadyRunning = errors.New("已有后台服务在运行")
+
// probeClipboard 在主线程直接走一遍探测与读取,用来把剪贴板问题
// 与 daemon 的其余部分隔离开。
func probeClipboard() {
@@ -99,12 +119,20 @@ func probeClipboard() {
func run(dataDir string) error {
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
+ // 注销、关机时由剪贴板窗口收到系统通知后调用(目前只有 Windows),见下方 SetSystemHooks
+ ctx, cancel := context.WithCancel(ctx)
+ defer cancel()
// ── 路径与配置 ──
paths, err := resolvePaths(dataDir)
if err != nil {
return err
}
+ release, ok := acquireInstance(paths.Root)
+ if !ok {
+ return errAlreadyRunning
+ }
+ defer release()
if err := paths.EnsureDirs(); err != nil {
return err
}
@@ -354,8 +382,20 @@ func run(dataDir string) error {
slog.Info("daemon 已就绪",
"port", port, "endpoint", paths.Endpoint, "cache", paths.Cache)
+ // 系统事件(目前只有 Windows 上报):注销关机时正常退出,唤醒后立即重新探测网络
+ clipboard.SetSystemHooks(
+ func() {
+ slog.Info("系统正在注销或关机,退出")
+ cancel()
+ },
+ func() {
+ slog.Info("从睡眠中唤醒,重新探测网络出口")
+ peerMgr.P2P().Reprobe()
+ },
+ )
+
// ── 主线程交给 MainLoop ──
- // 剪贴板相关的一切都在这条线程上执行,同时驱动 macOS run loop。
+ // 剪贴板相关的一切都在这条线程上执行,同时驱动平台的事件循环(macOS 的 run loop、Windows 的消息泵)。
loop.Run(ctx)
slog.Info("正在退出")
diff --git a/client-core/cmd/copysyncd/platform_other.go b/client-core/cmd/copysyncd/platform_other.go
new file mode 100644
index 0000000..7c86c78
--- /dev/null
+++ b/client-core/cmd/copysyncd/platform_other.go
@@ -0,0 +1,19 @@
+//go:build !windows
+
+package main
+
+import (
+ "io"
+ "os"
+)
+
+// Mac 上这些都由 launchd 负责:日志重定向到文件、只运行一个实例、崩溃自动拉起。
+
+func logOutput(string) io.Writer { return os.Stderr }
+
+func acquireInstance(string) (release func(), ok bool) { return func() {}, true }
+
+func runSupervisor(string) int {
+ os.Stderr.WriteString("-supervise 只在 Windows 上使用;这个平台由系统服务管理器负责拉起\n")
+ return 2
+}
diff --git a/client-core/cmd/copysyncd/platform_windows.go b/client-core/cmd/copysyncd/platform_windows.go
new file mode 100644
index 0000000..7eab354
--- /dev/null
+++ b/client-core/cmd/copysyncd/platform_windows.go
@@ -0,0 +1,136 @@
+//go:build windows
+
+package main
+
+// Windows 上 launchd 管的那些事要自己做:日志写文件、只运行一个实例、崩溃自动重启。
+//
+// 开机自启由界面在 HKCU\...\Run 下登记「copysyncd.exe -supervise」,
+// 守护进程再拉起真正干活的子进程(见 runSupervisor)。
+
+import (
+ "crypto/sha256"
+ "encoding/hex"
+ "errors"
+ "io"
+ "log/slog"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "runtime/debug"
+ "strings"
+ "time"
+
+ "golang.org/x/sys/windows"
+)
+
+const (
+ logMaxSize = 10 << 20 // 10 MB,轮转后最多占 20 MB
+ // restartThrottle 与 Mac 上 LaunchAgent 的 ThrottleInterval 一致:崩溃后至少隔这么久再拉起
+ restartThrottle = 10 * time.Second
+)
+
+// logOutput 打开日志文件。后台服务以 GUI 子系统运行、没有控制台,标准错误输出不可用。
+// 未处理的 panic 另写到 crash.log:日志文件会轮转,崩溃信息不能跟着被挤掉。
+func logOutput(dataDir string) io.Writer {
+ paths, err := resolvePaths(dataDir)
+ if err != nil {
+ return io.Discard
+ }
+ dir := filepath.Join(paths.Root, "logs")
+ w, err := openRotating(filepath.Join(dir, "daemon.log"), logMaxSize)
+ if err != nil {
+ return io.Discard
+ }
+ if f, err := os.OpenFile(filepath.Join(dir, "crash.log"),
+ os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o600); err == nil {
+ _ = debug.SetCrashOutput(f, debug.CrashOptions{})
+ f.Close() // SetCrashOutput 会自己复制一份句柄
+ }
+ return w
+}
+
+// acquireInstance 保证同一个数据目录只有一个后台服务在运行。
+// 用命名互斥量:进程不管怎么退出,系统都会释放它,不会留下僵死的锁。
+func acquireInstance(root string) (release func(), ok bool) {
+ return acquireMutex("CopySync.Daemon." + dirKey(root))
+}
+
+func acquireMutex(name string) (release func(), ok bool) {
+ p, err := windows.UTF16PtrFromString(`Local\` + name)
+ if err != nil {
+ return func() {}, true
+ }
+ h, err := windows.CreateMutex(nil, false, p)
+ if errors.Is(err, windows.ERROR_ALREADY_EXISTS) {
+ windows.CloseHandle(h)
+ return nil, false
+ }
+ if err != nil {
+ // 建不了互斥量就不做单实例保护,总比起不来好
+ return func() {}, true
+ }
+ return func() { windows.CloseHandle(h) }, true
+}
+
+// dirKey 把数据目录变成互斥量名字的一部分:开发时用 -data-dir 起的第二个实例不受影响。
+func dirKey(root string) string {
+ sum := sha256.Sum256([]byte(strings.ToLower(filepath.Clean(root))))
+ return hex.EncodeToString(sum[:6])
+}
+
+// runSupervisor 是守护模式:拉起后台服务,它异常退出就隔一会儿再拉起。
+//
+// 子进程正常退出(退出码 0:用户注销、或界面要求停止)或发现已有实例在运行时,
+// 守护进程也随之退出。界面要重启服务时,把两者一起结束再重新启动守护进程。
+func runSupervisor(dataDir string) int {
+ paths, err := resolvePaths(dataDir)
+ if err != nil {
+ return 1
+ }
+ release, ok := acquireMutex("CopySync.Supervisor." + dirKey(paths.Root))
+ if !ok {
+ return 0 // 已经有守护进程在看着了
+ }
+ defer release()
+
+ logFile, err := openRotating(filepath.Join(paths.Root, "logs", "supervisor.log"), 1<<20)
+ log := slog.New(slog.NewTextHandler(io.Discard, nil))
+ if err == nil {
+ defer logFile.Close()
+ log = slog.New(slog.NewTextHandler(logFile, nil))
+ }
+
+ exe, err := os.Executable()
+ if err != nil {
+ log.Error("找不到自身的路径", "err", err)
+ return 1
+ }
+ var args []string
+ if dataDir != "" {
+ args = append(args, "-data-dir", dataDir)
+ }
+
+ for {
+ started := time.Now()
+ cmd := exec.Command(exe, args...)
+ err := cmd.Run()
+ code := 0
+ var exitErr *exec.ExitError
+ switch {
+ case errors.As(err, &exitErr):
+ code = exitErr.ExitCode()
+ case err != nil:
+ log.Error("启动后台服务失败", "err", err)
+ code = 1
+ }
+ if code == 0 || code == exitAlreadyRunning {
+ log.Info("后台服务已退出,守护结束", "code", code)
+ return 0
+ }
+ wait := restartThrottle - time.Since(started)
+ log.Warn("后台服务异常退出,稍后重启", "code", code, "等待", wait.Round(time.Second))
+ if wait > 0 {
+ time.Sleep(wait)
+ }
+ }
+}
diff --git a/client-core/go.mod b/client-core/go.mod
index 078e714..38f9804 100644
--- a/client-core/go.mod
+++ b/client-core/go.mod
@@ -28,8 +28,6 @@ require (
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
github.com/wlynxg/anet v0.0.5 // indirect
golang.org/x/crypto v0.54.0 // indirect
- golang.org/x/sys v0.47.0 // indirect
- golang.org/x/text v0.40.0 // indirect
golang.org/x/time v0.14.0 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20260706201446-f0a921348800 // indirect
modernc.org/libc v1.75.7 // indirect
@@ -53,6 +51,8 @@ require (
github.com/pion/stun/v4 v4.0.0
github.com/pion/webrtc/v4 v4.2.20
golang.org/x/net v0.57.0
+ golang.org/x/sys v0.47.0
+ golang.org/x/text v0.40.0
)
replace github.com/baiyuze/copysync/server => ../server
diff --git a/client-core/internal/clipboard/clipboard.go b/client-core/internal/clipboard/clipboard.go
index cdfd1a9..3f1f9fd 100644
--- a/client-core/internal/clipboard/clipboard.go
+++ b/client-core/internal/clipboard/clipboard.go
@@ -93,6 +93,9 @@ type Snapshot struct {
Kind Kind
ContentType string // UTType 标识符,如 public.plain-text
Types []string // 原始类型列表,排障用
+ // Sensitive 表示复制它的程序(多为密码管理器)标明了「不要记录、不要同步」。
+ // 目前只有 Windows 实现会设置,见 windows.go 的 sensitive
+ Sensitive bool
}
// Content 是剪贴板的实际内容。读取它可能触发授权弹窗。
diff --git a/client-core/internal/clipboard/events.go b/client-core/internal/clipboard/events.go
new file mode 100644
index 0000000..f33fa23
--- /dev/null
+++ b/client-core/internal/clipboard/events.go
@@ -0,0 +1,21 @@
+package clipboard
+
+// 平台通过这里把系统事件交给后台服务。目前只有 Windows 会上报(见 windows.go),
+// 其他平台这些值保持为空。
+
+// changeNotify 在系统通知剪贴板变化时收到一个信号,Watcher 据此立即探测。
+// 在 InitPlatform 里设置,之后不再改变。
+var changeNotify chan struct{}
+
+var (
+ onSessionEnd func() // 用户注销或关机
+ onResume func() // 从睡眠中唤醒
+)
+
+// SetSystemHooks 注册系统事件的回调,须在 MainLoop 运行之前调用。
+//
+// sessionEnd 在系统即将结束会话时于主线程上调用,不能阻塞:返回之后进程随时可能被结束。
+// resume 在唤醒后调用,此时网络多半已经变了。
+func SetSystemHooks(sessionEnd, resume func()) {
+ onSessionEnd, onResume = sessionEnd, resume
+}
diff --git a/client-core/internal/clipboard/other.go b/client-core/internal/clipboard/other.go
index 35395d0..dd146b4 100644
--- a/client-core/internal/clipboard/other.go
+++ b/client-core/internal/clipboard/other.go
@@ -1,22 +1,20 @@
-//go:build !darwin
+//go:build !darwin && !windows
package clipboard
import "time"
-// 非 macOS 平台的占位实现。Windows 的实现是二期工作(M6/M7):
-// 文本与图片走 SetClipboardData + WM_RENDERFORMAT,
-// 文件粘贴需要在 Go 里实现 COM IDataObject。
+// 既非 macOS 也非 Windows 的平台(目前只有 Linux,服务器端用不到剪贴板)的占位实现。
type stubClipboard struct{}
func New() Clipboard { return stubClipboard{} }
func InitPlatform() {}
-func (stubClipboard) Peek() (Snapshot, error) { return Snapshot{}, ErrUnsupported }
-func (stubClipboard) Read() (Content, error) { return Content{}, ErrUnsupported }
-func (stubClipboard) Write(Content) error { return ErrUnsupported }
-func (stubClipboard) Permission() Permission { return PermissionNotApplicable }
+func (stubClipboard) Peek() (Snapshot, error) { return Snapshot{}, ErrUnsupported }
+func (stubClipboard) Read() (Content, error) { return Content{}, ErrUnsupported }
+func (stubClipboard) Write(Content) error { return ErrUnsupported }
+func (stubClipboard) Permission() Permission { return PermissionNotApplicable }
func (stubClipboard) OpenPermissionSettings() error { return ErrUnsupported }
// 无原生事件循环可驱动时,单纯让出 CPU。
diff --git a/client-core/internal/clipboard/watcher.go b/client-core/internal/clipboard/watcher.go
index 0dd4aeb..19ae686 100644
--- a/client-core/internal/clipboard/watcher.go
+++ b/client-core/internal/clipboard/watcher.go
@@ -70,12 +70,17 @@ func (w *Watcher) Run(ctx context.Context) {
ticker := time.NewTicker(w.interval)
defer ticker.Stop()
+ // 系统主动通知剪贴板变化的平台(Windows)上立即探测,轮询只作兜底;
+ // 其他平台这个通道为空,永远不会触发
+ notify := changeNotify
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
w.poll(ctx)
+ case <-notify:
+ w.poll(ctx)
}
}
}
@@ -118,6 +123,11 @@ func (w *Watcher) poll(ctx context.Context) {
w.log.Debug("跳过本机写入触发的变化", "changeCount", snap.ChangeCount)
return
}
+ // 密码等敏感内容:不同步,也不进复制记录
+ if snap.Sensitive {
+ w.log.Debug("跳过标记为敏感的内容", "changeCount", snap.ChangeCount)
+ return
+ }
w.log.Debug("检测到剪贴板变化",
"changeCount", snap.ChangeCount, "kind", snap.Kind,
diff --git a/client-core/internal/clipboard/windows.go b/client-core/internal/clipboard/windows.go
new file mode 100644
index 0000000..a5ef296
--- /dev/null
+++ b/client-core/internal/clipboard/windows.go
@@ -0,0 +1,521 @@
+//go:build windows
+
+package clipboard
+
+// Windows 的剪贴板实现。纯 Go 调用 Win32,不用 cgo,在 Mac 上也能交叉编译。
+//
+// 线程模型与 macOS 相同:主线程(已 LockOSThread)创建一个隐藏窗口作为剪贴板的
+// 拥有者,并在 MainLoop 的空闲间隙泵消息。所有剪贴板操作都经 MainLoop 投递到这个
+// 线程执行。
+//
+// 隐藏窗口用普通的顶层窗口,而不是「仅消息窗口」(HWND_MESSAGE):后者收不到
+// 注销、关机、睡眠唤醒这些只发给顶层窗口的消息。
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "image/png"
+ "log/slog"
+ "sync"
+ "time"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+)
+
+var (
+ user32 = windows.NewLazySystemDLL("user32.dll")
+ kernel32 = windows.NewLazySystemDLL("kernel32.dll")
+
+ procOpenClipboard = user32.NewProc("OpenClipboard")
+ procCloseClipboard = user32.NewProc("CloseClipboard")
+ procEmptyClipboard = user32.NewProc("EmptyClipboard")
+ procGetClipboardData = user32.NewProc("GetClipboardData")
+ procSetClipboardData = user32.NewProc("SetClipboardData")
+ procIsClipboardFormatAvailable = user32.NewProc("IsClipboardFormatAvailable")
+ procRegisterClipboardFormatW = user32.NewProc("RegisterClipboardFormatW")
+ procGetClipboardSequenceNumber = user32.NewProc("GetClipboardSequenceNumber")
+ procAddClipboardFormatListener = user32.NewProc("AddClipboardFormatListener")
+ procRegisterClassExW = user32.NewProc("RegisterClassExW")
+ procCreateWindowExW = user32.NewProc("CreateWindowExW")
+ procDefWindowProcW = user32.NewProc("DefWindowProcW")
+ procPeekMessageW = user32.NewProc("PeekMessageW")
+ procTranslateMessage = user32.NewProc("TranslateMessage")
+ procDispatchMessageW = user32.NewProc("DispatchMessageW")
+ procMsgWaitForMultipleObjectsEx = user32.NewProc("MsgWaitForMultipleObjectsEx")
+
+ procGetModuleHandleW = kernel32.NewProc("GetModuleHandleW")
+ procGlobalAlloc = kernel32.NewProc("GlobalAlloc")
+ procGlobalFree = kernel32.NewProc("GlobalFree")
+ procGlobalLock = kernel32.NewProc("GlobalLock")
+ procGlobalUnlock = kernel32.NewProc("GlobalUnlock")
+ procGlobalSize = kernel32.NewProc("GlobalSize")
+)
+
+// 标准剪贴板格式
+const (
+ cfUnicodeText = 13
+ cfHDROP = 15
+ cfDIB = 8
+ cfDIBV5 = 17
+)
+
+// 窗口消息
+const (
+ wmQueryEndSession = 0x0011
+ wmEndSession = 0x0016
+ wmPowerBroadcast = 0x0218
+ wmClipboardUpdate = 0x031D
+ pbtAPMResumeAuto = 0x0012
+ pmRemove = 0x0001
+ qsAllInput = 0x04FF
+ mwmoInputAvailable = 0x0004
+ gmemMoveable = 0x0002
+ dropEffectCopy = 1
+)
+
+// 注册格式:按名字向系统换一个编号,各程序用同一个名字就能互通。
+var formats struct {
+ once sync.Once
+
+ png, html, dropEffect uint32
+ // 密码管理器用来声明「别记录、别同步」的标记,见 sensitive
+ exclude, viewerIgnore, canIncludeHistory, canUploadCloud uint32
+}
+
+func registerFormats() {
+ formats.once.Do(func() {
+ reg := func(name string) uint32 {
+ p, _ := windows.UTF16PtrFromString(name)
+ r, _, _ := procRegisterClipboardFormatW.Call(uintptr(unsafe.Pointer(p)))
+ return uint32(r)
+ }
+ formats.png = reg("PNG")
+ formats.html = reg("HTML Format")
+ formats.dropEffect = reg("Preferred DropEffect")
+ formats.exclude = reg("ExcludeClipboardContentFromMonitorProcessing")
+ formats.viewerIgnore = reg("Clipboard Viewer Ignore")
+ formats.canIncludeHistory = reg("CanIncludeInClipboardHistory")
+ formats.canUploadCloud = reg("CanUploadToCloudClipboard")
+ })
+}
+
+// owner 是隐藏窗口的句柄。写剪贴板必须有拥有者窗口:用空句柄打开剪贴板时,
+// EmptyClipboard 会把拥有者设为空,随后的 SetClipboardData 一律失败。
+var owner uintptr
+
+type windowsClipboard struct{}
+
+func New() Clipboard { return windowsClipboard{} }
+
+// InitPlatform 在主线程上创建隐藏窗口并订阅剪贴板变化。
+// 必须与 MainLoop.Run 在同一个线程上调用:窗口的消息只投递给创建它的线程。
+func InitPlatform() {
+ registerFormats()
+ changeNotify = make(chan struct{}, 1)
+ if err := createOwnerWindow(); err != nil {
+ slog.Error("创建剪贴板窗口失败,无法写入剪贴板", "err", err)
+ return
+ }
+ if r, _, err := procAddClipboardFormatListener.Call(owner); r == 0 {
+ // 不致命:Watcher 的轮询兜底
+ slog.Warn("订阅剪贴板变化失败,退回轮询", "err", err)
+ }
+}
+
+type wndClassEx struct {
+ Size uint32
+ Style uint32
+ WndProc uintptr
+ ClsExtra int32
+ WndExtra int32
+ Instance uintptr
+ Icon uintptr
+ Cursor uintptr
+ Background uintptr
+ MenuName *uint16
+ ClassName *uint16
+ IconSm uintptr
+}
+
+type winMsg struct {
+ Hwnd uintptr
+ Message uint32
+ WParam uintptr
+ LParam uintptr
+ Time uint32
+ Pt struct{ X, Y int32 }
+ Private uint32
+}
+
+// wndProcCallback 必须是包级变量:NewCallback 生成的回调数量有上限,且不能被回收。
+var wndProcCallback = windows.NewCallback(wndProc)
+
+func createOwnerWindow() error {
+ instance, _, _ := procGetModuleHandleW.Call(0)
+ className, _ := windows.UTF16PtrFromString("CopySyncClipboardOwner")
+ wc := wndClassEx{
+ Size: uint32(unsafe.Sizeof(wndClassEx{})),
+ WndProc: wndProcCallback,
+ Instance: instance,
+ ClassName: className,
+ }
+ if r, _, err := procRegisterClassExW.Call(uintptr(unsafe.Pointer(&wc))); r == 0 {
+ return fmt.Errorf("注册窗口类: %w", err)
+ }
+ title, _ := windows.UTF16PtrFromString("CopySync")
+ // 样式为 0、尺寸为 0,且从不 ShowWindow:用户看不到,任务栏上也没有
+ hwnd, _, err := procCreateWindowExW.Call(0,
+ uintptr(unsafe.Pointer(className)), uintptr(unsafe.Pointer(title)),
+ 0, 0, 0, 0, 0, 0, 0, instance, 0)
+ if hwnd == 0 {
+ return fmt.Errorf("创建窗口: %w", err)
+ }
+ owner = hwnd
+ return nil
+}
+
+func wndProc(hwnd, msg, wparam, lparam uintptr) uintptr {
+ switch msg {
+ case wmClipboardUpdate:
+ select {
+ case changeNotify <- struct{}{}:
+ default: // 已有一个未处理的信号,合并
+ }
+ return 0
+ case wmQueryEndSession:
+ return 1 // 同意结束会话
+ case wmEndSession:
+ if wparam != 0 && onSessionEnd != nil {
+ onSessionEnd()
+ }
+ return 0
+ case wmPowerBroadcast:
+ if wparam == pbtAPMResumeAuto && onResume != nil {
+ go onResume()
+ }
+ return 1
+ }
+ r, _, _ := procDefWindowProcW.Call(hwnd, msg, wparam, lparam)
+ return r
+}
+
+// pumpRunLoop 等待最多 seconds 秒,期间有消息就分发掉。
+func pumpRunLoop(seconds float64) {
+ procMsgWaitForMultipleObjectsEx.Call(0, 0, uintptr(seconds*1000), qsAllInput, mwmoInputAvailable)
+ var m winMsg
+ for {
+ if r, _, _ := procPeekMessageW.Call(uintptr(unsafe.Pointer(&m)), 0, 0, 0, pmRemove); r == 0 {
+ return
+ }
+ procTranslateMessage.Call(uintptr(unsafe.Pointer(&m)))
+ procDispatchMessageW.Call(uintptr(unsafe.Pointer(&m)))
+ }
+}
+
+// ─────────────────────────── 探测 ───────────────────────────
+
+func available(format uint32) bool {
+ if format == 0 {
+ return false
+ }
+ r, _, _ := procIsClipboardFormatAvailable.Call(uintptr(format))
+ return r != 0
+}
+
+// Peek 只看有哪些格式,不读内容,也不打开剪贴板(判定敏感标记时例外)。
+func (windowsClipboard) Peek() (Snapshot, error) {
+ registerFormats()
+ seq, _, _ := procGetClipboardSequenceNumber.Call()
+ snap := Snapshot{ChangeCount: int64(seq)}
+
+ known := []struct {
+ id uint32
+ name string
+ }{
+ {cfHDROP, "CF_HDROP"}, {formats.png, "PNG"}, {cfDIBV5, "CF_DIBV5"}, {cfDIB, "CF_DIB"},
+ {formats.html, "HTML Format"}, {cfUnicodeText, "CF_UNICODETEXT"},
+ }
+ for _, f := range known {
+ if available(f.id) {
+ snap.Types = append(snap.Types, f.name)
+ }
+ }
+
+ hasText := available(cfUnicodeText)
+ hasImage := available(formats.png) || available(cfDIBV5) || available(cfDIB)
+ switch {
+ case available(cfHDROP):
+ // 资源管理器复制文件时同时带着文件名文本,文件优先
+ snap.Kind, snap.ContentType = KindFile, "public.file-url"
+ case hasImage && !hasText:
+ // 截图、画图、浏览器里「复制图片」只有图片格式。Excel、Word 复制的内容
+ // 同时带着一份渲染出来的图片,但有文本,应当按文本处理
+ snap.Kind, snap.ContentType = KindImage, "public.png"
+ case available(formats.html):
+ snap.Kind, snap.ContentType = KindHTML, "public.html"
+ case hasText:
+ snap.Kind, snap.ContentType = KindText, "public.utf8-plain-text"
+ case hasImage:
+ snap.Kind, snap.ContentType = KindImage, "public.png"
+ }
+ snap.Sensitive = sensitive()
+ return snap, nil
+}
+
+// sensitive 判断复制内容的程序是否要求「别记录、别同步」。
+//
+// 约定见微软文档「Cloud Clipboard and Clipboard History Formats」:
+// - ExcludeClipboardContentFromMonitorProcessing、Clipboard Viewer Ignore:存在即是
+// - CanIncludeInClipboardHistory、CanUploadToCloudClipboard:值为 0 才是。
+// Bitwarden 只写前者,只看存在与否会漏掉、也会误伤
+func sensitive() bool {
+ if available(formats.exclude) || available(formats.viewerIgnore) {
+ return true
+ }
+ for _, f := range []uint32{formats.canIncludeHistory, formats.canUploadCloud} {
+ if !available(f) {
+ continue
+ }
+ v, err := readDWORD(f)
+ if err != nil || v == 0 {
+ return true // 有标记却读不出来,宁可当作敏感
+ }
+ }
+ return false
+}
+
+func readDWORD(format uint32) (uint32, error) {
+ if err := openClipboard(); err != nil {
+ return 0, err
+ }
+ defer procCloseClipboard.Call()
+ b, err := getData(format)
+ if err != nil {
+ return 0, err
+ }
+ if len(b) < 4 {
+ return 0, errors.New("数据过短")
+ }
+ return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24, nil
+}
+
+// ─────────────────────────── 读取 ───────────────────────────
+
+func (c windowsClipboard) Read() (Content, error) {
+ snap, err := c.Peek()
+ if err != nil {
+ return Content{}, err
+ }
+ if err := openClipboard(); err != nil {
+ return Content{}, err
+ }
+ defer procCloseClipboard.Call()
+
+ out := Content{Kind: snap.Kind}
+ switch snap.Kind {
+ case KindFile:
+ b, err := getData(cfHDROP)
+ if err != nil {
+ return Content{}, err
+ }
+ if out.Files, err = decodeDropFiles(b); err != nil {
+ return Content{}, err
+ }
+ if len(out.Files) == 0 {
+ return Content{}, errors.New("剪贴板中没有可读取的文件路径")
+ }
+
+ case KindText:
+ out.Text = readText()
+
+ case KindHTML:
+ b, err := getData(formats.html)
+ if err != nil {
+ return Content{}, err
+ }
+ if out.HTML, err = decodeCFHTML(b); err != nil {
+ return Content{}, err
+ }
+ out.Text = readText()
+
+ case KindImage:
+ if out.Image, err = readImage(); err != nil {
+ return Content{}, err
+ }
+
+ default:
+ return Content{}, fmt.Errorf("不支持的剪贴板类型:%v", snap.Types)
+ }
+ return out, nil
+}
+
+func readText() string {
+ b, err := getData(cfUnicodeText)
+ if err != nil {
+ return ""
+ }
+ return fromCRLF(utf16String(b))
+}
+
+// readImage 优先取 PNG(保留透明度、无损),没有再从位图转。
+func readImage() ([]byte, error) {
+ if b, err := getData(formats.png); err == nil {
+ if _, err := png.DecodeConfig(bytes.NewReader(b)); err == nil {
+ return b, nil
+ }
+ }
+ var lastErr error
+ for _, f := range []uint32{cfDIBV5, cfDIB} {
+ b, err := getData(f)
+ if err != nil {
+ lastErr = err
+ continue
+ }
+ img, err := dibToImage(b)
+ if err != nil {
+ lastErr = err
+ continue
+ }
+ var buf bytes.Buffer
+ if err := png.Encode(&buf, img); err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), nil
+ }
+ return nil, fmt.Errorf("读取剪贴板图片失败: %w", lastErr)
+}
+
+// ─────────────────────────── 写入 ───────────────────────────
+
+// Write 覆盖本机剪贴板。各格式的数据先准备好,再打开剪贴板一次写完:
+// 剪贴板打开期间别的程序都用不了它,要尽量短。
+func (windowsClipboard) Write(content Content) error {
+ registerFormats()
+ type item struct {
+ format uint32
+ data []byte
+ }
+ var items []item
+
+ switch content.Kind {
+ case KindFile:
+ if len(content.Files) == 0 {
+ return errors.New("没有要写入的文件路径")
+ }
+ items = append(items,
+ item{cfHDROP, encodeDropFiles(content.Files)},
+ // 资源管理器粘贴时据此执行复制而不是移动:缓存里的文件不能被挪走
+ item{formats.dropEffect, dwordBytes(dropEffectCopy)})
+
+ case KindText:
+ items = append(items, item{cfUnicodeText, utf16Bytes(toCRLF(content.Text))})
+
+ case KindHTML:
+ items = append(items, item{formats.html, encodeCFHTML(content.HTML)})
+ if content.Text != "" {
+ items = append(items, item{cfUnicodeText, utf16Bytes(toCRLF(content.Text))})
+ }
+
+ case KindImage:
+ if len(content.Image) == 0 {
+ return errors.New("没有要写入的图片数据")
+ }
+ img, err := png.Decode(bytes.NewReader(content.Image))
+ if err != nil {
+ return fmt.Errorf("解析图片: %w", err)
+ }
+ // PNG 给 Office、浏览器等新程序;位图给只认位图的程序(画图等),
+ // CF_DIB 与 CF_BITMAP 由系统从 CF_DIBV5 自动合成
+ items = append(items, item{formats.png, content.Image}, item{cfDIBV5, imageToDIBV5(img)})
+
+ default:
+ return fmt.Errorf("不支持写入的类型:%v", content.Kind)
+ }
+
+ // 别让 Windows 自带的云剪贴板再把它同步到用户的其他电脑:内容本来就是从别的设备来的。
+ // 带着这个标记,Peek 会把它判为敏感;Watcher 先按 selfWrites 跳过本端写入,不受影响
+ items = append(items, item{formats.canUploadCloud, dwordBytes(0)})
+
+ if owner == 0 {
+ return errors.New("剪贴板窗口未创建,无法写入")
+ }
+ if err := openClipboard(); err != nil {
+ return err
+ }
+ defer procCloseClipboard.Call()
+ if r, _, err := procEmptyClipboard.Call(); r == 0 {
+ return fmt.Errorf("清空剪贴板: %w", err)
+ }
+ for _, it := range items {
+ if err := setData(it.format, it.data); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (windowsClipboard) Permission() Permission { return PermissionNotApplicable }
+
+func (windowsClipboard) OpenPermissionSettings() error { return nil }
+
+// ─────────────────────────── 底层 ───────────────────────────
+
+// openClipboard 打开剪贴板。别的程序正打开着时会失败,稍等重试。
+func openClipboard() error {
+ var lastErr error
+ for range 10 {
+ if r, _, err := procOpenClipboard.Call(owner); r != 0 {
+ return nil
+ } else {
+ lastErr = err
+ }
+ time.Sleep(20 * time.Millisecond)
+ }
+ return fmt.Errorf("剪贴板被其他程序占用: %w", lastErr)
+}
+
+// getData 复制出某个格式的数据。剪贴板必须已打开。
+func getData(format uint32) ([]byte, error) {
+ h, _, err := procGetClipboardData.Call(uintptr(format))
+ if h == 0 {
+ return nil, fmt.Errorf("读取剪贴板格式 %d: %w", format, err)
+ }
+ size, _, _ := procGlobalSize.Call(h)
+ p, _, err := procGlobalLock.Call(h)
+ if p == 0 {
+ return nil, fmt.Errorf("锁定剪贴板数据: %w", err)
+ }
+ defer procGlobalUnlock.Call(h)
+ return bytes.Clone(unsafe.Slice((*byte)(sysPtr(p)), size)), nil
+}
+
+// setData 把数据放进剪贴板。成功后内存归系统所有,失败才由本端释放。
+func setData(format uint32, data []byte) error {
+ if format == 0 || len(data) == 0 {
+ return fmt.Errorf("无效的剪贴板数据(格式 %d)", format)
+ }
+ h, _, err := procGlobalAlloc.Call(gmemMoveable, uintptr(len(data)))
+ if h == 0 {
+ return fmt.Errorf("分配剪贴板内存: %w", err)
+ }
+ p, _, err := procGlobalLock.Call(h)
+ if p == 0 {
+ procGlobalFree.Call(h)
+ return fmt.Errorf("锁定剪贴板内存: %w", err)
+ }
+ copy(unsafe.Slice((*byte)(sysPtr(p)), len(data)), data)
+ procGlobalUnlock.Call(h)
+ if r, _, err := procSetClipboardData.Call(uintptr(format), h); r == 0 {
+ procGlobalFree.Call(h)
+ return fmt.Errorf("写入剪贴板格式 %d: %w", format, err)
+ }
+ return nil
+}
+
+// sysPtr 把系统调用返回的地址转成指针。
+//
+// 这块内存由系统分配(GlobalLock 锁定期间地址固定),不归 Go 的垃圾回收管。
+// 写成这样而不是 unsafe.Pointer(p),是为了不让 go vet 把它误报成指针误用。
+func sysPtr(p uintptr) unsafe.Pointer { return *(*unsafe.Pointer)(unsafe.Pointer(&p)) }
diff --git a/client-core/internal/clipboard/windows_test.go b/client-core/internal/clipboard/windows_test.go
new file mode 100644
index 0000000..250bf25
--- /dev/null
+++ b/client-core/internal/clipboard/windows_test.go
@@ -0,0 +1,217 @@
+//go:build windows
+
+package clipboard
+
+// 在真实的 Windows 剪贴板上做读写往返。会覆盖本机剪贴板的内容,
+// 需要交互式桌面(没有时自动跳过)。
+
+import (
+ "bytes"
+ "context"
+ "image"
+ "image/color"
+ "image/png"
+ "os"
+ "path/filepath"
+ "reflect"
+ "runtime"
+ "strings"
+ "sync"
+ "testing"
+ "time"
+)
+
+var (
+ testLoop *MainLoop
+ testLoopOnce sync.Once
+)
+
+// mainLoop 与 copysyncd 一样:一个锁定的线程创建窗口、泵消息,剪贴板操作都投递过去。
+func mainLoop(t *testing.T) *MainLoop {
+ t.Helper()
+ testLoopOnce.Do(func() {
+ l := NewMainLoop()
+ ready := make(chan struct{})
+ go func() {
+ runtime.LockOSThread()
+ InitPlatform()
+ close(ready)
+ l.Run(context.Background())
+ }()
+ <-ready
+ testLoop = l
+ })
+ if owner == 0 {
+ t.Skip("没有交互式桌面,创建不了剪贴板窗口")
+ }
+ return testLoop
+}
+
+func onMain[T any](t *testing.T, fn func() (T, error)) T {
+ t.Helper()
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+ v, err := CallResult(ctx, mainLoop(t), fn)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return v
+}
+
+func write(t *testing.T, c Content) Snapshot {
+ t.Helper()
+ cb := New()
+ onMain(t, func() (struct{}, error) { return struct{}{}, cb.Write(c) })
+ return onMain(t, cb.Peek)
+}
+
+func TestWindowsText(t *testing.T) {
+ before := onMain(t, New().Peek).ChangeCount
+ snap := write(t, Content{Kind: KindText, Text: "第一行\n第二行 😀"})
+ if snap.Kind != KindText || snap.ChangeCount == before {
+ t.Fatalf("Peek = %+v(写入前序号 %d)", snap, before)
+ }
+ got := onMain(t, New().Read)
+ if got.Text != "第一行\n第二行 😀" {
+ t.Errorf("读回 %q", got.Text)
+ }
+ // 剪贴板里存的是 CRLF,记事本才认
+ raw := onMain(t, func() (string, error) {
+ if err := openClipboard(); err != nil {
+ return "", err
+ }
+ defer procCloseClipboard.Call()
+ b, err := getData(cfUnicodeText)
+ return utf16String(b), err
+ })
+ if !strings.Contains(raw, "\r\n") {
+ t.Errorf("剪贴板里的原始文本 %q 没有 CRLF", raw)
+ }
+}
+
+func TestWindowsHTML(t *testing.T) {
+ snap := write(t, Content{Kind: KindHTML, HTML: "<p><b>粗体</b>与普通</p>", Text: "粗体与普通"})
+ if snap.Kind != KindHTML {
+ t.Fatalf("Kind = %v,格式 %v", snap.Kind, snap.Types)
+ }
+ got := onMain(t, New().Read)
+ if !strings.Contains(got.HTML, "<p><b>粗体</b>与普通</p>") || got.Text != "粗体与普通" {
+ t.Errorf("读回 HTML=%q Text=%q", got.HTML, got.Text)
+ }
+}
+
+func TestWindowsImage(t *testing.T) {
+ src := image.NewNRGBA(image.Rect(0, 0, 2, 2))
+ src.SetNRGBA(0, 0, color.NRGBA{255, 0, 0, 255})
+ src.SetNRGBA(1, 1, color.NRGBA{0, 0, 255, 100})
+ var buf bytes.Buffer
+ if err := png.Encode(&buf, src); err != nil {
+ t.Fatal(err)
+ }
+ snap := write(t, Content{Kind: KindImage, Image: buf.Bytes()})
+ if snap.Kind != KindImage || !strings.Contains(strings.Join(snap.Types, ","), "CF_DIB") {
+ t.Fatalf("Peek = %+v(系统应从 CF_DIBV5 合成 CF_DIB)", snap)
+ }
+ got := onMain(t, New().Read)
+ img, err := png.Decode(bytes.NewReader(got.Image))
+ if err != nil {
+ t.Fatal(err)
+ }
+ for _, p := range []image.Point{{0, 0}, {1, 1}} {
+ want := src.NRGBAAt(p.X, p.Y)
+ if c := color.NRGBAModel.Convert(img.At(p.X, p.Y)); c != want {
+ t.Errorf("%v = %v,应为 %v", p, c, want)
+ }
+ }
+}
+
+func TestWindowsFiles(t *testing.T) {
+ dir := t.TempDir()
+ var paths []string
+ for _, name := range []string{"报表 2026.xlsx", "a.txt"} {
+ p := filepath.Join(dir, name)
+ if err := os.WriteFile(p, []byte(name), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ paths = append(paths, p)
+ }
+ snap := write(t, Content{Kind: KindFile, Files: paths})
+ if snap.Kind != KindFile {
+ t.Fatalf("Kind = %v,格式 %v", snap.Kind, snap.Types)
+ }
+ got := onMain(t, New().Read)
+ if !reflect.DeepEqual(got.Files, paths) {
+ t.Errorf("读回 %v", got.Files)
+ }
+}
+
+// 剪贴板里同时有图片和文本(Excel、Word 复制的内容)时按文本处理。
+func TestWindowsRichContentIsNotImage(t *testing.T) {
+ src := image.NewNRGBA(image.Rect(0, 0, 1, 1))
+ snap := onMain(t, func() (Snapshot, error) {
+ if err := openClipboard(); err != nil {
+ return Snapshot{}, err
+ }
+ procEmptyClipboard.Call()
+ _ = setData(formats.html, encodeCFHTML("<table><tr><td>1</td></tr></table>"))
+ _ = setData(cfUnicodeText, utf16Bytes("1"))
+ _ = setData(cfDIBV5, imageToDIBV5(src))
+ procCloseClipboard.Call()
+ return New().Peek()
+ })
+ if snap.Kind != KindHTML {
+ t.Errorf("Kind = %v,应按带格式文本处理", snap.Kind)
+ }
+}
+
+func TestWindowsSensitive(t *testing.T) {
+ cases := []struct {
+ name string
+ marker func() (uint32, []byte)
+ want bool
+ }{
+ {"无标记", nil, false},
+ {"ExcludeClipboardContentFromMonitorProcessing", func() (uint32, []byte) { return formats.exclude, []byte{0} }, true},
+ {"Clipboard Viewer Ignore", func() (uint32, []byte) { return formats.viewerIgnore, []byte{0} }, true},
+ {"CanIncludeInClipboardHistory=0", func() (uint32, []byte) { return formats.canIncludeHistory, dwordBytes(0) }, true},
+ {"CanIncludeInClipboardHistory=1", func() (uint32, []byte) { return formats.canIncludeHistory, dwordBytes(1) }, false},
+ }
+ for _, c := range cases {
+ t.Run(c.name, func(t *testing.T) {
+ snap := onMain(t, func() (Snapshot, error) {
+ if err := openClipboard(); err != nil {
+ return Snapshot{}, err
+ }
+ procEmptyClipboard.Call()
+ _ = setData(cfUnicodeText, utf16Bytes("密码"))
+ if c.marker != nil {
+ f, data := c.marker()
+ if err := setData(f, data); err != nil {
+ procCloseClipboard.Call()
+ return Snapshot{}, err
+ }
+ }
+ procCloseClipboard.Call()
+ return New().Peek()
+ })
+ if snap.Sensitive != c.want {
+ t.Errorf("Sensitive = %v,应为 %v", snap.Sensitive, c.want)
+ }
+ })
+ }
+}
+
+// 剪贴板变化时系统会通知,Watcher 不必等下一轮轮询。
+func TestWindowsChangeNotify(t *testing.T) {
+ mainLoop(t)
+ select { // 清掉之前的测试留下的信号
+ case <-changeNotify:
+ default:
+ }
+ write(t, Content{Kind: KindText, Text: "通知"})
+ select {
+ case <-changeNotify:
+ case <-time.After(2 * time.Second):
+ t.Error("写入后没有收到剪贴板变化通知")
+ }
+}
diff --git a/client-core/internal/clipboard/winfmt.go b/client-core/internal/clipboard/winfmt.go
new file mode 100644
index 0000000..4c21705
--- /dev/null
+++ b/client-core/internal/clipboard/winfmt.go
@@ -0,0 +1,382 @@
+package clipboard
+
+// Windows 剪贴板格式与 CopySync 内部表示之间的转换。
+//
+// 都是纯函数,不依赖 Win32 API,放在没有构建标签的文件里:任何平台都能编译和测试,
+// 在 Mac 上开发时就能验证。实际调用在 windows.go。
+
+import (
+ "bytes"
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "image"
+ "image/color"
+ "strconv"
+ "strings"
+ "unicode/utf16"
+)
+
+// ─────────────────────────── 文本 ───────────────────────────
+
+// 网络上传输的文本一律用 LF;Windows 程序(记事本等)要的是 CRLF。
+
+func toCRLF(s string) string {
+ return strings.ReplaceAll(fromCRLF(s), "\n", "\r\n")
+}
+
+func fromCRLF(s string) string {
+ return strings.ReplaceAll(s, "\r\n", "\n")
+}
+
+// utf16Bytes 把字符串编码成以 NUL 结尾的 UTF-16LE,即 CF_UNICODETEXT 的内存布局。
+func utf16Bytes(s string) []byte {
+ u := utf16.Encode([]rune(s))
+ b := make([]byte, 2*len(u)+2)
+ for i, v := range u {
+ binary.LittleEndian.PutUint16(b[2*i:], v)
+ }
+ return b
+}
+
+// utf16String 解析 UTF-16LE,遇到 NUL 截止。剪贴板里的内存块常比内容大,结尾是填充。
+func utf16String(b []byte) string {
+ u := make([]uint16, 0, len(b)/2)
+ for i := 0; i+1 < len(b); i += 2 {
+ v := binary.LittleEndian.Uint16(b[i:])
+ if v == 0 {
+ break
+ }
+ u = append(u, v)
+ }
+ return string(utf16.Decode(u))
+}
+
+// ─────────────────────────── HTML ───────────────────────────
+
+// CF_HTML(注册名 "HTML Format")是 UTF-8 的 HTML,前面加一段文本头部,
+// 用字节偏移量标出整个 HTML 与其中「片段」的位置:
+//
+// Version:0.9
+// StartHTML:0000000105
+// EndHTML:0000000199
+// StartFragment:0000000141
+// EndFragment:0000000163
+// <html><body><!--StartFragment-->…<!--EndFragment--></body></html>
+//
+// 见 https://learn.microsoft.com/windows/win32/dataxchg/html-clipboard-format
+
+const (
+ fragmentStart = "<!--StartFragment-->"
+ fragmentEnd = "<!--EndFragment-->"
+)
+
+// encodeCFHTML 生成 CF_HTML。html 可以是完整文档,也可以只是片段。
+//
+// 片段的范围:html 里已有 StartFragment/EndFragment 注释(多半是从 Windows 复制来的)
+// 就沿用;没有的话,完整文档取 <body> 的内容,否则整段都是片段。
+func encodeCFHTML(html string) []byte {
+ doc := html
+ if !strings.Contains(doc, fragmentStart) || !strings.Contains(doc, fragmentEnd) {
+ lower := strings.ToLower(doc)
+ bodyOpen := strings.Index(lower, "<body")
+ bodyClose := strings.LastIndex(lower, "</body>")
+ if bodyOpen >= 0 && bodyClose > bodyOpen {
+ if end := strings.IndexByte(doc[bodyOpen:], '>'); end >= 0 {
+ inner := bodyOpen + end + 1
+ if inner <= bodyClose {
+ doc = doc[:inner] + fragmentStart + doc[inner:bodyClose] + fragmentEnd + doc[bodyClose:]
+ }
+ }
+ } else {
+ doc = "<html><body>" + fragmentStart + doc + fragmentEnd + "</body></html>"
+ }
+ }
+
+ // 头部长度固定:偏移量都写成 10 位数,先算好再填
+ const header = "Version:0.9\r\nStartHTML:%010d\r\nEndHTML:%010d\r\n" +
+ "StartFragment:%010d\r\nEndFragment:%010d\r\n"
+ headerLen := len(fmt.Sprintf(header, 0, 0, 0, 0))
+ startHTML := headerLen
+ endHTML := startHTML + len(doc)
+ startFrag := startHTML + strings.Index(doc, fragmentStart) + len(fragmentStart)
+ endFrag := startHTML + strings.Index(doc, fragmentEnd)
+
+ var b bytes.Buffer
+ fmt.Fprintf(&b, header, startHTML, endHTML, startFrag, endFrag)
+ b.WriteString(doc)
+ b.WriteByte(0)
+ return b.Bytes()
+}
+
+// decodeCFHTML 取出 CF_HTML 里的 HTML。
+//
+// 返回 StartHTML 到 EndHTML 之间的完整文档,而不只是片段:片段常常依赖外层的
+// <style>、表格结构(从 Excel 复制时片段只是几个 <tr>),单独拿出来格式会丢。
+func decodeCFHTML(b []byte) (string, error) {
+ if i := bytes.IndexByte(b, 0); i >= 0 {
+ b = b[:i]
+ }
+ fields := map[string]int{}
+ rest := b
+ for {
+ line, after, ok := bytes.Cut(rest, []byte("\n"))
+ key, val, isField := strings.Cut(strings.TrimRight(string(line), "\r"), ":")
+ if !ok || !isField || strings.ContainsAny(key, "<> ") {
+ break
+ }
+ if n, err := strconv.Atoi(strings.TrimSpace(val)); err == nil {
+ fields[key] = n
+ }
+ rest = after
+ }
+
+ start, okStart := fields["StartHTML"]
+ end, okEnd := fields["EndHTML"]
+ // 有的程序把 StartHTML 写成 -1(只有片段),或者偏移量越界:退回片段
+ if !okStart || !okEnd || start < 0 || end > len(b) || start >= end {
+ fs, okFS := fields["StartFragment"]
+ fe, okFE := fields["EndFragment"]
+ if !okFS || !okFE || fs < 0 || fe > len(b) || fs >= fe {
+ return "", errors.New("CF_HTML 头部缺少有效的偏移量")
+ }
+ return string(b[fs:fe]), nil
+ }
+ return string(b[start:end]), nil
+}
+
+// ─────────────────────────── 文件列表 ───────────────────────────
+
+// CF_HDROP 的内存布局:DROPFILES 结构(20 字节),紧跟以 NUL 分隔、
+// 以两个 NUL 结尾的路径表。
+//
+// typedef struct { DWORD pFiles; POINT pt; BOOL fNC; BOOL fWide; } DROPFILES;
+const dropFilesHeader = 20
+
+func encodeDropFiles(paths []string) []byte {
+ var b bytes.Buffer
+ var hdr [dropFilesHeader]byte
+ binary.LittleEndian.PutUint32(hdr[0:], dropFilesHeader) // pFiles:路径表的偏移
+ binary.LittleEndian.PutUint32(hdr[16:], 1) // fWide:UTF-16
+ b.Write(hdr[:])
+ for _, p := range paths {
+ b.Write(utf16Bytes(p))
+ }
+ b.Write([]byte{0, 0}) // 表尾再一个 NUL
+ return b.Bytes()
+}
+
+func decodeDropFiles(b []byte) ([]string, error) {
+ if len(b) < dropFilesHeader {
+ return nil, errors.New("CF_HDROP 数据过短")
+ }
+ off := int(binary.LittleEndian.Uint32(b[0:]))
+ wide := binary.LittleEndian.Uint32(b[16:]) != 0
+ if off < dropFilesHeader || off > len(b) {
+ return nil, errors.New("CF_HDROP 偏移量无效")
+ }
+ if !wide {
+ return nil, errors.New("不支持 ANSI 编码的文件列表")
+ }
+ var paths []string
+ rest := b[off:]
+ for len(rest) >= 2 {
+ s := utf16String(rest)
+ if s == "" {
+ break
+ }
+ paths = append(paths, s)
+ rest = rest[2*len(utf16.Encode([]rune(s)))+2:]
+ }
+ return paths, nil
+}
+
+// dwordBytes 是 "Preferred DropEffect"、"CanUploadToCloudClipboard" 这类格式的内容:一个 DWORD。
+func dwordBytes(v uint32) []byte {
+ b := make([]byte, 4)
+ binary.LittleEndian.PutUint32(b, v)
+ return b
+}
+
+// ─────────────────────────── 图片 ───────────────────────────
+
+// Windows 的位图格式 CF_DIB / CF_DIBV5:BITMAPINFOHEADER(40 字节)或
+// BITMAPV5HEADER(124 字节),之后是调色板或颜色掩码,最后是像素。
+// 行按 4 字节对齐;高度为正时自下而上存放。
+
+const (
+ biRGB = 0
+ biBitfields = 3
+ lcsSRGB = 0x73524742 // 'sRGB'
+)
+
+// dibToImage 解析 CF_DIB / CF_DIBV5。支持 32、24 位,以及 1、4、8 位调色板。
+func dibToImage(b []byte) (image.Image, error) {
+ if len(b) < 40 {
+ return nil, errors.New("位图数据过短")
+ }
+ le := binary.LittleEndian
+ hdrSize := int(le.Uint32(b[0:]))
+ width := int(int32(le.Uint32(b[4:])))
+ height := int(int32(le.Uint32(b[8:])))
+ bitCount := int(le.Uint16(b[14:]))
+ compression := le.Uint32(b[16:])
+ clrUsed := int(le.Uint32(b[32:]))
+
+ if hdrSize < 40 || hdrSize > len(b) || width <= 0 || height == 0 || width > 1<<15 {
+ return nil, fmt.Errorf("位图头部无效(头部 %d 字节,%d×%d)", hdrSize, width, height)
+ }
+ topDown := height < 0
+ if topDown {
+ height = -height
+ }
+ if height > 1<<15 {
+ return nil, fmt.Errorf("位图尺寸无效:%d×%d", width, height)
+ }
+
+ pos := hdrSize
+ // 颜色掩码:V4/V5 头部里自带;只有 40 字节头部时紧跟在头部之后
+ masks := [4]uint32{0x00FF0000, 0x0000FF00, 0x000000FF, 0}
+ if compression == biBitfields {
+ if hdrSize >= 56 {
+ for i := range 4 {
+ masks[i] = le.Uint32(b[40+4*i:])
+ }
+ } else {
+ if len(b) < pos+12 {
+ return nil, errors.New("位图缺少颜色掩码")
+ }
+ for i := range 3 {
+ masks[i] = le.Uint32(b[pos+4*i:])
+ }
+ pos += 12
+ }
+ } else if compression != biRGB {
+ return nil, fmt.Errorf("不支持压缩的位图(compression=%d)", compression)
+ }
+
+ var palette []color.NRGBA
+ if bitCount <= 8 {
+ n := clrUsed
+ if n == 0 {
+ n = 1 << bitCount
+ }
+ if len(b) < pos+4*n {
+ return nil, errors.New("位图调色板不完整")
+ }
+ for i := range n {
+ p := b[pos+4*i:]
+ palette = append(palette, color.NRGBA{R: p[2], G: p[1], B: p[0], A: 0xFF})
+ }
+ pos += 4 * n
+ }
+
+ stride := ((width*bitCount + 31) / 32) * 4
+ if len(b) < pos+stride*height {
+ return nil, errors.New("位图像素数据不完整")
+ }
+ pixels := b[pos:]
+
+ img := image.NewNRGBA(image.Rect(0, 0, width, height))
+ alphaSeen := false
+ for y := range height {
+ row := pixels[y*stride:]
+ dy := height - 1 - y
+ if topDown {
+ dy = y
+ }
+ for x := range width {
+ var c color.NRGBA
+ switch bitCount {
+ case 32:
+ v := le.Uint32(row[4*x:])
+ c = color.NRGBA{
+ R: maskChannel(v, masks[0]), G: maskChannel(v, masks[1]),
+ B: maskChannel(v, masks[2]), A: 0xFF,
+ }
+ if compression == biRGB {
+ c.A = row[4*x+3] // BI_RGB 的第四个字节约定俗成是透明度,但常常全是 0
+ } else if masks[3] != 0 {
+ c.A = maskChannel(v, masks[3])
+ }
+ if c.A != 0 {
+ alphaSeen = true
+ }
+ case 24:
+ c = color.NRGBA{R: row[3*x+2], G: row[3*x+1], B: row[3*x], A: 0xFF}
+ case 8, 4, 1:
+ bit := x * bitCount
+ idx := int(row[bit/8]>>(8-bitCount-bit%8)) & (1<<bitCount - 1)
+ if idx < len(palette) {
+ c = palette[idx]
+ }
+ default:
+ return nil, fmt.Errorf("不支持 %d 位的位图", bitCount)
+ }
+ img.SetNRGBA(x, dy, c)
+ }
+ }
+ // 透明度全为 0 说明这个通道没被使用(很多程序这样写 32 位位图),当作不透明
+ if bitCount == 32 && !alphaSeen {
+ for i := 3; i < len(img.Pix); i += 4 {
+ img.Pix[i] = 0xFF
+ }
+ }
+ return img, nil
+}
+
+// maskChannel 按掩码取出一个通道,并缩放到 8 位。
+func maskChannel(v, mask uint32) uint8 {
+ if mask == 0 {
+ return 0
+ }
+ shift := 0
+ for mask&1 == 0 {
+ mask >>= 1
+ shift++
+ }
+ val := (v >> shift) & mask
+ if mask == 0xFF {
+ return uint8(val)
+ }
+ return uint8(val * 0xFF / mask)
+}
+
+// imageToDIBV5 生成 CF_DIBV5:32 位、带透明通道、自下而上。
+// 写入时同时放 PNG,这份给只认位图的程序(画图、旧版 Office)用;
+// CF_DIB 与 CF_BITMAP 由系统从它自动合成。
+func imageToDIBV5(img image.Image) []byte {
+ const hdrSize = 124
+ bounds := img.Bounds()
+ w, h := bounds.Dx(), bounds.Dy()
+ size := w * h * 4
+
+ b := make([]byte, hdrSize+size)
+ le := binary.LittleEndian
+ le.PutUint32(b[0:], hdrSize)
+ le.PutUint32(b[4:], uint32(int32(w)))
+ le.PutUint32(b[8:], uint32(int32(h))) // 正数:自下而上
+ le.PutUint16(b[12:], 1) // planes
+ le.PutUint16(b[14:], 32)
+ le.PutUint32(b[16:], biBitfields)
+ le.PutUint32(b[20:], uint32(size))
+ le.PutUint32(b[40:], 0x00FF0000) // 红
+ le.PutUint32(b[44:], 0x0000FF00) // 绿
+ le.PutUint32(b[48:], 0x000000FF) // 蓝
+ le.PutUint32(b[52:], 0xFF000000) // 透明度
+ le.PutUint32(b[56:], lcsSRGB)
+ le.PutUint32(b[108:], 4) // bV5Intent = LCS_GM_IMAGES
+
+ px := b[hdrSize:]
+ for y := range h {
+ row := px[(h-1-y)*w*4:]
+ for x := range w {
+ c := color.NRGBAModel.Convert(img.At(bounds.Min.X+x, bounds.Min.Y+y)).(color.NRGBA)
+ row[4*x+0] = c.B
+ row[4*x+1] = c.G
+ row[4*x+2] = c.R
+ row[4*x+3] = c.A
+ }
+ }
+ return b
+}
diff --git a/client-core/internal/clipboard/winfmt_test.go b/client-core/internal/clipboard/winfmt_test.go
new file mode 100644
index 0000000..d8afdab
--- /dev/null
+++ b/client-core/internal/clipboard/winfmt_test.go
@@ -0,0 +1,225 @@
+package clipboard
+
+import (
+ "encoding/binary"
+ "image"
+ "image/color"
+ "reflect"
+ "strings"
+ "testing"
+)
+
+func TestCRLF(t *testing.T) {
+ if got := toCRLF("a\nb\r\nc"); got != "a\r\nb\r\nc" {
+ t.Errorf("toCRLF = %q", got)
+ }
+ if got := fromCRLF("a\r\nb\nc"); got != "a\nb\nc" {
+ t.Errorf("fromCRLF = %q", got)
+ }
+}
+
+func TestUTF16(t *testing.T) {
+ for _, s := range []string{"", "hello", "中文:复制", "emoji 😀 与组合字符 が"} {
+ b := utf16Bytes(s)
+ if b[len(b)-1] != 0 || b[len(b)-2] != 0 {
+ t.Errorf("%q 没有以 NUL 结尾", s)
+ }
+ // 剪贴板的内存块常比内容大,结尾有填充
+ if got := utf16String(append(b, 'x', 0, 'y', 0)); got != s {
+ t.Errorf("往返 %q 得到 %q", s, got)
+ }
+ }
+}
+
+func TestCFHTMLRoundTrip(t *testing.T) {
+ cases := []struct {
+ name, in, fragment string
+ }{
+ {"片段", "<b>加粗</b> 文字", "<b>加粗</b> 文字"},
+ {"完整文档", "<html><head><meta charset=utf-8></head><body class=x><p>段落</p></body></html>", "<p>段落</p>"},
+ {"自带标记", "<html><body><!--StartFragment--><i>x</i><!--EndFragment--></body></html>", "<i>x</i>"},
+ }
+ for _, c := range cases {
+ t.Run(c.name, func(t *testing.T) {
+ b := encodeCFHTML(c.in)
+ if b[len(b)-1] != 0 {
+ t.Fatal("没有以 NUL 结尾")
+ }
+ s := string(b[:len(b)-1])
+ off := func(key string) int {
+ i := strings.Index(s, key+":")
+ var n int
+ for _, r := range s[i+len(key)+1 : i+len(key)+11] {
+ n = n*10 + int(r-'0')
+ }
+ return n
+ }
+ // 偏移量是字节偏移,中文是多字节,正好检验
+ if got := s[off("StartFragment"):off("EndFragment")]; got != c.fragment {
+ t.Errorf("片段 = %q,应为 %q", got, c.fragment)
+ }
+ if !strings.HasPrefix(s[off("StartHTML"):], "<html") || off("EndHTML") != len(s) {
+ t.Errorf("StartHTML/EndHTML 不对:%q", s)
+ }
+ html, err := decodeCFHTML(b)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !strings.Contains(html, c.fragment) || !strings.HasPrefix(html, "<html") {
+ t.Errorf("解析得到 %q", html)
+ }
+ })
+ }
+}
+
+func TestDecodeCFHTMLFromWindows(t *testing.T) {
+ // Chrome 写入的样子:带 SourceURL,值里有冒号
+ doc := "<html>\r\n<body>\r\n<!--StartFragment--><p>你好</p><!--EndFragment-->\r\n</body>\r\n</html>"
+ head := "Version:0.9\r\nStartHTML:0000000000\r\nEndHTML:0000000000\r\nStartFragment:0000000000\r\nEndFragment:0000000000\r\nSourceURL:https://example.com/a\r\n"
+ start := len(head)
+ head = strings.Replace(head, "StartHTML:0000000000", "StartHTML:"+pad10(start), 1)
+ head = strings.Replace(head, "EndHTML:0000000000", "EndHTML:"+pad10(start+len(doc)), 1)
+ fs := start + strings.Index(doc, "<p>")
+ fe := start + strings.Index(doc, "<!--End")
+ head = strings.Replace(head, "StartFragment:0000000000", "StartFragment:"+pad10(fs), 1)
+ head = strings.Replace(head, "EndFragment:0000000000", "EndFragment:"+pad10(fe), 1)
+
+ got, err := decodeCFHTML([]byte(head + doc + "\x00\x00"))
+ if err != nil || got != doc {
+ t.Fatalf("得到 %q, %v", got, err)
+ }
+
+ // StartHTML 为 -1 的程序:只给片段
+ onlyFrag := strings.Replace(head, "StartHTML:"+pad10(start), "StartHTML:-000000001", 1)
+ got, err = decodeCFHTML([]byte(onlyFrag + doc))
+ if err != nil || got != "<p>你好</p>" {
+ t.Fatalf("只有片段时得到 %q, %v", got, err)
+ }
+
+ if _, err := decodeCFHTML([]byte("<p>没有头部</p>")); err == nil {
+ t.Error("没有头部时应报错")
+ }
+}
+
+func pad10(n int) string {
+ s := strings.Repeat("0", 10)
+ d := []byte(s)
+ for i := 9; i >= 0 && n > 0; i-- {
+ d[i] = byte('0' + n%10)
+ n /= 10
+ }
+ return string(d)
+}
+
+func TestDropFiles(t *testing.T) {
+ paths := []string{`C:\Users\光光\Desktop\报表.xlsx`, `D:\a b\c`}
+ b := encodeDropFiles(paths)
+ if binary.LittleEndian.Uint32(b) != 20 || binary.LittleEndian.Uint32(b[16:]) != 1 {
+ t.Fatal("DROPFILES 头部不对")
+ }
+ if !strings.HasSuffix(string(b), "\x00\x00\x00\x00") {
+ t.Error("路径表应以两个 NUL 结尾")
+ }
+ got, err := decodeDropFiles(b)
+ if err != nil || !reflect.DeepEqual(got, paths) {
+ t.Fatalf("往返得到 %v, %v", got, err)
+ }
+ if _, err := decodeDropFiles(b[:10]); err == nil {
+ t.Error("过短的数据应报错")
+ }
+}
+
+func TestDIBRoundTrip(t *testing.T) {
+ src := image.NewNRGBA(image.Rect(0, 0, 3, 2))
+ src.SetNRGBA(0, 0, color.NRGBA{255, 0, 0, 255})
+ src.SetNRGBA(1, 0, color.NRGBA{0, 255, 0, 128}) // 半透明
+ src.SetNRGBA(2, 1, color.NRGBA{0, 0, 255, 0}) // 全透明
+
+ b := imageToDIBV5(src)
+ if len(b) != 124+3*2*4 {
+ t.Fatalf("长度 = %d", len(b))
+ }
+ got, err := dibToImage(b)
+ if err != nil {
+ t.Fatal(err)
+ }
+ for y := range 2 {
+ for x := range 3 {
+ if a, g := src.NRGBAAt(x, y), got.(*image.NRGBA).NRGBAAt(x, y); a != g {
+ t.Errorf("(%d,%d) = %v,应为 %v", x, y, g, a)
+ }
+ }
+ }
+}
+
+// dib 拼一个最简的 BITMAPINFOHEADER 位图。
+func dib(width, height, bitCount int, compression uint32, extra, pixels []byte) []byte {
+ b := make([]byte, 40)
+ le := binary.LittleEndian
+ le.PutUint32(b[0:], 40)
+ le.PutUint32(b[4:], uint32(int32(width)))
+ le.PutUint32(b[8:], uint32(int32(height)))
+ le.PutUint16(b[12:], 1)
+ le.PutUint16(b[14:], uint16(bitCount))
+ le.PutUint32(b[16:], compression)
+ return append(append(b, extra...), pixels...)
+}
+
+func TestDIBVariants(t *testing.T) {
+ t.Run("24 位,自下而上,行对齐", func(t *testing.T) {
+ // 宽 1:每行 3 字节,补到 4 字节。第一行存的是图片的最后一行
+ px := []byte{0, 0, 255, 0 /* 红,在底部 */, 255, 0, 0, 0 /* 蓝,在顶部 */}
+ img, err := dibToImage(dib(1, 2, 24, biRGB, nil, px))
+ if err != nil {
+ t.Fatal(err)
+ }
+ n := img.(*image.NRGBA)
+ if n.NRGBAAt(0, 0) != (color.NRGBA{0, 0, 255, 255}) || n.NRGBAAt(0, 1) != (color.NRGBA{255, 0, 0, 255}) {
+ t.Errorf("像素 = %v %v", n.NRGBAAt(0, 0), n.NRGBAAt(0, 1))
+ }
+ })
+ t.Run("32 位透明度全为 0 当作不透明", func(t *testing.T) {
+ img, err := dibToImage(dib(1, -1, 32, biRGB, nil, []byte{10, 20, 30, 0}))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if c := img.(*image.NRGBA).NRGBAAt(0, 0); c != (color.NRGBA{30, 20, 10, 255}) {
+ t.Errorf("像素 = %v", c)
+ }
+ })
+ t.Run("BI_BITFIELDS 掩码跟在 40 字节头部之后", func(t *testing.T) {
+ masks := make([]byte, 12)
+ binary.LittleEndian.PutUint32(masks[0:], 0x00FF0000)
+ binary.LittleEndian.PutUint32(masks[4:], 0x0000FF00)
+ binary.LittleEndian.PutUint32(masks[8:], 0x000000FF)
+ img, err := dibToImage(dib(1, 1, 32, biBitfields, masks, []byte{1, 2, 3, 0}))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if c := img.(*image.NRGBA).NRGBAAt(0, 0); c != (color.NRGBA{3, 2, 1, 255}) {
+ t.Errorf("像素 = %v", c)
+ }
+ })
+ t.Run("8 位调色板", func(t *testing.T) {
+ pal := []byte{0, 0, 0, 0, 255, 255, 255, 0} // 黑、白
+ le := binary.LittleEndian
+ b := dib(2, 1, 8, biRGB, pal, []byte{1, 0, 0, 0}) // 白、黑,补到 4 字节
+ le.PutUint32(b[32:], 2) // biClrUsed
+ img, err := dibToImage(b)
+ if err != nil {
+ t.Fatal(err)
+ }
+ n := img.(*image.NRGBA)
+ if n.NRGBAAt(0, 0) != (color.NRGBA{255, 255, 255, 255}) || n.NRGBAAt(1, 0) != (color.NRGBA{0, 0, 0, 255}) {
+ t.Errorf("像素 = %v %v", n.NRGBAAt(0, 0), n.NRGBAAt(1, 0))
+ }
+ })
+ t.Run("数据不完整", func(t *testing.T) {
+ if _, err := dibToImage(dib(10, 10, 32, biRGB, nil, []byte{1, 2, 3})); err == nil {
+ t.Error("应报错")
+ }
+ if _, err := dibToImage([]byte{1, 2, 3}); err == nil {
+ t.Error("应报错")
+ }
+ })
+}
diff --git a/client-core/internal/identity/identity.go b/client-core/internal/identity/identity.go
index eba1656..34e2eef 100644
--- a/client-core/internal/identity/identity.go
+++ b/client-core/internal/identity/identity.go
@@ -23,11 +23,12 @@ type Identity struct {
}
// 磁盘格式。私钥以 0600 权限存放在用户目录下——与 Syncthing 等
-// 同类工具一致。后续可换成 Keychain / DPAPI,接口不变。
+// 同类工具一致。Windows 上另用 DPAPI 加密,存在 ProtectedKey 里(见 protect_windows.go)。
type keyFile struct {
- DeviceID string `json:"device_id"`
- PublicKey []byte `json:"public_key"`
- PrivateKey []byte `json:"private_key"`
+ DeviceID string `json:"device_id"`
+ PublicKey []byte `json:"public_key"`
+ PrivateKey []byte `json:"private_key,omitempty"`
+ ProtectedKey []byte `json:"protected_private_key,omitempty"`
}
// LoadOrCreate 读取已有身份;不存在则生成一份并落盘。
@@ -39,6 +40,12 @@ func LoadOrCreate(path string) (*Identity, error) {
if err := json.Unmarshal(data, &kf); err != nil {
return nil, fmt.Errorf("解析身份文件 %s: %w", path, err)
}
+ plaintext := len(kf.ProtectedKey) == 0
+ if !plaintext {
+ if kf.PrivateKey, err = unprotectKey(kf.ProtectedKey); err != nil {
+ return nil, err
+ }
+ }
if len(kf.PrivateKey) != ed25519.PrivateKeySize ||
len(kf.PublicKey) != ed25519.PublicKeySize {
return nil, fmt.Errorf("身份文件 %s 已损坏(密钥长度不对)", path)
@@ -52,6 +59,10 @@ func LoadOrCreate(path string) (*Identity, error) {
if want := DeviceIDFor(id.PublicKey); want != id.DeviceID {
return nil, fmt.Errorf("身份文件 %s 的 device_id 与公钥不匹配", path)
}
+ // 需要加密的平台上遇到明文私钥(手工拷进来的文件),顺手加密存回去。失败也不影响使用
+ if keyProtected && plaintext {
+ _ = save(path, id)
+ }
return id, nil
case os.IsNotExist(err):
@@ -72,27 +83,34 @@ func create(path string) (*Identity, error) {
PublicKey: pub,
privateKey: priv,
}
+ if err := save(path, id); err != nil {
+ return nil, err
+ }
+ return id, nil
+}
+func save(path string, id *Identity) error {
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
- return nil, err
+ return err
}
- data, err := json.MarshalIndent(keyFile{
- DeviceID: id.DeviceID,
- PublicKey: pub,
- PrivateKey: priv,
- }, "", " ")
+ kf := keyFile{DeviceID: id.DeviceID, PublicKey: id.PublicKey, PrivateKey: id.privateKey}
+ if keyProtected {
+ sealed, err := protectKey(id.privateKey)
+ if err != nil {
+ return err
+ }
+ kf.PrivateKey, kf.ProtectedKey = nil, sealed
+ }
+ data, err := json.MarshalIndent(kf, "", " ")
if err != nil {
- return nil, err
+ return err
}
// 0600:私钥只有当前用户可读
tmp := path + ".tmp"
if err := os.WriteFile(tmp, data, 0o600); err != nil {
- return nil, fmt.Errorf("写入身份文件: %w", err)
+ return fmt.Errorf("写入身份文件: %w", err)
}
- if err := os.Rename(tmp, path); err != nil {
- return nil, err
- }
- return id, nil
+ return os.Rename(tmp, path)
}
func (i *Identity) Sign(data []byte) []byte {
diff --git a/client-core/internal/identity/protect_other.go b/client-core/internal/identity/protect_other.go
new file mode 100644
index 0000000..11c4b7d
--- /dev/null
+++ b/client-core/internal/identity/protect_other.go
@@ -0,0 +1,9 @@
+//go:build !windows
+
+package identity
+
+// 其他平台私钥以 0600 权限明文存放,与之前的版本一致。
+const keyProtected = false
+
+func protectKey(plain []byte) ([]byte, error) { return plain, nil }
+func unprotectKey(sealed []byte) ([]byte, error) { return sealed, nil }
diff --git a/client-core/internal/identity/protect_windows.go b/client-core/internal/identity/protect_windows.go
new file mode 100644
index 0000000..9b678d9
--- /dev/null
+++ b/client-core/internal/identity/protect_windows.go
@@ -0,0 +1,43 @@
+//go:build windows
+
+package identity
+
+import (
+ "fmt"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+)
+
+// keyProtected 表示私钥落盘前要加密。Windows 上用 DPAPI:密钥由系统按当前用户派生,
+// 换个用户、或把文件拷到别的电脑上都解不开。
+const keyProtected = true
+
+const cryptprotectUIForbidden = 0x1
+
+func protectKey(plain []byte) ([]byte, error) {
+ in := windows.DataBlob{Size: uint32(len(plain)), Data: &plain[0]}
+ var out windows.DataBlob
+ if err := windows.CryptProtectData(&in, nil, nil, 0, nil, cryptprotectUIForbidden, &out); err != nil {
+ return nil, fmt.Errorf("加密私钥: %w", err)
+ }
+ return takeBlob(out), nil
+}
+
+func unprotectKey(sealed []byte) ([]byte, error) {
+ if len(sealed) == 0 {
+ return nil, fmt.Errorf("加密的私钥为空")
+ }
+ in := windows.DataBlob{Size: uint32(len(sealed)), Data: &sealed[0]}
+ var out windows.DataBlob
+ if err := windows.CryptUnprotectData(&in, nil, nil, 0, nil, cryptprotectUIForbidden, &out); err != nil {
+ return nil, fmt.Errorf("解密私钥(身份文件可能来自别的用户或别的电脑): %w", err)
+ }
+ return takeBlob(out), nil
+}
+
+// takeBlob 复制出系统分配的结果并释放它。
+func takeBlob(b windows.DataBlob) []byte {
+ defer windows.LocalFree(windows.Handle(unsafe.Pointer(b.Data)))
+ return append([]byte(nil), unsafe.Slice(b.Data, b.Size)...)
+}
diff --git a/client-core/internal/identity/protect_windows_test.go b/client-core/internal/identity/protect_windows_test.go
new file mode 100644
index 0000000..313fa48
--- /dev/null
+++ b/client-core/internal/identity/protect_windows_test.go
@@ -0,0 +1,55 @@
+//go:build windows
+
+package identity
+
+import (
+ "bytes"
+ "encoding/json"
+ "os"
+ "path/filepath"
+ "testing"
+)
+
+func TestKeyIsProtectedOnDisk(t *testing.T) {
+ path := filepath.Join(t.TempDir(), "identity.json")
+ id, err := LoadOrCreate(path)
+ if err != nil {
+ t.Fatal(err)
+ }
+ raw, _ := os.ReadFile(path)
+ var kf keyFile
+ if err := json.Unmarshal(raw, &kf); err != nil {
+ t.Fatal(err)
+ }
+ if len(kf.PrivateKey) != 0 || len(kf.ProtectedKey) == 0 {
+ t.Fatalf("磁盘上应只有加密后的私钥:%s", raw)
+ }
+ again, err := LoadOrCreate(path)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if again.DeviceID != id.DeviceID || !bytes.Equal(again.privateKey, id.privateKey) {
+ t.Error("重新读取后身份不一致")
+ }
+}
+
+// 旧格式(明文私钥)读取后自动改存为加密格式,设备身份不变。
+func TestPlaintextKeyIsMigrated(t *testing.T) {
+ path := filepath.Join(t.TempDir(), "identity.json")
+ id, err := LoadOrCreate(path)
+ if err != nil {
+ t.Fatal(err)
+ }
+ plain, _ := json.Marshal(keyFile{DeviceID: id.DeviceID, PublicKey: id.PublicKey, PrivateKey: id.privateKey})
+ os.WriteFile(path, plain, 0o600)
+
+ if _, err := LoadOrCreate(path); err != nil {
+ t.Fatal(err)
+ }
+ raw, _ := os.ReadFile(path)
+ var kf keyFile
+ json.Unmarshal(raw, &kf)
+ if len(kf.PrivateKey) != 0 || len(kf.ProtectedKey) == 0 {
+ t.Errorf("明文私钥没有被加密存回:%s", raw)
+ }
+}
diff --git a/client-core/internal/pack/names.go b/client-core/internal/pack/names.go
new file mode 100644
index 0000000..d1f686c
--- /dev/null
+++ b/client-core/internal/pack/names.go
@@ -0,0 +1,157 @@
+package pack
+
+// 解包到 Windows 时的文件名处理。
+//
+// Mac 上合法的文件名在 Windows 上未必合法:轻则解包失败,重则出安全问题——
+// 名字里的冒号会被 NTFS 当作「备用数据流」,`a.txt:x` 写进的是 a.txt 的隐藏流。
+// 这里把每一级名字改成 Windows 能接受、又尽量保持原样的形式。只在 Windows 上启用,
+// 其他平台解包时名字原样落盘。
+
+import (
+ "fmt"
+ "path"
+ "runtime"
+ "strings"
+
+ "golang.org/x/text/unicode/norm"
+)
+
+// windowsNames 决定解包时是否按 Windows 的规则处理文件名。是变量而不是常量,
+// 好让测试在任何平台上都能验证这套规则。
+var windowsNames = runtime.GOOS == "windows"
+
+// Windows 不允许出现在文件名里的字符,换成对应的全角字符:名字仍然可读,
+// 也不会与已有的文件撞名。
+var fullwidth = map[rune]rune{
+ ':': ':', '*': '*', '?': '?', '"': '"',
+ '<': '<', '>': '>', '|': '|', '\\': '\',
+}
+
+// 设备保留名:不管带不带扩展名(nul.txt 也不行),都打不开、删不掉
+var reservedNames = map[string]bool{
+ "CON": true, "PRN": true, "AUX": true, "NUL": true, "CONIN$": true, "CONOUT$": true,
+ "COM1": true, "COM2": true, "COM3": true, "COM4": true, "COM5": true,
+ "COM6": true, "COM7": true, "COM8": true, "COM9": true,
+ "LPT1": true, "LPT2": true, "LPT3": true, "LPT4": true, "LPT5": true,
+ "LPT6": true, "LPT7": true, "LPT8": true, "LPT9": true,
+}
+
+// windowsSafeName 把一级名字改成 Windows 上合法的形式。
+func windowsSafeName(name string) string {
+ // Mac 上的文件名常是分解形式(「が」存成「か」加浊点两个码位),
+ // 资源管理器会显示成两个字符、也搜不到。统一成组合形式
+ name = norm.NFC.String(name)
+
+ var b strings.Builder
+ for _, r := range name {
+ switch {
+ case fullwidth[r] != 0:
+ b.WriteRune(fullwidth[r])
+ case r < 0x20:
+ b.WriteByte('_') // 控制字符
+ default:
+ b.WriteRune(r)
+ }
+ }
+ s := b.String()
+
+ // 结尾的点和空格会被 Windows 悄悄去掉,「notes.」就成了「notes」
+ if strings.TrimRight(s, ". ") != s {
+ s += "_"
+ }
+ stem, _, _ := strings.Cut(s, ".")
+ if reservedNames[strings.ToUpper(strings.TrimRight(stem, " "))] {
+ s = "_" + s
+ }
+ if s == "" {
+ s = "_"
+ }
+ return s
+}
+
+// skipOnWindows 是不该带到 Windows 上的 Mac 系统文件:
+// Finder 的目录设置,以及在非 APFS 磁盘上保存扩展属性的 AppleDouble 文件。
+func skipOnWindows(name string) bool {
+ return name == ".DS_Store" || strings.HasPrefix(name, "._")
+}
+
+// skipWhenPacking 是在 Windows 上打包时跳过的系统文件:缩略图缓存与文件夹设置。
+func skipWhenPacking(name string) bool {
+ if !windowsNames {
+ return false
+ }
+ switch strings.ToLower(name) {
+ case "thumbs.db", "desktop.ini":
+ return true
+ }
+ return false
+}
+
+// destNames 给解包出来的每个条目决定落盘的相对路径(正斜杠分隔)。
+//
+// 名字经过改写后可能与别的条目重名,Windows 又不区分大小写(Readme.md 与 README.md
+// 是同一个文件),所以要记下已经用掉的名字:同名的目录合并,同名的文件改名为
+// 「README (2).md」,不能互相覆盖。
+type destNames struct {
+ used map[string]usedName // 小写的落盘路径 → 实际占用的名字
+ dirs map[string]string // 归档里的目录 → 落盘路径
+}
+
+type usedName struct {
+ path string
+ isDir bool
+}
+
+func newDestNames() *destNames {
+ return &destNames{used: map[string]usedName{}, dirs: map[string]string{}}
+}
+
+// rel 返回归档条目 name 的落盘相对路径。含 .. 或绝对路径的条目直接拒绝。
+func (d *destNames) rel(name string, isDir bool) (string, error) {
+ clean := path.Clean(strings.TrimSuffix(name, "/"))
+ if clean == "." || clean == ".." || strings.HasPrefix(clean, "../") || strings.HasPrefix(clean, "/") {
+ return "", fmt.Errorf("归档中含非法路径: %q", name)
+ }
+ parent := d.dir(path.Dir(clean))
+ leaf := d.claim(parent, windowsSafeName(path.Base(clean)), isDir)
+ if isDir {
+ d.dirs[clean] = leaf
+ }
+ return leaf, nil
+}
+
+// dir 返回归档里某个目录的落盘路径;归档里没有单独的目录条目时,在这里补上。
+func (d *destNames) dir(orig string) string {
+ if orig == "." || orig == "" {
+ return ""
+ }
+ if mapped, ok := d.dirs[orig]; ok {
+ return mapped
+ }
+ mapped := d.claim(d.dir(path.Dir(orig)), windowsSafeName(path.Base(orig)), true)
+ d.dirs[orig] = mapped
+ return mapped
+}
+
+// claim 在 parent 下占用一个不重名的名字。
+func (d *destNames) claim(parent, name string, isDir bool) string {
+ candidate := path.Join(parent, name)
+ ext := path.Ext(name)
+ stem := strings.TrimSuffix(name, ext)
+ if isDir {
+ stem, ext = name, ""
+ }
+ for n := 2; ; n++ {
+ prev, taken := d.used[strings.ToLower(candidate)]
+ if !taken {
+ d.used[strings.ToLower(candidate)] = usedName{candidate, isDir}
+ return candidate
+ }
+ if isDir && prev.isDir {
+ // 两个只差大小写的目录在 Windows 上就是同一个:合并,沿用先占用的名字,
+ // 免得复制列表里出现两个顶层条目
+ return prev.path
+ }
+ candidate = path.Join(parent, fmt.Sprintf("%s (%d)%s", stem, n, ext))
+ }
+}
diff --git a/client-core/internal/pack/names_test.go b/client-core/internal/pack/names_test.go
new file mode 100644
index 0000000..fe69ff4
--- /dev/null
+++ b/client-core/internal/pack/names_test.go
@@ -0,0 +1,163 @@
+package pack
+
+import (
+ "archive/tar"
+ "bytes"
+ "io"
+ "os"
+ "path/filepath"
+ "sort"
+ "testing"
+
+ "github.com/klauspost/compress/zstd"
+)
+
+func TestWindowsSafeName(t *testing.T) {
+ cases := map[string]string{
+ "会议:纪要.txt": "会议:纪要.txt",
+ `a*b?c"d<e>f|g\h`: "a*b?c"d<e>f|g\h",
+ "notes.": "notes._",
+ "trailing ": "trailing _",
+ "CON": "_CON",
+ "nul.txt": "_nul.txt",
+ "com1.tar.gz": "_com1.tar.gz",
+ "console.txt": "console.txt", // 只是以保留名开头,不算
+ "が.txt": "が.txt", // か + 浊点 → が
+ "中文文件名.docx": "中文文件名.docx",
+ "tab\tname": "tab_name",
+ }
+ for in, want := range cases {
+ if got := windowsSafeName(in); got != want {
+ t.Errorf("windowsSafeName(%q) = %q,应为 %q", in, got, want)
+ }
+ }
+}
+
+func TestDestNames(t *testing.T) {
+ d := newDestNames()
+ steps := []struct {
+ name string
+ isDir bool
+ want string
+ }{
+ {"项目/", true, "项目"},
+ {"项目/Readme.md", false, "项目/Readme.md"},
+ {"项目/README.md", false, "项目/README (2).md"}, // 只差大小写的文件改名
+ {"项目/readme.md", false, "项目/readme (3).md"},
+ {"项目/a:b/c.txt", false, "项目/a:b/c.txt"}, // 归档里没有单独的目录条目
+ {"项目/A:B/", true, "项目/a:b"}, // 与上面的目录只差大小写:合并,沿用先占用的名字
+ {"Docs/x", false, "Docs/x"},
+ {"docs/y", false, "Docs/y"}, // 父目录只差大小写,落到同一个目录里
+ }
+ for _, s := range steps {
+ got, err := d.rel(s.name, s.isDir)
+ if err != nil || got != s.want {
+ t.Errorf("rel(%q) = %q, %v,应为 %q", s.name, got, err, s.want)
+ }
+ }
+ for _, bad := range []string{"../x", "/etc/passwd", "..", "a/../../b"} {
+ if _, err := d.rel(bad, false); err == nil {
+ t.Errorf("rel(%q) 应拒绝", bad)
+ }
+ }
+}
+
+// writeTar 手工拼一个归档:Mac 的文件系统多半不区分大小写,造不出只差大小写的两个文件。
+func writeTar(t *testing.T, entries []tar.Header, bodies map[string]string) io.Reader {
+ t.Helper()
+ var buf bytes.Buffer
+ enc, _ := zstd.NewWriter(&buf)
+ tw := tar.NewWriter(enc)
+ for _, h := range entries {
+ body := bodies[h.Name]
+ h.Size = int64(len(body))
+ if h.Mode == 0 {
+ h.Mode = 0o644
+ }
+ if err := tw.WriteHeader(&h); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := tw.Write([]byte(body)); err != nil {
+ t.Fatal(err)
+ }
+ }
+ tw.Close()
+ enc.Close()
+ return &buf
+}
+
+func TestUnpackForWindows(t *testing.T) {
+ windowsNames = true
+ t.Cleanup(func() { windowsNames = false })
+
+ r := writeTar(t, []tar.Header{
+ {Name: "会议:纪要/", Typeflag: tar.TypeDir, Mode: 0o755},
+ {Name: "会议:纪要/Readme.md", Typeflag: tar.TypeReg},
+ {Name: "会议:纪要/README.md", Typeflag: tar.TypeReg},
+ {Name: "会议:纪要/.DS_Store", Typeflag: tar.TypeReg},
+ {Name: "会议:纪要/._Readme.md", Typeflag: tar.TypeReg},
+ // 上级目录不存在,符号链接一定建不成:模拟 Windows 上没有权限
+ {Name: "会议:纪要/sub/link", Typeflag: tar.TypeSymlink, Linkname: "x"},
+ {Name: "CON", Typeflag: tar.TypeReg},
+ }, map[string]string{
+ "会议:纪要/Readme.md": "1", "会议:纪要/README.md": "2", "会议:纪要/.DS_Store": "x",
+ "会议:纪要/._Readme.md": "x", "CON": "3",
+ })
+
+ dest := t.TempDir()
+ tops, err := Unpack(r, dest)
+ if err != nil {
+ t.Fatal(err)
+ }
+ sort.Strings(tops)
+ want := []string{filepath.Join(dest, "_CON"), filepath.Join(dest, "会议:纪要")}
+ sort.Strings(want)
+ if len(tops) != 2 || tops[0] != want[0] || tops[1] != want[1] {
+ t.Errorf("顶层条目 = %v,应为 %v", tops, want)
+ }
+
+ entries, _ := os.ReadDir(filepath.Join(dest, "会议:纪要"))
+ var names []string
+ for _, e := range entries {
+ names = append(names, e.Name())
+ }
+ sort.Strings(names)
+ wantNames := []string{"README (2).md", "Readme.md"}
+ if len(names) != 2 || names[0] != wantNames[0] || names[1] != wantNames[1] {
+ t.Errorf("目录内容 = %v,应为 %v(.DS_Store、._ 文件不落盘,建不了的符号链接跳过)", names, wantNames)
+ }
+ for name, body := range map[string]string{"Readme.md": "1", "README (2).md": "2"} {
+ b, _ := os.ReadFile(filepath.Join(dest, "会议:纪要", name))
+ if string(b) != body {
+ t.Errorf("%s 内容 = %q,应为 %q(不能互相覆盖)", name, b, body)
+ }
+ }
+}
+
+// 打不开的文件要整个跳过,不能写了头却没有内容,把整个归档弄坏。
+func TestPackSkipsUnreadableFile(t *testing.T) {
+ if os.Geteuid() == 0 {
+ t.Skip("root 能读任何文件")
+ }
+ dir := t.TempDir()
+ root := filepath.Join(dir, "d")
+ os.MkdirAll(root, 0o755)
+ os.WriteFile(filepath.Join(root, "ok.txt"), []byte("ok"), 0o644)
+ locked := filepath.Join(root, "locked.txt")
+ os.WriteFile(locked, []byte("secret"), 0o000)
+
+ var buf bytes.Buffer
+ if err := Pack(&buf, []string{root}); err != nil {
+ t.Fatal(err)
+ }
+ dest := t.TempDir()
+ if _, err := Unpack(&buf, dest); err != nil {
+ t.Fatalf("归档损坏:%v", err)
+ }
+ if b, err := os.ReadFile(filepath.Join(dest, "d", "ok.txt")); err != nil || string(b) != "ok" {
+ t.Errorf("能读的文件没传过来:%q, %v", b, err)
+ }
+ if _, err := os.Stat(filepath.Join(dest, "d", "locked.txt")); err == nil {
+ t.Error("打不开的文件不该出现")
+ }
+}
diff --git a/client-core/internal/pack/pack.go b/client-core/internal/pack/pack.go
index 6e50227..078ba44 100644
--- a/client-core/internal/pack/pack.go
+++ b/client-core/internal/pack/pack.go
@@ -9,6 +9,7 @@ import (
"fmt"
"io"
"os"
+ "path"
"path/filepath"
"strings"
@@ -104,6 +105,9 @@ func addPath(tw *tar.Writer, root string) error {
if err != nil {
return err
}
+ if skipWhenPacking(info.Name()) {
+ return nil
+ }
name := base
if rel != "." {
name = filepath.Join(base, rel)
@@ -122,6 +126,17 @@ func addFile(tw *tar.Writer, path, name string, info os.FileInfo) error {
}
}
+ // 普通文件先打开再写头:头里已经声明了大小,写完头才发现打不开的话,
+ // 整个 tar 流就坏了,对端一个文件也收不到。Windows 上被别的程序锁住的文件很常见
+ var f *os.File
+ if info.Mode().IsRegular() {
+ var err error
+ if f, err = os.Open(path); err != nil {
+ return nil // 打开失败就跳过,不因单个文件中断整次传输
+ }
+ defer f.Close()
+ }
+
hdr, err := tar.FileInfoHeader(info, link)
if err != nil {
return fmt.Errorf("构造 tar 头 %s: %w", path, err)
@@ -135,16 +150,9 @@ func addFile(tw *tar.Writer, path, name string, info os.FileInfo) error {
if err := tw.WriteHeader(hdr); err != nil {
return fmt.Errorf("写 tar 头 %s: %w", name, err)
}
- if !info.Mode().IsRegular() {
+ if f == nil {
return nil // 目录与符号链接没有内容体
}
-
- f, err := os.Open(path)
- if err != nil {
- return nil // 打开失败就跳过,不因单个文件中断整次传输
- }
- defer f.Close()
-
if _, err := io.Copy(tw, f); err != nil {
return fmt.Errorf("写入 %s 内容: %w", name, err)
}
@@ -169,6 +177,7 @@ func Unpack(r io.Reader, destDir string) ([]string, error) {
tr := tar.NewReader(dec)
seen := make(map[string]struct{})
var tops []string
+ names := newDestNames()
for {
hdr, err := tr.Next()
@@ -179,13 +188,24 @@ func Unpack(r io.Reader, destDir string) ([]string, error) {
return tops, fmt.Errorf("读取 tar 条目: %w", err)
}
- target, err := safeJoin(destDir, hdr.Name)
+ // Windows 上先把名字改成合法的(见 names.go),其他平台原样使用
+ name := hdr.Name
+ if windowsNames {
+ if skipOnWindows(path.Base(strings.TrimSuffix(name, "/"))) {
+ continue
+ }
+ if name, err = names.rel(hdr.Name, hdr.Typeflag == tar.TypeDir); err != nil {
+ return tops, err
+ }
+ }
+
+ target, err := safeJoin(destDir, name)
if err != nil {
return tops, err
}
// 记录顶层条目,供写入剪贴板使用
- if top := topLevel(hdr.Name); top != "" {
+ if top := topLevel(name); top != "" {
if _, ok := seen[top]; !ok {
seen[top] = struct{}{}
tops = append(tops, filepath.Join(destDir, top))
@@ -200,6 +220,11 @@ func Unpack(r io.Reader, destDir string) ([]string, error) {
case tar.TypeSymlink:
os.Remove(target)
if err := os.Symlink(hdr.Linkname, target); err != nil {
+ if windowsNames {
+ // 普通用户在 Windows 上没有创建符号链接的权限(除非开了开发者模式)。
+ // 跳过这一个,别让整次解包失败
+ continue
+ }
return tops, fmt.Errorf("创建符号链接 %s: %w", target, err)
}
case tar.TypeReg:
@@ -226,7 +251,8 @@ func Unpack(r io.Reader, destDir string) ([]string, error) {
// 归档来自对端设备,即便已配对也不该无条件信任其中的路径。
func safeJoin(base, name string) (string, error) {
clean := filepath.Clean(filepath.FromSlash(name))
- if filepath.IsAbs(clean) || strings.HasPrefix(clean, "..") {
+ // VolumeName 拦住 Windows 上的「C:foo」「\\server\share」:它们不算绝对路径,Join 之后却能跑出去
+ if filepath.IsAbs(clean) || strings.HasPrefix(clean, "..") || filepath.VolumeName(clean) != "" {
return "", fmt.Errorf("归档中含非法路径: %q", name)
}
target := filepath.Join(base, clean)
diff --git a/client-core/internal/transport/p2p/egress_history.go b/client-core/internal/transport/p2p/egress_history.go
index 3a74b47..bde5d62 100644
--- a/client-core/internal/transport/p2p/egress_history.go
+++ b/client-core/internal/transport/p2p/egress_history.go
@@ -6,6 +6,7 @@ import (
"net/netip"
"os"
"path/filepath"
+ "runtime"
"sort"
"strings"
"sync"
@@ -131,7 +132,7 @@ func localNetworkKey() string {
}
var addrs []string
for _, ifc := range ifaces {
- if ifc.Flags&net.FlagUp == 0 || ifc.Flags&net.FlagLoopback != 0 {
+ if ifc.Flags&net.FlagUp == 0 || ifc.Flags&net.FlagLoopback != 0 || unstableAdapter(ifc.Name) {
continue
}
list, err := ifc.Addrs()
@@ -147,3 +148,12 @@ func localNetworkKey() string {
sort.Strings(addrs)
return strings.Join(addrs, ",")
}
+
+// unstableAdapter 判断一块网卡是否该排除在网络标识之外。
+//
+// Windows 上 WSL、Hyper-V、Docker 的虚拟网卡(名字以 vEthernet 开头)每次开机地址都会变,
+// 算进来的话,同一个网络每次开机都像是新网络,出口历史就用不上了。其他平台不排除,
+// 与之前的行为一致。
+func unstableAdapter(name string) bool {
+ return runtime.GOOS == "windows" && strings.HasPrefix(name, "vEthernet")
+}
diff --git a/client-core/internal/transport/p2p/manager.go b/client-core/internal/transport/p2p/manager.go
index 92761c8..9b9dc48 100644
--- a/client-core/internal/transport/p2p/manager.go
+++ b/client-core/internal/transport/p2p/manager.go
@@ -162,6 +162,9 @@ func (m *Manager) Close() {
})
}
+// Reprobe 立即重新探测出口。从睡眠中唤醒时调用:网络多半已经变了,不必等下一轮。
+func (m *Manager) Reprobe() { m.triggerProbe() }
+
// Egress 返回最近一轮出口探测的结果(含按历史推算的出口),供诊断展示。
func (m *Manager) Egress() EgressReport {
m.egressMu.Lock()