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
feat(core): send files over a direct TCP link on the local network
baiyuzea86be919fc92
diff --git a/client-core/cmd/pasteferryd/main.go b/client-core/cmd/pasteferryd/main.goindex 0e5d4bb..afc6e9a 100644--- a/client-core/cmd/pasteferryd/main.go+++ b/client-core/cmd/pasteferryd/main.go@@ -384,11 +384,14 @@ func run(dataDir string) error {defer engine.Close()// ── 隔空传送 ──+ listenLAN, dialLAN := lanHooks(id, peerMgr)sender = send.New(send.Options{Store: db,LoadConfig: loadCfg,Send: peerMgr.P2P().Send,OpenStream: peerMgr.P2P().OpenStream,+ ListenLAN: listenLAN,+ DialLAN: dialLAN,Peer: func(deviceID string) send.Peer {_, list := peerMgr.Devices()for _, d := range list {diff --git a/client-core/cmd/pasteferryd/send_lan.go b/client-core/cmd/pasteferryd/send_lan.gonew file mode 100644index 0000000..431ab68--- /dev/null+++ b/client-core/cmd/pasteferryd/send_lan.go@@ -0,0 +1,55 @@+package main++import (+ "context"+ "io"+ "log/slog"++ "github.com/baiyuze/pasteferry/client-core/internal/identity"+ "github.com/baiyuze/pasteferry/client-core/internal/peers"+ "github.com/baiyuze/pasteferry/client-core/internal/transport/lantcp"+)++type (+ listenLANFunc = func(deviceID string) (string, func(context.Context) (io.ReadCloser, string, error), bool)+ dialLANFunc = func(ctx context.Context, deviceID, addr, label string) (io.WriteCloser, error)+)++// lanHooks 把局域网快速通道(2.5.1,lantcp)接到隔空传送上。+// 证书建不起来时两个函数都为空,隔空传送只用数据通道,与 2.5.0 相同。+func lanHooks(id *identity.Identity, peerMgr *peers.Manager) (listenLANFunc, dialLANFunc) {+ link, err := lantcp.New(id.Signer())+ if err != nil {+ slog.Warn("局域网快速通道不可用", "err", err)+ return nil, nil+ }+ listen := func(deviceID string) (string, func(context.Context) (io.ReadCloser, string, error), bool) {+ if !peerMgr.HasFeature(deviceID, peers.FeatureSendFilesTCP) {+ return "", nil, false+ }+ ip, ok := peerMgr.P2P().LANAddr(deviceID)+ if !ok {+ return "", nil, false+ }+ ln, err := link.Listen(ip, deviceID)+ if err != nil {+ slog.Info("开不了局域网快速通道的端口,用数据通道", "addr", ip, "err", err)+ return "", nil, false+ }+ return ln.Addr(), func(ctx context.Context) (io.ReadCloser, string, error) {+ c, label, err := ln.Accept(ctx)+ if err != nil {+ return nil, "", err+ }+ return c, label, nil+ }, true+ }+ dial := func(ctx context.Context, deviceID, addr, label string) (io.WriteCloser, error) {+ c, err := link.Dial(ctx, addr, deviceID, label)+ if err != nil {+ return nil, err+ }+ return c, nil+ }+ return listen, dial+}diff --git a/client-core/internal/identity/identity.go b/client-core/internal/identity/identity.goindex 2e63bec..1871c58 100644--- a/client-core/internal/identity/identity.go+++ b/client-core/internal/identity/identity.go@@ -6,6 +6,7 @@package identityimport (+ "crypto""crypto/ed25519""crypto/rand""encoding/json"@@ -135,6 +136,9 @@ func Verify(pub ed25519.PublicKey, data, sig []byte) bool {// Fingerprint 返回供用户肉眼核对的短指纹,形如 "K7X2-M9PL-4RT8"。func (i *Identity) Fingerprint() string { return deviceid.Fingerprint(i.PublicKey) }+// Signer 返回设备私钥,只用来给本机的 TLS 证书签名(隔空传送的局域网通道),不要拿去签别的东西。+func (i *Identity) Signer() crypto.Signer { return i.privateKey }+// 派生规则属于协议契约,与服务器共用同一份实现(proto/deviceid)。var (FingerprintFor = deviceid.Fingerprintdiff --git a/client-core/internal/peers/manager.go b/client-core/internal/peers/manager.goindex 09f1ae6..481700a 100644--- a/client-core/internal/peers/manager.go+++ b/client-core/internal/peers/manager.go@@ -349,6 +349,8 @@ func (m *Manager) OfficialUsage() *pb.OfficialUsage {const (FeatureSendFiles = "send_files_v1"FeatureSendFilesOff = "send_files_off" // 能接收隔空传送,但用户关掉了+ // 隔空传送能走局域网 TCP 快速通道(2.5.1),见 internal/transport/lantcp+ FeatureSendFilesTCP = "send_files_tcp_v1")func (m *Manager) featuresMessage() *pb.PeerMessage {@@ -356,6 +358,7 @@ func (m *Manager) featuresMessage() *pb.PeerMessage {if m.loadConfig().ReceiveDisabled {f = []string{FeatureSendFilesOff}}+ f = append(f, FeatureSendFilesTCP)return &pb.PeerMessage{Payload: &pb.PeerMessage_Features{Features: &pb.PeerFeatures{Features: f}}}}@@ -397,6 +400,13 @@ func (m *Manager) SendFilesSupport(deviceID string) (supported, disabled bool) {return f[FeatureSendFiles] || f[FeatureSendFilesOff], f[FeatureSendFilesOff]}+// HasFeature 报告对端是否声明了某项功能。+func (m *Manager) HasFeature(deviceID, feature string) bool {+ m.mu.RLock()+ defer m.mu.RUnlock()+ return m.features[deviceID][feature]+}+// ConnState 返回与某台设备的 P2P 连接状态。func (m *Manager) ConnState(deviceID string) p2p.ConnState { return m.p2p.State(deviceID) }diff --git a/client-core/internal/send/incoming.go b/client-core/internal/send/incoming.goindex 93f2841..469b66e 100644--- a/client-core/internal/send/incoming.go+++ b/client-core/internal/send/incoming.go@@ -38,12 +38,12 @@ type incoming struct {ctx context.Contextcancel context.CancelCauseFunc- streamCh chan *p2p.Stream+ streamCh chan io.ReadCloser // 数据通道或局域网 TCP,先到的那条done chan struct{}active atomic.Int64 // 最近一次收到数据的时间(UnixNano),看门狗用mu sync.Mutex- stream *p2p.Stream+ stream io.ReadCloser}func (in *incoming) abort(cause error) {@@ -134,7 +134,7 @@ func (e *Engine) handleOffer(from string, offer *pb.SendOffer) {var t store.Transferin := &incoming{id: id, device: from, attempt: offer.GetAttempt(), offer: offer,tops: map[string]bool{}, names: pack.NewNames(),- streamCh: make(chan *p2p.Stream, 1), done: make(chan struct{})}+ streamCh: make(chan io.ReadCloser, 1), done: make(chan struct{})}for _, it := range offer.GetItems() {in.tops[it.GetName()] = true}@@ -227,7 +227,8 @@ func (e *Engine) handleOffer(from string, offer *pb.SendOffer) {defer e.wg.Done()e.runIncoming(in, t)}()- answer(&pb.SendAnswer{Accepted: true, ResumeIndex: in.resumeIndex, ResumeOffset: in.resumeOffset})+ answer(&pb.SendAnswer{Accepted: true, ResumeIndex: in.resumeIndex, ResumeOffset: in.resumeOffset,+ LanAddr: e.listenLAN(in)})}func validOffer(o *pb.SendOffer) error {@@ -309,6 +310,11 @@ func (e *Engine) resumePoint(in *incoming) error {// HandleStream 接管对端为隔空传送新开的数据通道。func (e *Engine) HandleStream(from, label string, st *p2p.Stream) {+ e.deliverStream(from, label, newDCStream(st))+}++// deliverStream 把一条数据流(数据通道或局域网 TCP)交给对应的那一批。+func (e *Engine) deliverStream(from, label string, st io.ReadCloser) {rest := strings.TrimPrefix(label, streamPrefix)id, attempt, ok := strings.Cut(rest, ":")n, err := strconv.ParseUint(attempt, 10, 32)@@ -338,7 +344,7 @@ func (e *Engine) runIncoming(in *incoming, t store.Transfer) {e.mu.Unlock()}()- var st *p2p.Stream+ var st io.ReadCloserselect {case st = <-in.streamCh:case <-in.ctx.Done():@@ -443,8 +449,8 @@ func (e *Engine) incomingStopped(in *incoming, t store.Transfer, cause error) {}// receive 读帧流,把条目写进临时目录,读到结束帧后收尾。-func (e *Engine) receive(in *incoming, t store.Transfer, st *p2p.Stream) error {- fr, err := pack.NewFrameReader(st.Reader())+func (e *Engine) receive(in *incoming, t store.Transfer, st io.Reader) error {+ fr, err := pack.NewFrameReader(st)if err != nil {return err}diff --git a/client-core/internal/send/outgoing.go b/client-core/internal/send/outgoing.goindex f852d19..140f3db 100644--- a/client-core/internal/send/outgoing.go+++ b/client-core/internal/send/outgoing.go@@ -9,11 +9,8 @@ import ("sync""time"- "github.com/pion/webrtc/v4"-"github.com/baiyuze/pasteferry/client-core/internal/pack""github.com/baiyuze/pasteferry/client-core/internal/store"- "github.com/baiyuze/pasteferry/client-core/internal/transport/p2p"pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1")@@ -27,17 +24,17 @@ type outgoing struct {attempt uint32answer chan *pb.SendAnswerresult chan *pb.SendResult- dc *webrtc.DataChannel+ pipe sendPipedone chan struct{} // runOutgoing 返回时关闭}func (o *outgoing) abort(cause error) {o.cancel(cause)o.mu.Lock()- dc := o.dc+ p := o.pipeo.mu.Unlock()- if dc != nil {- _ = dc.Close() // 让卡在发送缓冲上的写入立刻返回+ if p != nil {+ _ = p.Close() // 让卡在发送缓冲上的写入立刻返回}}@@ -278,7 +275,7 @@ func (e *Engine) runOutgoing(t store.Transfer) {e.save(t)e.setBusy(t.ID, true)- err = e.stream(ctx, o, t, answer.GetResumeIndex(), answer.GetResumeOffset(), filesBefore)+ 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))@@ -323,35 +320,24 @@ func (e *Engine) runOutgoing(t store.Transfer) {}}-// stream 开一条数据通道,从第 index 个条目的 offset 处开始发帧流。-func (e *Engine) stream(ctx context.Context, o *outgoing, t store.Transfer, index, offset, filesBefore int64) error {+// 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)- dc, err := e.opts.OpenStream(t.DeviceID, label)+ 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)}- opened := make(chan struct{})- var once sync.Once- dc.OnOpen(func() { once.Do(func() { close(opened) }) })- if dc.ReadyState() == webrtc.DataChannelStateOpen {- once.Do(func() { close(opened) })- }o.mu.Lock()- o.dc = dc+ o.pipe = po.mu.Unlock()- defer dc.Close()- select {- case <-opened:- case <-ctx.Done():- return ctx.Err()- case <-time.After(e.opts.AnswerTimeout):- return errors.New("数据流打开超时")- }+ defer p.Close()m := e.meterFor(t)m.start(t.DoneBytes)- cw := p2p.NewChunkWriter(dc, nil)- fw, err := pack.NewFrameWriter(cw, m.add)+ fw, err := pack.NewFrameWriter(p, m.add)if err != nil {return err}@@ -390,11 +376,7 @@ func (e *Engine) stream(ctx context.Context, o *outgoing, t store.Transfer, indeif err := fw.Finish(); err != nil {return err}- if err := cw.Flush(); err != nil {- return err- }- // 等发送缓冲排空再关通道,否则尾部数据会被丢掉- return cw.WaitDrained(ctx, time.Minute)+ return p.finish(ctx)}// sourceErrorCode 把读源文件的错误转成发给对方、显示给用户的代码;不是源文件的问题时返回空。diff --git a/client-core/internal/send/pipe.go b/client-core/internal/send/pipe.gonew file mode 100644index 0000000..f4384ee--- /dev/null+++ b/client-core/internal/send/pipe.go@@ -0,0 +1,139 @@+package send++import (+ "context"+ "errors"+ "io"+ "sync"+ "time"++ "github.com/pion/webrtc/v4"++ "github.com/baiyuze/pasteferry/client-core/internal/transport/p2p"+)++// 文件数据走的管道有两种:WebRTC 数据通道(一直都有),和局域网 TCP 快速通道(2.5.1,见 lantcp)。+// 帧流只认读写,换管道时组帧、续传、校验、进度都不用动;控制消息始终走控制通道。++// lanDialTimeout 是试局域网 TCP 的时限,超过就退回数据通道+const lanDialTimeout = 2 * time.Second++// sendPipe 是发送方写帧流的管道。+type sendPipe interface {+ io.Writer+ // finish 在写完结束帧后调用,保证数据都送到了对方+ finish(ctx context.Context) error+ Close() error+}++// dcPipe 是数据通道:写入经 ChunkWriter 分块并按发送缓冲限速。+type dcPipe struct {+ dc *webrtc.DataChannel+ cw *p2p.ChunkWriter+}++func (p *dcPipe) Write(b []byte) (int, error) { return p.cw.Write(b) }++func (p *dcPipe) finish(ctx context.Context) error {+ if err := p.cw.Flush(); err != nil {+ return err+ }+ // 等发送缓冲排空再关通道,否则尾部数据会被丢掉+ return p.cw.WaitDrained(ctx, time.Minute)+}++func (p *dcPipe) Close() error { return p.dc.Close() }++// tcpPipe 是局域网 TCP:内核负责送达,写完以后关掉写方向即可。+type tcpPipe struct {+ io.WriteCloser+}++func (p *tcpPipe) finish(context.Context) error {+ if cw, ok := p.WriteCloser.(interface{ CloseWrite() error }); ok {+ return cw.CloseWrite()+ }+ return nil+}++// openPipe 开这次尝试的管道:对方给了局域网地址就先试 TCP,不行再开数据通道。+func (e *Engine) openPipe(ctx context.Context, t sendTarget, lanAddr string) (sendPipe, error) {+ if lanAddr != "" && e.opts.DialLAN != nil {+ dctx, cancel := context.WithTimeout(ctx, lanDialTimeout)+ c, err := e.opts.DialLAN(dctx, t.device, lanAddr, t.label)+ cancel()+ if err == nil {+ e.log.Info("隔空传送走局域网快速通道", "transfer", t.id, "addr", lanAddr)+ return &tcpPipe{c}, nil+ }+ if ctx.Err() != nil {+ return nil, ctx.Err()+ }+ e.log.Info("局域网快速通道连不上,改用数据通道", "transfer", t.id, "addr", lanAddr, "err", err)+ }+ return e.openDataChannel(ctx, t)+}++// sendTarget 是开管道需要的信息。+type sendTarget struct {+ id, device, label string+}++// openDataChannel 开一条数据通道并等它打开。+func (e *Engine) openDataChannel(ctx context.Context, t sendTarget) (sendPipe, error) {+ dc, err := e.opts.OpenStream(t.device, t.label)+ if err != nil {+ return nil, err+ }+ opened := make(chan struct{})+ var once sync.Once+ dc.OnOpen(func() { once.Do(func() { close(opened) }) })+ if dc.ReadyState() == webrtc.DataChannelStateOpen {+ once.Do(func() { close(opened) })+ }+ select {+ case <-opened:+ case <-ctx.Done():+ _ = dc.Close()+ return nil, ctx.Err()+ case <-time.After(e.opts.AnswerTimeout):+ _ = dc.Close()+ return nil, errors.New("数据流打开超时")+ }+ return &dcPipe{dc: dc, cw: p2p.NewChunkWriter(dc, nil)}, nil+}++// dcStream 把收到的数据通道包成接收方要的读取接口。+type dcStream struct {+ st *p2p.Stream+ r io.Reader+}++func newDCStream(st *p2p.Stream) *dcStream { return &dcStream{st: st, r: st.Reader()} }++func (s *dcStream) Read(b []byte) (int, error) { return s.r.Read(b) }+func (s *dcStream) Close() error { return s.st.Close() }++// listenLAN 在条件满足时为这次尝试开局域网 TCP 端口,返回写进应答里的地址;不满足时返回空。+// 端口只接一次连接,最晚在应答超时后关掉;先到的是数据通道也没关系,后到的那条会被丢弃。+func (e *Engine) listenLAN(in *incoming) string {+ if e.opts.ListenLAN == nil {+ return ""+ }+ addr, accept, ok := e.opts.ListenLAN(in.device)+ if !ok {+ return ""+ }+ ctx, cancel := context.WithTimeout(in.ctx, e.opts.AnswerTimeout)+ e.wg.Add(1)+ go func() {+ defer e.wg.Done()+ defer cancel()+ c, label, err := accept(ctx)+ if err != nil {+ return+ }+ e.deliverStream(in.device, label, c)+ }()+ return addr+}diff --git a/client-core/internal/send/pipe_test.go b/client-core/internal/send/pipe_test.gonew file mode 100644index 0000000..38801f1--- /dev/null+++ b/client-core/internal/send/pipe_test.go@@ -0,0 +1,224 @@+package send++import (+ "context"+ "crypto/ed25519"+ "crypto/rand"+ "io"+ "net/netip"+ "os"+ "path/filepath"+ "sync/atomic"+ "testing"+ "time"++ "github.com/pion/webrtc/v4"++ "github.com/baiyuze/pasteferry/client-core/internal/store"+ "github.com/baiyuze/pasteferry/client-core/internal/transport/lantcp"+ "github.com/baiyuze/pasteferry/proto/deviceid"+)++// 局域网快速通道:在两台设备之间接上真实的 lantcp(本机回环),看文件数据确实改走 TCP,+// 续传、取消照常,连不上时退回数据通道。++type lanStats struct {+ dials atomic.Int32 // 发送方连上 TCP 的次数+ accepts atomic.Int32 // 接收方接到 TCP 的次数+ channels atomic.Int32 // 发送方开数据通道的次数+}++// useLAN 给两边装上 ListenLAN、DialLAN。refuse 为 true 时接收方给出的端口一开就关,模拟防火墙挡住。+func useLAN(t *testing.T, p *pair, refuse bool) *lanStats {+ t.Helper()+ ids := map[string]string{} // 测试里的设备名 → 由公钥派生的设备 ID(lantcp 按它核对身份)+ links := map[string]*lantcp.Link{}+ for _, name := range []string{"alice", "bob"} {+ pub, priv, err := ed25519.GenerateKey(rand.Reader)+ if err != nil {+ t.Fatal(err)+ }+ l, err := lantcp.New(priv)+ if err != nil {+ t.Fatal(err)+ }+ ids[name], links[name] = deviceid.For(pub), l+ }+ st := &lanStats{}+ for _, s := range []*side{p.a, p.b} {+ self := links[s.id]+ open := s.eng.opts.OpenStream+ s.eng.opts.OpenStream = func(deviceID, label string) (*webrtc.DataChannel, error) {+ st.channels.Add(1)+ return open(deviceID, label)+ }+ s.eng.opts.ListenLAN = func(deviceID string) (string, func(context.Context) (io.ReadCloser, string, error), bool) {+ ln, err := self.Listen(netip.MustParseAddr("127.0.0.1"), ids[deviceID])+ if err != nil {+ t.Error(err)+ return "", nil, false+ }+ addr := ln.Addr()+ if refuse {+ ln.Close()+ }+ return addr, func(ctx context.Context) (io.ReadCloser, string, error) {+ c, label, err := ln.Accept(ctx)+ if err != nil {+ return nil, "", err+ }+ st.accepts.Add(1)+ return c, label, nil+ }, true+ }+ s.eng.opts.DialLAN = func(ctx context.Context, deviceID, addr, label string) (io.WriteCloser, error) {+ c, err := self.Dial(ctx, addr, ids[deviceID], label)+ if err != nil {+ return nil, err+ }+ st.dials.Add(1)+ return c, nil+ }+ }+ return st+}++func TestSendOverLAN(t *testing.T) {+ p := newPair(t)+ st := useLAN(t, p, false)+ src := t.TempDir()+ report := randomBytes(t, 3<<20)+ photo := randomBytes(t, 700<<10)+ writeFile(t, filepath.Join(src, "报告.pdf"), report)+ writeFile(t, filepath.Join(src, "照片", "2026", "IMG_1.HEIC"), photo)+ writeFile(t, filepath.Join(src, "照片", "空文件.txt"), nil)+ if err := os.MkdirAll(filepath.Join(src, "照片", "空文件夹"), 0o755); err != nil {+ t.Fatal(err)+ }++ tr, err := p.a.eng.SendFiles("bob", []string{filepath.Join(src, "报告.pdf"), filepath.Join(src, "照片")}, false)+ if err != nil {+ t.Fatal(err)+ }+ waitStatus(t, p.a, tr.GetId(), store.TransferDone)+ waitStatus(t, p.b, tr.GetId(), store.TransferDone)+ sameFile(t, report, filepath.Join(p.b.recvDir, "报告.pdf"))+ sameFile(t, photo, filepath.Join(p.b.recvDir, "照片", "2026", "IMG_1.HEIC"))+ sameFile(t, nil, filepath.Join(p.b.recvDir, "照片", "空文件.txt"))+ if info, err := os.Stat(filepath.Join(p.b.recvDir, "照片", "空文件夹")); err != nil || !info.IsDir() {+ t.Fatal("空文件夹没有收到")+ }+ if st.dials.Load() != 1 || st.accepts.Load() != 1 || st.channels.Load() != 0 {+ t.Fatalf("应当只走 TCP:连上 %d 次,接到 %d 次,数据通道 %d 次", st.dials.Load(), st.accepts.Load(), st.channels.Load())+ }+}++func TestResumeOverLAN(t *testing.T) {+ p := newPair(t)+ st := useLAN(t, p, false)+ src := t.TempDir()+ first := randomBytes(t, 2<<20)+ big := randomBytes(t, 120<<20)+ writeFile(t, filepath.Join(src, "a", "1.bin"), first)+ writeFile(t, filepath.Join(src, "a", "2.bin"), big)++ tr, err := p.a.eng.SendFiles("bob", []string{filepath.Join(src, "a")}, false)+ if err != nil {+ t.Fatal(err)+ }+ waitFor(t, 60*time.Second, func() bool {+ rows, _ := p.b.db.TransferEntries(tr.GetId(), 0, 10)+ return len(rows) == 3 && rows[2].DoneBytes > 8<<20+ })+ p.b.eng.mu.Lock()+ in := p.b.eng.in[tr.GetId()]+ p.b.eng.mu.Unlock()+ if in == nil {+ t.Skip("这台机器太快,还没来得及掐断就传完了")+ }+ in.abort(errIdle)+ waitStatus(t, p.b, tr.GetId(), store.TransferInterrupted)+ waitStatus(t, p.a, tr.GetId(), store.TransferInterrupted)++ p.a.eng.PeerReady("bob")+ waitStatus(t, p.a, tr.GetId(), store.TransferDone)+ waitStatus(t, p.b, tr.GetId(), store.TransferDone)+ sameFile(t, first, filepath.Join(p.b.recvDir, "a", "1.bin"))+ sameFile(t, big, filepath.Join(p.b.recvDir, "a", "2.bin"))+ if st.dials.Load() != 2 || st.channels.Load() != 0 {+ t.Fatalf("两次尝试都应当走 TCP:连上 %d 次,数据通道 %d 次", st.dials.Load(), st.channels.Load())+ }+}++func TestCancelOverLAN(t *testing.T) {+ p := newPair(t)+ st := useLAN(t, p, false)+ src := t.TempDir()+ writeFile(t, filepath.Join(src, "big.bin"), randomBytes(t, 200<<20))+ tr, err := p.a.eng.SendFiles("bob", []string{filepath.Join(src, "big.bin")}, false)+ if err != nil {+ t.Fatal(err)+ }+ waitStatus(t, p.b, tr.GetId(), store.TransferActive)+ if err := p.a.eng.Cancel(tr.GetId()); err != nil {+ t.Fatal(err)+ }+ waitStatus(t, p.a, tr.GetId(), store.TransferCancelled)+ got := waitStatus(t, p.b, tr.GetId(), store.TransferCancelled)+ if got.Error != "peer_cancelled" {+ t.Fatalf("接收方的原因应为 peer_cancelled,实际 %q", got.Error)+ }+ if _, err := os.Stat(filepath.Join(p.b.recvDir, partialDir, tr.GetId())); !os.IsNotExist(err) {+ t.Fatal("取消后没收完的部分应当删掉")+ }+ if st.dials.Load() != 1 {+ t.Fatalf("应当走 TCP,连上 %d 次", st.dials.Load())+ }+}++// 接收方给了地址但连不上(防火墙挡住):退回数据通道,照常传完+func TestFallsBackWhenLANRefused(t *testing.T) {+ p := newPair(t)+ st := useLAN(t, p, true)+ src := t.TempDir()+ data := randomBytes(t, 5<<20)+ writeFile(t, filepath.Join(src, "a.bin"), data)+ tr, err := p.a.eng.SendFiles("bob", []string{filepath.Join(src, "a.bin")}, false)+ if err != nil {+ t.Fatal(err)+ }+ waitStatus(t, p.a, tr.GetId(), store.TransferDone)+ waitStatus(t, p.b, tr.GetId(), store.TransferDone)+ sameFile(t, data, filepath.Join(p.b.recvDir, "a.bin"))+ if st.dials.Load() != 0 || st.channels.Load() != 1 {+ t.Fatalf("应当退回数据通道:连上 %d 次,数据通道 %d 次", st.dials.Load(), st.channels.Load())+ }+}++// 接收方不开端口(对方不支持、不是局域网直连):应答里没有地址,直接走数据通道+func TestNoLANAddrUsesDataChannel(t *testing.T) {+ p := newPair(t)+ st := useLAN(t, p, false)+ p.b.eng.opts.ListenLAN = func(string) (string, func(context.Context) (io.ReadCloser, string, error), bool) {+ return "", nil, false+ }+ src := t.TempDir()+ data := randomBytes(t, 2<<20)+ writeFile(t, filepath.Join(src, "a.bin"), data)+ tr, err := p.a.eng.SendFiles("bob", []string{filepath.Join(src, "a.bin")}, false)+ if err != nil {+ t.Fatal(err)+ }+ waitStatus(t, p.a, tr.GetId(), store.TransferDone)+ sameFile(t, data, filepath.Join(p.b.recvDir, "a.bin"))+ p.a.mu.Lock()+ defer p.a.mu.Unlock()+ for _, a := range p.a.answers {+ if a.GetLanAddr() != "" {+ t.Fatalf("不开端口时应答里不该有地址:%q", a.GetLanAddr())+ }+ }+ if st.dials.Load() != 0 || st.channels.Load() != 1 {+ t.Fatalf("应当走数据通道:连上 %d 次,数据通道 %d 次", st.dials.Load(), st.channels.Load())+ }+}diff --git a/client-core/internal/send/send.go b/client-core/internal/send/send.goindex e8a5826..90c5277 100644--- a/client-core/internal/send/send.go+++ b/client-core/internal/send/send.go@@ -15,6 +15,7 @@ import ("crypto/rand""encoding/hex""errors"+ "io""log/slog""strings""sync"@@ -100,6 +101,13 @@ type Options struct {// Inhibit 阻止系统空闲睡眠,返回解除的函数。有传输在进行时持有Inhibit func() (release func())+ // 局域网快速通道(2.5.1),两个都可以为空,为空时只用数据通道。+ // ListenLAN 为对方这次发来的一批开一个临时 TCP 端口,返回给对方拨号的地址和等连接的函数+ // (accept 只接一次,ctx 结束时放弃);对方不支持、不是局域网直连或开不了端口时 ok 为 false。+ ListenLAN func(deviceID string) (addr string, accept func(ctx context.Context) (io.ReadCloser, string, error), ok bool)+ // DialLAN 连到对方给的地址,并写上数据流标签+ DialLAN func(ctx context.Context, deviceID, addr, label string) (io.WriteCloser, error)+OnChange func(*pb.Transfer)OnRemoved func(id string)OnNotice func(NoticeKind, *pb.Transfer)diff --git a/client-core/internal/transport/lantcp/lantcp.go b/client-core/internal/transport/lantcp/lantcp.gonew file mode 100644index 0000000..e97f8d2--- /dev/null+++ b/client-core/internal/transport/lantcp/lantcp.go@@ -0,0 +1,205 @@+// Package lantcp 是隔空传送的局域网快速通道:两台设备在同一局域网直连时,+// 文件数据改走一条 TCP 连接,比 WebRTC 数据通道快得多(逐包处理的开销小)。+//+// 只管连接本身:接收方在本端的局域网地址上临时监听、只接一次;发送方拨过去。+// 两端用 TLS 1.3 互相出示证书,证书的公钥就是设备身份密钥,按设备 ID 核对对方,+// 所以安全性与数据通道相同。握手后发送方先写一个数据流标签,接收方据此把连接交给对应的传输。+// 什么时候用、连不上怎么退回,由 internal/send 决定。+package lantcp++import (+ "context"+ "crypto"+ "crypto/ed25519"+ "crypto/rand"+ "crypto/tls"+ "crypto/x509"+ "encoding/binary"+ "errors"+ "fmt"+ "io"+ "math/big"+ "net"+ "net/netip"+ "sync"+ "time"++ "github.com/baiyuze/pasteferry/proto/deviceid"+)++const (+ keepAlive = 15 * time.Second+ handshakeTimeout = 5 * time.Second+ // 每次写入的超时:对方睡眠或断网时,写入在这之后报错,发送方据此标为中断+ writeTimeout = 30 * time.Second+ maxLabel = 256+)++var ErrClosed = errors.New("lantcp: 已关闭")++// Link 持有本机的 TLS 证书,负责监听与拨号。+type Link struct {+ cert tls.Certificate+}++// New 用设备身份密钥生成一张自签名证书(只在内存里)。+func New(signer crypto.Signer) (*Link, error) {+ if _, ok := signer.Public().(ed25519.PublicKey); !ok {+ return nil, errors.New("lantcp: 身份密钥不是 Ed25519")+ }+ serial, err := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 63))+ if err != nil {+ return nil, err+ }+ tmpl := &x509.Certificate{+ SerialNumber: serial,+ NotBefore: time.Now().Add(-24 * time.Hour),+ NotAfter: time.Now().AddDate(10, 0, 0),+ }+ der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, signer.Public(), signer)+ if err != nil {+ return nil, err+ }+ return &Link{cert: tls.Certificate{Certificate: [][]byte{der}, PrivateKey: signer}}, nil+}++// config 只认 peerID 这台设备:证书公钥派生出的设备 ID 必须等于它。+// 证书是自签名的,不走证书链校验,身份完全由公钥决定。+func (l *Link) config(peerID string) *tls.Config {+ return &tls.Config{+ Certificates: []tls.Certificate{l.cert},+ MinVersion: tls.VersionTLS13,+ InsecureSkipVerify: true,+ ClientAuth: tls.RequireAnyClientCert,+ VerifyPeerCertificate: func(raw [][]byte, _ [][]*x509.Certificate) error {+ if len(raw) != 1 {+ return errors.New("lantcp: 对方没有出示证书")+ }+ c, err := x509.ParseCertificate(raw[0])+ if err != nil {+ return err+ }+ pub, ok := c.PublicKey.(ed25519.PublicKey)+ if !ok || !deviceid.Valid(peerID, pub) {+ return errors.New("lantcp: 对方不是要连的那台设备")+ }+ return nil+ },+ }+}++// Listener 是为一次传输尝试临时开的端口,只接一次连接。+type Listener struct {+ ln net.Listener+ conf *tls.Config++ once sync.Once+}++// Listen 在本端的局域网地址 ip 上开一个随机端口,只接受 peerID 这台设备。+func (l *Link) Listen(ip netip.Addr, peerID string) (*Listener, error) {+ lc := net.ListenConfig{KeepAlive: keepAlive}+ ln, err := lc.Listen(context.Background(), "tcp", netip.AddrPortFrom(ip, 0).String())+ if err != nil {+ return nil, err+ }+ return &Listener{ln: ln, conf: l.config(peerID)}, nil+}++// Addr 返回给对方拨号用的地址(ip:port)。+func (ln *Listener) Addr() string { return ln.ln.Addr().String() }++// Close 关掉端口;正在等的 Accept 随即返回错误。+func (ln *Listener) Close() error {+ var err error+ ln.once.Do(func() { err = ln.ln.Close() })+ return err+}++// Accept 等那台设备连上来,完成握手并读出数据流标签,然后关掉端口。+// 握手失败或身份不对的连接直接断开,继续等;ctx 结束时返回 ctx 的错误。+func (ln *Listener) Accept(ctx context.Context) (net.Conn, string, error) {+ stop := context.AfterFunc(ctx, func() { ln.Close() })+ defer stop()+ defer ln.Close()+ for {+ raw, err := ln.ln.Accept()+ if err != nil {+ if ctx.Err() != nil {+ return nil, "", ctx.Err()+ }+ return nil, "", ErrClosed+ }+ c := tls.Server(raw, ln.conf)+ label, err := serverHello(c)+ if err != nil {+ _ = c.Close()+ continue+ }+ return &conn{Conn: c}, label, nil+ }+}++func serverHello(c *tls.Conn) (string, error) {+ _ = c.SetDeadline(time.Now().Add(handshakeTimeout))+ if err := c.Handshake(); err != nil {+ return "", err+ }+ var n [2]byte+ if _, err := io.ReadFull(c, n[:]); err != nil {+ return "", err+ }+ size := binary.BigEndian.Uint16(n[:])+ if size == 0 || size > maxLabel {+ return "", fmt.Errorf("lantcp: 标签长度不对: %d", size)+ }+ label := make([]byte, size)+ if _, err := io.ReadFull(c, label); err != nil {+ return "", err+ }+ _ = c.SetDeadline(time.Time{})+ return string(label), nil+}++// Dial 连到对方给的地址,核对对方是 peerID,再写上数据流标签。+func (l *Link) Dial(ctx context.Context, addr, peerID, label string) (net.Conn, error) {+ if len(label) == 0 || len(label) > maxLabel {+ return nil, fmt.Errorf("lantcp: 标签长度不对: %d", len(label))+ }+ d := net.Dialer{KeepAlive: keepAlive}+ raw, err := d.DialContext(ctx, "tcp", addr)+ if err != nil {+ return nil, err+ }+ c := tls.Client(raw, l.config(peerID))+ stop := context.AfterFunc(ctx, func() { _ = raw.Close() })+ defer stop()+ _ = c.SetDeadline(time.Now().Add(handshakeTimeout))+ if err := c.HandshakeContext(ctx); err != nil {+ _ = c.Close()+ return nil, err+ }+ msg := make([]byte, 2+len(label))+ binary.BigEndian.PutUint16(msg, uint16(len(label)))+ copy(msg[2:], label)+ if _, err := c.Write(msg); err != nil {+ _ = c.Close()+ return nil, err+ }+ _ = c.SetDeadline(time.Time{})+ if ctx.Err() != nil {+ _ = c.Close()+ return nil, ctx.Err()+ }+ return &conn{Conn: c}, nil+}++// conn 给每次写入加超时,对方没了的时候写入不会一直卡着。+type conn struct {+ *tls.Conn+}++func (c *conn) Write(p []byte) (int, error) {+ _ = c.Conn.SetWriteDeadline(time.Now().Add(writeTimeout))+ return c.Conn.Write(p)+}diff --git a/client-core/internal/transport/lantcp/lantcp_test.go b/client-core/internal/transport/lantcp/lantcp_test.gonew file mode 100644index 0000000..d9e0497--- /dev/null+++ b/client-core/internal/transport/lantcp/lantcp_test.go@@ -0,0 +1,159 @@+package lantcp++import (+ "bytes"+ "context"+ "crypto/ed25519"+ "crypto/rand"+ "io"+ "net"+ "net/netip"+ "testing"+ "time"++ "github.com/baiyuze/pasteferry/proto/deviceid"+)++type device struct {+ id string+ link *Link+}++func newDevice(t *testing.T) device {+ t.Helper()+ pub, priv, err := ed25519.GenerateKey(rand.Reader)+ if err != nil {+ t.Fatal(err)+ }+ l, err := New(priv)+ if err != nil {+ t.Fatal(err)+ }+ return device{id: deviceid.For(pub), link: l}+}++var loopback = netip.MustParseAddr("127.0.0.1")++func TestSendThroughLink(t *testing.T) {+ sender, receiver := newDevice(t), newDevice(t)+ ln, err := receiver.link.Listen(loopback, sender.id)+ if err != nil {+ t.Fatal(err)+ }+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)+ defer cancel()++ data := make([]byte, 8<<20)+ _, _ = rand.Read(data)+ go func() {+ c, err := sender.link.Dial(ctx, ln.Addr(), receiver.id, "send:abc:1")+ if err != nil {+ t.Error(err)+ return+ }+ defer c.Close()+ if _, err := c.Write(data); err != nil {+ t.Error(err)+ }+ }()++ c, label, err := ln.Accept(ctx)+ if err != nil {+ t.Fatal(err)+ }+ defer c.Close()+ if label != "send:abc:1" {+ t.Fatalf("label = %q", label)+ }+ got, err := io.ReadAll(c)+ if err != nil {+ t.Fatal(err)+ }+ if !bytes.Equal(got, data) {+ t.Fatalf("收到 %d 字节,内容不一致", len(got))+ }++ // 只接一次:端口已经关了+ if _, err := net.DialTimeout("tcp", ln.Addr(), time.Second); err == nil {+ t.Fatal("接过一次之后端口还开着")+ }+}++// 不是那台设备的连接被断开,端口继续等真正的那台+func TestRejectsOtherDevices(t *testing.T) {+ sender, receiver, stranger := newDevice(t), newDevice(t), newDevice(t)+ ln, err := receiver.link.Listen(loopback, sender.id)+ if err != nil {+ t.Fatal(err)+ }+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)+ defer cancel()++ type result struct {+ label string+ err error+ }+ accepted := make(chan result, 1)+ go func() {+ c, label, err := ln.Accept(ctx)+ if c != nil {+ c.Close()+ }+ accepted <- result{label, err}+ }()++ if c, err := stranger.link.Dial(ctx, ln.Addr(), receiver.id, "send:x:1"); err == nil {+ // TLS 1.3 里客户端证书在服务器那边才校验,客户端这一侧可能先“成功”;读一下就会发现被断开+ _ = c.SetReadDeadline(time.Now().Add(3 * time.Second))+ if _, err := c.Read(make([]byte, 1)); err == nil {+ t.Fatal("陌生设备的连接没有被断开")+ }+ c.Close()+ }+ // 发送方认错了接收方,也连不上+ if _, err := sender.link.Dial(ctx, ln.Addr(), stranger.id, "send:x:1"); err == nil {+ t.Fatal("接收方身份不对时还能连上")+ }++ c, err := sender.link.Dial(ctx, ln.Addr(), receiver.id, "send:ok:2")+ if err != nil {+ t.Fatal(err)+ }+ defer c.Close()+ r := <-accepted+ if r.err != nil || r.label != "send:ok:2" {+ t.Fatalf("accept = %q, %v", r.label, r.err)+ }+}++func TestAcceptStopsWithContext(t *testing.T) {+ sender, receiver := newDevice(t), newDevice(t)+ ln, err := receiver.link.Listen(loopback, sender.id)+ if err != nil {+ t.Fatal(err)+ }+ ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)+ defer cancel()+ start := time.Now()+ if _, _, err := ln.Accept(ctx); err == nil {+ t.Fatal("没有连接时 Accept 不该成功")+ }+ if time.Since(start) > 3*time.Second {+ t.Fatal("ctx 结束后 Accept 没有及时返回")+ }+}++func TestDialFailsFast(t *testing.T) {+ sender, receiver := newDevice(t), newDevice(t)+ ln, err := receiver.link.Listen(loopback, sender.id)+ if err != nil {+ t.Fatal(err)+ }+ addr := ln.Addr()+ ln.Close()+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)+ defer cancel()+ if _, err := sender.link.Dial(ctx, addr, receiver.id, "send:x:1"); err == nil {+ t.Fatal("端口关了还能连上")+ }+}diff --git a/client-core/internal/transport/p2p/manager.go b/client-core/internal/transport/p2p/manager.goindex 4f1776c..8ab2d31 100644--- a/client-core/internal/transport/p2p/manager.go+++ b/client-core/internal/transport/p2p/manager.go@@ -4,6 +4,7 @@ import ("context""log/slog""net"+ "net/netip""slices""strings""sync"@@ -458,6 +459,19 @@ func (m *Manager) OpenStream(deviceID, label string) (*webrtc.DataChannel, errorreturn p.OpenStream(label)}+// LANAddr 报告与某台设备的连接是不是局域网直连(本端是网卡上的地址,对端也是),+// 是的话返回本端用的那个地址。隔空传送据此决定能不能在这个地址上另开 TCP 通道。+func (m *Manager) LANAddr(deviceID string) (netip.Addr, bool) {+ m.mu.RLock()+ p := m.selectedLocked(deviceID)+ m.mu.RUnlock()++ if p == nil {+ return netip.Addr{}, false+ }+ return p.LANAddr()+}+func (m *Manager) State(deviceID string) ConnState {m.mu.RLock()p := m.selectedLocked(deviceID)diff --git a/client-core/internal/transport/p2p/peer.go b/client-core/internal/transport/p2p/peer.goindex f98e6cd..0ee8e9f 100644--- a/client-core/internal/transport/p2p/peer.go+++ b/client-core/internal/transport/p2p/peer.go@@ -11,6 +11,7 @@ import ("errors""fmt""log/slog"+ "net/netip""strings""sync""time"@@ -221,6 +222,32 @@ func (p *Peer) State() ConnState {return p.state}+// LANAddr 见 Manager.LANAddr。对端是 prflx 也算:局域网里对端的地址常常先从收到的包里认出来。+func (p *Peer) LANAddr() (netip.Addr, bool) {+ p.mu.Lock()+ pc := p.pc+ state := p.state+ p.mu.Unlock()+ if pc == nil || state != StateDirect {+ return netip.Addr{}, false+ }+ sctp := pc.SCTP()+ if sctp == nil || sctp.Transport() == nil || sctp.Transport().ICETransport() == nil {+ return netip.Addr{}, false+ }+ pair, err := sctp.Transport().ICETransport().GetSelectedCandidatePair()+ if err != nil || pair == nil || pair.Local == nil || pair.Remote == nil ||+ pair.Local.Typ != webrtc.ICECandidateTypeHost ||+ (pair.Remote.Typ != webrtc.ICECandidateTypeHost && pair.Remote.Typ != webrtc.ICECandidateTypePrflx) {+ return netip.Addr{}, false+ }+ addr, err := netip.ParseAddr(pair.Local.Address)+ if err != nil || addr.IsLoopback() || addr.IsUnspecified() {+ return netip.Addr{}, false+ }+ return addr.Unmap(), true+}+func (p *Peer) DirectAttemptReady() bool {p.mu.Lock()defer p.mu.Unlock()diff --git a/design/send-files-lan-tcp.md b/design/send-files-lan-tcp.mdnew file mode 100644index 0000000..d0c569d--- /dev/null+++ b/design/send-files-lan-tcp.md@@ -0,0 +1,128 @@+# 隔空传送:局域网快速通道(2.5.1)++状态:方案,待审核。主方案见 [send-files.md](send-files.md),测速依据见其中第 12.1 节。++## 1. 目标++两台电脑在同一局域网(或同在 Tailscale 里)时,隔空传送的文件数据改走一条 TCP 连接,千兆有线网从现在的约 19 MB/s 提到接近跑满(约 100 MB/s)。++不变的东西:++- 外网直连和中转照旧走现在的 WebRTC 数据通道。+- 发送请求、应答、取消、结果这些控制消息照旧走现在的控制通道,只有文件数据换管道。+- 帧格式、断点续传、逐文件 SHA-256、进度、通知、界面都不改。+- 现有数据通道的代码一行逻辑都不改,只把它包成「管道」的一种实现。+- 任何一步失败都退回数据通道,用户感觉不到差别,只是慢一些。++这是性能改进,版本号 2.5.1。++## 2. 什么时候走 TCP++三个条件同时满足才试 TCP,缺一个就直接用数据通道:++1. 对方声明支持:能力列表里有 `send_files_tcp_v1`(2.5.1 起)。+2. 当前的 WebRTC 连接是局域网直连:选中的 candidate 对里,本端是 host(本机网卡上的真实地址),对端是 host 或 prflx。经 TURN 中转(relay)、经 NAT 映射(srflx)的连接都不算。Tailscale 的 100.x 地址也是 host,会走 TCP。+3. 接收方能在这个地址上监听 TCP 端口。++第 2 条直接复用 ICE 已经打通的那条路,地址是现成的,不用猜,也不会去碰外网地址。++## 3. 流程++```+发送方 接收方+ │ SendOffer(不变) │+ │ ──────────────────────────────────────▶ │ 接受;满足第 2 节的条件时,+ │ │ 在本端 host 地址上开一个临时 TCP 端口+ │ SendAnswer(多一个 lan_addr) │+ │ ◀────────────────────────────────────── │+ │ 有 lan_addr:拨号 + TLS 握手(2 秒超时) │+ │ ══════════════ TCP ═══════════════════▶ │ 核对对方身份,读到数据流标签+ │ 帧流(不变) │ 交给原来的接收流程+ │ ══════════════════════════════════════▶ │+ │ SendResult(不变) │+ │ ◀────────────────────────────────────── │+```++- 接收方的临时端口只接一次连接,连上或这次尝试结束(超时、取消、完成)就关掉。不常驻监听,不新增固定端口。+- 发送方连不上、握手失败或超时,就照原来的方式开数据通道,接收方两条路都在等,先到哪条用哪条。+- 续传时(新的一次尝试)重新走一遍判断,可能这次走 TCP、下次走数据通道,帧流从断点接着发,与管道无关。++## 4. 认证与加密++- TLS 1.3,两端都出示证书,证书的公钥就是设备身份的 Ed25519 密钥(配对时已核对过指纹的那把)。证书在后台服务启动时从身份密钥现生成,只在内存里。+- 接收方核对:连过来的证书公钥算出的设备 ID,必须等于这次传输的发送方。发送方同样核对接收方。对不上立即断开。不需要另发口令。+- 握手后发送方先写一行数据流标签(`send:<传输 ID>:<第几次尝试>`,与数据通道的标签相同),接收方用原来的规则核对,对不上就丢弃。+- 安全性与现在的数据通道相同:端到端加密,第三方看不到内容,也冒充不了设备。++## 5. 卡住与断线++- TCP 打开 keepalive(15 秒)。+- 发送方每次写入设 30 秒超时,对方睡眠或拔网线时写入会报错,按现在的方式标为中断、等重连后续传。+- 接收方原有的看门狗(一段时间收不到数据就中断)照样生效。+- 取消:原来取消时关数据通道,现在关当前这条管道,两种管道都一样。++## 6. 代码改动++**新文件**++| 文件 | 内容 | 估计 |+| --- | --- | --- |+| `internal/transport/lantcp/lantcp.go` | 用身份密钥生成证书;`Listen(本端地址, 对端 ID)` 返回临时端口与只接一次的 `Accept`;`Dial(地址, 对端 ID, 标签)`;身份核对;keepalive 与写入超时 | 约 200 行 |+| `internal/transport/lantcp/lantcp_test.go` | 握手、身份对不上被拒、标签传递、超时、只接一次 | 约 150 行 |++**改动的文件**++| 文件 | 改什么 | 对原通道的影响 |+| --- | --- | --- |+| `proto/.../wire.proto` | `SendAnswer` 加 `string lan_addr = 8;` | 无,旧版本忽略新字段 |+| `internal/send/send.go` | `Options` 加两个可选函数 `ListenLAN`、`DialLAN`,为空时行为与 2.5.0 完全相同 | 无 |+| `internal/send/outgoing.go` | 把「开管道」从 `stream()` 里拆出来:有 `lan_addr` 时先试 TCP,不行就走原来的开数据通道代码(原样搬进一个函数);`o.dc` 换成 `o.pipe`(只用来在取消时关闭) | 数据通道的代码原样保留,只是挪了位置 |+| `internal/send/incoming.go` | 接受时如满足条件就开临时端口,把 `lan_addr` 放进应答;`streamCh` 的元素从 `*p2p.Stream` 换成一个只有读和关闭的小接口,数据通道那边包一层 | 数据通道照旧送进同一个 `streamCh` |+| `internal/transport/p2p` | 加一个只读查询:与某台设备的连接是不是局域网直连,是的话返回本端地址 | 只读,不改连接逻辑 |+| `internal/peers/manager.go` | 能力列表加 `send_files_tcp_v1` | 无 |+| `cmd/pasteferryd/main.go` | 把 `lantcp` 接到 `ListenLAN`、`DialLAN` 上 | 无 |+| `internal/transport/lan/permission_windows.go` | 「放行」按钮在 UDP 规则之外再加一条 TCP 允许规则 | 不影响 UDP 规则 |++界面不改。++## 7. 兼容++| 发送方 | 接收方 | 结果 |+| --- | --- | --- |+| 2.5.1 | 2.5.1,局域网直连 | TCP |+| 2.5.1 | 2.5.1,外网或中转 | 数据通道 |+| 2.5.1 | 2.5.0 | 数据通道(对方不声明能力,也不会给 `lan_addr`) |+| 2.5.0 | 2.5.1 | 数据通道(对方不声明能力,接收方不开端口) |++## 8. 防火墙++- **Windows**:第一次运行时系统弹窗点了允许,会同时放行 TCP 和 UDP,不用做什么。之前用设置里的「放行」按钮加的规则只有 UDP,TCP 入站会被挡,这时自动退回数据通道;2.5.1 的「放行」按钮会把 TCP 也加上。要实测:接收方第一次开 TCP 端口时会不会再弹一次防火墙询问。+- **macOS**:后台服务已有「本地网络」权限。系统防火墙默认关闭;用户打开了的话要实测会不会询问。+- **Linux**:Ubuntu 默认不启用 ufw。启用了的话 TCP 被挡,退回数据通道。++## 9. 测试++**自动测试**++- `lantcp`:见第 6 节。+- `send`:在现有两个后台服务互发的测试里,加上 `ListenLAN`、`DialLAN`:+ - 走 TCP 发文件和文件夹,内容一致+ - TCP 上中断后续传+ - TCP 上取消+ - 拨号失败时退回数据通道+ - 对方不支持时不开端口+- 原有的 `send` 测试不带这两个函数,照样全部通过,证明不设置时行为不变。++**实机测试**++| 线路 | 看什么 |+| --- | --- |+| Mac ↔ 局域网里的 Windows 台式机 | 速度(目标约 100 MB/s)、防火墙会不会弹窗 |+| Mac ↔ Linux 虚拟机、Mac ↔ Windows 虚拟机 | 两个方向、杀进程续传、取消 |+| 一端 2.5.0、一端 2.5.1 | 退回数据通道,照常传完 |+| Windows 上用防火墙挡住 TCP | 退回数据通道,照常传完 |+| 官方服务中转(外网) | 不走 TCP,行为与 2.5.0 相同 |++## 10. 发版++2.5.1:性能改进。CHANGELOG 写「同一局域网里的隔空传送快很多」,附上实测速度;Upgrade notes 说明两台都升级才生效,否则照旧。diff --git a/proto/gen/pasteferry/v1/wire.pb.go b/proto/gen/pasteferry/v1/wire.pb.goindex 0be7bdd..e54c1db 100644--- a/proto/gen/pasteferry/v1/wire.pb.go+++ b/proto/gen/pasteferry/v1/wire.pb.go@@ -2986,8 +2986,11 @@ type SendAnswer struct {ShortfallBytes int64 `protobuf:"varint,5,opt,name=shortfall_bytes,json=shortfallBytes,proto3" json:"shortfall_bytes,omitempty"` // no_space 时还差多少ResumeIndex int64 `protobuf:"varint,6,opt,name=resume_index,json=resumeIndex,proto3" json:"resume_index,omitempty"` // 从第几个条目开始(全新传输为 0)ResumeOffset int64 `protobuf:"varint,7,opt,name=resume_offset,json=resumeOffset,proto3" json:"resume_offset,omitempty"` // 这个条目已经收到多少字节- unknownFields protoimpl.UnknownFields- sizeCache protoimpl.SizeCache+ // 局域网快速通道(2.5.1):接收方为这次尝试临时监听的 TCP 地址(ip:port)。+ // 只在两端都声明 send_files_tcp_v1、且当前连接是局域网直连时给出;为空或连不上时走数据通道+ LanAddr string `protobuf:"bytes,8,opt,name=lan_addr,json=lanAddr,proto3" json:"lan_addr,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache}func (x *SendAnswer) Reset() {@@ -3069,6 +3072,13 @@ func (x *SendAnswer) GetResumeOffset() int64 {return 0}+func (x *SendAnswer) GetLanAddr() string {+ if x != nil {+ return x.LanAddr+ }+ return ""+}+// 任何一方取消,或者发送方读源文件出错时发出。对方停下并清理没收完的部分type SendCancel struct {state protoimpl.MessageState `protogen:"open.v1"`@@ -3700,7 +3710,7 @@ const file_pasteferry_v1_wire_proto_rawDesc = "" +"file_count\x18\x05 \x01(\x03R\tfileCount\x12!\n" +"\flargest_file\x18\x06 \x01(\x03R\vlargestFile\x12&\n" +"\x0fcreated_at_unix\x18\a \x01(\x03R\rcreatedAtUnix\x12\x16\n" +- "\x06resume\x18\b \x01(\bR\x06resume\"\xec\x01\n" ++ "\x06resume\x18\b \x01(\bR\x06resume\"\x87\x02\n" +"\n" +"SendAnswer\x12\x1f\n" +"\vtransfer_id\x18\x01 \x01(\tR\n" +@@ -3710,7 +3720,8 @@ const file_pasteferry_v1_wire_proto_rawDesc = "" +"\x06reason\x18\x04 \x01(\tR\x06reason\x12'\n" +"\x0fshortfall_bytes\x18\x05 \x01(\x03R\x0eshortfallBytes\x12!\n" +"\fresume_index\x18\x06 \x01(\x03R\vresumeIndex\x12#\n" +- "\rresume_offset\x18\a \x01(\x03R\fresumeOffset\"E\n" ++ "\rresume_offset\x18\a \x01(\x03R\fresumeOffset\x12\x19\n" ++ "\blan_addr\x18\b \x01(\tR\alanAddr\"E\n" +"\n" +"SendCancel\x12\x1f\n" +"\vtransfer_id\x18\x01 \x01(\tR\n" +diff --git a/proto/pasteferry/v1/wire.proto b/proto/pasteferry/v1/wire.protoindex 21b49ee..9382940 100644--- a/proto/pasteferry/v1/wire.proto+++ b/proto/pasteferry/v1/wire.proto@@ -376,6 +376,9 @@ message SendAnswer {int64 shortfall_bytes = 5; // no_space 时还差多少int64 resume_index = 6; // 从第几个条目开始(全新传输为 0)int64 resume_offset = 7; // 这个条目已经收到多少字节+ // 局域网快速通道(2.5.1):接收方为这次尝试临时监听的 TCP 地址(ip:port)。+ // 只在两端都声明 send_files_tcp_v1、且当前连接是局域网直连时给出;为空或连不上时走数据通道+ string lan_addr = 8;}// 任何一方取消,或者发送方读源文件出错时发出。对方停下并清理没收完的部分diff --git a/ui/lib/gen/pasteferry/v1/wire.pb.dart b/ui/lib/gen/pasteferry/v1/wire.pb.dartindex fdbeacc..9659050 100644--- a/ui/lib/gen/pasteferry/v1/wire.pb.dart+++ b/ui/lib/gen/pasteferry/v1/wire.pb.dart@@ -3693,6 +3693,7 @@ class SendAnswer extends $pb.GeneratedMessage {$fixnum.Int64? shortfallBytes,$fixnum.Int64? resumeIndex,$fixnum.Int64? resumeOffset,+ $core.String? lanAddr,}) {final result = SendAnswer._();if (transferId != null) result.transferId = transferId;@@ -3702,6 +3703,7 @@ class SendAnswer extends $pb.GeneratedMessage {if (shortfallBytes != null) result.shortfallBytes = shortfallBytes;if (resumeIndex != null) result.resumeIndex = resumeIndex;if (resumeOffset != null) result.resumeOffset = resumeOffset;+ if (lanAddr != null) result.lanAddr = lanAddr;return result;}@@ -3725,6 +3727,7 @@ class SendAnswer extends $pb.GeneratedMessage {..aInt64(5, _omitFieldNames ? '' : 'shortfallBytes')..aInt64(6, _omitFieldNames ? '' : 'resumeIndex')..aInt64(7, _omitFieldNames ? '' : 'resumeOffset')+ ..aOS(8, _omitFieldNames ? '' : 'lanAddr')..hasRequiredFields = false;@$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')@@ -3811,6 +3814,17 @@ class SendAnswer extends $pb.GeneratedMessage {$core.bool hasResumeOffset() => $_has(6);@$pb.TagNumber(7)void clearResumeOffset() => $_clearField(7);++ /// 局域网快速通道(2.5.1):接收方为这次尝试临时监听的 TCP 地址(ip:port)。+ /// 只在两端都声明 send_files_tcp_v1、且当前连接是局域网直连时给出;为空或连不上时走数据通道+ @$pb.TagNumber(8)+ $core.String get lanAddr => $_getSZ(7);+ @$pb.TagNumber(8)+ set lanAddr($core.String value) => $_setString(7, value);+ @$pb.TagNumber(8)+ $core.bool hasLanAddr() => $_has(7);+ @$pb.TagNumber(8)+ void clearLanAddr() => $_clearField(8);}/// 任何一方取消,或者发送方读源文件出错时发出。对方停下并清理没收完的部分diff --git a/ui/lib/gen/pasteferry/v1/wire.pbjson.dart b/ui/lib/gen/pasteferry/v1/wire.pbjson.dartindex 505280e..5ee80d1 100644--- a/ui/lib/gen/pasteferry/v1/wire.pbjson.dart+++ b/ui/lib/gen/pasteferry/v1/wire.pbjson.dart@@ -1049,6 +1049,7 @@ const SendAnswer$json = {{'1': 'shortfall_bytes', '3': 5, '4': 1, '5': 3, '10': 'shortfallBytes'},{'1': 'resume_index', '3': 6, '4': 1, '5': 3, '10': 'resumeIndex'},{'1': 'resume_offset', '3': 7, '4': 1, '5': 3, '10': 'resumeOffset'},+ {'1': 'lan_addr', '3': 8, '4': 1, '5': 9, '10': 'lanAddr'},],};@@ -1058,7 +1059,7 @@ final $typed_data.Uint8List sendAnswerDescriptor = $convert.base64Decode('QYAiABKA1SB2F0dGVtcHQSGgoIYWNjZXB0ZWQYAyABKAhSCGFjY2VwdGVkEhYKBnJlYXNvbhgE''IAEoCVIGcmVhc29uEicKD3Nob3J0ZmFsbF9ieXRlcxgFIAEoA1IOc2hvcnRmYWxsQnl0ZXMSIQ''oMcmVzdW1lX2luZGV4GAYgASgDUgtyZXN1bWVJbmRleBIjCg1yZXN1bWVfb2Zmc2V0GAcgASgD'- 'UgxyZXN1bWVPZmZzZXQ=');+ 'UgxyZXN1bWVPZmZzZXQSGQoIbGFuX2FkZHIYCCABKAlSB2xhbkFkZHI=');@$core.Deprecated('Use sendCancelDescriptor instead')const SendCancel$json = {