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.

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.go
index 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.go
new file mode 100644
index 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.go
index 2e63bec..1871c58 100644
--- a/client-core/internal/identity/identity.go
+++ b/client-core/internal/identity/identity.go
@@ -6,6 +6,7 @@
package identity
import (
+ "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.Fingerprint
diff --git a/client-core/internal/peers/manager.go b/client-core/internal/peers/manager.go
index 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.go
index 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.Context
cancel 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.Transfer
in := &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.ReadCloser
select {
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.go
index 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 uint32
answer chan *pb.SendAnswer
result chan *pb.SendResult
- dc *webrtc.DataChannel
+ pipe sendPipe
done chan struct{} // runOutgoing 返回时关闭
}
func (o *outgoing) abort(cause error) {
o.cancel(cause)
o.mu.Lock()
- dc := o.dc
+ p := o.pipe
o.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 = p
o.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, inde
if 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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, error
return 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.go
index 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.md
new file mode 100644
index 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.go
index 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.proto
index 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.dart
index 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.dart
index 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 = {