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.
Dart airdrop-alternativeclipboardclipboard-sharingclipboard-synccopy-pastecross-platformend-to-end-encryptionfile-syncfile-transferfluttergolanglinuxmacosnat-traversalp2pself-hostedtailscaleuniversal-clipboardwebrtcwindows
package sync
import (
"context"
"errors"
"slices"
"sync"
"time"
"github.com/baiyuze/pasteferry/client-core/internal/config"
"github.com/baiyuze/pasteferry/client-core/internal/store"
pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
)
// 补发:复制时对端连不上(断线、睡眠、连接已失效但还没被发现),
// 这条内容就记下来,连接恢复后再发过去。只记在内存里,后台服务重启后清空。
const (
backlogMax = 20 // 每台设备最多补发的条数,只留最新的
backlogMaxAge = 24 * time.Hour // 再旧的不补
)
type backlog struct {
mu sync.Mutex
pending map[string][]string // 设备 ID → 待补发的记录 ID,按复制先后排列
}
func (b *backlog) add(peer, clipID string) {
b.mu.Lock()
defer b.mu.Unlock()
b.addLocked(peer, clipID)
}
func (b *backlog) addLocked(peer, clipID string) {
if b.pending == nil {
b.pending = make(map[string][]string)
}
list := slices.DeleteFunc(b.pending[peer], func(id string) bool { return id == clipID })
list = append(list, clipID)
if len(list) > backlogMax {
list = slices.Clone(list[len(list)-backlogMax:])
}
b.pending[peer] = list
}
// take 取走某台设备的全部待补发记录。
func (b *backlog) take(peer string) []string {
b.mu.Lock()
defer b.mu.Unlock()
list := b.pending[peer]
delete(b.pending, peer)
return list
}
// offerToPeers 把一条本机复制发给每台已配对设备。没送达的记进待补发,
// 连接恢复后再发(见 PeerReady)。
func (e *Engine) offerToPeers(ctx context.Context, clip store.Clip, cfg config.Config) {
peers := e.pairedPeers()
if len(peers) == 0 {
return
}
offer := e.buildOffer(clip, cfg)
msg := &pb.PeerMessage{Payload: &pb.PeerMessage_Offer{Offer: offer}}
var reached []string
for _, peer := range peers {
if !cfg.SyncAllowed(peer) || !e.loadConfig().SyncAllowed(peer) {
continue
}
if err := e.send(peer, msg); err != nil {
e.queueMissed(peer, clip.ID)
continue
}
reached = append(reached, peer)
}
e.log.Info("已广播剪贴板内容", "clip", clip.ID, "kind", clip.Kind, "size", clip.TotalSize,
"对端数", len(reached), "待补发", len(peers)-len(reached))
// 小内容随即推送,对端无需等待即可粘贴
if pushes(offer, clip) {
for _, peer := range reached {
go e.pushOrRequeue(context.WithoutCancel(ctx), peer, clip)
}
}
}
// PeerReady 在与某台设备的连接建立或恢复时调用,补发连不上期间没送达的内容。
//
// 补发的 offer 带 backlog 标记,对端只记进复制记录、不写进剪贴板:
// 它此刻剪贴板里的内容比这些旧内容更新。
func (e *Engine) PeerReady(ctx context.Context, peer string) {
// 推送没送到的内容无论如何都要重推,所以放在开关判断之前
defer e.retryPushes(ctx, peer)
generation := e.policyGeneration.Load()
ids := e.backlog.take(peer)
if len(ids) == 0 {
return
}
cfg := e.loadConfig()
if !cfg.SyncBacklog || !cfg.SyncAllowed(peer) {
return
}
var sent int
for i, id := range ids {
cfg = e.loadConfig()
if generation != e.policyGeneration.Load() || !cfg.SyncBacklog || !cfg.SyncAllowed(peer) {
break
}
clip, err := e.store.GetClip(id)
if err != nil || time.Since(clip.CreatedAt) > backlogMaxAge {
continue // 已删除或太旧
}
offer := e.buildOffer(clip, cfg)
offer.Backlog = true
if err := e.send(peer, &pb.PeerMessage{Payload: &pb.PeerMessage_Offer{Offer: offer}}); err != nil {
// 刚连上又断了:剩下的放回去,等下次
for _, rest := range ids[i:] {
e.queueMissed(peer, rest)
}
break
}
sent++
if pushes(offer, clip) {
// 逐条推、不并发:补发可能有一串,同时开流会互相抢带宽
e.pushOrRequeue(ctx, peer, clip)
}
}
if sent > 0 {
e.log.Info("已补发连接中断期间的内容", "to", peer, "条数", sent)
}
}
// pushOrRequeue 推送内容;中途断了就记进「推送重试」,重连后连同 offer 一起重来,
// 不让对端的记录一直停在「接收中」。
//
// 这条不受「补发离线期间的内容」开关影响:对方已经收到了这条记录(offer 发出去了),
// 只是数据没送到,不重试就等于永久丢失。开关管的是 offer 根本没发出去的情况,见 offerToPeers。
func (e *Engine) pushOrRequeue(ctx context.Context, peer string, clip store.Clip) {
generation := e.policyGeneration.Load()
if !e.loadConfig().SyncAllowed(peer) {
return
}
if err := e.pushTo(ctx, peer, clip); err != nil {
e.log.Warn("推送内容失败,连接恢复后重试", "clip", clip.ID, "to", peer, "err", err)
if generation == e.policyGeneration.Load() {
e.pushRetry.add(peer, clip.ID)
}
}
}
// retryPushes 在连接恢复时重推那些「offer 发出去了、数据没送到」的内容。
// 重发的是同一条 offer(不带补发标记):对端已经有这条记录,只会接着收,不会重复记录,
// 也不会被当成旧内容而跳过自动写入剪贴板。
func (e *Engine) retryPushes(ctx context.Context, peer string) {
ids := e.pushRetry.take(peer)
if len(ids) == 0 {
return
}
cfg := e.loadConfig()
if !cfg.SyncAllowed(peer) {
return
}
pushed := 0
for _, id := range ids {
clip, err := e.store.GetClip(id)
if err != nil || time.Since(clip.CreatedAt) > backlogMaxAge {
continue // 已删除或太旧
}
offer := e.buildOffer(clip, cfg)
if err := e.send(peer, &pb.PeerMessage{Payload: &pb.PeerMessage_Offer{Offer: offer}}); err != nil {
// 刚连上又断了:放回去,等下次
e.pushRetry.add(peer, id)
break
}
if pushes(offer, clip) {
e.pushOrRequeue(ctx, peer, clip)
pushed++
}
}
if pushed > 0 {
e.log.Info("已重推没送到对方的内容", "to", peer, "条数", pushed)
}
}
func pushes(offer *pb.ClipOffer, clip store.Clip) bool {
return offer.GetWillPush() && (clip.Kind == store.KindFile || clip.Kind == store.KindImage)
}
func (e *Engine) queueMissed(peer, id string) {
e.backlog.mu.Lock()
defer e.backlog.mu.Unlock()
cfg := e.loadConfig()
if cfg.SyncBacklog && cfg.SyncAllowed(peer) {
e.backlog.addLocked(peer, id)
}
}
// ApplySyncPolicy drops pending records immediately when sharing is paused.
// Resuming sharing therefore starts with new copies only.
func (e *Engine) ApplySyncPolicy() {
e.policyGeneration.Add(1)
e.offerMu.Lock()
defer e.offerMu.Unlock()
cfg := e.loadConfig()
e.backlog.mu.Lock()
for peer := range e.backlog.pending {
if !cfg.SyncBacklog || !cfg.SyncAllowed(peer) {
delete(e.backlog.pending, peer)
}
}
e.backlog.mu.Unlock()
e.mu.Lock()
blocked := make(map[string]*receiveAttempt)
for id, attempt := range e.receives {
clip, err := e.store.GetClip(id)
if err == nil && !attempt.manual && !attempt.preview &&
(!cfg.SyncAllowed(clip.OriginDeviceID) || (e.quiet[id] && !cfg.SyncBacklog)) {
blocked[id] = attempt
}
}
e.mu.Unlock()
for id, attempt := range blocked {
e.failReceive(id, attempt, errors.New("clipboard sync paused"))
}
}