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 send
import (
"context"
"errors"
"fmt"
"os"
"path/filepath"
"strings"
"sync"
"time"
"github.com/baiyuze/pasteferry/client-core/internal/pack"
"github.com/baiyuze/pasteferry/client-core/internal/store"
pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
)
// outgoing 是一批正在发的文件。
type outgoing struct {
id, device string
ctx context.Context
cancel context.CancelCauseFunc
mu sync.Mutex
attempt uint32
answer chan *pb.SendAnswer
result chan *pb.SendResult
pipe sendPipe
done chan struct{} // runOutgoing 返回时关闭
}
func (o *outgoing) abort(cause error) {
o.cancel(cause)
o.closePipe()
}
func (o *outgoing) closePipe() {
o.mu.Lock()
p := o.pipe
o.pipe = nil
o.mu.Unlock()
if p != nil {
_ = p.Close() // 让卡在发送缓冲上的写入立刻返回
}
}
// peerCancel 是对方取消了这一批。
type peerCancel struct{ reason string }
func (p *peerCancel) Error() string { return "对方取消了:" + p.reason }
// SendFiles 把 paths 发给一台设备。立即返回这一批的记录:先统计,统计完排队,轮到了就发。
func (e *Engine) SendFiles(deviceID string, paths []string, allowRelay bool, note string) (*pb.Transfer, error) {
p := e.opts.Peer(deviceID)
other := p.Role != "" && p.Role != store.RoleSelf
switch {
case !p.Known:
return nil, ErrUnknownDevice
case !p.Online:
return nil, ErrOffline
case p.Connecting && (!p.Supported || other && !p.Ask):
if e.opts.Connect != nil {
go e.opts.Connect(deviceID)
}
return nil, ErrConnecting
case !p.Supported, other && !p.Ask:
// 旧版本收到会直接接收,绕过对方用户的确认,所以不发
return nil, ErrUnsupported
case p.Disabled:
return nil, ErrPeerDisabled
case len(paths) == 0:
return nil, ErrNoPaths
}
note, ok := CleanNote(note)
if !ok {
return nil, ErrBadNote
}
clean := make([]string, 0, len(paths))
items := make([]store.Item, 0, len(paths))
for _, path := range paths {
abs, err := filepath.Abs(path)
if err != nil {
return nil, fmt.Errorf("%w: %s", ErrNoPaths, path)
}
info, err := os.Stat(abs)
if err != nil {
return nil, fmt.Errorf("%w: %s", ErrNoPaths, path)
}
clean = append(clean, abs)
items = append(items, store.Item{Name: filepath.Base(abs), Size: info.Size(), IsDir: info.IsDir()})
}
if p.Relayed && e.opts.LoadConfig().Official() && !allowRelay {
return nil, ErrNeedRelayConsent
}
now := e.opts.Now()
t := store.Transfer{
ID: newID(), Direction: store.Outgoing, DeviceID: deviceID, DeviceName: p.Name,
Status: store.TransferScanning, Items: items, Paths: clean, AllowRelay: allowRelay,
Relayed: p.Relayed, CreatedAt: now, PeerRole: p.Role, Note: note,
}
e.save(t)
if other && !p.Connected && e.opts.Connect != nil {
// 好友不常连:现在连上,连上后(PeerReady)开始发
go e.opts.Connect(deviceID)
}
e.wg.Add(1)
go func() {
defer e.wg.Done()
e.scan(t)
}()
return e.toProto(t), nil
}
// scan 统计要发的文件,把清单记进数据库,然后排队。
func (e *Engine) scan(t store.Transfer) {
m := e.meterFor(t)
entries, tops, err := pack.BuildManifest(e.ctx, t.Paths, func(files int64) {
m.setScanned(files)
})
if e.ctx.Err() != nil {
return
}
// 统计期间用户可能已经取消了
if cur, gerr := e.opts.Store.GetTransfer(t.ID); gerr != nil || cur.Status != store.TransferScanning {
return
}
if err != nil {
code := "read_error"
if errors.Is(err, pack.ErrSourceMissing) {
code = "source_missing"
}
e.log.Warn("统计要发的文件失败", "transfer", t.ID, "err", err)
e.finish(t, store.TransferFailed, code)
return
}
rows := make([]store.TransferEntry, len(entries))
var total, files int64
for i, en := range entries {
rows[i] = store.TransferEntry{Index: int64(i), Path: en.Path, Size: en.Size, IsDir: en.IsDir,
Mode: en.Mode, MTime: en.MTime, Link: en.Link, Source: en.Source}
if !en.IsDir && en.Link == "" {
total += en.Size
files++
}
}
if err := e.opts.Store.PutTransferEntries(t.ID, rows); err != nil {
e.log.Warn("保存清单失败", "transfer", t.ID, "err", err)
e.finish(t, store.TransferFailed, "read_error")
return
}
t.Items = t.Items[:0]
for _, top := range tops {
t.Items = append(t.Items, store.Item{Name: top.Name, Size: top.Size, IsDir: top.IsDir})
}
t.TotalBytes, t.FileCount, t.Status = total, files, store.TransferQueued
e.mu.Lock()
delete(e.progress, t.ID)
e.mu.Unlock()
e.save(t)
e.kick(t.DeviceID)
}
// Resume 让中断或暂停的一批从断点继续。
func (e *Engine) Resume(id string) error {
t, err := e.opts.Store.GetTransfer(id)
if err != nil {
return ErrNotFound
}
if strings.HasPrefix(t.DeviceID, "web:") || t.Direction != store.Outgoing || (t.Status != store.TransferInterrupted && t.Status != store.TransferPaused) {
return ErrNotResumable
}
t.Status, t.Error = store.TransferQueued, ""
e.save(t)
e.kick(t.DeviceID)
return nil
}
// kick 确保这台设备有一个发送工作者在跑。
func (e *Engine) kick(deviceID string) {
e.mu.Lock()
if e.workers[deviceID] || e.ctx.Err() != nil {
e.mu.Unlock()
return
}
e.workers[deviceID] = true
e.mu.Unlock()
e.wg.Add(1)
go func() {
defer e.wg.Done()
e.runDevice(deviceID)
}()
}
// runDevice 按先后顺序一批一批地发给一台设备。连接断了就停下,等 PeerReady 再来。
func (e *Engine) runDevice(deviceID string) {
// 重连可能早于旧尝试的应答超时:PeerReady 看不到稍后才标为中断的批次。
// 每批补试一次;持续失败仍等下一次重连或用户点「继续」,不循环重发。
var retried string
for e.ctx.Err() == nil {
t, ok := e.nextQueued(deviceID)
if !ok || !e.opts.Peer(deviceID).Connected {
break
}
e.runOutgoing(t)
if retried != t.ID {
if cur, err := e.opts.Store.GetTransfer(t.ID); err == nil && cur.Status == store.TransferInterrupted && e.opts.Peer(deviceID).Connected {
retried = t.ID
e.retryInterrupted(cur)
}
}
}
e.mu.Lock()
delete(e.workers, deviceID)
e.mu.Unlock()
// 停下的同时可能有新的一批排进来了
if _, ok := e.nextQueued(deviceID); ok && e.opts.Peer(deviceID).Connected && e.ctx.Err() == nil {
e.kick(deviceID)
}
}
// retryInterrupted 给对方重启留一点时间,等待期间的取消、手动继续和退出优先。
func (e *Engine) retryInterrupted(t store.Transfer) {
timer := time.NewTimer(3 * time.Second)
defer timer.Stop()
select {
case <-e.ctx.Done():
return
case <-timer.C:
}
cur, err := e.opts.Store.GetTransfer(t.ID)
if err != nil || cur.Status != store.TransferInterrupted || cur.Attempt != t.Attempt || !e.opts.Peer(t.DeviceID).Connected {
return
}
cur.Status, cur.Error = store.TransferQueued, ""
e.save(cur)
}
func (e *Engine) nextQueued(deviceID string) (store.Transfer, bool) {
list, err := e.opts.Store.UnfinishedTransfers()
if err != nil {
return store.Transfer{}, false
}
for _, t := range list {
if t.Direction == store.Outgoing && t.DeviceID == deviceID && t.Status == store.TransferQueued {
return t, true
}
}
return store.Transfer{}, false
}
// runOutgoing 发一批:发起、等应答、发帧流、等结果。
func (e *Engine) runOutgoing(t store.Transfer) {
ctx, cancel := context.WithCancelCause(e.ctx)
defer cancel(nil)
o := &outgoing{id: t.ID, device: t.DeviceID, ctx: ctx, cancel: cancel,
answer: make(chan *pb.SendAnswer, 2), result: make(chan *pb.SendResult, 1), done: make(chan struct{})}
defer o.closePipe()
e.mu.Lock()
e.out[t.ID] = o
e.mu.Unlock()
defer func() {
e.mu.Lock()
delete(e.out, t.ID)
e.mu.Unlock()
close(o.done)
}()
fresh := t.Attempt == 0 // 对方从没收到过这一批
retried := false
for {
t.Attempt++
o.mu.Lock()
o.attempt = uint32(t.Attempt)
o.mu.Unlock()
peer := e.opts.Peer(t.DeviceID)
t.Status, t.Error, t.Shortfall, t.Relayed = store.TransferWaiting, "", 0, peer.Relayed
e.save(t)
largest, _ := e.opts.Store.LargestTransferEntry(t.ID)
items := make([]*pb.ClipItem, len(t.Items))
for i, it := range t.Items {
items[i] = &pb.ClipItem{Name: it.Name, Size: it.Size, IsDir: it.IsDir}
}
offer := &pb.SendOffer{TransferId: t.ID, Attempt: uint32(t.Attempt), Items: items,
TotalBytes: t.TotalBytes, FileCount: t.FileCount, LargestFile: largest,
CreatedAtUnix: t.CreatedAt.Unix(), Resume: !fresh, Note: t.Note}
if err := e.opts.Send(t.DeviceID, &pb.PeerMessage{Payload: &pb.PeerMessage_SendOffer{SendOffer: offer}}); err != nil {
e.interrupt(t)
return
}
var answer *pb.SendAnswer
wait := time.NewTimer(e.opts.AnswerTimeout)
waitAnswer:
for {
select {
case answer = <-o.answer:
if !answer.GetAccepted() && answer.GetReason() == "pending" {
// 对方在等它的用户接受:多等一会儿
t.Status = store.TransferAsking
e.save(t)
wait.Reset(e.opts.AskTimeout + askSlack)
continue
}
break waitAnswer
case <-ctx.Done():
wait.Stop()
e.stopped(t, context.Cause(ctx))
return
case <-wait.C:
if t.Status == store.TransferAsking {
e.log.Info("对方的用户没有回应", "transfer", t.ID)
_ = e.opts.Send(t.DeviceID, &pb.PeerMessage{Payload: &pb.PeerMessage_SendCancel{
SendCancel: &pb.SendCancel{TransferId: t.ID, Reason: "timeout"}}})
e.finish(t, store.TransferDeclined, "timeout")
return
}
e.log.Info("对方没有应答", "transfer", t.ID)
// 带上原因:界面据此说「对方没有应答」,而不是只显示「中断」,用户不知道该怎么办
e.interruptWith(t, "peer_unreachable")
return
}
}
wait.Stop()
if !answer.GetAccepted() {
if answer.GetReason() == "already_done" {
// 上次其实已经收完了,只是结果没传回来(比如走局域网快速通道时控制通道恰好断了)
t.DoneBytes = t.TotalBytes
e.finish(t, store.TransferDone, "")
e.log.Info("隔空传送已送达(对方上次已收完)", "transfer", t.ID, "to", t.DeviceID)
return
}
if answer.GetReason() == "unknown_transfer" && !fresh {
// 对方已经清掉了没收完的部分(或者换了电脑重装过),从头再发
fresh = true
t.DoneBytes = 0
continue
}
t.Shortfall = answer.GetShortfallBytes()
e.finish(t, store.TransferDeclined, answer.GetReason())
return
}
fresh = false
base, filesBefore, err := e.opts.Store.TransferEntryTotals(t.ID, answer.GetResumeIndex())
if err != nil {
e.interrupt(t)
return
}
t.DoneBytes = base + answer.GetResumeOffset()
t.Status = store.TransferActive
e.save(t)
e.setBusy(t.ID, true)
err = e.stream(ctx, o, t, answer.GetResumeIndex(), answer.GetResumeOffset(), filesBefore, answer.GetLanAddr())
if err != nil {
if ctx.Err() != nil {
e.stopped(t, context.Cause(ctx))
return
}
if code := sourceErrorCode(err); code != "" {
e.log.Warn("读源文件失败", "transfer", t.ID, "err", err)
_ = e.opts.Send(t.DeviceID, &pb.PeerMessage{Payload: &pb.PeerMessage_SendCancel{
SendCancel: &pb.SendCancel{TransferId: t.ID, Reason: code}}})
e.finish(t, store.TransferFailed, code)
return
}
e.log.Info("发送中断", "transfer", t.ID, "err", err)
e.interrupt(e.withProgress(t))
return
}
var result *pb.SendResult
select {
case result = <-o.result:
case <-ctx.Done():
e.stopped(t, context.Cause(ctx))
return
case <-time.After(e.opts.ResultTimeout):
e.interrupt(e.withProgress(t))
return
}
o.closePipe()
if result.GetOk() {
t.DoneBytes = t.TotalBytes
e.finish(t, store.TransferDone, "")
if t.PeerRole == store.RoleFriend && e.opts.Delivered != nil {
e.opts.Delivered(t.DeviceID)
}
e.log.Info("隔空传送已送达", "transfer", t.ID, "to", t.DeviceID, "字节", t.TotalBytes)
return
}
if result.GetError() == "hash_mismatch" && !retried {
// 对方已经删掉了校验不对的那个文件,从它开始再发一次
retried = true
e.setBusy(t.ID, false)
continue
}
e.finish(e.withProgress(t), store.TransferFailed, result.GetError())
return
}
}
// stream 开这次尝试的管道(局域网 TCP 或数据通道),从第 index 个条目的 offset 处开始发帧流。
func (e *Engine) stream(ctx context.Context, o *outgoing, t store.Transfer, index, offset, filesBefore int64, lanAddr string) error {
label := fmt.Sprintf("%s%s:%d", streamPrefix, t.ID, t.Attempt)
p, err := e.openPipe(ctx, sendTarget{id: t.ID, device: t.DeviceID, label: label}, lanAddr)
if err != nil {
if ctx.Err() != nil {
return ctx.Err()
}
return fmt.Errorf("打开数据流: %w", err)
}
o.mu.Lock()
o.pipe = p
o.mu.Unlock()
// Keep the stream alive until the receiver acknowledges the end frame.
// An empty local send buffer alone does not confirm remote consumption.
m := e.meterFor(t)
m.start(t.DoneBytes)
fw, err := pack.NewFrameWriter(p, m.add)
if err != nil {
return err
}
ordinal := filesBefore
for from := index; ; {
batch, err := e.opts.Store.TransferEntries(t.ID, from, 1000)
if err != nil {
fw.Close()
return err
}
if len(batch) == 0 {
break
}
for _, en := range batch {
if err := ctx.Err(); err != nil {
fw.Close()
return err
}
off := int64(0)
if en.Index == index {
off = offset
}
if !en.IsDir && en.Link == "" {
ordinal++
m.setCurrent(en.Path, ordinal)
}
entry := pack.Entry{Path: en.Path, Source: en.Source, Size: en.Size, IsDir: en.IsDir,
Mode: en.Mode, MTime: en.MTime, Link: en.Link}
if err := fw.WriteEntry(en.Index, entry, off); err != nil {
fw.Close()
return err
}
}
from = batch[len(batch)-1].Index + 1
}
if err := fw.Finish(); err != nil {
return err
}
return p.finish(ctx)
}
// sourceErrorCode 把读源文件的错误转成发给对方、显示给用户的代码;不是源文件的问题时返回空。
func sourceErrorCode(err error) string {
var re *pack.ReadError
switch {
case errors.Is(err, pack.ErrSourceChanged):
return "source_changed"
case errors.Is(err, pack.ErrSourceMissing):
return "source_missing"
case errors.As(err, &re):
return "read_error"
}
return ""
}
// interrupt 把一批标为中断:连上以后自动续传。经官方服务中转、而今天的额度用完了时标为暂停。
func (e *Engine) interrupt(t store.Transfer) { e.interruptWith(t, "") }
// interruptWith 与 interrupt 相同,另外把原因记进记录:界面据 error 显示更具体的提示,
// 状态仍然是「中断」,用户点「继续」还是能接着发。
func (e *Engine) interruptWith(t store.Transfer, reason string) {
e.setBusy(t.ID, false)
t.Status = store.TransferInterrupted
t.Error = reason
if t.Relayed && e.opts.LoadConfig().Official() && e.opts.RelayQuotaExhausted != nil && e.opts.RelayQuotaExhausted() {
t.Status, t.Error = store.TransferPaused, "relay_quota"
}
e.mu.Lock()
delete(e.progress, t.ID)
e.mu.Unlock()
e.save(t)
}
// stopped 处理被取消的一批:用户取消、对方取消,或者后台服务正在退出。
func (e *Engine) stopped(t store.Transfer, cause error) {
t = e.withProgress(t)
var pc *peerCancel
switch {
case errors.Is(cause, errCancelled):
_ = e.opts.Send(t.DeviceID, &pb.PeerMessage{Payload: &pb.PeerMessage_SendCancel{
SendCancel: &pb.SendCancel{TransferId: t.ID, Reason: "cancelled"}}})
e.finish(t, store.TransferCancelled, "cancelled")
case errors.As(cause, &pc):
e.finish(t, store.TransferCancelled, "peer_cancelled")
default:
e.interrupt(t)
}
}
// withProgress 把内存里的进度写回记录。
func (e *Engine) withProgress(t store.Transfer) store.Transfer {
e.mu.Lock()
m := e.progress[t.ID]
e.mu.Unlock()
if m != nil {
t.DoneBytes = m.doneBytes()
}
return t
}
func (e *Engine) handleAnswer(from string, a *pb.SendAnswer) {
e.mu.Lock()
o := e.out[a.GetTransferId()]
e.mu.Unlock()
if o == nil || o.device != from {
return
}
o.mu.Lock()
match := a.GetAttempt() == o.attempt
o.mu.Unlock()
if !match {
return
}
select {
case o.answer <- a:
default:
}
}
func (e *Engine) handleResult(from string, r *pb.SendResult) {
e.mu.Lock()
o := e.out[r.GetTransferId()]
e.mu.Unlock()
if o == nil || o.device != from {
return
}
o.mu.Lock()
match := r.GetAttempt() == o.attempt
o.mu.Unlock()
if !match {
return
}
select {
case o.result <- r:
default:
}
}
// handleCancel 处理对方的取消:正在进行的停下,没在进行的直接结束。
//
// 正在进行的那一批可能恰好刚因为数据流断了而判为中断、还没退出,取消就落空了。
// 所以停下它以后等它退出,再按记录补做一次;它自己已经处理过取消的话,记录已经结束,不会重复。
func (e *Engine) handleCancel(from string, c *pb.SendCancel) {
id := c.GetTransferId()
if e.cancelAsk(id, from) {
return
}
cause := &peerCancel{reason: c.GetReason()}
e.mu.Lock()
o, in := e.out[id], e.in[id]
e.mu.Unlock()
var running chan struct{}
switch {
case o != nil && o.device == from:
o.abort(cause)
running = o.done
case in != nil && in.device == from:
in.abort(cause)
running = in.done
}
if running == nil {
e.applyPeerCancel(from, c)
return
}
e.wg.Add(1)
go func() {
defer e.wg.Done()
select {
case <-running:
case <-time.After(10 * time.Second):
}
e.applyPeerCancel(from, c)
}()
}
// applyPeerCancel 按记录处理对方的取消:还没结束的一批直接结束,收到的删掉没收完的部分。
func (e *Engine) applyPeerCancel(from string, c *pb.SendCancel) {
id := c.GetTransferId()
t, err := e.opts.Store.GetTransfer(id)
if err != nil || t.DeviceID != from || store.TransferFinished(t.Status) {
return
}
if t.Direction == store.Incoming {
e.removePartial(t)
code := "peer_cancelled"
if r := c.GetReason(); r == "source_changed" || r == "source_missing" || r == "read_error" {
e.finish(t, store.TransferFailed, r)
e.notice(NoticeFailed, t)
return
}
e.finish(t, store.TransferCancelled, code)
return
}
e.finish(t, store.TransferCancelled, "peer_cancelled")
}