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): pair and sync on the local network without a server

baiyuze1056eb7c3748
diff --git a/client-core/cmd/copysync-cli/main.go b/client-core/cmd/copysync-cli/main.go
index 4f9731e..527210a 100644
--- a/client-core/cmd/copysync-cli/main.go
+++ b/client-core/cmd/copysync-cli/main.go
@@ -3,10 +3,15 @@
// 它走与 Flutter UI 完全相同的 gRPC 接口,因此既能在 UI 就绪前验证 daemon,
// 也能在之后用来区分「是 daemon 的问题还是 UI 的问题」。
//
-// copysync-cli status 查看 daemon 状态
-// copysync-cli watch 订阅事件流
-// copysync-cli history 列出历史记录
-// copysync-cli config 查看配置
+// copysync-cli status 查看 daemon 状态
+// copysync-cli watch 订阅事件流
+// copysync-cli history 列出历史记录
+// copysync-cli config 查看配置
+// copysync-cli devices 列出已配对设备
+// copysync-cli nat 网络出口、局域网与各设备连接情况
+// copysync-cli pair 生成配对码
+// copysync-cli join CODE [ADDRESS] 兑换配对码;不在同一网段时带上对方显示的地址
+// copysync-cli address DEVICE ADDR 手动指定某台设备的地址
package main
import (
@@ -37,7 +42,7 @@ func main() {
cmd := flag.Arg(0)
if cmd == "" {
fmt.Fprintln(os.Stderr,
- "用法: copysync-cli [-data-dir DIR] <status|watch|history|config|devices|nat|pair|join CODE>")
+ "用法: copysync-cli [-data-dir DIR] <status|watch|history|config|devices|nat|pair|join CODE [ADDRESS]|address DEVICE ADDR>")
os.Exit(2)
}
@@ -88,7 +93,9 @@ func run(cmd, dataDir string) error {
case "pair":
return createPairing(ctx, client)
case "join":
- return joinPairing(ctx, client, flag.Arg(1))
+ return joinPairing(ctx, client, flag.Arg(1), flag.Arg(2))
+ case "address":
+ return setAddress(ctx, client, flag.Arg(1), flag.Arg(2))
default:
return fmt.Errorf("未知命令 %q", cmd)
}
@@ -152,9 +159,14 @@ func createPairing(ctx context.Context, c pb.DaemonServiceClient) error {
}
fmt.Printf("\n 配对码:%s\n", resp.GetCode())
- fmt.Printf(" 有效期至 %s\n\n",
- time.Unix(resp.GetExpiresAtUnix(), 0).Format("15:04:05"))
- fmt.Println(" 在另一台设备上运行:copysync-cli join " + resp.GetCode())
+ fmt.Printf(" 有效期至 %s\n", time.Unix(resp.GetExpiresAtUnix(), 0).Format("15:04:05"))
+ if addrs := resp.GetLanAddresses(); len(addrs) > 0 {
+ fmt.Printf(" 本机地址:%s\n", strings.Join(addrs, " "))
+ }
+ fmt.Println("\n 在另一台设备上运行:copysync-cli join " + resp.GetCode())
+ if addrs := resp.GetLanAddresses(); len(addrs) > 0 {
+ fmt.Printf(" 不在同一网段时:copysync-cli join %s %s\n", resp.GetCode(), addrs[0])
+ }
fmt.Println(" 等待对方兑换…(Ctrl+C 取消)")
for {
@@ -257,6 +269,8 @@ func showNetwork(ctx context.Context, c pb.DaemonServiceClient) error {
fmt.Println("按历史推算的出口这一轮没探测到,但它不改端口,地址可以推算出来。")
}
+ showLAN(info.GetLan())
+
devs, err := c.ListDevices(ctx, &pb.Empty{})
if err != nil {
return nil
@@ -270,14 +284,67 @@ func showNetwork(ctx context.Context, c pb.DaemonServiceClient) error {
return nil
}
-func joinPairing(ctx context.Context, c pb.DaemonServiceClient, code string) error {
+// showLAN 打印局域网直连的情况:本机在哪个端口、发现了几个实例、各设备在局域网里能否找到。
+func showLAN(lan *pb.LanInfo) {
+ if lan == nil {
+ return
+ }
+ fmt.Println()
+ if !lan.GetEnabled() {
+ fmt.Println("局域网 已关闭")
+ return
+ }
+ fmt.Printf("局域网 端口 %d(UDP),本机地址 %s\n", lan.GetPort(), strings.Join(lan.GetLocalAddresses(), " "))
+ fmt.Printf(" mDNS 发现了 %d 个 CopySync(含未配对的)\n", lan.GetDiscovered())
+ if lan.GetBlocked() {
+ fmt.Println(" 系统拦下了发往局域网的包:到「系统设置 → 隐私与安全性 → 本地网络」里打开 CopySync")
+ }
+ for _, p := range lan.GetPeers() {
+ state := "找不到"
+ if p.GetReachable() {
+ state = "可达 " + p.GetAddress()
+ }
+ fmt.Printf(" %-18s %s\n", p.GetDeviceName(), state)
+ if known := p.GetKnownAddresses(); len(known) > 0 {
+ fmt.Printf(" %-18s 记住的地址 %s\n", "", strings.Join(known, " "))
+ }
+ }
+}
+
+func setAddress(ctx context.Context, c pb.DaemonServiceClient, device, addr string) error {
+ if device == "" || addr == "" {
+ return errors.New("用法: copysync-cli address <设备名或 ID> <地址>")
+ }
+ ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+ defer cancel()
+ devs, err := c.ListDevices(ctx, &pb.Empty{})
+ if err != nil {
+ return err
+ }
+ id := ""
+ for _, p := range devs.GetPeers() {
+ if p.GetId() == device || p.GetName() == device {
+ id = p.GetId()
+ }
+ }
+ if id == "" {
+ return fmt.Errorf("没有叫 %q 的已配对设备", device)
+ }
+ if _, err := c.SetDeviceAddress(ctx, &pb.SetDeviceAddressRequest{DeviceId: id, Address: addr}); err != nil {
+ return err
+ }
+ fmt.Println("已记下,正在那个地址上找它;用 copysync-cli nat 查看结果")
+ return nil
+}
+
+func joinPairing(ctx context.Context, c pb.DaemonServiceClient, code, address string) error {
if code == "" {
- return errors.New("用法: copysync-cli join <配对码>")
+ return errors.New("用法: copysync-cli join <配对码> [对方地址]")
}
ctx, cancel := context.WithTimeout(ctx, 20*time.Second)
defer cancel()
- resp, err := c.RedeemPairingCode(ctx, &pb.RedeemPairingCodeRequest{Code: code})
+ resp, err := c.RedeemPairingCode(ctx, &pb.RedeemPairingCodeRequest{Code: code, Address: address})
if err != nil {
return err
}
@@ -328,7 +395,16 @@ func showStatus(ctx context.Context, c pb.DaemonServiceClient, ep rpc.Endpoint)
fmt.Printf("daemon PID %d 端口 %d 版本 %s\n", ep.PID, ep.Port, st.GetVersion())
fmt.Printf("设备 %s\n", st.GetDeviceName())
fmt.Printf("设备 ID %s\n", st.GetDeviceId())
- fmt.Printf("信令 %s\n", boolText(st.GetSignalingConnected(), "已连接", "未连接"))
+ server := "未设置(只在局域网里同步)"
+ if st.GetServerConfigured() {
+ server = boolText(st.GetSignalingConnected(), "已连接", "未连接")
+ }
+ fmt.Printf("服务器 %s\n", server)
+ lan := boolText(st.GetLanEnabled(), "开启", "关闭")
+ if st.GetLanBlocked() {
+ lan += "(被系统拦截,需要允许本地网络访问)"
+ }
+ fmt.Printf("局域网 %s\n", lan)
fmt.Printf("在线对端 %d\n", st.GetPeersOnline())
fmt.Printf("剪贴板授权 %s\n", st.GetClipboardPermission())
fmt.Printf("缓存占用 %s\n", humanBytes(st.GetCacheBytesUsed()))
@@ -433,7 +509,12 @@ func showConfig(ctx context.Context, c pb.DaemonServiceClient) error {
return err
}
fmt.Printf("设备名称 %s\n", cfg.GetDeviceName())
- fmt.Printf("信令地址 %s\n", cfg.GetSignalingUrl())
+ server := cfg.GetSignalingUrl()
+ if server == "" {
+ server = "(未设置)"
+ }
+ fmt.Printf("信令地址 %s\n", server)
+ fmt.Printf("局域网发现 %v\n", !cfg.GetLanDisabled())
fmt.Printf("自动同步阈值 %s\n", humanBytes(cfg.GetAutoSyncThresholdBytes()))
fmt.Printf("历史保留 %s\n", time.Duration(cfg.GetHistoryTtlSeconds())*time.Second)
fmt.Printf("缓存保留 %s\n", time.Duration(cfg.GetCacheTtlSeconds())*time.Second)
diff --git a/client-core/cmd/copysyncd/main.go b/client-core/cmd/copysyncd/main.go
index c1b8e33..7230459 100644
--- a/client-core/cmd/copysyncd/main.go
+++ b/client-core/cmd/copysyncd/main.go
@@ -28,6 +28,7 @@ import (
"github.com/baiyuze/copysync/client-core/internal/rpc"
"github.com/baiyuze/copysync/client-core/internal/store"
syncengine "github.com/baiyuze/copysync/client-core/internal/sync"
+ "github.com/baiyuze/copysync/client-core/internal/transport/lan"
"github.com/baiyuze/copysync/client-core/internal/transport/p2p"
pb "github.com/baiyuze/copysync/proto/gen/copysync/v1"
)
@@ -300,6 +301,15 @@ func run(dataDir string) error {
slog.Info("信令服务器地址已变更", "from", prev.SignalingURL, "to", c.SignalingURL)
peerMgr.SetSignalingURL(c.SignalingURL)
}
+ if c.LANDisabled != prev.LANDisabled {
+ peerMgr.SetLANEnabled(!c.LANDisabled)
+ }
+ if c.SignalingURL != prev.SignalingURL || c.LANDisabled != prev.LANDisabled {
+ select {
+ case statusDirty <- struct{}{}:
+ default:
+ }
+ }
return nil
}
@@ -309,23 +319,28 @@ func run(dataDir string) error {
return err
}
srv := rpc.NewServer(rpc.Deps{
- Store: db,
- Paths: paths,
- Version: version,
- DeviceID: id.DeviceID,
- LoadConfig: loadCfg,
- SaveConfig: saveCfgAndApply,
- Devices: peerMgr.Devices,
- CreatePairingCode: peerMgr.CreatePairingCode,
- RedeemPairingCode: peerMgr.RedeemPairingCode,
- ConfirmPairing: peerMgr.ConfirmPairing,
- Unpair: peerMgr.Unpair,
- SignalingConnected: peerMgr.Connected,
- Fetch: engine.Fetch,
- FetchForPreview: engine.FetchForPreview,
- ApplyToClipboard: engine.ApplyToClipboard,
- ImagePreview: engine.ImagePreview,
- CacheBytesUsed: blobs.Size,
+ Store: db,
+ Paths: paths,
+ Version: version,
+ DeviceID: id.DeviceID,
+ LoadConfig: loadCfg,
+ SaveConfig: saveCfgAndApply,
+ Devices: peerMgr.Devices,
+ CreatePairingCode: peerMgr.CreatePairingCode,
+ RedeemPairingCode: peerMgr.RedeemPairingCode,
+ ConfirmPairing: peerMgr.ConfirmPairing,
+ Unpair: peerMgr.Unpair,
+ SetDeviceAddress: peerMgr.SetDeviceAddress,
+ SignalingConnected: peerMgr.Connected,
+ ServerConfigured: peerMgr.ServerConfigured,
+ LANEnabled: peerMgr.LANEnabled,
+ LANBlocked: peerMgr.LANBlocked,
+ OpenLocalNetworkSettings: lan.RequestPermission,
+ Fetch: engine.Fetch,
+ FetchForPreview: engine.FetchForPreview,
+ ApplyToClipboard: engine.ApplyToClipboard,
+ ImagePreview: engine.ImagePreview,
+ CacheBytesUsed: blobs.Size,
Permission: func() clipboard.Permission {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
@@ -343,6 +358,7 @@ func run(dataDir string) error {
Guessed: e.Guessed(), Via: e.Via,
})
}
+ info.Lan = peerMgr.LANInfo()
return info
},
OpenPermissionSettings: func() error {
diff --git a/client-core/go.mod b/client-core/go.mod
index 38f9804..14e44b4 100644
--- a/client-core/go.mod
+++ b/client-core/go.mod
@@ -12,8 +12,6 @@ require (
github.com/pion/datachannel v1.6.2 // indirect
github.com/pion/dtls/v3 v3.1.8 // indirect
github.com/pion/interceptor v0.1.48 // indirect
- github.com/pion/logging v0.2.4 // indirect
- github.com/pion/mdns/v2 v2.2.0 // indirect
github.com/pion/randutil v0.1.0 // indirect
github.com/pion/rtcp v1.2.17 // indirect
github.com/pion/rtp v1.10.5 // indirect
@@ -48,6 +46,8 @@ require (
github.com/baiyuze/copysync/server v0.0.0
github.com/klauspost/compress v1.20.0
github.com/pion/ice/v4 v4.4.2
+ github.com/pion/logging v0.2.4
+ github.com/pion/mdns/v2 v2.2.0
github.com/pion/stun/v4 v4.0.0
github.com/pion/webrtc/v4 v4.2.20
golang.org/x/net v0.57.0
diff --git a/client-core/internal/config/config.go b/client-core/internal/config/config.go
index 77e551d..f647152 100644
--- a/client-core/internal/config/config.go
+++ b/client-core/internal/config/config.go
@@ -12,8 +12,12 @@ import (
// Config 是用户可调的全部设置。字段与 proto 的 copysync.v1.Config 一一对应。
type Config struct {
- DeviceID string `json:"device_id"`
- DeviceName string `json:"device_name"`
+ // Version 是配置文件的格式版本,见 migrate。
+ Version int `json:"config_version"`
+ DeviceID string `json:"device_id"`
+ DeviceName string `json:"device_name"`
+ // SignalingURL 是信令服务器地址。可以为空:同一局域网里的设备不需要服务器,
+ // 只有跨网络同步时才要填。
SignalingURL string `json:"signaling_url"`
// 小于此值的内容在复制时自动推送给对端;大于则只同步元数据,
@@ -39,16 +43,29 @@ type Config struct {
// Language 是界面语言:空字符串跟随系统,否则为 "zh-Hans"、"en"、"ja" 之一。
// 托盘菜单(Windows)也按它显示
Language string `json:"language,omitempty"`
+
+ // LANDisabled 关掉局域网发现:不在局域网里广播和查找设备,也不接受局域网里的配对请求。
+ // 写成反向的,旧配置文件没有这一项时就是开启。
+ LANDisabled bool `json:"lan_disabled,omitempty"`
}
+// CurrentVersion 是当前的配置格式版本。
+//
+// 版本 2(1.4.0):服务器变成可选,默认地址从 ws://127.0.0.1:8787/signal 改为空。
+const CurrentVersion = 2
+
+// legacyDefaultURL 是 1.4.0 之前的默认服务器地址。没改过它的用户其实没有服务器,
+// 升级后应当直接进入局域网模式,而不是一直显示「服务器连不上」。
+const legacyDefaultURL = "ws://127.0.0.1:8787/signal"
+
func Default() Config {
host, _ := os.Hostname()
if host == "" {
host = "未命名设备"
}
return Config{
+ Version: CurrentVersion,
DeviceName: host,
- SignalingURL: "ws://127.0.0.1:8787/signal",
AutoSyncThresholdBytes: 50 << 20, // 50 MiB
HistoryTTL: Duration(3 * 24 * time.Hour),
CacheTTL: Duration(3 * 24 * time.Hour),
@@ -67,9 +84,6 @@ func (c *Config) Validate() {
if c.DeviceName == "" {
c.DeviceName = d.DeviceName
}
- if c.SignalingURL == "" {
- c.SignalingURL = d.SignalingURL
- }
if c.AutoSyncThresholdBytes <= 0 {
c.AutoSyncThresholdBytes = d.AutoSyncThresholdBytes
}
@@ -171,13 +185,31 @@ func Load(p Paths) (Config, error) {
}
c := Default() // 以默认值打底,缺失字段自动继承
+ c.Version = 0 // 旧文件没有版本号,要能认出来
if err := json.Unmarshal(data, &c); err != nil {
return Config{}, fmt.Errorf("解析配置 %s: %w", p.Config, err)
}
+ migrated := c.migrate()
c.Validate()
+ if migrated {
+ // 存回去,免得用户之后特意填回旧默认地址时又被清掉
+ _ = Save(p, c)
+ }
return c, nil
}
+// migrate 把旧格式的配置升级到 CurrentVersion,返回是否有改动。
+func (c *Config) migrate() bool {
+ if c.Version >= CurrentVersion {
+ return false
+ }
+ if c.Version < 2 && c.SignalingURL == legacyDefaultURL {
+ c.SignalingURL = ""
+ }
+ c.Version = CurrentVersion
+ return true
+}
+
func Save(p Paths, c Config) error {
if err := p.EnsureDirs(); err != nil {
return err
diff --git a/client-core/internal/config/config_test.go b/client-core/internal/config/config_test.go
index a812421..3269635 100644
--- a/client-core/internal/config/config_test.go
+++ b/client-core/internal/config/config_test.go
@@ -118,8 +118,12 @@ func TestValidateClampsBadValues(t *testing.T) {
}
c.Validate()
- if c.DeviceName == "" || c.SignalingURL == "" {
- t.Error("空值未被补为默认值")
+ if c.DeviceName == "" {
+ t.Error("空的设备名未被补为默认值")
+ }
+ // 服务器是可选的:空地址就是不用服务器,不能被补成别的
+ if c.SignalingURL != "" {
+ t.Errorf("空的服务器地址被改成了 %q", c.SignalingURL)
}
if c.AutoSyncThresholdBytes <= 0 {
t.Errorf("负阈值未被修正: %d", c.AutoSyncThresholdBytes)
@@ -209,3 +213,50 @@ func TestSaveWritesPrivatePermissions(t *testing.T) {
t.Errorf("配置文件权限 = %o,期望 0600", perm)
}
}
+
+// 1.4.0 之前的默认服务器地址其实没有服务器在跑:升级后清空,进入局域网模式;
+// 用户自己填过的地址原样保留,迁移只做一次。
+func TestMigrateClearsLegacyDefaultURL(t *testing.T) {
+ cases := []struct {
+ name, file, want string
+ }{
+ {"旧默认地址", `{"device_name":"a","signaling_url":"ws://127.0.0.1:8787/signal"}`, ""},
+ {"自己的服务器", `{"device_name":"a","signaling_url":"ws://192.168.1.20:8787/signal"}`, "ws://192.168.1.20:8787/signal"},
+ {"已迁移过", `{"config_version":2,"device_name":"a","signaling_url":"ws://127.0.0.1:8787/signal"}`, "ws://127.0.0.1:8787/signal"},
+ }
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ p := PathsUnder(t.TempDir())
+ if err := p.EnsureDirs(); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(p.Config, []byte(tc.file), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ c, err := Load(p)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if c.SignalingURL != tc.want {
+ t.Errorf("signaling_url = %q,期望 %q", c.SignalingURL, tc.want)
+ }
+ if c.Version != CurrentVersion {
+ t.Errorf("版本 = %d,期望 %d", c.Version, CurrentVersion)
+ }
+ if c.LANDisabled {
+ t.Error("旧配置没有 lan_disabled,应当默认开启局域网")
+ }
+ // 迁移结果已经存回文件:再读一次不会再变
+ again, err := Load(p)
+ if err != nil || again.SignalingURL != tc.want {
+ t.Errorf("再次读取得到 %q, %v", again.SignalingURL, err)
+ }
+ })
+ }
+}
+
+func TestDefaultHasNoServer(t *testing.T) {
+ if d := Default(); d.SignalingURL != "" || d.LANDisabled {
+ t.Errorf("新装的默认配置应当不用服务器、开启局域网,得到 %q / %v", d.SignalingURL, d.LANDisabled)
+ }
+}
diff --git a/client-core/internal/peers/manager.go b/client-core/internal/peers/manager.go
index 9c6d92a..5206715 100644
--- a/client-core/internal/peers/manager.go
+++ b/client-core/internal/peers/manager.go
@@ -1,4 +1,8 @@
// Package peers 管理已配对设备:配对流程、在线状态、信令收发。
+//
+// 信令有两条通道:信令服务器(可选,跨网络时用)和局域网(同一网络里直接收发)。
+// 两条通道并存,信令同时从两条路发出,接收方按 nonce 去重;
+// 任意一条通道报告对方在线,就算在线。配对结果两条通道通用。
package peers
import (
@@ -9,6 +13,7 @@ import (
"errors"
"fmt"
"log/slog"
+ "net/netip"
"runtime"
"sync"
"time"
@@ -16,26 +21,44 @@ import (
"github.com/baiyuze/copysync/client-core/internal/config"
"github.com/baiyuze/copysync/client-core/internal/identity"
"github.com/baiyuze/copysync/client-core/internal/store"
+ "github.com/baiyuze/copysync/client-core/internal/transport/lan"
"github.com/baiyuze/copysync/client-core/internal/transport/p2p"
"github.com/baiyuze/copysync/client-core/internal/transport/signaling"
+ "github.com/baiyuze/copysync/client-core/internal/transport/signed"
"github.com/baiyuze/copysync/proto/deviceid"
pb "github.com/baiyuze/copysync/proto/gen/copysync/v1"
+ "github.com/baiyuze/copysync/proto/pairingcode"
)
// pendingPair 是一次等待用户核对指纹的配对。
//
-// 配对必须由双方各自确认指纹后才落库:信令服务器能替换转发中的公钥,
-// 但无法让两端显示出相同的指纹——用户的肉眼核对是防中间人的最后一道闸。
+// 配对必须由双方各自确认指纹后才落库:信令服务器(或同一网络里的其他人)
+// 能替换转发中的公钥,但无法让两端显示出相同的指纹——用户的肉眼核对是防中间人的最后一道闸。
type pendingPair struct {
session string
peer store.Device
expiresAt time.Time
// initiated 表示本机是配对码的发起方(对方兑换了我的码)
initiated bool
+ // addrs 是在局域网里配对时对方的地址,确认后写进地址簿
+ addrs []string
}
const pendingTTL = 5 * time.Minute
+// activeCode 是本机正在显示的配对码。连着服务器时它同时在服务器和局域网两边开放,
+// 一边用掉之后,另一边的兑换一律不认。
+type activeCode struct {
+ code string
+ expires time.Time
+ used bool
+}
+
+type redeemResult struct {
+ ev *pb.PairingRedeemResponse
+ err error
+}
+
type Manager struct {
identity *identity.Identity
store *store.Store
@@ -51,23 +74,31 @@ type Manager struct {
// onPeerReady 见 Options.OnPeerReady
onPeerReady func(deviceID string)
- client *signaling.Client
- p2p *p2p.Manager
-
- mu sync.RWMutex
- known map[string]store.Device // 已配对设备
- online map[string]bool
- conn map[string]p2p.ConnState // P2P 连接状态(直连/中转)
- pending map[string]*pendingPair // session -> 待确认配对
+ client *signaling.Client
+ lan *lan.Transport
+ verifier *signed.Verifier
+ p2p *p2p.Manager
+
+ mu sync.RWMutex
+ // 不能在持有 mu 时调用 lan 里会加它自己的锁的方法(Reachable 除外):
+ // lan 持锁期间会回调这里
+ known map[string]store.Device // 已配对设备
+ // serverOnline 是信令服务器报告的在线状态;局域网的在线状态在 lan 里
+ serverOnline map[string]bool
+ conn map[string]p2p.ConnState // P2P 连接状态(直连/中转)
+ pending map[string]*pendingPair // session -> 待确认配对
// stashed 暂存配对确认前到达的信令,按对端 device_id 归集
stashed map[string][]*pb.SignalMessage
- // 等待配对码的请求方(CreatePairingCode 是异步的,靠这个回传结果)
- codeWaiters []chan pairingCode
+ active *activeCode
+ // 等服务器回音的配对请求(服务器的回复是异步的,靠这些通道回传结果)
+ codeWaiters []chan pairingCode
+ redeemWaiters []chan redeemResult
}
type pairingCode struct {
code string
expiresAt time.Time
+ err error
}
type Options struct {
@@ -85,6 +116,9 @@ type Options struct {
OnPeerReady func(deviceID string)
// StatePath 保存网络出口历史的文件,见 p2p/egress_history.go
StatePath string
+ // LANPort / LANDiscovery 供测试替换局域网通道的端口和发现方式,默认 8788 与 mDNS
+ LANPort int
+ LANDiscovery lan.Discovery
}
func NewManager(opts Options) (*Manager, error) {
@@ -103,7 +137,7 @@ func NewManager(opts Options) (*Manager, error) {
onSignal: opts.OnSignal,
onPeerReady: opts.OnPeerReady,
known: make(map[string]store.Device),
- online: make(map[string]bool),
+ serverOnline: make(map[string]bool),
conn: make(map[string]p2p.ConnState),
pending: make(map[string]*pendingPair),
stashed: make(map[string][]*pb.SignalMessage),
@@ -125,19 +159,41 @@ func NewManager(opts Options) (*Manager, error) {
OnMessage: opts.OnPeerMessage,
OnStream: opts.OnPeerStream,
StatePath: opts.StatePath,
- // 公共 STUN 服务器 IP 分散,能探测到更多出口;用户可以在设置里关掉
+ // 公共 STUN 服务器 IP 分散,能探测到更多出口;用户可以在设置里关掉。
+ // 没有服务器时只在局域网里连,探测出口没有用,还会把公网 IP 暴露给公共服务器
ProbeServers: func() []string {
- if opts.LoadConfig().OnlyOwnSTUN {
+ cfg := opts.LoadConfig()
+ if cfg.OnlyOwnSTUN || cfg.SignalingURL == "" {
return nil
}
return p2p.DefaultProbeServers
},
})
+ m.verifier = signed.NewVerifier(opts.Identity.DeviceID, m.publicKeyOf)
+ m.lan = lan.New(lan.Options{
+ Identity: opts.Identity,
+ Logger: log,
+ Port: opts.LANPort,
+ Discovery: opts.LANDiscovery,
+ Verifier: m.verifier,
+ Book: opts.Store,
+ Peers: m.pairedIDs,
+ Connected: func(id string) bool { return connected(m.p2p.State(id)) },
+ DeviceInfo: func() (string, string) {
+ return m.loadConfig().DeviceName, runtime.GOOS
+ },
+ OnSignal: m.handleSignal,
+ OnReachable: m.handleLANReachable,
+ AcceptPair: m.acceptLANPair,
+ OnChange: m.notifyStatus,
+ })
+
m.client = signaling.New(signaling.Options{
Identity: opts.Identity,
URL: opts.LoadConfig().SignalingURL,
Logger: log,
+ Verifier: m.verifier,
PublicKeyOf: m.publicKeyOf,
DeviceInfo: m.deviceInfo,
Handlers: signaling.Handlers{
@@ -151,18 +207,33 @@ func NewManager(opts Options) (*Manager, error) {
OnIceConfig: func(servers []*pb.IceServer) {
m.p2p.SetICEServers(servers)
},
- OnServerError: func(code, msg string) {
- log.Warn("信令服务器错误", "code", code, "msg", msg)
- },
+ OnServerError: m.handleServerError,
},
})
return m, nil
}
func (m *Manager) Run(ctx context.Context) {
+ if !m.loadConfig().LANDisabled {
+ if err := m.lan.Start(); err != nil {
+ m.log.Warn("局域网直连启动失败", "err", err)
+ }
+ }
go m.gcPending(ctx)
go m.reconnectLoop(ctx)
m.client.Run(ctx)
+ m.lan.Stop()
+}
+
+// SetLANEnabled 在用户于设置里开关局域网发现后调用,立即生效。
+func (m *Manager) SetLANEnabled(enabled bool) {
+ if enabled {
+ if err := m.lan.Start(); err != nil {
+ m.log.Warn("局域网直连启动失败", "err", err)
+ }
+ return
+ }
+ m.lan.Stop()
}
// reconnectLoop 定期把"在线但尚未建立 P2P 通道"的对端重新连上。
@@ -190,7 +261,7 @@ func (m *Manager) connectPending(ctx context.Context) {
m.mu.RLock()
var candidates []string
for id := range m.known {
- if m.online[id] && m.p2p.State(id) == p2p.StateOffline {
+ if m.isOnlineLocked(id) && m.p2p.State(id) == p2p.StateOffline {
candidates = append(candidates, id)
}
}
@@ -205,8 +276,18 @@ func (m *Manager) connectPending(ctx context.Context) {
}
}
+// Connected 报告是否连着信令服务器。
func (m *Manager) Connected() bool { return m.client.Connected() }
+// ServerConfigured 报告设置里是否填了服务器地址。没填时只在局域网里同步。
+func (m *Manager) ServerConfigured() bool { return m.loadConfig().SignalingURL != "" }
+
+// LANEnabled 报告局域网直连是否在运行。
+func (m *Manager) LANEnabled() bool { return m.lan.Running() }
+
+// LANBlocked 报告系统是否拦下了发往局域网的包(macOS 的本地网络权限)。
+func (m *Manager) LANBlocked() bool { return m.lan.Blocked() }
+
// SetSignalingURL 在用户于设置里改了服务器地址后调用,立即重连。
func (m *Manager) SetSignalingURL(url string) { m.client.SetURL(url) }
@@ -250,8 +331,8 @@ func (m *Manager) handleConnected() {
func (m *Manager) handleDisconnected(error) {
m.mu.Lock()
- // 信令断开后无法得知对端状态,一律视为离线
- m.online = make(map[string]bool)
+ // 信令断开后无法从服务器得知对端状态;局域网那边的在线状态不受影响
+ m.serverOnline = make(map[string]bool)
m.mu.Unlock()
m.notifyAll()
m.notifyStatus()
@@ -259,28 +340,15 @@ func (m *Manager) handleDisconnected(error) {
func (m *Manager) handlePresence(deviceID string, online bool) {
m.mu.Lock()
- m.online[deviceID] = online
+ m.serverOnline[deviceID] = online
m.mu.Unlock()
m.log.Debug("对端状态变化", "device", deviceID, "online", online)
if online {
- // 对端上线即建立 P2P 通道,这样真正要传数据时已经就绪。
- // 谁发起由 p2p.Manager 内部按 device_id 字典序决定,这里无脑调用即可。
- go func() {
- ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
- defer cancel()
-
- // 只在完全没有连接时发起。正在握手中就不要插手——
- // 重置会换掉 ICE ufrag,让对端已经发出的 answer 全部失配。
- if m.p2p.State(deviceID) != p2p.StateOffline {
- return
- }
- if err := m.p2p.Connect(ctx, deviceID); err != nil {
- m.log.Warn("建立 P2P 连接失败", "device", deviceID, "err", err)
- }
- }()
- } else {
+ m.connectIfOffline(deviceID)
+ } else if !m.lan.Reachable(deviceID) {
+ // 服务器说对方下线了,局域网里也找不到:连接多半已经失效
m.p2p.Disconnect(deviceID)
m.mu.Lock()
delete(m.conn, deviceID)
@@ -293,6 +361,42 @@ func (m *Manager) handlePresence(deviceID string, online bool) {
m.notifyStatus() // 在线对端数随之变化
}
+// handleLANReachable 在局域网里找到或失去某台设备时调用。
+// 失去时不主动断开:P2P 连接自己能发现对方没了,可能对方只是换了地址。
+func (m *Manager) handleLANReachable(deviceID string, reachable bool) {
+ if reachable {
+ m.connectIfOffline(deviceID)
+ }
+ if d, ok := m.device(deviceID); ok {
+ m.notify(d)
+ }
+ m.notifyStatus()
+}
+
+// connectIfOffline 在对端上线时建立 P2P 通道,这样真正要传数据时已经就绪。
+// 谁发起由 p2p.Manager 内部按 device_id 字典序决定,这里无脑调用即可。
+func (m *Manager) connectIfOffline(deviceID string) {
+ m.mu.RLock()
+ _, paired := m.known[deviceID]
+ m.mu.RUnlock()
+ if !paired {
+ return
+ }
+ go func() {
+ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ defer cancel()
+
+ // 只在完全没有连接时发起。正在握手中就不要插手——
+ // 重置会换掉 ICE ufrag,让对端已经发出的 answer 全部失配。
+ if m.p2p.State(deviceID) != p2p.StateOffline {
+ return
+ }
+ if err := m.p2p.Connect(ctx, deviceID); err != nil {
+ m.log.Warn("建立 P2P 连接失败", "device", deviceID, "err", err)
+ }
+ }()
+}
+
func (m *Manager) handleSignal(from string, msg *pb.SignalMessage) {
m.mu.RLock()
_, paired := m.known[from]
@@ -391,8 +495,37 @@ func connected(s p2p.ConnState) bool {
return s == p2p.StateDirect || s == p2p.StateRelay
}
+// ErrNoRoute 表示对方既不在局域网里,本机也没连上服务器,信令无路可走。
+var ErrNoRoute = errors.New("对方不在局域网里,也没有连上服务器")
+
+// sendSignal 签一次名,从所有可用的通道发出去:局域网里能找到对方就走局域网,
+// 连着服务器就也经服务器转发。接收方按 nonce 去重,只处理先到的那份。
func (m *Manager) sendSignal(ctx context.Context, to string, msg *pb.SignalMessage) error {
- return m.client.Signal(ctx, to, msg)
+ s, err := signed.Sign(m.identity, to, msg)
+ if err != nil {
+ return err
+ }
+ sent := false
+ var lastErr error
+ if m.lan.Reachable(to) {
+ if lastErr = m.lan.Send(to, s); lastErr == nil {
+ sent = true
+ }
+ }
+ if m.client.Connected() {
+ if err := m.client.SendSigned(ctx, s); err == nil {
+ sent = true
+ } else {
+ lastErr = err
+ }
+ }
+ if sent {
+ return nil
+ }
+ if lastErr == nil {
+ lastErr = ErrNoRoute
+ }
+ return lastErr
}
// P2P 暴露数据面给上层(M4 的同步逻辑用)。
@@ -405,37 +538,105 @@ func (m *Manager) handlePairingCreated(code string, expiresAt time.Time) {
m.mu.Unlock()
for _, ch := range waiters {
- ch <- pairingCode{code, expiresAt}
+ ch <- pairingCode{code: code, expiresAt: expiresAt}
close(ch)
}
}
-// handlePairingRedeemed:本机是发起方,有人兑换了我的配对码。
+// handleServerError 把服务器对配对请求的拒绝交给正在等的调用方,免得它干等到超时。
+func (m *Manager) handleServerError(code, msg string) {
+ m.log.Warn("信令服务器错误", "code", code, "msg", msg)
+ err := fmt.Errorf("服务器: %s", msg)
+ m.mu.Lock()
+ var codeWaiters []chan pairingCode
+ var redeemWaiter chan redeemResult
+ switch code {
+ case "pairing_create_failed":
+ codeWaiters, m.codeWaiters = m.codeWaiters, nil
+ case "pairing_redeem_failed":
+ if len(m.redeemWaiters) > 0 {
+ redeemWaiter, m.redeemWaiters = m.redeemWaiters[0], m.redeemWaiters[1:]
+ }
+ }
+ m.mu.Unlock()
+
+ for _, ch := range codeWaiters {
+ ch <- pairingCode{err: err}
+ close(ch)
+ }
+ if redeemWaiter != nil {
+ redeemWaiter <- redeemResult{err: ErrCodeRejected}
+ }
+}
+
+// handlePairingRedeemed:本机是发起方,有人经服务器兑换了我的配对码。
// 同样要经用户确认指纹后才落库。
func (m *Manager) handlePairingRedeemed(ev *pb.PairingRedeemed) {
- m.addPending(store.Device{
+ m.mu.Lock()
+ a := m.active
+ if a != nil && a.used {
+ m.mu.Unlock()
+ m.log.Warn("忽略服务器转来的配对:这个配对码已在局域网里用掉", "peer", ev.GetPeerDeviceName())
+ return
+ }
+ if a != nil {
+ a.used = true
+ }
+ m.mu.Unlock()
+ m.lan.ClosePairing()
+
+ _, _ = m.addPending(store.Device{
ID: ev.GetPeerDeviceId(),
Name: ev.GetPeerDeviceName(),
Platform: ev.GetPeerPlatform(),
PublicKey: ev.GetPeerPublicKey(),
- }, true)
+ }, true, nil)
}
-// handlePairingResult:本机是兑换方,拿到了发起方信息。
+// handlePairingResult:本机是兑换方,服务器回传了发起方信息。
func (m *Manager) handlePairingResult(ev *pb.PairingRedeemResponse) {
- m.addPending(store.Device{
- ID: ev.GetPeerDeviceId(),
- Name: ev.GetPeerDeviceName(),
- Platform: ev.GetPeerPlatform(),
- PublicKey: ev.GetPeerPublicKey(),
- }, false)
+ m.mu.Lock()
+ var ch chan redeemResult
+ if len(m.redeemWaiters) > 0 {
+ ch, m.redeemWaiters = m.redeemWaiters[0], m.redeemWaiters[1:]
+ }
+ m.mu.Unlock()
+ if ch == nil {
+ m.log.Warn("忽略迟到的配对结果", "peer", ev.GetPeerDeviceName())
+ return
+ }
+ ch <- redeemResult{ev: ev}
+}
+
+// acceptLANPair:本机是发起方,有人在局域网里用对了我的配对码。
+// 返回 false 表示这个码已经在服务器那边用掉了。
+func (m *Manager) acceptLANPair(peer lan.PeerInfo) bool {
+ m.mu.Lock()
+ a := m.active
+ if a == nil || a.used || time.Now().After(a.expires) {
+ m.mu.Unlock()
+ return false
+ }
+ a.used = true
+ m.mu.Unlock()
+
+ _, err := m.addPending(store.Device{
+ ID: peer.ID,
+ Name: peer.Name,
+ Platform: peer.Platform,
+ PublicKey: peer.PublicKey,
+ }, true, peer.Addrs)
+ return err == nil
}
-func (m *Manager) addPending(peer store.Device, initiated bool) {
+// ErrBadPeerID 表示对方的 device_id 与公钥对不上:有人在转发途中改了它。
+var ErrBadPeerID = errors.New("对方的设备 ID 与公钥不匹配")
+
+func (m *Manager) addPending(peer store.Device, initiated bool, addrs []string) (string, error) {
// 校验对端 ID 确由其公钥派生,挡住服务器伪造的 device_id
if !deviceid.Valid(peer.ID, peer.PublicKey) {
m.log.Warn("拒绝配对:device_id 与公钥不匹配", "device", peer.ID)
- return
+ return "", ErrBadPeerID
}
session := randomToken()
@@ -445,6 +646,7 @@ func (m *Manager) addPending(peer store.Device, initiated bool) {
peer: peer,
expiresAt: time.Now().Add(pendingTTL),
initiated: initiated,
+ addrs: addrs,
}
m.mu.Unlock()
@@ -456,21 +658,60 @@ func (m *Manager) addPending(peer store.Device, initiated bool) {
if initiated {
m.notify(m.toProto(peer, false, session))
}
+ return session, nil
}
// ─────────────────────── 对外 API ───────────────────────
var (
- ErrNotConnected = errors.New("未连接到信令服务器")
+ // ErrNoChannel 表示局域网发现已关闭,也没连上服务器,没法配对
+ ErrNoChannel = errors.New("局域网发现已关闭,也没有连上服务器")
ErrSessionUnknown = errors.New("配对会话不存在或已过期")
+ // ErrCodeRejected 是服务器拒绝了配对码:码不存在或已过期,服务器不区分这两种
+ ErrCodeRejected = errors.New("配对码不对或已失效")
+ ErrNotPaired = errors.New("没有与这台设备配对")
)
-// CreatePairingCode 生成配对码。服务器异步返回,这里等待结果。
-func (m *Manager) CreatePairingCode(ctx context.Context) (string, time.Time, error) {
- if !m.client.Connected() {
- return "", time.Time{}, ErrNotConnected
+// CreatePairingCode 生成配对码,返回码、有效期和本机的局域网地址。
+//
+// 连着服务器时用服务器签发的码,同一个码也在局域网里开放,两边谁先用掉算谁的;
+// 没连服务器时在本机生成,只在局域网里开放。
+func (m *Manager) CreatePairingCode(ctx context.Context) (string, time.Time, []string, error) {
+ lanOn := m.lan.Running()
+ var code string
+ var expires time.Time
+ if m.client.Connected() {
+ var err error
+ code, expires, err = m.serverPairingCode(ctx)
+ if err != nil && !lanOn {
+ return "", time.Time{}, nil, err
+ }
+ if err != nil {
+ m.log.Warn("服务器没给出配对码,改为只在局域网里配对", "err", err)
+ }
}
+ if code == "" {
+ if !lanOn {
+ return "", time.Time{}, nil, ErrNoChannel
+ }
+ var err error
+ if code, err = pairingcode.Generate(); err != nil {
+ return "", time.Time{}, nil, err
+ }
+ expires = time.Now().Add(pairingcode.TTL)
+ }
+
+ m.mu.Lock()
+ m.active = &activeCode{code: code, expires: expires}
+ m.mu.Unlock()
+ if lanOn {
+ m.lan.OpenPairing(code, expires)
+ }
+ return code, expires, m.lan.DisplayAddrs(), nil
+}
+// serverPairingCode 请服务器签发配对码。服务器异步返回,这里等待结果。
+func (m *Manager) serverPairingCode(ctx context.Context) (string, time.Time, error) {
ch := make(chan pairingCode, 1)
m.mu.Lock()
m.codeWaiters = append(m.codeWaiters, ch)
@@ -482,7 +723,7 @@ func (m *Manager) CreatePairingCode(ctx context.Context) (string, time.Time, err
select {
case got := <-ch:
- return got.code, got.expiresAt, nil
+ return got.code, got.expiresAt, got.err
case <-ctx.Done():
return "", time.Time{}, ctx.Err()
case <-time.After(10 * time.Second):
@@ -492,36 +733,97 @@ func (m *Manager) CreatePairingCode(ctx context.Context) (string, time.Time, err
// RedeemPairingCode 兑换配对码,返回待用户核对的对端信息与会话 ID。
// 此时尚未建立互信——必须再调 ConfirmPairing。
-func (m *Manager) RedeemPairingCode(ctx context.Context, code string) (*pb.Device, string, error) {
- if !m.client.Connected() {
- return nil, "", ErrNotConnected
- }
- if err := m.client.RedeemPairingCode(ctx, code); err != nil {
- return nil, "", err
+//
+// 先在局域网里找(address 是用户输入的对方地址,不在同一网段时用),
+// 找不到且连着服务器时再去服务器上兑换。
+func (m *Manager) RedeemPairingCode(ctx context.Context, code, address string) (*pb.Device, string, error) {
+ code = pairingcode.Normalize(code)
+ var extra []netip.AddrPort
+ if address != "" {
+ aps, err := lan.ResolveAddress(ctx, address)
+ if err != nil {
+ return nil, "", err
+ }
+ extra = aps
}
- // 等待服务器回传发起方信息(经 handlePairingResult 落入 pending)
- deadline := time.After(10 * time.Second)
- for {
- select {
- case <-ctx.Done():
- return nil, "", ctx.Err()
- case <-deadline:
- return nil, "", errors.New("兑换配对码超时(配对码可能已失效)")
- case <-time.After(50 * time.Millisecond):
- m.mu.RLock()
- var found *pendingPair
- for _, p := range m.pending {
- if !p.initiated {
- found = p
- break
- }
+ lanErr := lan.ErrDisabled
+ if m.lan.Running() {
+ wait := 3 * time.Second
+ if len(extra) > 0 {
+ wait = 5 * time.Second
+ }
+ lctx, cancel := context.WithTimeout(ctx, wait)
+ peer, err := m.lan.Pair(lctx, code, extra)
+ cancel()
+ if err == nil {
+ dev := store.Device{ID: peer.ID, Name: peer.Name, Platform: peer.Platform, PublicKey: peer.PublicKey}
+ session, err := m.addPending(dev, false, peer.Addrs)
+ if err != nil {
+ return nil, "", err
}
- m.mu.RUnlock()
- if found != nil {
- return m.toProto(found.peer, false, found.session), found.session, nil
+ return m.toProto(dev, false, session), session, nil
+ }
+ lanErr = err
+ }
+
+ if m.client.Connected() {
+ dev, session, err := m.redeemViaServer(ctx, code)
+ // 服务器也没这个码时,局域网里那台的明确拒绝(码不对、已失效)更有用
+ if err != nil && (errors.Is(lanErr, lan.ErrWrongCode) || errors.Is(lanErr, lan.ErrTooManyAttempts) ||
+ errors.Is(lanErr, lan.ErrCodeClosed)) {
+ return nil, "", lanErr
+ }
+ return dev, session, err
+ }
+ if errors.Is(lanErr, lan.ErrDisabled) {
+ return nil, "", ErrNoChannel
+ }
+ return nil, "", lanErr
+}
+
+func (m *Manager) redeemViaServer(ctx context.Context, code string) (*pb.Device, string, error) {
+ ch := make(chan redeemResult, 1)
+ m.mu.Lock()
+ m.redeemWaiters = append(m.redeemWaiters, ch)
+ m.mu.Unlock()
+ drop := func() {
+ m.mu.Lock()
+ for i, w := range m.redeemWaiters {
+ if w == ch {
+ m.redeemWaiters = append(m.redeemWaiters[:i], m.redeemWaiters[i+1:]...)
+ break
}
}
+ m.mu.Unlock()
+ }
+
+ if err := m.client.RedeemPairingCode(ctx, code); err != nil {
+ drop()
+ return nil, "", err
+ }
+ select {
+ case r := <-ch:
+ if r.err != nil {
+ return nil, "", r.err
+ }
+ dev := store.Device{
+ ID: r.ev.GetPeerDeviceId(),
+ Name: r.ev.GetPeerDeviceName(),
+ Platform: r.ev.GetPeerPlatform(),
+ PublicKey: r.ev.GetPeerPublicKey(),
+ }
+ session, err := m.addPending(dev, false, nil)
+ if err != nil {
+ return nil, "", err
+ }
+ return m.toProto(dev, false, session), session, nil
+ case <-ctx.Done():
+ drop()
+ return nil, "", ctx.Err()
+ case <-time.After(10 * time.Second):
+ drop()
+ return nil, "", ErrCodeRejected
}
}
@@ -556,9 +858,17 @@ func (m *Manager) ConfirmPairing(ctx context.Context, session string, accept boo
m.log.Info("配对成功", "peer", p.peer.Name, "device", p.peer.ID)
+ // 配对时对方所在的地址记进地址簿(设备已落库,外键才满足),然后马上去局域网里找它
+ if len(p.addrs) > 0 {
+ m.lan.Remember(p.peer.ID, p.addrs)
+ }
+ m.lan.PeersChanged()
+
// 让服务器知道我们现在关心这个设备的在线状态
- if err := m.client.RefreshPaired(ctx); err != nil {
- m.log.Warn("刷新关注列表失败", "err", err)
+ if m.client.Connected() {
+ if err := m.client.RefreshPaired(ctx); err != nil {
+ m.log.Warn("刷新关注列表失败", "err", err)
+ }
}
if d, ok := m.device(p.peer.ID); ok {
m.notify(d)
@@ -588,16 +898,65 @@ func (m *Manager) Unpair(ctx context.Context, deviceID string) error {
}
m.mu.Lock()
delete(m.known, deviceID)
- delete(m.online, deviceID)
+ delete(m.serverOnline, deviceID)
+ delete(m.conn, deviceID)
m.mu.Unlock()
- if err := m.client.RefreshPaired(ctx); err != nil {
- m.log.Warn("刷新关注列表失败", "err", err)
+ // 已经不再互信,连接也不该留着
+ m.p2p.Disconnect(deviceID)
+ m.lan.Forget(deviceID)
+ if m.client.Connected() {
+ if err := m.client.RefreshPaired(ctx); err != nil {
+ m.log.Warn("刷新关注列表失败", "err", err)
+ }
}
m.log.Info("已解除配对", "device", deviceID)
+ m.notifyStatus()
return nil
}
+// SetDeviceAddress 记下用户手动输入的某台设备的地址,并立即去那里找它。
+func (m *Manager) SetDeviceAddress(ctx context.Context, deviceID, address string) error {
+ m.mu.RLock()
+ _, ok := m.known[deviceID]
+ m.mu.RUnlock()
+ if !ok {
+ return ErrNotPaired
+ }
+ if !m.lan.Running() {
+ return lan.ErrDisabled
+ }
+ return m.lan.SetPeerAddr(ctx, deviceID, address)
+}
+
+// LANInfo 返回局域网直连的诊断信息。
+func (m *Manager) LANInfo() *pb.LanInfo {
+ info := m.lan.Info()
+ out := &pb.LanInfo{
+ Enabled: info.Running,
+ Port: int32(info.Port),
+ LocalAddresses: info.LocalAddrs,
+ Discovered: int32(info.Discovered),
+ Blocked: info.Blocked,
+ }
+ m.mu.RLock()
+ defer m.mu.RUnlock()
+ for _, p := range info.Peers {
+ lp := &pb.LanPeer{
+ DeviceId: p.ID,
+ DeviceName: m.known[p.ID].Name,
+ Reachable: p.Reachable,
+ Address: p.Addr,
+ KnownAddresses: p.Known,
+ }
+ if !p.LastSeen.IsZero() {
+ lp.LastSeenUnix = p.LastSeen.Unix()
+ }
+ out.Peers = append(out.Peers, lp)
+ }
+ return out
+}
+
// Devices 返回本机与所有已配对设备。
func (m *Manager) Devices() (*pb.Device, []*pb.Device) {
cfg := m.loadConfig()
@@ -605,7 +964,7 @@ func (m *Manager) Devices() (*pb.Device, []*pb.Device) {
Id: m.identity.DeviceID,
Name: cfg.DeviceName,
Platform: runtime.GOOS,
- Online: m.client.Connected(),
+ Online: m.client.Connected() || m.lan.Running(),
PublicKeyFingerprint: m.identity.Fingerprint(),
}
@@ -613,20 +972,36 @@ func (m *Manager) Devices() (*pb.Device, []*pb.Device) {
defer m.mu.RUnlock()
peers := make([]*pb.Device, 0, len(m.known))
for _, d := range m.known {
- peers = append(peers, m.toProtoLocked(d, m.online[d.ID], ""))
+ peers = append(peers, m.toProtoLocked(d, m.isOnlineLocked(d.ID), ""))
}
return self, peers
}
// Signal 向对端发送信令。M2 的 WebRTC 层用它交换 SDP 与 candidate。
func (m *Manager) Signal(ctx context.Context, to string, msg *pb.SignalMessage) error {
- return m.client.Signal(ctx, to, msg)
+ return m.sendSignal(ctx, to, msg)
}
func (m *Manager) IsOnline(deviceID string) bool {
m.mu.RLock()
defer m.mu.RUnlock()
- return m.online[deviceID]
+ return m.isOnlineLocked(deviceID)
+}
+
+// isOnlineLocked:服务器说在线、局域网里找得到、或者 P2P 已经连着,都算在线。
+func (m *Manager) isOnlineLocked(deviceID string) bool {
+ return m.serverOnline[deviceID] || m.lan.Reachable(deviceID) || connected(m.conn[deviceID])
+}
+
+// pairedIDs 返回所有已配对设备,供局域网通道去找它们。
+func (m *Manager) pairedIDs() []string {
+ m.mu.RLock()
+ defer m.mu.RUnlock()
+ ids := make([]string, 0, len(m.known))
+ for id := range m.known {
+ ids = append(ids, id)
+ }
+ return ids
}
// ─────────────────────── 内部辅助 ───────────────────────
@@ -638,7 +1013,7 @@ func (m *Manager) device(deviceID string) (*pb.Device, bool) {
if !ok {
return nil, false
}
- return m.toProtoLocked(d, m.online[deviceID], ""), true
+ return m.toProtoLocked(d, m.isOnlineLocked(deviceID), ""), true
}
func (m *Manager) toProto(d store.Device, online bool, session string) *pb.Device {
diff --git a/client-core/internal/peers/manager_test.go b/client-core/internal/peers/manager_test.go
new file mode 100644
index 0000000..bd70f31
--- /dev/null
+++ b/client-core/internal/peers/manager_test.go
@@ -0,0 +1,286 @@
+package peers
+
+import (
+ "context"
+ "errors"
+ "io"
+ "log/slog"
+ "net/http/httptest"
+ "path/filepath"
+ "strconv"
+ "strings"
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/baiyuze/copysync/client-core/internal/config"
+ "github.com/baiyuze/copysync/client-core/internal/identity"
+ "github.com/baiyuze/copysync/client-core/internal/store"
+ "github.com/baiyuze/copysync/client-core/internal/transport/lan"
+ "github.com/baiyuze/copysync/client-core/internal/transport/p2p"
+ pb "github.com/baiyuze/copysync/proto/gen/copysync/v1"
+ "github.com/baiyuze/copysync/server/signal"
+)
+
+// device 是测试里的一台完整设备:真实的 peers.Manager、数据库和身份。
+type device struct {
+ name string
+ m *Manager
+
+ mu sync.Mutex
+ cfg config.Config
+ sessions chan string // 对方兑换了我的码,界面上该弹出的确认
+ messages chan *pb.PeerMessage
+}
+
+func newDevice(t *testing.T, name string, net *lan.MemoryNetwork, cfg config.Config) *device {
+ t.Helper()
+ dir := t.TempDir()
+ id, err := identity.LoadOrCreate(filepath.Join(dir, "identity.json"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ db, err := store.Open(filepath.Join(dir, "copysync.db"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { db.Close() })
+
+ cfg.DeviceName = name
+ d := &device{
+ name: name,
+ cfg: cfg,
+ sessions: make(chan string, 4),
+ messages: make(chan *pb.PeerMessage, 16),
+ }
+ var disc lan.Discovery
+ if net != nil {
+ disc = net.Discovery()
+ }
+ d.m, err = NewManager(Options{
+ Identity: id,
+ Store: db,
+ Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
+ LoadConfig: d.config,
+ StatePath: filepath.Join(dir, "egress.json"),
+ OnDeviceChanged: func(dev *pb.Device) {
+ if dev.GetPairingSession() != "" {
+ d.sessions <- dev.GetPairingSession()
+ }
+ },
+ OnPeerMessage: func(_ string, msg *pb.PeerMessage) { d.messages <- msg },
+ LANPort: -1,
+ LANDiscovery: disc,
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ ctx, cancel := context.WithCancel(context.Background())
+ done := make(chan struct{})
+ go func() { d.m.Run(ctx); close(done) }()
+ t.Cleanup(func() {
+ cancel()
+ <-done
+ d.m.P2P().Close()
+ })
+ return d
+}
+
+func (d *device) config() config.Config {
+ d.mu.Lock()
+ defer d.mu.Unlock()
+ return d.cfg
+}
+
+func (d *device) id() string { return d.m.identity.DeviceID }
+
+func lanOnly() config.Config {
+ c := config.Default()
+ c.SignalingURL = ""
+ return c
+}
+
+func waitFor(t *testing.T, what string, cond func() bool) {
+ t.Helper()
+ deadline := time.Now().Add(15 * time.Second)
+ for !cond() {
+ if time.Now().After(deadline) {
+ t.Fatalf("等不到:%s", what)
+ }
+ time.Sleep(50 * time.Millisecond)
+ }
+}
+
+func waitLANUp(t *testing.T, ds ...*device) {
+ t.Helper()
+ for _, d := range ds {
+ waitFor(t, d.name+" 的局域网通道开启", d.m.LANEnabled)
+ }
+}
+
+// pairDevices 走一遍完整的配对:a 显示码,b 输入码(和地址),双方核对后确认。
+func pairDevices(t *testing.T, a, b *device, address string) {
+ t.Helper()
+ ctx := context.Background()
+ code, _, addrs, err := a.m.CreatePairingCode(ctx)
+ if err != nil {
+ t.Fatalf("生成配对码: %v", err)
+ }
+ if len(code) != 6 {
+ t.Fatalf("配对码格式不对: %q", code)
+ }
+ _ = addrs
+
+ peer, session, err := b.m.RedeemPairingCode(ctx, strings.ToLower(code), address)
+ if err != nil {
+ t.Fatalf("兑换配对码: %v", err)
+ }
+ if peer.GetId() != a.id() {
+ t.Fatalf("找到的不是 a: %v", peer)
+ }
+
+ var aSession string
+ select {
+ case aSession = <-a.sessions:
+ case <-time.After(5 * time.Second):
+ t.Fatal("显示码的一方没收到配对请求")
+ }
+ if err := a.m.ConfirmPairing(ctx, aSession, true); err != nil {
+ t.Fatal(err)
+ }
+ if err := b.m.ConfirmPairing(ctx, session, true); err != nil {
+ t.Fatal(err)
+ }
+}
+
+func waitDirect(t *testing.T, a, b *device) {
+ t.Helper()
+ waitFor(t, "P2P 直连", func() bool {
+ return a.m.P2P().State(b.id()) == p2p.StateDirect && b.m.P2P().State(a.id()) == p2p.StateDirect
+ })
+}
+
+func sendAndExpect(t *testing.T, from, to *device, clipID string) {
+ t.Helper()
+ msg := &pb.PeerMessage{Payload: &pb.PeerMessage_Fetch{Fetch: &pb.PeerFetch{ClipId: clipID}}}
+ if err := from.m.P2P().Send(to.id(), msg); err != nil {
+ t.Fatal(err)
+ }
+ deadline := time.After(5 * time.Second)
+ for {
+ select {
+ case got := <-to.messages:
+ if got.GetFetch().GetClipId() == clipID {
+ return
+ }
+ case <-deadline:
+ t.Fatalf("%s 没收到 %s 发的消息", to.name, from.name)
+ }
+ }
+}
+
+// 没有服务器:同一网络里的两台设备配对、直连、互发消息。
+func TestPairAndConnectWithoutServer(t *testing.T) {
+ net := lan.NewMemoryNetwork()
+ a, b := newDevice(t, "a", net, lanOnly()), newDevice(t, "b", net, lanOnly())
+ waitLANUp(t, a, b)
+
+ pairDevices(t, a, b, "")
+ waitDirect(t, a, b)
+ sendAndExpect(t, a, b, "clip-1")
+ sendAndExpect(t, b, a, "clip-2")
+
+ _, peers := a.m.Devices()
+ if len(peers) != 1 || !peers[0].GetOnline() {
+ t.Fatalf("配对后对方应当显示在线: %v", peers)
+ }
+
+ // 解除配对后连接要断开,对方也不再显示
+ if err := a.m.Unpair(context.Background(), b.id()); err != nil {
+ t.Fatal(err)
+ }
+ waitFor(t, "解除配对后断开连接", func() bool { return a.m.P2P().State(b.id()) == p2p.StateOffline })
+ if _, peers := a.m.Devices(); len(peers) != 0 {
+ t.Fatalf("解除配对后不该还有设备: %v", peers)
+ }
+}
+
+// 不在同一网段:mDNS 找不到对方,输入对方显示的地址配对;之后靠地址簿重新找到对方。
+func TestPairByAddressAcrossSubnets(t *testing.T) {
+ a := newDevice(t, "a", lan.NewMemoryNetwork(), lanOnly())
+ b := newDevice(t, "b", lan.NewMemoryNetwork(), lanOnly())
+ waitLANUp(t, a, b)
+
+ ctx := context.Background()
+ code, _, _, err := a.m.CreatePairingCode(ctx)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, _, err := b.m.RedeemPairingCode(ctx, code, ""); !errors.Is(err, lan.ErrNotFound) {
+ t.Fatalf("不输地址应当找不到,得到 %v", err)
+ }
+ // 上一次兑换没碰到 a,码还有效;这次带上地址
+ a.m.lan.ClosePairing()
+ addr := "127.0.0.1:" + strconv.Itoa(a.m.lan.Port())
+ pairDevices(t, a, b, addr)
+ waitDirect(t, a, b)
+ sendAndExpect(t, b, a, "clip-3")
+}
+
+// 关掉局域网,只用服务器:原来的配对路径不受影响。
+func TestServerOnlyPairingStillWorks(t *testing.T) {
+ srv := httptest.NewServer(signal.NewServer(signal.Options{}))
+ t.Cleanup(srv.Close)
+ cfg := config.Default()
+ cfg.SignalingURL = "ws" + strings.TrimPrefix(srv.URL, "http") + "/signal"
+ cfg.LANDisabled = true
+
+ a, b := newDevice(t, "a", nil, cfg), newDevice(t, "b", nil, cfg)
+ waitFor(t, "连上服务器", func() bool { return a.m.Connected() && b.m.Connected() })
+ if a.m.LANEnabled() {
+ t.Fatal("关掉局域网后不该开启局域网通道")
+ }
+
+ pairDevices(t, a, b, "")
+ waitFor(t, "P2P 连通", func() bool { return connected(a.m.P2P().State(b.id())) })
+ sendAndExpect(t, a, b, "clip-4")
+
+ // 服务器上不存在的码:立即报错,而不是干等
+ start := time.Now()
+ if _, _, err := b.m.RedeemPairingCode(context.Background(), "ZZZZZZ", ""); !errors.Is(err, ErrCodeRejected) {
+ t.Fatalf("错码应当被服务器拒绝,得到 %v", err)
+ }
+ if time.Since(start) > 5*time.Second {
+ t.Errorf("服务器拒绝后应当马上返回,花了 %v", time.Since(start))
+ }
+}
+
+// 局域网和服务器都开着:同一个码两边都开放,用掉一次就失效。
+func TestCodeUsableOnceAcrossChannels(t *testing.T) {
+ srv := httptest.NewServer(signal.NewServer(signal.Options{}))
+ t.Cleanup(srv.Close)
+ cfg := config.Default()
+ cfg.SignalingURL = "ws" + strings.TrimPrefix(srv.URL, "http") + "/signal"
+
+ net := lan.NewMemoryNetwork()
+ a, b, c := newDevice(t, "a", net, cfg), newDevice(t, "b", net, cfg), newDevice(t, "c", net, cfg)
+ waitFor(t, "连上服务器", func() bool { return a.m.Connected() && b.m.Connected() && c.m.Connected() })
+ waitLANUp(t, a, b, c)
+
+ ctx := context.Background()
+ code, _, _, err := a.m.CreatePairingCode(ctx)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, _, err := b.m.RedeemPairingCode(ctx, code, ""); err != nil {
+ t.Fatal(err)
+ }
+ <-a.sessions
+ // c 拿同一个码:局域网里已撤下,服务器那边的兑换也会被 a 忽略
+ _, _, _ = c.m.RedeemPairingCode(ctx, code, "")
+ select {
+ case s := <-a.sessions:
+ t.Fatalf("同一个码不该被用第二次,又收到配对请求 %s", s)
+ case <-time.After(time.Second):
+ }
+}
diff --git a/client-core/internal/rpc/convert.go b/client-core/internal/rpc/convert.go
index 9a32724..0c81732 100644
--- a/client-core/internal/rpc/convert.go
+++ b/client-core/internal/rpc/convert.go
@@ -55,6 +55,7 @@ func configToProto(c config.Config) *pb.Config {
SignalingUrl: c.SignalingURL,
OnlyOwnStun: c.OnlyOwnSTUN,
Language: c.Language,
+ LanDisabled: c.LANDisabled,
}
}
@@ -77,9 +78,6 @@ func configFromProto(in *pb.Config, base config.Config) config.Config {
if in.GetDeviceName() != "" {
c.DeviceName = in.GetDeviceName()
}
- if in.GetSignalingUrl() != "" {
- c.SignalingURL = in.GetSignalingUrl()
- }
// 布尔项没有"未设置"语义,UI 每次都会带全量值,直接覆盖
c.SyncText = in.GetSyncText()
c.SyncHTML = in.GetSyncHtml()
@@ -90,6 +88,9 @@ func configFromProto(in *pb.Config, base config.Config) config.Config {
c.OnlyOwnSTUN = in.GetOnlyOwnStun()
// 空字符串就是「跟随系统」,与「没设置」同义,直接覆盖
c.Language = in.GetLanguage()
+ // 服务器地址同理:空字符串就是不用服务器
+ c.SignalingURL = in.GetSignalingUrl()
+ c.LANDisabled = in.GetLanDisabled()
return c
}
diff --git a/client-core/internal/rpc/server.go b/client-core/internal/rpc/server.go
index 33e14e7..da77395 100644
--- a/client-core/internal/rpc/server.go
+++ b/client-core/internal/rpc/server.go
@@ -4,6 +4,7 @@ package rpc
import (
"context"
"crypto/subtle"
+ "errors"
"fmt"
"net"
"time"
@@ -15,7 +16,9 @@ import (
"github.com/baiyuze/copysync/client-core/internal/clipboard"
"github.com/baiyuze/copysync/client-core/internal/config"
+ "github.com/baiyuze/copysync/client-core/internal/peers"
"github.com/baiyuze/copysync/client-core/internal/store"
+ "github.com/baiyuze/copysync/client-core/internal/transport/lan"
pb "github.com/baiyuze/copysync/proto/gen/copysync/v1"
)
@@ -43,12 +46,18 @@ type Deps struct {
// Network 返回最近一轮网络出口探测的结果
Network func() *pb.NetworkInfo
Devices func() (self *pb.Device, peers []*pb.Device)
- CreatePairingCode func(ctx context.Context) (code string, expiresAt time.Time, err error)
- RedeemPairingCode func(ctx context.Context, code string) (*pb.Device, string, error)
+ CreatePairingCode func(ctx context.Context) (code string, expiresAt time.Time, lanAddrs []string, err error)
+ RedeemPairingCode func(ctx context.Context, code, address string) (*pb.Device, string, error)
ConfirmPairing func(ctx context.Context, session string, accept bool) error
Unpair func(ctx context.Context, deviceID string) error
+ SetDeviceAddress func(ctx context.Context, deviceID, address string) error
SignalingConnected func() bool
- CacheBytesUsed func() int64
+ ServerConfigured func() bool
+ LANEnabled func() bool
+ LANBlocked func() bool
+ // OpenLocalNetworkSettings 让系统放行局域网访问(macOS 打开设置面板,Windows 放行防火墙)
+ OpenLocalNetworkSettings func() error
+ CacheBytesUsed func() int64
}
type Server struct {
@@ -274,6 +283,15 @@ func (s *Server) GetStatus(context.Context, *pb.Empty) (*pb.Status, error) {
if s.deps.SignalingConnected != nil {
st.SignalingConnected = s.deps.SignalingConnected()
}
+ if s.deps.ServerConfigured != nil {
+ st.ServerConfigured = s.deps.ServerConfigured()
+ }
+ if s.deps.LANEnabled != nil {
+ st.LanEnabled = s.deps.LANEnabled()
+ }
+ if s.deps.LANBlocked != nil {
+ st.LanBlocked = s.deps.LANBlocked()
+ }
if s.deps.CacheBytesUsed != nil {
st.CacheBytesUsed = s.deps.CacheBytesUsed()
}
@@ -305,8 +323,49 @@ func (s *Server) RequestClipboardPermission(context.Context, *pb.Empty) (*pb.Emp
return &pb.Empty{}, nil
}
+func (s *Server) RequestLocalNetworkPermission(context.Context, *pb.Empty) (*pb.Empty, error) {
+ if s.deps.OpenLocalNetworkSettings == nil {
+ return nil, status.Error(codes.Unimplemented, "当前平台无需授权")
+ }
+ if err := s.deps.OpenLocalNetworkSettings(); err != nil {
+ if errors.Is(err, errors.ErrUnsupported) {
+ return nil, status.Error(codes.Unimplemented, "当前平台无需授权")
+ }
+ return nil, status.Errorf(codes.Internal, "放行局域网访问失败: %v", err)
+ }
+ return &pb.Empty{}, nil
+}
+
// ─────────────────────────── 设备与配对 ───────────────────────────
+// 配对出错时,消息以「原因: 说明」开头,界面按原因显示本地化的提示,
+// 不认识的原因再直接显示说明:
+//
+// not_found 局域网里没找到正在配对的设备,服务器也没连(界面会请用户输入对方地址)
+// wrong_code 配对码不对(或服务器那边码不存在、已过期,服务器不区分)
+// code_expired 配对码已失效,或输错次数太多
+// bad_address 输入的地址无法识别
+// no_channel 局域网发现已关闭,也没连服务器
+func pairingStatus(err error) error {
+ reason, code := "", codes.Internal
+ switch {
+ case errors.Is(err, lan.ErrNotFound):
+ reason, code = "not_found", codes.NotFound
+ case errors.Is(err, lan.ErrWrongCode), errors.Is(err, peers.ErrCodeRejected):
+ reason, code = "wrong_code", codes.InvalidArgument
+ case errors.Is(err, lan.ErrCodeClosed), errors.Is(err, lan.ErrTooManyAttempts):
+ reason, code = "code_expired", codes.FailedPrecondition
+ case errors.Is(err, lan.ErrBadAddress):
+ reason, code = "bad_address", codes.InvalidArgument
+ case errors.Is(err, peers.ErrNoChannel), errors.Is(err, lan.ErrDisabled):
+ reason, code = "no_channel", codes.FailedPrecondition
+ }
+ if reason == "" {
+ return status.Error(code, err.Error())
+ }
+ return status.Error(code, reason+": "+err.Error())
+}
+
func (s *Server) ListDevices(context.Context, *pb.Empty) (*pb.ListDevicesResponse, error) {
if s.deps.Devices == nil {
return nil, status.Error(codes.Unimplemented, "配对尚未接入(M1)")
@@ -320,11 +379,11 @@ func (s *Server) CreatePairingCode(ctx context.Context,
if s.deps.CreatePairingCode == nil {
return nil, status.Error(codes.Unimplemented, "配对尚未接入(M1)")
}
- code, exp, err := s.deps.CreatePairingCode(ctx)
+ code, exp, addrs, err := s.deps.CreatePairingCode(ctx)
if err != nil {
- return nil, status.Errorf(codes.Internal, "生成配对码: %v", err)
+ return nil, pairingStatus(err)
}
- return &pb.CreatePairingCodeResponse{Code: code, ExpiresAtUnix: exp.Unix()}, nil
+ return &pb.CreatePairingCodeResponse{Code: code, ExpiresAtUnix: exp.Unix(), LanAddresses: addrs}, nil
}
func (s *Server) RedeemPairingCode(ctx context.Context,
@@ -332,9 +391,9 @@ func (s *Server) RedeemPairingCode(ctx context.Context,
if s.deps.RedeemPairingCode == nil {
return nil, status.Error(codes.Unimplemented, "配对尚未接入(M1)")
}
- peer, session, err := s.deps.RedeemPairingCode(ctx, req.GetCode())
+ peer, session, err := s.deps.RedeemPairingCode(ctx, req.GetCode(), req.GetAddress())
if err != nil {
- return nil, status.Errorf(codes.InvalidArgument, "兑换配对码: %v", err)
+ return nil, pairingStatus(err)
}
return &pb.RedeemPairingCodeResponse{Peer: peer, PairingSession: session}, nil
}
@@ -358,3 +417,16 @@ func (s *Server) Unpair(ctx context.Context, req *pb.UnpairRequest) (*pb.Empty,
}
return &pb.Empty{}, nil
}
+
+func (s *Server) SetDeviceAddress(ctx context.Context, req *pb.SetDeviceAddressRequest) (*pb.Empty, error) {
+ if s.deps.SetDeviceAddress == nil {
+ return nil, status.Error(codes.Unimplemented, "当前版本不支持手动输入地址")
+ }
+ if err := s.deps.SetDeviceAddress(ctx, req.GetDeviceId(), req.GetAddress()); err != nil {
+ if errors.Is(err, peers.ErrNotPaired) {
+ return nil, status.Error(codes.NotFound, err.Error())
+ }
+ return nil, pairingStatus(err)
+ }
+ return &pb.Empty{}, nil
+}
diff --git a/client-core/internal/store/store.go b/client-core/internal/store/store.go
index fa5d0eb..1e9b8bf 100644
--- a/client-core/internal/store/store.go
+++ b/client-core/internal/store/store.go
@@ -174,6 +174,14 @@ CREATE TABLE IF NOT EXISTS devices (
paired_at INTEGER NOT NULL
);
+-- 已配对设备在局域网里用过的地址,跨网段与重启后重新找到对方靠它
+CREATE TABLE IF NOT EXISTS device_addrs (
+ device_id TEXT NOT NULL REFERENCES devices(id) ON DELETE CASCADE,
+ addr TEXT NOT NULL,
+ last_seen INTEGER NOT NULL,
+ PRIMARY KEY (device_id, addr)
+);
+
CREATE TABLE IF NOT EXISTS meta (
key TEXT PRIMARY KEY,
value TEXT NOT NULL
@@ -435,6 +443,51 @@ func (s *Store) DeleteDevice(id string) error {
return err
}
+// MaxDeviceAddrs 是每台设备最多记住的局域网地址数,多出来的按最久没见过的先删。
+const MaxDeviceAddrs = 8
+
+// PutDeviceAddr 记下某台已配对设备的一个局域网地址(ip:port)。
+// 设备必须已经存在,否则外键约束会拒绝。
+func (s *Store) PutDeviceAddr(deviceID, addr string, seen time.Time) error {
+ tx, err := s.db.Begin()
+ if err != nil {
+ return err
+ }
+ defer tx.Rollback()
+ if _, err := tx.Exec(`
+INSERT INTO device_addrs (device_id, addr, last_seen) VALUES (?,?,?)
+ON CONFLICT(device_id, addr) DO UPDATE SET last_seen=max(last_seen, excluded.last_seen)`,
+ deviceID, addr, seen.Unix()); err != nil {
+ return err
+ }
+ if _, err := tx.Exec(`
+DELETE FROM device_addrs WHERE device_id=? AND addr NOT IN (
+ SELECT addr FROM device_addrs WHERE device_id=? ORDER BY last_seen DESC, addr LIMIT ?)`,
+ deviceID, deviceID, MaxDeviceAddrs); err != nil {
+ return err
+ }
+ return tx.Commit()
+}
+
+// DeviceAddrs 返回某台设备记住的地址,最近见过的在前。
+func (s *Store) DeviceAddrs(deviceID string) ([]string, error) {
+ rows, err := s.db.Query(`
+SELECT addr FROM device_addrs WHERE device_id=? ORDER BY last_seen DESC, addr`, deviceID)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ var out []string
+ for rows.Next() {
+ var a string
+ if err := rows.Scan(&a); err != nil {
+ return nil, err
+ }
+ out = append(out, a)
+ }
+ return out, rows.Err()
+}
+
// ─────────────────────────── meta ───────────────────────────
func (s *Store) GetMeta(key string) (string, error) {
diff --git a/client-core/internal/store/store_test.go b/client-core/internal/store/store_test.go
index de6103c..541fa80 100644
--- a/client-core/internal/store/store_test.go
+++ b/client-core/internal/store/store_test.go
@@ -363,3 +363,48 @@ VALUES ('legacy', 2, 1, '<p>旧记录</p>', 1, 9999999999);`); err != nil {
s.Close()
}
}
+
+// 地址簿:按最近见过排序、超过上限时删最旧的、随设备一起删除。
+func TestDeviceAddrs(t *testing.T) {
+ s := openTest(t)
+ if err := s.PutDevice(Device{ID: "dev-1", PublicKey: []byte("k"), PairedAt: time.Now()}); err != nil {
+ t.Fatal(err)
+ }
+ base := time.Unix(1_700_000_000, 0)
+ for i := 0; i < MaxDeviceAddrs+2; i++ {
+ addr := "192.168.1." + string(rune('a'+i)) + ":8788"
+ if err := s.PutDeviceAddr("dev-1", addr, base.Add(time.Duration(i)*time.Minute)); err != nil {
+ t.Fatal(err)
+ }
+ }
+ // 再见到一个老地址,它应当排到最前面
+ if err := s.PutDeviceAddr("dev-1", "192.168.1.c:8788", base.Add(time.Hour)); err != nil {
+ t.Fatal(err)
+ }
+ got, err := s.DeviceAddrs("dev-1")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(got) != MaxDeviceAddrs {
+ t.Fatalf("应当只留 %d 个,得到 %d: %v", MaxDeviceAddrs, len(got), got)
+ }
+ if got[0] != "192.168.1.c:8788" {
+ t.Errorf("最近见过的应排第一,得到 %v", got)
+ }
+ for _, a := range got {
+ if a == "192.168.1.a:8788" || a == "192.168.1.b:8788" {
+ t.Errorf("最旧的地址应当被删掉,仍有 %s", a)
+ }
+ }
+
+ if err := s.PutDeviceAddr("unknown", "10.0.0.1:8788", base); err == nil {
+ t.Error("未配对设备的地址不该能写入")
+ }
+
+ if err := s.DeleteDevice("dev-1"); err != nil {
+ t.Fatal(err)
+ }
+ if got, _ := s.DeviceAddrs("dev-1"); len(got) != 0 {
+ t.Errorf("删除设备后地址应一并删除,仍有 %v", got)
+ }
+}
diff --git a/client-core/internal/transport/lan/addrs.go b/client-core/internal/transport/lan/addrs.go
new file mode 100644
index 0000000..965fcb4
--- /dev/null
+++ b/client-core/internal/transport/lan/addrs.go
@@ -0,0 +1,206 @@
+package lan
+
+import (
+ "context"
+ "crypto/sha256"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "net"
+ "net/netip"
+ "runtime"
+ "sort"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// cgnat 是运营商级 NAT 的地址段,Tailscale 的 100.x 地址也在这里面。
+var cgnat = netip.MustParsePrefix("100.64.0.0/10")
+
+// usableAddr 判断一个本机地址能不能给对端用:只要局域网私有地址和 Tailscale 地址。
+func usableAddr(ip netip.Addr) bool {
+ return ip.Is4() && (ip.IsPrivate() || cgnat.Contains(ip))
+}
+
+// skippedAdapter 判断一块网卡是否不该拿来给对端连:WSL、Hyper-V、Docker 的虚拟网卡
+// 只通本机里的虚拟机,地址还每次开机都变。
+func skippedAdapter(name string) bool {
+ if runtime.GOOS == "windows" {
+ return strings.HasPrefix(name, "vEthernet")
+ }
+ return strings.HasPrefix(name, "docker") || strings.HasPrefix(name, "br-") || strings.HasPrefix(name, "veth")
+}
+
+// LocalAddrs 返回本机可供对端连接的 IPv4 地址:默认路由所在的网卡排第一,
+// 然后是 Tailscale 地址,最后是其他网卡。
+func LocalAddrs() []netip.Addr {
+ ifaces, err := net.Interfaces()
+ if err != nil {
+ return nil
+ }
+ var out []netip.Addr
+ for _, ifc := range ifaces {
+ if ifc.Flags&net.FlagUp == 0 || ifc.Flags&net.FlagLoopback != 0 || skippedAdapter(ifc.Name) {
+ continue
+ }
+ list, err := ifc.Addrs()
+ if err != nil {
+ continue
+ }
+ for _, a := range list {
+ ipn, ok := a.(*net.IPNet)
+ if !ok {
+ continue
+ }
+ ip, ok := netip.AddrFromSlice(ipn.IP)
+ if ok && usableAddr(ip.Unmap()) {
+ out = append(out, ip.Unmap())
+ }
+ }
+ }
+ primary, _ := defaultRouteIP()
+ rank := func(ip netip.Addr) int {
+ switch {
+ case ip == primary:
+ return 0
+ case cgnat.Contains(ip):
+ return 1
+ }
+ return 2
+ }
+ sort.SliceStable(out, func(i, j int) bool { return rank(out[i]) < rank(out[j]) })
+ return dedupeAddrs(out)
+}
+
+// defaultRouteIP 返回默认路由所用的本机地址。UDP 的「连接」只查路由表,不会发包。
+func defaultRouteIP() (netip.Addr, bool) {
+ c, err := net.Dial("udp4", "192.0.2.1:9") // 文档保留地址,不会真的有人收
+ if err != nil {
+ return netip.Addr{}, false
+ }
+ defer c.Close()
+ ap, err := netip.ParseAddrPort(c.LocalAddr().String())
+ if err != nil || !usableAddr(ap.Addr()) {
+ return netip.Addr{}, false
+ }
+ return ap.Addr(), true
+}
+
+// localNetworks 返回本机各网卡直连的网段。
+func localNetworks() []netip.Prefix {
+ ifaces, err := net.Interfaces()
+ if err != nil {
+ return nil
+ }
+ var out []netip.Prefix
+ for _, ifc := range ifaces {
+ if ifc.Flags&net.FlagUp == 0 || ifc.Flags&net.FlagLoopback != 0 {
+ continue
+ }
+ list, _ := ifc.Addrs()
+ for _, a := range list {
+ if ipn, ok := a.(*net.IPNet); ok && ipn.IP.To4() != nil {
+ ones, _ := ipn.Mask.Size()
+ ip, _ := netip.AddrFromSlice(ipn.IP.To4())
+ out = append(out, netip.PrefixFrom(ip, ones).Masked())
+ }
+ }
+ }
+ return out
+}
+
+// onLink 判断地址是否在本机直连的网段里(不经路由器就能到)。
+func onLink(ip netip.Addr) bool {
+ for _, p := range localNetworks() {
+ if p.Contains(ip) {
+ return true
+ }
+ }
+ return false
+}
+
+// networkKey 标识本机当前所在的网络:网卡地址变了,就要重启发现、重新打招呼。
+func networkKey() string {
+ var parts []string
+ for _, ip := range LocalAddrs() {
+ parts = append(parts, ip.String())
+ }
+ sort.Strings(parts)
+ return strings.Join(parts, ",")
+}
+
+// DisplayAddr 把地址写成给人看的形式:端口是默认值时省略端口。
+func DisplayAddr(ap netip.AddrPort) string {
+ if ap.Port() == DefaultPort {
+ return ap.Addr().String()
+ }
+ return ap.String()
+}
+
+// ErrBadAddress 表示用户输入的地址无法识别。
+var ErrBadAddress = errors.New("地址格式不对")
+
+// ResolveAddress 把用户输入的地址解析成 ip:port。可以是 ip、ip:port 或主机名
+// (如 Tailscale 的 MagicDNS 名字),没写端口时用默认端口。
+func ResolveAddress(ctx context.Context, s string) ([]netip.AddrPort, error) {
+ s = strings.TrimSpace(s)
+ if s == "" {
+ return nil, ErrBadAddress
+ }
+ host, port := s, DefaultPort
+ if h, p, err := net.SplitHostPort(s); err == nil {
+ n, err := strconv.Atoi(p)
+ if err != nil || n <= 0 || n > 65535 {
+ return nil, ErrBadAddress
+ }
+ host, port = h, n
+ }
+ if ip, err := netip.ParseAddr(host); err == nil {
+ if !ip.Unmap().Is4() {
+ return nil, fmt.Errorf("%w:只支持 IPv4", ErrBadAddress)
+ }
+ return []netip.AddrPort{netip.AddrPortFrom(ip.Unmap(), uint16(port))}, nil
+ }
+ ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
+ defer cancel()
+ ips, err := net.DefaultResolver.LookupNetIP(ctx, "ip4", host)
+ if err != nil || len(ips) == 0 {
+ return nil, fmt.Errorf("%w:解析 %s 失败", ErrBadAddress, host)
+ }
+ out := make([]netip.AddrPort, 0, len(ips))
+ for _, ip := range ips {
+ out = append(out, netip.AddrPortFrom(ip.Unmap(), uint16(port)))
+ }
+ return out, nil
+}
+
+// presenceToken 是设备在某一天(UTC)广播的令牌。
+//
+// 广播里不放设备名和 ID:同一网络里的其他人看到的只是一串每天都变的字符。
+// 已配对的设备知道对方的 ID,自己算一遍就能认出来。
+func presenceToken(deviceID string, day time.Time) string {
+ sum := sha256.Sum256([]byte("copysync-lan|" + deviceID + "|" + day.UTC().Format("2006-01-02")))
+ return hex.EncodeToString(sum[:8])
+}
+
+func dedupeAddrs(in []netip.Addr) []netip.Addr {
+ seen := make(map[netip.Addr]bool, len(in))
+ out := in[:0]
+ for _, a := range in {
+ if !seen[a] {
+ seen[a] = true
+ out = append(out, a)
+ }
+ }
+ return out
+}
+
+func sortedKeys(m map[string]string) []string {
+ keys := make([]string, 0, len(m))
+ for k := range m {
+ keys = append(keys, k)
+ }
+ sort.Strings(keys)
+ return keys
+}
diff --git a/client-core/internal/transport/lan/discovery.go b/client-core/internal/transport/lan/discovery.go
new file mode 100644
index 0000000..fd8d88d
--- /dev/null
+++ b/client-core/internal/transport/lan/discovery.go
@@ -0,0 +1,105 @@
+package lan
+
+import (
+ "context"
+ "net/netip"
+ "sync"
+)
+
+// ServiceType 是 CopySync 在 mDNS(DNS-SD)里用的服务类型。
+const ServiceType = "_copysync._udp"
+
+// Instance 是在局域网里发现的一个 CopySync 实例。
+type Instance struct {
+ Name string
+ Addr netip.AddrPort
+ Text map[string]string
+}
+
+// Discovery 负责在局域网里广播本机、发现其他实例。
+//
+// 默认实现是 mDNS(见 mdns.go);测试和 natlab 用 MemoryNetwork。
+type Discovery interface {
+ // Start 开始广播本机并浏览其他实例。found 对每个发现或更新的实例调用,
+ // 同一个实例可能反复出现,由调用方去重;不会对本机自己调用。
+ Start(ctx context.Context, name string, port int, text map[string]string, found func(Instance)) error
+ // Update 更换本机广播的 TXT 记录。
+ Update(text map[string]string) error
+ Stop()
+}
+
+// MemoryNetwork 是进程内的「局域网」,供测试使用:
+// 在同一个 MemoryNetwork 上 Start 的实例互相可见,地址都是 127.0.0.1。
+type MemoryNetwork struct {
+ mu sync.Mutex
+ members map[*memoryDiscovery]bool
+}
+
+func NewMemoryNetwork() *MemoryNetwork {
+ return &MemoryNetwork{members: make(map[*memoryDiscovery]bool)}
+}
+
+// Discovery 返回一个挂在这个网络上的 Discovery。
+func (n *MemoryNetwork) Discovery() Discovery { return &memoryDiscovery{net: n} }
+
+type memoryDiscovery struct {
+ net *MemoryNetwork
+ self Instance
+ found func(Instance)
+}
+
+func (d *memoryDiscovery) Start(_ context.Context, name string, port int, text map[string]string, found func(Instance)) error {
+ d.net.mu.Lock()
+ d.self = Instance{
+ Name: name,
+ Addr: netip.AddrPortFrom(netip.MustParseAddr("127.0.0.1"), uint16(port)),
+ Text: copyText(text),
+ }
+ d.found = found
+ d.net.members[d] = true
+ others := d.othersLocked()
+ d.net.mu.Unlock()
+
+ for _, o := range others {
+ found(o.self)
+ o.found(d.self)
+ }
+ return nil
+}
+
+func (d *memoryDiscovery) Update(text map[string]string) error {
+ d.net.mu.Lock()
+ d.self.Text = copyText(text)
+ self := d.self
+ others := d.othersLocked()
+ d.net.mu.Unlock()
+
+ for _, o := range others {
+ o.found(self)
+ }
+ return nil
+}
+
+func (d *memoryDiscovery) Stop() {
+ d.net.mu.Lock()
+ delete(d.net.members, d)
+ d.net.mu.Unlock()
+}
+
+func (d *memoryDiscovery) othersLocked() []*memoryDiscovery {
+ var out []*memoryDiscovery
+ for m := range d.net.members {
+ if m != d {
+ out = append(out, m)
+ }
+ }
+ return out
+}
+
+func copyText(text map[string]string) map[string]string {
+ out := make(map[string]string, len(text))
+ for k, v := range text {
+ out[k] = v
+ }
+ return out
+}
diff --git a/client-core/internal/transport/lan/lan.go b/client-core/internal/transport/lan/lan.go
new file mode 100644
index 0000000..b5cab20
--- /dev/null
+++ b/client-core/internal/transport/lan/lan.go
@@ -0,0 +1,925 @@
+// Package lan 让同一局域网里的设备不经服务器,直接互相发现、配对、交换信令。
+//
+// 做法:
+// - 每台设备在固定的 UDP 端口(默认 8788)上收发 LanPacket,并用 mDNS 广播自己。
+// 广播里只有一个每天都变的令牌,已配对的设备能认出来,别人认不出。
+// - 对每台已配对但还没连通的设备,定期往它可能在的地址发签名的 hello;收到的一方回一条。
+// 两边都在发,有状态的防火墙(Windows)会把对方的包当作回包放行,所以不需要入站规则。
+// - 收到对方的有效消息,就记下来源地址:之后的信令发往那里,地址也存进地址簿,
+// 跨网段或重启之后靠它重新找到对方。
+//
+// 信令仍是 transport/signed 签名的 Signed,信任模型与经服务器转发时完全一样。
+package lan
+
+import (
+ "context"
+ cryptorand "crypto/rand"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "log/slog"
+ "net"
+ "net/netip"
+ "sync"
+ "time"
+
+ "google.golang.org/protobuf/proto"
+
+ "github.com/baiyuze/copysync/client-core/internal/identity"
+ "github.com/baiyuze/copysync/client-core/internal/transport/signed"
+ pb "github.com/baiyuze/copysync/proto/gen/copysync/v1"
+)
+
+const (
+ // DefaultPort 是局域网信令的 UDP 端口。被占用时(同一台电脑上两个用户都登录着)改用随机端口,
+ // 端口号随 mDNS 广播和 hello 里的地址告诉对方。
+ DefaultPort = 8788
+
+ magic = "CSL1"
+ maxPacket = 16 << 10
+
+ helloInterval = 10 * time.Second // 对方还没连通时
+ keepaliveInterval = 30 * time.Second // 已连通时只需低频保活
+ tickInterval = 2 * time.Second
+ maxCandidates = 12
+ resendDelay = 150 * time.Millisecond // 信令补发一次,抵消 UDP 偶尔丢包
+ perIPLimit = 200 // 每个来源每秒最多处理的包数
+ blockedFor = 5 * time.Minute
+ instanceTTL = 5 * time.Minute
+ saveAddrEvery = 10 * time.Minute
+)
+
+var (
+ ErrDisabled = errors.New("局域网发现已关闭")
+ ErrUnreachable = errors.New("对方不在局域网里")
+)
+
+// PeerInfo 是配对时从对方那里拿到的信息。
+type PeerInfo struct {
+ ID string
+ Name string
+ Platform string
+ PublicKey []byte
+ // Addrs 是对方自报的地址加上实际收到回复的地址,确认配对后写进地址簿
+ Addrs []string
+}
+
+// AddrBook 持久化已配对设备的地址,由 store.Store 实现。
+type AddrBook interface {
+ DeviceAddrs(deviceID string) ([]string, error)
+ PutDeviceAddr(deviceID, addr string, seen time.Time) error
+}
+
+type Options struct {
+ Identity *identity.Identity
+ Logger *slog.Logger
+ // Port 为 0 用 DefaultPort(被占用时退回随机端口),小于 0 直接用随机端口(测试用)
+ Port int
+ Discovery Discovery // 为空时用 mDNS
+ Verifier *signed.Verifier
+ Book AddrBook
+
+ // Peers 返回要在局域网里找的已配对设备
+ Peers func() []string
+ // Connected 报告与某台设备的 P2P 连接是否已建立:已连通的设备只低频保活
+ Connected func(deviceID string) bool
+ DeviceInfo func() (name, platform string)
+
+ // OnSignal 收到已验签的信令(hello 除外)
+ OnSignal func(from string, msg *pb.SignalMessage)
+ // OnReachable 某台设备在局域网里变得可达或不可达
+ OnReachable func(deviceID string, reachable bool)
+ // AcceptPair 在有人用正确的配对码发来请求时调用。返回 false 表示这个码已经在别处
+ // (服务器那边)用掉了,请求会被拒绝。
+ AcceptPair func(peer PeerInfo) bool
+ // OnChange 在开关、系统拦截状态变化时调用,用来刷新界面上的状态
+ OnChange func()
+}
+
+type peerState struct {
+ addr netip.AddrPort // 最近一次收到对方有效消息的来源
+ lastSeen time.Time
+ ttl time.Duration
+ reachable bool
+
+ reported []netip.AddrPort // 对方 hello 里自报的地址
+ discovered map[netip.AddrPort]time.Time // mDNS 发现的地址
+ book []netip.AddrPort // 地址簿里存的地址
+ bookLoaded bool
+
+ nextHello time.Time
+ lastReply time.Time
+ savedAddr netip.AddrPort
+ savedAt time.Time
+}
+
+type seenInstance struct {
+ inst Instance
+ seen time.Time
+}
+
+type Transport struct {
+ opts Options
+ log *slog.Logger
+ id *identity.Identity
+ discovery Discovery
+ instance string
+
+ mu sync.Mutex
+ running bool
+ conn *net.UDPConn
+ port int
+ cancel context.CancelFunc
+ peers map[string]*peerState
+ instances map[string]seenInstance
+ tokens map[string]string // 令牌 → 已配对设备
+ tokensDay string
+ selfAddrs []string
+ netKey string
+ blockedAt time.Time
+ rate map[netip.Addr]int
+ rateAt time.Time
+
+ pairing *pairingState
+ responses map[string]cachedResponse
+ waiters map[string]*pairWaiter
+
+ // reach 是各设备可达状态的副本,由叶子锁保护:peers 层会在持有自己的锁时查询它,
+ // 不能让它去等 t.mu(t.mu 持有期间可能回调 peers 层)
+ reachMu sync.RWMutex
+ reach map[string]bool
+}
+
+func New(opts Options) *Transport {
+ log := opts.Logger
+ if log == nil {
+ log = slog.Default()
+ }
+ d := opts.Discovery
+ if d == nil {
+ d = NewMDNS()
+ }
+ suffix := make([]byte, 6)
+ _, _ = cryptorand.Read(suffix)
+ return &Transport{
+ opts: opts,
+ log: log.With("模块", "局域网"),
+ id: opts.Identity,
+ discovery: d,
+ // 实例名每次启动随机,不带设备名:同一网络里的其他人看不出这是谁的电脑
+ instance: "copysync-" + hex.EncodeToString(suffix),
+ peers: make(map[string]*peerState),
+ instances: make(map[string]seenInstance),
+ tokens: make(map[string]string),
+ rate: make(map[netip.Addr]int),
+ responses: make(map[string]cachedResponse),
+ waiters: make(map[string]*pairWaiter),
+ reach: make(map[string]bool),
+ }
+}
+
+// Start 开始在局域网里收发。已经在运行时什么也不做。
+func (t *Transport) Start() error {
+ peers := t.peerIDs()
+ t.mu.Lock()
+ if t.running {
+ t.mu.Unlock()
+ return nil
+ }
+ conn, err := t.listen()
+ if err != nil {
+ t.mu.Unlock()
+ return err
+ }
+ ctx, cancel := context.WithCancel(context.Background())
+ t.conn, t.cancel, t.running = conn, cancel, true
+ t.port = conn.LocalAddr().(*net.UDPAddr).Port
+ t.netKey = networkKey()
+ t.refreshSelfLocked()
+ t.rebuildTokensLocked(time.Now(), peers)
+ t.mu.Unlock()
+
+ t.startDiscovery(ctx)
+ go t.readLoop(conn)
+ go t.tickLoop(ctx)
+ t.log.Info("局域网直连已开启", "端口", t.Port())
+ t.changed()
+ return nil
+}
+
+func (t *Transport) listen() (*net.UDPConn, error) {
+ port := t.opts.Port
+ if port == 0 {
+ port = DefaultPort
+ }
+ if port > 0 {
+ if conn, err := net.ListenUDP("udp4", &net.UDPAddr{Port: port}); err == nil {
+ return conn, nil
+ } else {
+ t.log.Warn("局域网端口被占用,改用随机端口", "端口", port, "err", err)
+ }
+ }
+ conn, err := net.ListenUDP("udp4", &net.UDPAddr{})
+ if err != nil {
+ return nil, fmt.Errorf("监听局域网端口: %w", err)
+ }
+ return conn, nil
+}
+
+// Stop 停止收发。所有对端都变为不可达。
+func (t *Transport) Stop() {
+ t.mu.Lock()
+ if !t.running {
+ t.mu.Unlock()
+ return
+ }
+ t.running = false
+ t.cancel()
+ _ = t.conn.Close()
+ var lost []string
+ for id, st := range t.peers {
+ if st.reachable {
+ t.setReachableLocked(id, st, false)
+ lost = append(lost, id)
+ }
+ }
+ t.instances = make(map[string]seenInstance)
+ t.pairing = nil
+ t.mu.Unlock()
+
+ t.discovery.Stop()
+ for _, id := range lost {
+ t.reachable(id, false)
+ }
+ t.log.Info("局域网直连已关闭")
+ t.changed()
+}
+
+func (t *Transport) Running() bool {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ return t.running
+}
+
+// Port 返回实际监听的端口,没在运行时为 0。
+func (t *Transport) Port() int {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ if !t.running {
+ return 0
+ }
+ return t.port
+}
+
+// Blocked 报告系统是不是拦下了本机发往局域网的包(macOS 的本地网络权限)。
+func (t *Transport) Blocked() bool {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ return t.running && !t.blockedAt.IsZero() && time.Since(t.blockedAt) < blockedFor
+}
+
+// Reachable 报告某台设备当前能否在局域网里收到本机的信令。
+// 可以在持有其他锁时调用。
+func (t *Transport) Reachable(deviceID string) bool {
+ t.reachMu.RLock()
+ defer t.reachMu.RUnlock()
+ return t.reach[deviceID]
+}
+
+// Send 把一条已签名的信令发到对方最近所在的地址。
+func (t *Transport) Send(to string, s *pb.Signed) error {
+ t.mu.Lock()
+ st := t.peers[to]
+ if !t.running || st == nil || !st.reachable {
+ t.mu.Unlock()
+ return ErrUnreachable
+ }
+ dst := st.addr
+ t.mu.Unlock()
+
+ pkt, err := encode(&pb.LanPacket{Payload: &pb.LanPacket_Signal{Signal: s}})
+ if err != nil {
+ return err
+ }
+ err = t.write(dst, pkt)
+ time.AfterFunc(resendDelay, func() { _ = t.write(dst, pkt) })
+ return err
+}
+
+// DisplayAddrs 返回给用户看的本机地址:不在同一网段时,另一台要输入其中一个。
+func (t *Transport) DisplayAddrs() []string {
+ port := t.Port()
+ if port == 0 {
+ return nil
+ }
+ var out []string
+ for _, ip := range LocalAddrs() {
+ out = append(out, DisplayAddr(netip.AddrPortFrom(ip, uint16(port))))
+ if len(out) == 3 {
+ break
+ }
+ }
+ return out
+}
+
+// PeersChanged 在配对关系变化后调用:重算令牌,马上向新设备打招呼。
+func (t *Transport) PeersChanged() {
+ peers := t.peerIDs()
+ t.mu.Lock()
+ t.rebuildTokensLocked(time.Now(), peers)
+ for _, st := range t.peers {
+ st.bookLoaded = false
+ st.nextHello = time.Time{}
+ }
+ t.mu.Unlock()
+ t.tick()
+}
+
+// Remember 把地址写进某台设备的地址簿(配对确认后调用)。
+func (t *Transport) Remember(deviceID string, addrs []string) {
+ now := time.Now()
+ for _, a := range addrs {
+ ap, err := netip.ParseAddrPort(a)
+ if err != nil || !ap.Addr().Is4() {
+ continue
+ }
+ if t.opts.Book != nil {
+ if err := t.opts.Book.PutDeviceAddr(deviceID, ap.String(), now); err != nil {
+ t.log.Debug("保存地址失败", "device", deviceID, "addr", ap, "err", err)
+ }
+ }
+ }
+ t.mu.Lock()
+ st := t.peerLocked(deviceID)
+ st.bookLoaded = false
+ st.nextHello = time.Time{}
+ t.mu.Unlock()
+}
+
+// SetPeerAddr 记下用户手动输入的地址,并立即往那里打招呼。
+func (t *Transport) SetPeerAddr(ctx context.Context, deviceID, addr string) error {
+ aps, err := ResolveAddress(ctx, addr)
+ if err != nil {
+ return err
+ }
+ var list []string
+ for _, ap := range aps {
+ list = append(list, ap.String())
+ }
+ t.Remember(deviceID, list)
+ t.sendHello(deviceID, aps, true, helloInterval)
+ return nil
+}
+
+// Forget 在解除配对后丢掉这台设备的状态(地址簿随设备记录一起由 store 删除)。
+func (t *Transport) Forget(deviceID string) {
+ peers := t.peerIDs()
+ t.mu.Lock()
+ if st := t.peers[deviceID]; st != nil {
+ t.setReachableLocked(deviceID, st, false)
+ }
+ delete(t.peers, deviceID)
+ t.rebuildTokensLocked(time.Now(), peers)
+ t.mu.Unlock()
+}
+
+// PeerStatus 是某台已配对设备在局域网里的状态,供诊断展示。
+type PeerStatus struct {
+ ID string
+ Reachable bool
+ Addr string // 最近一次收到对方消息的地址
+ Known []string
+ LastSeen time.Time
+}
+
+// Info 是局域网直连的诊断信息,见 copysync-cli nat。
+type Info struct {
+ Running bool
+ Port int
+ LocalAddrs []string
+ Discovered int // mDNS 发现的实例数,含未配对的
+ Blocked bool
+ Peers []PeerStatus
+}
+
+func (t *Transport) Info() Info {
+ peers := t.peerIDs()
+ blocked := t.Blocked()
+ t.mu.Lock()
+ info := Info{
+ Running: t.running,
+ Port: t.port,
+ LocalAddrs: append([]string(nil), t.selfAddrs...),
+ Discovered: len(t.instances),
+ Blocked: blocked,
+ }
+ if !t.running {
+ info.Port = 0
+ }
+ for _, id := range peers {
+ ps := PeerStatus{ID: id}
+ if st := t.peers[id]; st != nil {
+ ps.Reachable = st.reachable
+ ps.LastSeen = st.lastSeen
+ if st.addr.IsValid() {
+ ps.Addr = st.addr.String()
+ }
+ }
+ info.Peers = append(info.Peers, ps)
+ }
+ t.mu.Unlock()
+
+ if t.opts.Book != nil {
+ for i := range info.Peers {
+ info.Peers[i].Known, _ = t.opts.Book.DeviceAddrs(info.Peers[i].ID)
+ }
+ }
+ return info
+}
+
+// ─────────────────────────── 接收 ───────────────────────────
+
+func (t *Transport) readLoop(conn *net.UDPConn) {
+ buf := make([]byte, 64<<10)
+ for {
+ n, src, err := conn.ReadFromUDPAddrPort(buf)
+ if err != nil {
+ if errors.Is(err, net.ErrClosed) {
+ return
+ }
+ // Windows 上对端端口不可达时,下一次读会收到 ICMP 引起的错误,忽略即可
+ continue
+ }
+ src = netip.AddrPortFrom(src.Addr().Unmap(), src.Port())
+ if n < len(magic) || n > maxPacket || string(buf[:len(magic)]) != magic || !t.allow(src.Addr()) {
+ continue
+ }
+ var pkt pb.LanPacket
+ if err := proto.Unmarshal(buf[len(magic):n], &pkt); err != nil {
+ continue
+ }
+ t.handle(&pkt, src)
+ }
+}
+
+// allow 按来源限速,挡住同一网络里的刷包。
+func (t *Transport) allow(ip netip.Addr) bool {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ now := time.Now()
+ if now.Sub(t.rateAt) >= time.Second {
+ t.rateAt = now
+ clear(t.rate)
+ }
+ t.rate[ip]++
+ return t.rate[ip] <= perIPLimit
+}
+
+func (t *Transport) handle(pkt *pb.LanPacket, src netip.AddrPort) {
+ switch p := pkt.GetPayload().(type) {
+ case *pb.LanPacket_Signal:
+ from, msg, err := t.opts.Verifier.Verify(p.Signal)
+ switch {
+ case errors.Is(err, signed.ErrReplay), errors.Is(err, signed.ErrUnknownSender):
+ // 重复的包(同时发往对方的几个地址)、或是解除配对后对方还在打招呼:都正常
+ return
+ case err != nil:
+ t.log.Debug("丢弃局域网信令", "from", from, "src", src, "原因", err)
+ return
+ }
+ hello := msg.GetLanHello()
+ t.sawPeer(from, src, hello)
+ if hello != nil {
+ t.answerHello(from, src, hello)
+ return
+ }
+ if t.opts.OnSignal != nil {
+ t.opts.OnSignal(from, msg)
+ }
+
+ case *pb.LanPacket_PairRequest:
+ t.handlePairRequest(p.PairRequest, src)
+ case *pb.LanPacket_PairResponse:
+ t.handlePairResponse(p.PairResponse, src)
+ case *pb.LanPacket_PairReject:
+ t.handlePairReject(p.PairReject)
+ }
+}
+
+// sawPeer 记下某台设备的一条有效消息:它在 src,此刻可达。
+func (t *Transport) sawPeer(id string, src netip.AddrPort, hello *pb.LanHello) {
+ now := time.Now()
+ t.mu.Lock()
+ if !t.running {
+ t.mu.Unlock()
+ return
+ }
+ st := t.peerLocked(id)
+ st.addr, st.lastSeen = src, now
+ if hello != nil {
+ st.ttl = ttlFor(hello.GetIntervalSeconds())
+ st.reported = parseAddrs(hello.GetAddresses())
+ } else if st.ttl == 0 {
+ st.ttl = ttlFor(0)
+ }
+ became := !st.reachable
+ t.setReachableLocked(id, st, true)
+ save := src != st.savedAddr || now.Sub(st.savedAt) > saveAddrEvery
+ if save {
+ st.savedAddr, st.savedAt = src, now
+ }
+ t.mu.Unlock()
+
+ if save && t.opts.Book != nil {
+ // 正在配对、尚未确认的设备还没落库,这里会因外键失败,确认时再存
+ _ = t.opts.Book.PutDeviceAddr(id, src.String(), now)
+ }
+ if became {
+ t.log.Info("局域网里找到了设备", "device", id, "地址", src)
+ t.reachable(id, true)
+ }
+}
+
+func (t *Transport) answerHello(from string, src netip.AddrPort, hello *pb.LanHello) {
+ if !hello.GetReplyWanted() {
+ return
+ }
+ t.mu.Lock()
+ st := t.peerLocked(from)
+ // 对方往几个地址各发了一份时只回一次
+ if time.Since(st.lastReply) < time.Second {
+ t.mu.Unlock()
+ return
+ }
+ st.lastReply = time.Now()
+ t.mu.Unlock()
+ t.sendHello(from, []netip.AddrPort{src}, false, t.intervalFor(from))
+}
+
+func ttlFor(intervalSeconds uint32) time.Duration {
+ if intervalSeconds == 0 {
+ intervalSeconds = uint32(helloInterval / time.Second)
+ }
+ return 3*time.Duration(intervalSeconds)*time.Second + 5*time.Second
+}
+
+// ─────────────────────────── 定时任务 ───────────────────────────
+
+func (t *Transport) tickLoop(ctx context.Context) {
+ tk := time.NewTicker(tickInterval)
+ defer tk.Stop()
+ t.tick()
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ case <-tk.C:
+ t.tick()
+ }
+ }
+}
+
+// tick 处理到期的事:网络变化、令牌换天、可达状态过期、该打招呼的设备。
+func (t *Transport) tick() {
+ now := time.Now()
+ peers := t.peerIDs()
+ // 回调 P2P 层要在锁外:它发信令时会反过来调用 Send
+ intervals := make(map[string]time.Duration, len(peers))
+ for _, id := range peers {
+ intervals[id] = t.intervalFor(id)
+ }
+
+ t.mu.Lock()
+ if !t.running {
+ t.mu.Unlock()
+ return
+ }
+ netChanged := false
+ if k := networkKey(); k != t.netKey {
+ t.netKey = k
+ netChanged = true
+ t.refreshSelfLocked()
+ }
+ dayChanged := now.UTC().Format("2006-01-02") != t.tokensDay
+ if dayChanged {
+ t.rebuildTokensLocked(now, peers)
+ }
+ pairingExpired := t.pairing != nil && now.After(t.pairing.expires)
+ if pairingExpired {
+ t.pairing = nil
+ }
+ for k, r := range t.responses {
+ if now.Sub(r.at) > 2*time.Minute {
+ delete(t.responses, k)
+ }
+ }
+ for k, si := range t.instances {
+ if now.Sub(si.seen) > instanceTTL {
+ delete(t.instances, k)
+ }
+ }
+
+ var lost []string
+ for id, st := range t.peers {
+ if st.reachable && now.Sub(st.lastSeen) > st.ttl {
+ t.setReachableLocked(id, st, false)
+ lost = append(lost, id)
+ }
+ }
+
+ type due struct {
+ id string
+ targets []netip.AddrPort
+ interval time.Duration
+ }
+ var hellos []due
+ for _, id := range peers {
+ st := t.peerLocked(id)
+ if netChanged {
+ st.nextHello = time.Time{}
+ }
+ if now.Before(st.nextHello) {
+ continue
+ }
+ interval := intervals[id]
+ st.nextHello = now.Add(interval)
+ if targets := t.candidatesLocked(id, st, now); len(targets) > 0 {
+ hellos = append(hellos, due{id, targets, interval})
+ }
+ }
+ ctx := context.Background()
+ t.mu.Unlock()
+
+ for _, id := range lost {
+ t.log.Info("局域网里的设备不再可达", "device", id)
+ t.reachable(id, false)
+ }
+ if netChanged {
+ // 网卡变了:mDNS 要在新网卡上重新加入组播
+ t.log.Info("网络已变化,重新开始局域网发现")
+ t.discovery.Stop()
+ t.startDiscovery(ctx)
+ } else if dayChanged || pairingExpired {
+ t.updateAdvert()
+ }
+ for _, h := range hellos {
+ t.sendHello(h.id, h.targets, true, h.interval)
+ }
+}
+
+// intervalFor 返回向某台设备打招呼的间隔。不能在持有 t.mu 时调用。
+func (t *Transport) intervalFor(id string) time.Duration {
+ if t.opts.Connected != nil && t.opts.Connected(id) {
+ return keepaliveInterval
+ }
+ return helloInterval
+}
+
+// candidatesLocked 汇总某台设备可能在的地址:最近的来源、对方自报的、mDNS 发现的、地址簿里的。
+func (t *Transport) candidatesLocked(id string, st *peerState, now time.Time) []netip.AddrPort {
+ if !st.bookLoaded && t.opts.Book != nil {
+ st.bookLoaded = true
+ st.book = nil
+ if list, err := t.opts.Book.DeviceAddrs(id); err == nil {
+ st.book = parseAddrs(list)
+ }
+ }
+ var out []netip.AddrPort
+ seen := map[netip.AddrPort]bool{}
+ add := func(ap netip.AddrPort) {
+ if ap.IsValid() && ap.Addr().Is4() && !seen[ap] && len(out) < maxCandidates {
+ seen[ap] = true
+ out = append(out, ap)
+ }
+ }
+ add(st.addr)
+ for ap, at := range st.discovered {
+ if now.Sub(at) < instanceTTL {
+ add(ap)
+ }
+ }
+ for _, ap := range st.reported {
+ add(ap)
+ }
+ for _, ap := range st.book {
+ add(ap)
+ }
+ return out
+}
+
+func (t *Transport) sendHello(to string, targets []netip.AddrPort, replyWanted bool, interval time.Duration) {
+ t.mu.Lock()
+ addrs := append([]string(nil), t.selfAddrs...)
+ t.mu.Unlock()
+
+ s, err := signed.Sign(t.id, to, &pb.SignalMessage{Payload: &pb.SignalMessage_LanHello{LanHello: &pb.LanHello{
+ Addresses: addrs,
+ ReplyWanted: replyWanted,
+ IntervalSeconds: uint32(interval / time.Second),
+ }}})
+ if err != nil {
+ return
+ }
+ pkt, err := encode(&pb.LanPacket{Payload: &pb.LanPacket_Signal{Signal: s}})
+ if err != nil {
+ return
+ }
+ for _, dst := range targets {
+ _ = t.write(dst, pkt)
+ }
+}
+
+// ─────────────────────────── 发现 ───────────────────────────
+
+func (t *Transport) startDiscovery(ctx context.Context) {
+ t.mu.Lock()
+ port := t.port
+ text := t.advertTextLocked()
+ t.mu.Unlock()
+ if err := t.discovery.Start(ctx, t.instance, port, text, t.found); err != nil {
+ // 没有 mDNS 也能用:输入地址、地址簿里的地址照样能连
+ t.log.Warn("局域网发现启动失败", "err", err)
+ }
+}
+
+func (t *Transport) updateAdvert() {
+ t.mu.Lock()
+ if !t.running {
+ t.mu.Unlock()
+ return
+ }
+ text := t.advertTextLocked()
+ t.mu.Unlock()
+ if err := t.discovery.Update(text); err != nil {
+ t.log.Debug("更新局域网广播失败", "err", err)
+ }
+}
+
+func (t *Transport) advertTextLocked() map[string]string {
+ text := map[string]string{
+ "v": "1",
+ "t": presenceToken(t.id.DeviceID, time.Now()),
+ }
+ if t.pairing != nil {
+ text["p"] = "1"
+ }
+ return text
+}
+
+// found 处理 mDNS 发现的实例:认出已配对的设备就马上打招呼。
+func (t *Transport) found(inst Instance) {
+ if inst.Text["v"] != "1" || !inst.Addr.IsValid() {
+ return
+ }
+ now := time.Now()
+ t.mu.Lock()
+ if !t.running {
+ t.mu.Unlock()
+ return
+ }
+ prev, had := t.instances[inst.Name]
+ t.instances[inst.Name] = seenInstance{inst: inst, seen: now}
+ // pion 每秒都会报一次同样的结果,只在有新信息时行动
+ fresh := !had || prev.inst.Addr != inst.Addr || prev.inst.Text["t"] != inst.Text["t"] ||
+ now.Sub(prev.seen) > 30*time.Second
+
+ var hello string
+ if id := t.tokens[inst.Text["t"]]; id != "" {
+ st := t.peerLocked(id)
+ if st.discovered == nil {
+ st.discovered = make(map[netip.AddrPort]time.Time)
+ }
+ st.discovered[inst.Addr] = now
+ if fresh && !st.reachable {
+ hello = id
+ }
+ }
+ t.mu.Unlock()
+
+ if hello != "" {
+ t.sendHello(hello, []netip.AddrPort{inst.Addr}, true, t.intervalFor(hello))
+ }
+}
+
+// peerIDs 向上层要已配对设备的列表。不能在持有 t.mu 时调用。
+func (t *Transport) peerIDs() []string {
+ if t.opts.Peers == nil {
+ return nil
+ }
+ return t.opts.Peers()
+}
+
+func (t *Transport) rebuildTokensLocked(now time.Time, peers []string) {
+ t.tokens = make(map[string]string)
+ t.tokensDay = now.UTC().Format("2006-01-02")
+ for _, id := range peers {
+ // 两边的时钟可能不在同一天,前后各算一天
+ for _, d := range []time.Duration{-24 * time.Hour, 0, 24 * time.Hour} {
+ t.tokens[presenceToken(id, now.Add(d))] = id
+ }
+ }
+ // 配对之前就发现了的实例,现在可能认得出来了
+ for _, si := range t.instances {
+ if id := t.tokens[si.inst.Text["t"]]; id != "" {
+ st := t.peerLocked(id)
+ if st.discovered == nil {
+ st.discovered = make(map[netip.AddrPort]time.Time)
+ }
+ st.discovered[si.inst.Addr] = si.seen
+ }
+ }
+}
+
+// ─────────────────────────── 内部辅助 ───────────────────────────
+
+func (t *Transport) setReachableLocked(id string, st *peerState, ok bool) {
+ st.reachable = ok
+ t.reachMu.Lock()
+ if ok {
+ t.reach[id] = true
+ } else {
+ delete(t.reach, id)
+ }
+ t.reachMu.Unlock()
+}
+
+func (t *Transport) peerLocked(id string) *peerState {
+ st := t.peers[id]
+ if st == nil {
+ st = &peerState{}
+ t.peers[id] = st
+ }
+ return st
+}
+
+func (t *Transport) refreshSelfLocked() {
+ t.selfAddrs = t.selfAddrs[:0]
+ for _, ip := range LocalAddrs() {
+ t.selfAddrs = append(t.selfAddrs, netip.AddrPortFrom(ip, uint16(t.port)).String())
+ }
+}
+
+// write 发一个包。macOS 拒绝本地网络访问时记下来,界面据此提示用户去授权。
+func (t *Transport) write(dst netip.AddrPort, pkt []byte) error {
+ t.mu.Lock()
+ conn := t.conn
+ running := t.running
+ t.mu.Unlock()
+ if !running {
+ return ErrDisabled
+ }
+ _, err := conn.WriteToUDPAddrPort(pkt, dst)
+
+ local := onLink(dst.Addr())
+ t.mu.Lock()
+ wasBlocked := !t.blockedAt.IsZero()
+ switch {
+ case err != nil && local && deniedByOS(err):
+ t.blockedAt = time.Now()
+ case err == nil && local:
+ t.blockedAt = time.Time{}
+ }
+ nowBlocked := !t.blockedAt.IsZero()
+ t.mu.Unlock()
+
+ if nowBlocked != wasBlocked {
+ if nowBlocked {
+ t.log.Warn("系统拦下了发往局域网的包,需要在系统设置里允许本地网络访问", "dst", dst, "err", err)
+ }
+ t.changed()
+ }
+ return err
+}
+
+func (t *Transport) reachable(id string, ok bool) {
+ if t.opts.OnReachable != nil {
+ t.opts.OnReachable(id, ok)
+ }
+}
+
+func (t *Transport) changed() {
+ if t.opts.OnChange != nil {
+ t.opts.OnChange()
+ }
+}
+
+func encode(pkt *pb.LanPacket) ([]byte, error) {
+ body, err := proto.Marshal(pkt)
+ if err != nil {
+ return nil, err
+ }
+ if len(magic)+len(body) > maxPacket {
+ return nil, fmt.Errorf("局域网消息过大: %d 字节", len(body))
+ }
+ return append([]byte(magic), body...), nil
+}
+
+func parseAddrs(list []string) []netip.AddrPort {
+ var out []netip.AddrPort
+ for _, s := range list {
+ if ap, err := netip.ParseAddrPort(s); err == nil && ap.Addr().Is4() {
+ out = append(out, ap)
+ }
+ }
+ return out
+}
diff --git a/client-core/internal/transport/lan/lan_test.go b/client-core/internal/transport/lan/lan_test.go
new file mode 100644
index 0000000..408bc00
--- /dev/null
+++ b/client-core/internal/transport/lan/lan_test.go
@@ -0,0 +1,330 @@
+package lan
+
+import (
+ "context"
+ "crypto/ed25519"
+ "errors"
+ "net/netip"
+ "path/filepath"
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/baiyuze/copysync/client-core/internal/identity"
+ "github.com/baiyuze/copysync/client-core/internal/transport/signed"
+ pb "github.com/baiyuze/copysync/proto/gen/copysync/v1"
+)
+
+// node 是测试里的一台设备:一个 Transport 加上它认识的公钥和收到的东西。
+type node struct {
+ id *identity.Identity
+ t *Transport
+
+ mu sync.Mutex
+ known map[string]ed25519.PublicKey
+ book map[string][]string
+ accepted []PeerInfo
+ signals chan *pb.SignalMessage
+ reach chan string
+}
+
+func newNode(t *testing.T, net *MemoryNetwork) *node {
+ t.Helper()
+ id, err := identity.LoadOrCreate(filepath.Join(t.TempDir(), "identity.json"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ n := &node{
+ id: id,
+ known: map[string]ed25519.PublicKey{},
+ book: map[string][]string{},
+ signals: make(chan *pb.SignalMessage, 16),
+ reach: make(chan string, 16),
+ }
+ var d Discovery
+ if net != nil {
+ d = net.Discovery()
+ } else {
+ d = NewMemoryNetwork().Discovery() // 自成一个网络:谁也发现不了它
+ }
+ n.t = New(Options{
+ Identity: id,
+ Port: -1,
+ Discovery: d,
+ Verifier: signed.NewVerifier(id.DeviceID, n.keyOf),
+ Book: n,
+ Peers: n.peers,
+ DeviceInfo: func() (string, string) { return "node-" + id.DeviceID[:4], "test" },
+ OnSignal: func(_ string, msg *pb.SignalMessage) { n.signals <- msg },
+ OnReachable: func(id string, ok bool) {
+ if ok {
+ n.reach <- id
+ }
+ },
+ AcceptPair: func(p PeerInfo) bool {
+ n.mu.Lock()
+ defer n.mu.Unlock()
+ n.accepted = append(n.accepted, p)
+ return true
+ },
+ })
+ if err := n.t.Start(); err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(n.t.Stop)
+ return n
+}
+
+func (n *node) keyOf(id string) ed25519.PublicKey {
+ n.mu.Lock()
+ defer n.mu.Unlock()
+ return n.known[id]
+}
+
+func (n *node) peers() []string {
+ n.mu.Lock()
+ defer n.mu.Unlock()
+ var out []string
+ for id := range n.known {
+ out = append(out, id)
+ }
+ return out
+}
+
+func (n *node) DeviceAddrs(id string) ([]string, error) {
+ n.mu.Lock()
+ defer n.mu.Unlock()
+ return append([]string(nil), n.book[id]...), nil
+}
+
+func (n *node) PutDeviceAddr(id, addr string, _ time.Time) error {
+ n.mu.Lock()
+ defer n.mu.Unlock()
+ for _, a := range n.book[id] {
+ if a == addr {
+ return nil
+ }
+ }
+ n.book[id] = append(n.book[id], addr)
+ return nil
+}
+
+// pair 让两台设备互相认识(相当于已经配对过)。
+func pair(a, b *node) {
+ a.mu.Lock()
+ a.known[b.id.DeviceID] = b.id.PublicKey
+ a.mu.Unlock()
+ b.mu.Lock()
+ b.known[a.id.DeviceID] = a.id.PublicKey
+ b.mu.Unlock()
+ a.t.PeersChanged()
+ b.t.PeersChanged()
+}
+
+func (n *node) addr() netip.AddrPort {
+ return netip.AddrPortFrom(netip.MustParseAddr("127.0.0.1"), uint16(n.t.Port()))
+}
+
+func waitReachable(t *testing.T, n *node, peer string) {
+ t.Helper()
+ deadline := time.After(5 * time.Second)
+ for !n.t.Reachable(peer) {
+ select {
+ case <-n.reach:
+ case <-time.After(50 * time.Millisecond):
+ case <-deadline:
+ t.Fatalf("%s 等不到 %s 可达", n.id.DeviceID[:6], peer[:6])
+ }
+ }
+}
+
+// 同一网络里的两台已配对设备靠 mDNS 互相找到,之后信令直接在局域网里收发。
+func TestPairedDevicesFindEachOtherAndSignal(t *testing.T) {
+ net := NewMemoryNetwork()
+ a, b := newNode(t, net), newNode(t, net)
+ pair(a, b)
+
+ waitReachable(t, a, b.id.DeviceID)
+ waitReachable(t, b, a.id.DeviceID)
+
+ s, err := signed.Sign(a.id, b.id.DeviceID, &pb.SignalMessage{
+ Payload: &pb.SignalMessage_Ping{Ping: &pb.Ping{SentAtUnix: 42}},
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := a.t.Send(b.id.DeviceID, s); err != nil {
+ t.Fatal(err)
+ }
+ select {
+ case msg := <-b.signals:
+ if msg.GetPing().GetSentAtUnix() != 42 {
+ t.Fatalf("收到 %v", msg)
+ }
+ case <-time.After(3 * time.Second):
+ t.Fatal("没收到信令")
+ }
+ // 补发的那一份会被当作重复消息丢掉
+ select {
+ case msg := <-b.signals:
+ t.Fatalf("同一条信令交给上层两次: %v", msg)
+ case <-time.After(400 * time.Millisecond):
+ }
+
+ if got, _ := a.DeviceAddrs(b.id.DeviceID); len(got) == 0 {
+ t.Error("对方的地址应当记进地址簿")
+ }
+}
+
+// 跨网段时 mDNS 过不去:只要一边知道另一边的地址,打过招呼后双方都可达。
+func TestReachableByRememberedAddress(t *testing.T) {
+ a, b := newNode(t, nil), newNode(t, nil)
+ pair(a, b)
+ a.t.Remember(b.id.DeviceID, []string{b.addr().String()})
+
+ waitReachable(t, a, b.id.DeviceID)
+ waitReachable(t, b, a.id.DeviceID)
+}
+
+// 未配对的设备发来的 hello 不算数。
+func TestStrangerIsIgnored(t *testing.T) {
+ a, stranger := newNode(t, nil), newNode(t, nil)
+ stranger.mu.Lock()
+ stranger.known[a.id.DeviceID] = a.id.PublicKey // 陌生人知道 a,但 a 不认识它
+ stranger.mu.Unlock()
+ stranger.t.Remember(a.id.DeviceID, []string{a.addr().String()})
+ stranger.t.PeersChanged()
+
+ time.Sleep(500 * time.Millisecond)
+ if a.t.Reachable(stranger.id.DeviceID) {
+ t.Fatal("未配对设备不该被当成可达")
+ }
+}
+
+func TestPairingOverLAN(t *testing.T) {
+ net := NewMemoryNetwork()
+ shower, joiner := newNode(t, net), newNode(t, net)
+
+ shower.t.OpenPairing("abc-234", time.Now().Add(time.Minute))
+ ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+ defer cancel()
+ peer, err := joiner.t.Pair(ctx, "ABC234", nil)
+ if err != nil {
+ t.Fatalf("配对失败: %v", err)
+ }
+ if peer.ID != shower.id.DeviceID || string(peer.PublicKey) != string(shower.id.PublicKey) {
+ t.Fatalf("拿到的不是对方的身份: %+v", peer)
+ }
+ if len(peer.Addrs) == 0 || peer.Addrs[0] != shower.addr().String() {
+ t.Errorf("回复的来源地址应排第一,得到 %v", peer.Addrs)
+ }
+
+ shower.mu.Lock()
+ accepted := shower.accepted
+ shower.mu.Unlock()
+ if len(accepted) != 1 || accepted[0].ID != joiner.id.DeviceID {
+ t.Fatalf("显示码的一方应当收到对方的身份,得到 %+v", accepted)
+ }
+
+ // 码只能用一次
+ late := newNode(t, net)
+ ctx2, cancel2 := context.WithTimeout(context.Background(), 1500*time.Millisecond)
+ defer cancel2()
+ if _, err := late.t.Pair(ctx2, "ABC234", []netip.AddrPort{shower.addr()}); !errors.Is(err, ErrCodeClosed) {
+ t.Fatalf("用过的码应当失效,得到 %v", err)
+ }
+}
+
+// 不在同一网段:mDNS 找不到,靠用户输入的地址配对。
+func TestPairingByAddress(t *testing.T) {
+ shower, joiner := newNode(t, nil), newNode(t, nil)
+ shower.t.OpenPairing("K7MP2X", time.Now().Add(time.Minute))
+
+ ctx, cancel := context.WithTimeout(context.Background(), 1500*time.Millisecond)
+ defer cancel()
+ if _, err := joiner.t.Pair(ctx, "K7MP2X", nil); !errors.Is(err, ErrNotFound) {
+ t.Fatalf("不输地址应当找不到,得到 %v", err)
+ }
+
+ ctx2, cancel2 := context.WithTimeout(context.Background(), 3*time.Second)
+ defer cancel2()
+ peer, err := joiner.t.Pair(ctx2, "K7MP2X", []netip.AddrPort{shower.addr()})
+ if err != nil || peer.ID != shower.id.DeviceID {
+ t.Fatalf("按地址配对失败: %+v, %v", peer, err)
+ }
+}
+
+func TestWrongCodeLocksAfterTooManyAttempts(t *testing.T) {
+ shower, joiner := newNode(t, nil), newNode(t, nil)
+ shower.t.OpenPairing("K7MP2X", time.Now().Add(time.Minute))
+ try := func(code string) error {
+ ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+ defer cancel()
+ _, err := joiner.t.Pair(ctx, code, []netip.AddrPort{shower.addr()})
+ return err
+ }
+
+ if err := try("WRONG2"); !errors.Is(err, ErrWrongCode) {
+ t.Fatalf("错码: %v", err)
+ }
+ for i := 0; i < maxPairAttempts; i++ {
+ _ = try("WRONG2")
+ }
+ if err := try("K7MP2X"); !errors.Is(err, ErrCodeClosed) {
+ t.Fatalf("错太多次之后,正确的码也应当失效,得到 %v", err)
+ }
+}
+
+// 可达状态超过对方声明的间隔三倍没刷新就过期。
+func TestReachabilityExpires(t *testing.T) {
+ net := NewMemoryNetwork()
+ a, b := newNode(t, net), newNode(t, net)
+ pair(a, b)
+ waitReachable(t, a, b.id.DeviceID)
+
+ b.t.Stop()
+ a.t.mu.Lock()
+ a.t.peers[b.id.DeviceID].lastSeen = time.Now().Add(-time.Hour)
+ a.t.mu.Unlock()
+ a.t.tick()
+ if a.t.Reachable(b.id.DeviceID) {
+ t.Fatal("对方长时间没消息,应当变为不可达")
+ }
+}
+
+func TestResolveAddress(t *testing.T) {
+ cases := map[string]string{
+ "192.168.1.20": "192.168.1.20:8788",
+ " 192.168.1.20:9000": "192.168.1.20:9000",
+ }
+ for in, want := range cases {
+ got, err := ResolveAddress(context.Background(), in)
+ if err != nil || len(got) != 1 || got[0].String() != want {
+ t.Errorf("%q → %v, %v;期望 %s", in, got, err, want)
+ }
+ }
+ for _, bad := range []string{"", "192.168.1.20:0", "[::1]:8788"} {
+ if _, err := ResolveAddress(context.Background(), bad); !errors.Is(err, ErrBadAddress) {
+ t.Errorf("%q 应当报地址格式不对,得到 %v", bad, err)
+ }
+ }
+ if DisplayAddr(netip.MustParseAddrPort("10.0.0.2:8788")) != "10.0.0.2" ||
+ DisplayAddr(netip.MustParseAddrPort("10.0.0.2:9000")) != "10.0.0.2:9000" {
+ t.Error("默认端口应当省略,其他端口保留")
+ }
+}
+
+// 广播里的令牌每天都变,不含设备 ID 本身。
+func TestPresenceTokenRotatesDaily(t *testing.T) {
+ day := time.Date(2026, 10, 11, 12, 0, 0, 0, time.UTC)
+ a := presenceToken("dev", day)
+ if a == presenceToken("dev", day.Add(24*time.Hour)) {
+ t.Error("令牌应当每天变化")
+ }
+ if a != presenceToken("dev", day.Add(5*time.Hour)) {
+ t.Error("同一天的令牌应当相同")
+ }
+ if a == presenceToken("other", day) {
+ t.Error("不同设备的令牌应当不同")
+ }
+}
diff --git a/client-core/internal/transport/lan/mdns.go b/client-core/internal/transport/lan/mdns.go
new file mode 100644
index 0000000..50f19c4
--- /dev/null
+++ b/client-core/internal/transport/lan/mdns.go
@@ -0,0 +1,137 @@
+package lan
+
+import (
+ "context"
+ "fmt"
+ "net"
+ "net/netip"
+ "sync"
+
+ "github.com/pion/logging"
+ "github.com/pion/mdns/v2"
+ "golang.org/x/net/ipv4"
+)
+
+// mdnsDiscovery 用 pion/mdns 在局域网里广播和浏览。
+//
+// Windows 上广播改由系统的 DNS-SD 服务负责(见 mdns_windows.go):mDNS 查询是别人主动发来的包,
+// 后台服务没有防火墙放行规则时收不到,也就答不了;系统服务有现成的放行规则。
+// 浏览不受影响——本机先发出查询,对方的回答属于回包,防火墙会放行。
+type mdnsDiscovery struct {
+ mu sync.Mutex
+ conn *mdns.Conn
+ name string
+ port int
+ registered bool
+ sys *systemAdvertiser // 仅 Windows
+}
+
+// NewMDNS 返回默认的 mDNS 发现实现。
+func NewMDNS() Discovery { return &mdnsDiscovery{} }
+
+func (d *mdnsDiscovery) Start(ctx context.Context, name string, port int, text map[string]string, found func(Instance)) error {
+ addr, err := net.ResolveUDPAddr("udp4", mdns.DefaultAddressIPv4)
+ if err != nil {
+ return err
+ }
+ l, err := net.ListenUDP("udp4", addr)
+ if err != nil {
+ return fmt.Errorf("监听 mDNS 端口: %w", err)
+ }
+ logger := logging.NewDefaultLoggerFactory()
+ logger.DefaultLogLevel = logging.LogLevelError
+ conn, err := mdns.NewServer(ipv4.NewPacketConn(l), nil, mdns.WithLoggerFactory(logger))
+ if err != nil {
+ _ = l.Close()
+ return fmt.Errorf("启动 mDNS: %w", err)
+ }
+
+ d.mu.Lock()
+ d.conn, d.name, d.port = conn, name, port
+ d.mu.Unlock()
+
+ if err := d.advertise(text); err != nil {
+ d.Stop()
+ return err
+ }
+
+ conn.OnServiceDiscovered(func(ev mdns.ServiceEvent) {
+ if ev.Instance.Service != ServiceType || ev.Instance.Instance == name {
+ return
+ }
+ ip := ev.Addr.Unmap().WithZone("")
+ if !ip.Is4() {
+ return
+ }
+ found(Instance{
+ Name: ev.Instance.Instance,
+ Addr: netip.AddrPortFrom(ip, ev.Instance.Port),
+ Text: txtMap(ev.Instance.Text),
+ })
+ })
+ if err := conn.Browse(ctx, ServiceType); err != nil {
+ d.Stop()
+ return fmt.Errorf("浏览 mDNS: %w", err)
+ }
+ return nil
+}
+
+func (d *mdnsDiscovery) Update(text map[string]string) error { return d.advertise(text) }
+
+func (d *mdnsDiscovery) advertise(text map[string]string) error {
+ d.mu.Lock()
+ defer d.mu.Unlock()
+ if d.conn == nil {
+ return nil
+ }
+ if useSystemAdvertiser {
+ if d.sys == nil {
+ d.sys = &systemAdvertiser{}
+ }
+ return d.sys.register(d.name, d.port, text)
+ }
+
+ entries := txtEntries(text)
+ if d.registered {
+ return d.conn.UpdateTXT(d.name, ServiceType, entries)
+ }
+ err := d.conn.Register(mdns.ServiceInstance{
+ Instance: d.name,
+ Service: ServiceType,
+ Domain: "local",
+ Host: d.name + ".local.",
+ Port: uint16(d.port),
+ Text: entries,
+ })
+ d.registered = err == nil
+ return err
+}
+
+func (d *mdnsDiscovery) Stop() {
+ d.mu.Lock()
+ conn, sys := d.conn, d.sys
+ d.conn, d.sys, d.registered = nil, nil, false
+ d.mu.Unlock()
+ if sys != nil {
+ sys.unregister()
+ }
+ if conn != nil {
+ _ = conn.Close()
+ }
+}
+
+func txtEntries(text map[string]string) []mdns.TXTEntry {
+ out := make([]mdns.TXTEntry, 0, len(text))
+ for _, k := range sortedKeys(text) {
+ out = append(out, mdns.TXTEntry{Key: k, Value: []byte(text[k])})
+ }
+ return out
+}
+
+func txtMap(entries []mdns.TXTEntry) map[string]string {
+ out := make(map[string]string, len(entries))
+ for _, e := range entries {
+ out[e.Key] = string(e.Value)
+ }
+ return out
+}
diff --git a/client-core/internal/transport/lan/mdns_other.go b/client-core/internal/transport/lan/mdns_other.go
new file mode 100644
index 0000000..144dfba
--- /dev/null
+++ b/client-core/internal/transport/lan/mdns_other.go
@@ -0,0 +1,11 @@
+//go:build !windows
+
+package lan
+
+// 其他平台由 pion/mdns 自己回答查询。
+const useSystemAdvertiser = false
+
+type systemAdvertiser struct{}
+
+func (*systemAdvertiser) register(string, int, map[string]string) error { return nil }
+func (*systemAdvertiser) unregister() {}
diff --git a/client-core/internal/transport/lan/mdns_windows.go b/client-core/internal/transport/lan/mdns_windows.go
new file mode 100644
index 0000000..649c3cf
--- /dev/null
+++ b/client-core/internal/transport/lan/mdns_windows.go
@@ -0,0 +1,143 @@
+//go:build windows
+
+package lan
+
+import (
+ "errors"
+ "fmt"
+ "os"
+ "sync"
+ "time"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+)
+
+// Windows 上由系统的 DNS-SD 服务(Dnscache)替我们回答 mDNS 查询。
+// 实测:后台服务被防火墙挡住入站时,别的电脑照样能通过它发现本机。
+const useSystemAdvertiser = true
+
+var (
+ dnsapi = windows.NewLazySystemDLL("dnsapi.dll")
+ procConstructInstance = dnsapi.NewProc("DnsServiceConstructInstance")
+ procFreeInstance = dnsapi.NewProc("DnsServiceFreeInstance")
+ procDnsServiceRegister = dnsapi.NewProc("DnsServiceRegister")
+ procDnsServiceDeRegister = dnsapi.NewProc("DnsServiceDeRegister")
+
+ // 回调只能建有限个且不会释放,全局建一个;注册与注销由 sysMu 串行化,结果经 sysDone 传回
+ sysCallback = windows.NewCallback(func(status uint32, _ uintptr, _ uintptr) uintptr {
+ select {
+ case sysDone <- status:
+ default:
+ }
+ return 0
+ })
+ sysDone = make(chan uint32, 1)
+ sysMu sync.Mutex
+)
+
+const dnsRequestPending = 9506 // DNS_REQUEST_PENDING
+
+// dnsServiceRegisterRequest 对应 DNS_SERVICE_REGISTER_REQUEST。
+type dnsServiceRegisterRequest struct {
+ Version uint32
+ InterfaceIndex uint32
+ ServiceInstance uintptr
+ Callback uintptr
+ Context uintptr
+ Credentials uintptr
+ UnicastEnabled int32
+}
+
+type systemAdvertiser struct {
+ req *dnsServiceRegisterRequest
+}
+
+func (a *systemAdvertiser) register(name string, port int, text map[string]string) error {
+ a.unregister()
+
+ ip, ok := defaultRouteIP()
+ if !ok {
+ return errors.New("没有可用的局域网地址")
+ }
+ host, _ := os.Hostname()
+ svc, err := windows.UTF16PtrFromString(name + "." + ServiceType + ".local")
+ if err != nil {
+ return err
+ }
+ hostName, err := windows.UTF16PtrFromString(host + ".local")
+ if err != nil {
+ return err
+ }
+ keys := make([]*uint16, 0, len(text))
+ values := make([]*uint16, 0, len(text))
+ for _, k := range sortedKeys(text) {
+ kp, err1 := windows.UTF16PtrFromString(k)
+ vp, err2 := windows.UTF16PtrFromString(text[k])
+ if err1 != nil || err2 != nil {
+ return fmt.Errorf("TXT 记录含非法字符: %q", k)
+ }
+ keys = append(keys, kp)
+ values = append(values, vp)
+ }
+ var keysPtr, valuesPtr uintptr
+ if len(keys) > 0 {
+ keysPtr = uintptr(unsafe.Pointer(&keys[0]))
+ valuesPtr = uintptr(unsafe.Pointer(&values[0]))
+ }
+ // IP4_ADDRESS 是网络字节序的 DWORD
+ b := ip.As4()
+ addr := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+
+ inst, _, callErr := procConstructInstance.Call(
+ uintptr(unsafe.Pointer(svc)), uintptr(unsafe.Pointer(hostName)),
+ uintptr(unsafe.Pointer(&addr)), 0,
+ uintptr(port), 0, 0, uintptr(len(keys)), keysPtr, valuesPtr)
+ if inst == 0 {
+ return fmt.Errorf("DnsServiceConstructInstance: %v", callErr)
+ }
+
+ req := &dnsServiceRegisterRequest{Version: 1, ServiceInstance: inst, Callback: sysCallback}
+ if err := sysCall(procDnsServiceRegister, req); err != nil {
+ procFreeInstance.Call(inst)
+ return fmt.Errorf("DnsServiceRegister: %w", err)
+ }
+ a.req = req
+ return nil
+}
+
+func (a *systemAdvertiser) unregister() {
+ if a.req == nil {
+ return
+ }
+ req := a.req
+ a.req = nil
+ _ = sysCall(procDnsServiceDeRegister, req)
+ procFreeInstance.Call(req.ServiceInstance)
+}
+
+// sysCall 发起一次异步的注册或注销,等系统回调给出结果。
+func sysCall(proc *windows.LazyProc, req *dnsServiceRegisterRequest) error {
+ if err := proc.Find(); err != nil {
+ return err // 系统太旧,没有这组 API
+ }
+ sysMu.Lock()
+ defer sysMu.Unlock()
+ select { // 清掉上一次超时后才到的结果
+ case <-sysDone:
+ default:
+ }
+ r, _, _ := proc.Call(uintptr(unsafe.Pointer(req)), 0)
+ if r != dnsRequestPending {
+ return fmt.Errorf("返回 %d", r)
+ }
+ select {
+ case st := <-sysDone:
+ if st != 0 {
+ return fmt.Errorf("状态 %d", st)
+ }
+ return nil
+ case <-time.After(5 * time.Second):
+ return errors.New("等待系统回调超时")
+ }
+}
diff --git a/client-core/internal/transport/lan/pairing.go b/client-core/internal/transport/lan/pairing.go
new file mode 100644
index 0000000..3dbe96b
--- /dev/null
+++ b/client-core/internal/transport/lan/pairing.go
@@ -0,0 +1,335 @@
+package lan
+
+import (
+ "context"
+ cryptorand "crypto/rand"
+ "crypto/subtle"
+ "encoding/hex"
+ "errors"
+ "net/netip"
+ "time"
+
+ "google.golang.org/protobuf/proto"
+
+ "github.com/baiyuze/copysync/client-core/internal/identity"
+ "github.com/baiyuze/copysync/client-core/internal/transport/signed"
+ "github.com/baiyuze/copysync/proto/deviceid"
+ pb "github.com/baiyuze/copysync/proto/gen/copysync/v1"
+ "github.com/baiyuze/copysync/proto/pairingcode"
+)
+
+// 在局域网里配对:显示配对码的一方把码「开放」出来(mDNS 广播里带 p=1),
+// 输入配对码的一方把码发给所有正在配对的实例,以及用户输入的地址。
+//
+// 配对码在局域网里明文传输,与经服务器配对时服务器能看到配对码是一回事:
+// 拿到配对码最多能冒充一方发起配对,但两端显示的指纹会对不上——
+// 防中间人靠的是用户核对指纹,不是配对码。
+// 显示码的一方限制错误次数,挡住在 5 分钟内暴力猜码。
+
+const maxPairAttempts = 10
+
+var (
+ ErrNotFound = errors.New("没在局域网里找到正在配对的设备")
+ ErrWrongCode = errors.New("配对码不对")
+ ErrCodeClosed = errors.New("配对码已失效")
+ ErrTooManyAttempts = errors.New("配对码输错次数太多,已失效")
+)
+
+type pairingState struct {
+ code string
+ expires time.Time
+ attempts int
+}
+
+// cachedResponse 是发出去的配对回复:对方没收到而重发请求时原样再发一次。
+type cachedResponse struct {
+ pkt []byte
+ at time.Time
+}
+
+type pairWaiter struct {
+ resp chan pairResult
+ rejects map[string]bool
+ rejectedAt time.Time
+}
+
+type pairResult struct {
+ info *pb.LanPairInfo
+ src netip.AddrPort
+}
+
+// OpenPairing 在局域网里开放一个配对码,有效期到 expires。
+func (t *Transport) OpenPairing(code string, expires time.Time) {
+ t.mu.Lock()
+ t.pairing = &pairingState{code: pairingcode.Normalize(code), expires: expires}
+ t.mu.Unlock()
+ t.updateAdvert()
+}
+
+// ClosePairing 撤回正在开放的配对码。
+func (t *Transport) ClosePairing() {
+ t.mu.Lock()
+ was := t.pairing != nil
+ t.pairing = nil
+ t.mu.Unlock()
+ if was {
+ t.updateAdvert()
+ }
+}
+
+// Pair 用配对码在局域网里找到对方并交换公钥,直到 ctx 结束。extra 是用户输入的地址,
+// 不在同一网段(mDNS 过不去)时靠它。
+func (t *Transport) Pair(ctx context.Context, code string, extra []netip.AddrPort) (PeerInfo, error) {
+ if !t.Running() {
+ return PeerInfo{}, ErrDisabled
+ }
+ nonce := make([]byte, 16)
+ if _, err := cryptorand.Read(nonce); err != nil {
+ return PeerInfo{}, err
+ }
+ req := t.selfPairInfo()
+ req.Code = pairingcode.Normalize(code)
+ req.Nonce = nonce
+ pkt, err := t.encodePairInfo(req, true)
+ if err != nil {
+ return PeerInfo{}, err
+ }
+
+ key := hex.EncodeToString(nonce)
+ w := &pairWaiter{resp: make(chan pairResult, 1), rejects: make(map[string]bool)}
+ t.mu.Lock()
+ t.waiters[key] = w
+ t.mu.Unlock()
+ defer func() {
+ t.mu.Lock()
+ delete(t.waiters, key)
+ t.mu.Unlock()
+ }()
+
+ tk := time.NewTicker(500 * time.Millisecond)
+ defer tk.Stop()
+ for {
+ for _, dst := range t.pairTargets(extra) {
+ _ = t.write(dst, pkt)
+ }
+ select {
+ case r := <-w.resp:
+ return PeerInfo{
+ ID: r.info.GetDeviceId(),
+ Name: r.info.GetDeviceName(),
+ Platform: r.info.GetPlatform(),
+ PublicKey: r.info.GetPublicKey(),
+ Addrs: mergeAddrs(r.info.GetAddresses(), r.src),
+ }, nil
+ case <-ctx.Done():
+ if err := t.rejectError(w, true); err != nil {
+ return PeerInfo{}, err
+ }
+ return PeerInfo{}, ErrNotFound
+ case <-tk.C:
+ // 有人明确拒绝了:再等一轮,万一另一台设备才是对的那台;之后就不必等到超时
+ if err := t.rejectError(w, false); err != nil {
+ return PeerInfo{}, err
+ }
+ }
+ }
+}
+
+// rejectError 把收到的拒绝换成错误。final 为假时,只在拒绝到达半秒以后才算数。
+func (t *Transport) rejectError(w *pairWaiter, final bool) error {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ if w.rejectedAt.IsZero() || (!final && time.Since(w.rejectedAt) < 500*time.Millisecond) {
+ return nil
+ }
+ switch {
+ case w.rejects["wrong_code"]:
+ return ErrWrongCode
+ case w.rejects["too_many_attempts"]:
+ return ErrTooManyAttempts
+ }
+ return ErrCodeClosed
+}
+
+// pairTargets 是配对请求要发往的地址:用户输入的,加上正在广播配对的实例(最多 16 个)。
+func (t *Transport) pairTargets(extra []netip.AddrPort) []netip.AddrPort {
+ out := append([]netip.AddrPort(nil), extra...)
+ now := time.Now()
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ for _, si := range t.instances {
+ if len(out) >= 16+len(extra) {
+ break
+ }
+ if si.inst.Text["p"] == "1" && now.Sub(si.seen) < time.Minute {
+ out = append(out, si.inst.Addr)
+ }
+ }
+ return out
+}
+
+func (t *Transport) handlePairRequest(ps *pb.LanPairSigned, src netip.AddrPort) {
+ info, ok := t.openPairInfo(ps)
+ if !ok || len(info.GetNonce()) < 8 {
+ return
+ }
+ key := hex.EncodeToString(info.GetNonce())
+ now := time.Now()
+
+ t.mu.Lock()
+ if cached, ok := t.responses[key]; ok {
+ t.mu.Unlock()
+ _ = t.write(src, cached.pkt)
+ return
+ }
+ p := t.pairing
+ reason := ""
+ closeAdvert := false
+ switch {
+ case p == nil || now.After(p.expires):
+ reason = "closed"
+ case subtle.ConstantTimeCompare([]byte(pairingcode.Normalize(info.GetCode())), []byte(p.code)) != 1:
+ p.attempts++
+ reason = "wrong_code"
+ if p.attempts >= maxPairAttempts {
+ t.log.Warn("配对码输错次数太多,已作废", "src", src)
+ t.pairing, reason, closeAdvert = nil, "too_many_attempts", true
+ }
+ default:
+ // 码对了:先撤下,同一个码不会再被第二个人用到
+ t.pairing, closeAdvert = nil, true
+ }
+ t.mu.Unlock()
+ if closeAdvert {
+ t.updateAdvert()
+ }
+ if reason != "" {
+ t.reject(src, info.GetNonce(), reason)
+ return
+ }
+
+ peer := PeerInfo{
+ ID: info.GetDeviceId(),
+ Name: info.GetDeviceName(),
+ Platform: info.GetPlatform(),
+ PublicKey: info.GetPublicKey(),
+ Addrs: mergeAddrs(info.GetAddresses(), src),
+ }
+ if t.opts.AcceptPair != nil && !t.opts.AcceptPair(peer) {
+ t.reject(src, info.GetNonce(), "closed")
+ return
+ }
+
+ resp := t.selfPairInfo()
+ resp.Nonce = make([]byte, 16)
+ _, _ = cryptorand.Read(resp.Nonce)
+ resp.RequestNonce = info.GetNonce()
+ pkt, err := t.encodePairInfo(resp, false)
+ if err != nil {
+ return
+ }
+ t.mu.Lock()
+ t.responses[key] = cachedResponse{pkt: pkt, at: now}
+ t.mu.Unlock()
+ t.log.Info("局域网配对请求已接受,等待用户核对指纹", "peer", peer.Name, "src", src)
+ _ = t.write(src, pkt)
+ time.AfterFunc(resendDelay, func() { _ = t.write(src, pkt) })
+}
+
+func (t *Transport) handlePairResponse(ps *pb.LanPairSigned, src netip.AddrPort) {
+ info, ok := t.openPairInfo(ps)
+ if !ok {
+ return
+ }
+ t.mu.Lock()
+ w := t.waiters[hex.EncodeToString(info.GetRequestNonce())]
+ t.mu.Unlock()
+ // 按回显的 nonce 找到发出请求的那次 Pair:回复只能对应本机真正发过的请求
+ if w == nil {
+ return
+ }
+ select {
+ case w.resp <- pairResult{info: info, src: src}:
+ default:
+ }
+}
+
+func (t *Transport) handlePairReject(r *pb.LanPairReject) {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ if w := t.waiters[hex.EncodeToString(r.GetRequestNonce())]; w != nil {
+ w.rejects[r.GetReason()] = true
+ if w.rejectedAt.IsZero() {
+ w.rejectedAt = time.Now()
+ }
+ }
+}
+
+func (t *Transport) reject(dst netip.AddrPort, nonce []byte, reason string) {
+ pkt, err := encode(&pb.LanPacket{Payload: &pb.LanPacket_PairReject{PairReject: &pb.LanPairReject{
+ RequestNonce: nonce,
+ Reason: reason,
+ }}})
+ if err == nil {
+ _ = t.write(dst, pkt)
+ }
+}
+
+func (t *Transport) selfPairInfo() *pb.LanPairInfo {
+ name, platform := "", ""
+ if t.opts.DeviceInfo != nil {
+ name, platform = t.opts.DeviceInfo()
+ }
+ t.mu.Lock()
+ addrs := append([]string(nil), t.selfAddrs...)
+ t.mu.Unlock()
+ return &pb.LanPairInfo{
+ DeviceId: t.id.DeviceID,
+ DeviceName: name,
+ Platform: platform,
+ PublicKey: t.id.PublicKey,
+ Addresses: addrs,
+ TimestampUnix: time.Now().Unix(),
+ }
+}
+
+func (t *Transport) encodePairInfo(info *pb.LanPairInfo, request bool) ([]byte, error) {
+ payload, err := proto.Marshal(info)
+ if err != nil {
+ return nil, err
+ }
+ ps := &pb.LanPairSigned{Payload: payload, Signature: t.id.Sign(payload)}
+ if request {
+ return encode(&pb.LanPacket{Payload: &pb.LanPacket_PairRequest{PairRequest: ps}})
+ }
+ return encode(&pb.LanPacket{Payload: &pb.LanPacket_PairResponse{PairResponse: ps}})
+}
+
+// openPairInfo 解出并校验配对消息:签名对得上自带的公钥、ID 由公钥派生、时间戳不离谱、不是自己。
+func (t *Transport) openPairInfo(ps *pb.LanPairSigned) (*pb.LanPairInfo, bool) {
+ var info pb.LanPairInfo
+ if err := proto.Unmarshal(ps.GetPayload(), &info); err != nil {
+ return nil, false
+ }
+ if !identity.Verify(info.GetPublicKey(), ps.GetPayload(), ps.GetSignature()) ||
+ !deviceid.Valid(info.GetDeviceId(), info.GetPublicKey()) ||
+ info.GetDeviceId() == t.id.DeviceID {
+ return nil, false
+ }
+ skew := time.Since(time.Unix(info.GetTimestampUnix(), 0))
+ if skew > signed.MaxClockSkew || skew < -signed.MaxClockSkew {
+ return nil, false
+ }
+ return &info, true
+}
+
+// mergeAddrs 把对方自报的地址与实际来源合在一起,来源排第一。
+func mergeAddrs(reported []string, src netip.AddrPort) []string {
+ out := []string{src.String()}
+ for _, a := range reported {
+ if ap, err := netip.ParseAddrPort(a); err == nil && ap.Addr().Is4() && ap != src {
+ out = append(out, ap.String())
+ }
+ }
+ return out
+}
diff --git a/client-core/internal/transport/lan/permission_darwin.go b/client-core/internal/transport/lan/permission_darwin.go
new file mode 100644
index 0000000..7856d72
--- /dev/null
+++ b/client-core/internal/transport/lan/permission_darwin.go
@@ -0,0 +1,23 @@
+//go:build darwin
+
+package lan
+
+import (
+ "errors"
+ "os/exec"
+ "syscall"
+)
+
+// RequestPermission 打开「隐私与安全性 → 本地网络」,让用户放行后台服务。
+//
+// macOS 15 起,后台服务主动往局域网地址发包要经用户允许,没允许时 sendto
+// 直接返回 EHOSTUNREACH(对方先发来的包仍能收到、能回复)。
+func RequestPermission() error {
+ return exec.Command("open", "x-apple.systempreferences:com.apple.preference.security?Privacy_LocalNetwork").Run()
+}
+
+// deniedByOS 判断一次发送失败是不是被系统的本地网络权限拦下的。
+// 只对本机直连网段里的地址下这个结论:真的没有路由时也会是同一个错误。
+func deniedByOS(err error) bool {
+ return errors.Is(err, syscall.EHOSTUNREACH)
+}
diff --git a/client-core/internal/transport/lan/permission_other.go b/client-core/internal/transport/lan/permission_other.go
new file mode 100644
index 0000000..eb955cb
--- /dev/null
+++ b/client-core/internal/transport/lan/permission_other.go
@@ -0,0 +1,10 @@
+//go:build !darwin && !windows
+
+package lan
+
+import "errors"
+
+// RequestPermission 在其他平台上没有可做的事。
+func RequestPermission() error { return errors.ErrUnsupported }
+
+func deniedByOS(error) bool { return false }
diff --git a/client-core/internal/transport/lan/permission_windows.go b/client-core/internal/transport/lan/permission_windows.go
new file mode 100644
index 0000000..010e26b
--- /dev/null
+++ b/client-core/internal/transport/lan/permission_windows.go
@@ -0,0 +1,43 @@
+//go:build windows
+
+package lan
+
+import (
+ "fmt"
+ "os"
+ "strings"
+
+ "golang.org/x/sys/windows"
+)
+
+// RequestPermission 申请一次管理员权限(弹出 UAC),在 Windows 防火墙里放行后台服务。
+//
+// 第一次运行时 Windows 会问是否允许后台服务通过防火墙;点了取消会留下阻止规则,
+// 而且那条规则只对当时的网络类型生效。不放行时本机仍能主动连别人,
+// 但别人连不上本机——跨网段配对时要输入地址的那一方正是被连的一方。
+// 这里删掉本程序原有的入站规则(包括阻止规则,阻止优先于允许),
+// 再加一条对所有网络类型生效的 UDP 允许规则。
+func RequestPermission() error {
+ exe, err := os.Executable()
+ if err != nil {
+ return err
+ }
+ if strings.ContainsRune(exe, '"') {
+ return fmt.Errorf("程序路径含引号,无法放行: %s", exe)
+ }
+ script := fmt.Sprintf(
+ `/c netsh advfirewall firewall delete rule name=all dir=in program="%[1]s" & `+
+ `netsh advfirewall firewall add rule name="CopySync" dir=in action=allow program="%[1]s" protocol=UDP profile=any`,
+ exe)
+ verb, _ := windows.UTF16PtrFromString("runas")
+ file, _ := windows.UTF16PtrFromString("cmd.exe")
+ args, err := windows.UTF16PtrFromString(script)
+ if err != nil {
+ return err
+ }
+ // 用户在 UAC 里点了「否」时返回 ERROR_CANCELLED
+ return windows.ShellExecute(0, verb, file, args, nil, windows.SW_HIDE)
+}
+
+// Windows 不会在发送时拦截,防火墙只挡入站。
+func deniedByOS(error) bool { return false }
diff --git a/proto/copysync/v1/daemon.proto b/proto/copysync/v1/daemon.proto
index a502155..847dce1 100644
--- a/proto/copysync/v1/daemon.proto
+++ b/proto/copysync/v1/daemon.proto
@@ -29,6 +29,8 @@ service DaemonService {
// 配对双方各自确认指纹后才真正互信
rpc ConfirmPairing(ConfirmPairingRequest) returns (Empty);
rpc Unpair(UnpairRequest) returns (Empty);
+ // 手动告诉后台服务某台设备的局域网地址:跨网段、或两边都换了地址时用
+ rpc SetDeviceAddress(SetDeviceAddressRequest) returns (Empty);
rpc GetConfig(Empty) returns (Config);
rpc UpdateConfig(Config) returns (Config);
@@ -36,6 +38,9 @@ service DaemonService {
rpc GetStatus(Empty) returns (Status);
// 引导用户授予剪贴板权限(打开系统设置面板)
rpc RequestClipboardPermission(Empty) returns (Empty);
+ // 让系统放行局域网访问:macOS 打开「本地网络」设置面板;
+ // Windows 申请管理员权限,在防火墙里放行后台服务。其他平台返回 UNIMPLEMENTED。
+ rpc RequestLocalNetworkPermission(Empty) returns (Empty);
// 网络出口与打洞诊断:本机有几个出口、各自的公网地址,见 copysync-cli nat
rpc GetNetwork(Empty) returns (NetworkInfo);
@@ -186,10 +191,17 @@ message ListDevicesResponse {
message CreatePairingCodeResponse {
string code = 1;
int64 expires_at_unix = 2;
+ // 本机的局域网地址,默认路由所在的网卡排第一。不在同一网段时,
+ // 另一台要在输入配对码的同时输入其中一个。端口是默认值时省略端口。
+ repeated string lan_addresses = 3;
}
+// 在局域网和服务器上都找不到这个配对码时返回 NOT_FOUND;
+// 找到了但配对码不对返回 INVALID_ARGUMENT;配对码已失效返回 FAILED_PRECONDITION。
message RedeemPairingCodeRequest {
string code = 1;
+ // 可选:对方配对码下面显示的地址(ip 或 ip:port),不在同一网段时填写
+ string address = 2;
}
message RedeemPairingCodeResponse {
@@ -207,6 +219,11 @@ message UnpairRequest {
string device_id = 1;
}
+message SetDeviceAddressRequest {
+ string device_id = 1;
+ string address = 2; // ip 或 ip:port
+}
+
// ─────────────────────────── 配置与状态 ───────────────────────────
message Config {
@@ -234,6 +251,10 @@ message Config {
// 界面语言:空字符串表示跟随系统;否则是 "zh-Hans"、"en"、"ja" 之一。
// 存在后台服务这里而不是界面里:Windows 的托盘菜单由后台服务画,也要跟着变。
string language = 13;
+
+ // 不在局域网里查找设备、也不接受局域网里的配对请求。
+ // 默认 false(即开启):写成反向的,旧配置不用迁移。
+ bool lan_disabled = 14;
}
// 最近一轮网络出口探测的结果。
@@ -243,6 +264,26 @@ message NetworkInfo {
int32 probed = 3; // 探测的服务器数(按 IP 去重后)
int32 answered = 4; // 有响应的服务器数
int64 probed_at_unix = 5;
+ LanInfo lan = 6;
+}
+
+// 局域网直连的诊断信息,见 copysync-cli nat。
+message LanInfo {
+ bool enabled = 1;
+ int32 port = 2; // 局域网信令的 UDP 端口
+ repeated string local_addresses = 3;
+ int32 discovered = 4; // mDNS 发现的 CopySync 实例数(含未配对的)
+ repeated LanPeer peers = 5;
+ bool blocked = 6; // 系统拦下了本机发往局域网的包(macOS 本地网络权限)
+}
+
+message LanPeer {
+ string device_id = 1;
+ string device_name = 2;
+ bool reachable = 3;
+ string address = 4; // 最近一次收到对方消息的地址
+ repeated string known_addresses = 5;
+ int64 last_seen_unix = 6;
}
message NetworkEgress {
@@ -260,6 +301,11 @@ message Status {
int64 cache_bytes_used = 5;
int32 peers_online = 6;
string version = 7;
+ // 设置里填了服务器地址。没填时只在局域网里同步,不算异常。
+ bool server_configured = 8;
+ bool lan_enabled = 9;
+ // 系统拦下了本机发往局域网的包:macOS 上是没允许「本地网络」权限
+ bool lan_blocked = 10;
}
message GetImagePreviewRequest {
diff --git a/proto/copysync/v1/wire.proto b/proto/copysync/v1/wire.proto
index 18e5440..10ebd81 100644
--- a/proto/copysync/v1/wire.proto
+++ b/proto/copysync/v1/wire.proto
@@ -1,8 +1,9 @@
-// 线上协议:客户端 ↔ 信令服务器,以及设备 ↔ 设备。
+// 线上协议:客户端 ↔ 信令服务器,同一局域网里的设备 ↔ 设备(UDP),
+// 以及连通之后的设备 ↔ 设备(DataChannel)。
//
// 信令服务器只转发、不解密内容,也不存用户——设备靠配对时交换的
-// Ed25519 公钥互相认证。所有经服务器中转的信令都带签名,
-// 防止服务器伪造 peer 身份做中间人。
+// Ed25519 公钥互相认证。所有经服务器或局域网转发的信令都带签名,
+// 防止服务器或同一网络里的其他人伪造 peer 身份做中间人。
syntax = "proto3";
@@ -27,6 +28,7 @@ message SignalMessage {
// 防重放:接收方拒绝时间戳过旧或 nonce 重复的消息
int64 timestamp_unix = 1;
bytes nonce = 2;
+ // 接收方只收发给自己的消息:局域网里谁都能把截到的消息转发给第三台设备
string to_device_id = 3;
oneof payload {
@@ -34,6 +36,7 @@ message SignalMessage {
SdpAnswer answer = 11;
IceCandidate candidate = 12;
Ping ping = 13;
+ LanHello lan_hello = 14; // 只走局域网,见下文
}
}
@@ -160,6 +163,55 @@ message ServerError {
string message = 2;
}
+// ═══════════════════ 局域网层(UDP 承载)═══════════════════
+//
+// 同一局域网里的设备不经服务器,用固定的 UDP 端口直接互发 LanPacket,
+// 每个包前面加 4 字节魔数 "CSL1"。设备靠 mDNS(_copysync._udp)互相发现。
+//
+// 已配对设备之间发的是与服务器转发时完全相同的 Signed,信任模型不变。
+// 配对请求与回复各自用发送方自带的公钥签名:这只能证明发送方持有那把私钥,
+// 防中间人仍然靠双方肉眼核对指纹——与经服务器配对时一样。
+
+message LanPacket {
+ oneof payload {
+ Signed signal = 1;
+ LanPairSigned pair_request = 2;
+ LanPairSigned pair_response = 3;
+ LanPairReject pair_reject = 4;
+ }
+}
+
+// 已配对设备之间的上线通知。还没连通时定期发,连通后低频保活。
+// 两端都往对方发,有状态的防火墙(Windows)会放行对方的包。
+message LanHello {
+ repeated string addresses = 1; // 发送方本机的局域网地址,ip:port
+ bool reply_wanted = 2; // 收到后回一条,让发送方也知道本端可达
+ uint32 interval_seconds = 3; // 发送方多久发一次;超过三倍没收到即视为不可达
+}
+
+// payload 是序列化后的 LanPairInfo,signature 用 LanPairInfo.public_key 签名。
+message LanPairSigned {
+ bytes payload = 1;
+ bytes signature = 2;
+}
+
+message LanPairInfo {
+ string code = 1; // 请求里是用户输入的配对码;回复里为空
+ string device_id = 2;
+ string device_name = 3;
+ string platform = 4;
+ bytes public_key = 5;
+ repeated string addresses = 6; // 发送方本机的局域网地址,ip:port
+ int64 timestamp_unix = 7;
+ bytes nonce = 8;
+ bytes request_nonce = 9; // 回复里回显请求的 nonce,把回复绑定到这次请求
+}
+
+message LanPairReject {
+ bytes request_nonce = 1;
+ string reason = 2; // wrong_code / closed / too_many_attempts
+}
+
// ═══════════════════ 设备间协议(DataChannel 承载)═══════════════════
//
// 控制消息与数据流走不同的 DataChannel,避免大文件传输阻塞控制通道。
diff --git a/proto/gen/copysync/v1/daemon.pb.go b/proto/gen/copysync/v1/daemon.pb.go
index f8491b1..04e851e 100644
--- a/proto/gen/copysync/v1/daemon.pb.go
+++ b/proto/gen/copysync/v1/daemon.pb.go
@@ -1183,6 +1183,9 @@ type CreatePairingCodeResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
ExpiresAtUnix int64 `protobuf:"varint,2,opt,name=expires_at_unix,json=expiresAtUnix,proto3" json:"expires_at_unix,omitempty"`
+ // 本机的局域网地址,默认路由所在的网卡排第一。不在同一网段时,
+ // 另一台要在输入配对码的同时输入其中一个。端口是默认值时省略端口。
+ LanAddresses []string `protobuf:"bytes,3,rep,name=lan_addresses,json=lanAddresses,proto3" json:"lan_addresses,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -1231,9 +1234,20 @@ func (x *CreatePairingCodeResponse) GetExpiresAtUnix() int64 {
return 0
}
+func (x *CreatePairingCodeResponse) GetLanAddresses() []string {
+ if x != nil {
+ return x.LanAddresses
+ }
+ return nil
+}
+
+// 在局域网和服务器上都找不到这个配对码时返回 NOT_FOUND;
+// 找到了但配对码不对返回 INVALID_ARGUMENT;配对码已失效返回 FAILED_PRECONDITION。
type RedeemPairingCodeRequest struct {
- state protoimpl.MessageState `protogen:"open.v1"`
- Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
+ state protoimpl.MessageState `protogen:"open.v1"`
+ Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
+ // 可选:对方配对码下面显示的地址(ip 或 ip:port),不在同一网段时填写
+ Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -1275,6 +1289,13 @@ func (x *RedeemPairingCodeRequest) GetCode() string {
return ""
}
+func (x *RedeemPairingCodeRequest) GetAddress() string {
+ if x != nil {
+ return x.Address
+ }
+ return ""
+}
+
type RedeemPairingCodeResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
// 返回对端信息供用户肉眼核对指纹,确认后再调 ConfirmPairing
@@ -1424,6 +1445,58 @@ func (x *UnpairRequest) GetDeviceId() string {
return ""
}
+type SetDeviceAddressRequest struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ DeviceId string `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
+ Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` // ip 或 ip:port
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *SetDeviceAddressRequest) Reset() {
+ *x = SetDeviceAddressRequest{}
+ mi := &file_copysync_v1_daemon_proto_msgTypes[18]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *SetDeviceAddressRequest) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SetDeviceAddressRequest) ProtoMessage() {}
+
+func (x *SetDeviceAddressRequest) ProtoReflect() protoreflect.Message {
+ mi := &file_copysync_v1_daemon_proto_msgTypes[18]
+ if x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use SetDeviceAddressRequest.ProtoReflect.Descriptor instead.
+func (*SetDeviceAddressRequest) Descriptor() ([]byte, []int) {
+ return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *SetDeviceAddressRequest) GetDeviceId() string {
+ if x != nil {
+ return x.DeviceId
+ }
+ return ""
+}
+
+func (x *SetDeviceAddressRequest) GetAddress() string {
+ if x != nil {
+ return x.Address
+ }
+ return ""
+}
+
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
// 小于此值自动预取,大于此值只同步元数据等用户手动拉取
@@ -1444,14 +1517,17 @@ type Config struct {
OnlyOwnStun bool `protobuf:"varint,12,opt,name=only_own_stun,json=onlyOwnStun,proto3" json:"only_own_stun,omitempty"`
// 界面语言:空字符串表示跟随系统;否则是 "zh-Hans"、"en"、"ja" 之一。
// 存在后台服务这里而不是界面里:Windows 的托盘菜单由后台服务画,也要跟着变。
- Language string `protobuf:"bytes,13,opt,name=language,proto3" json:"language,omitempty"`
+ Language string `protobuf:"bytes,13,opt,name=language,proto3" json:"language,omitempty"`
+ // 不在局域网里查找设备、也不接受局域网里的配对请求。
+ // 默认 false(即开启):写成反向的,旧配置不用迁移。
+ LanDisabled bool `protobuf:"varint,14,opt,name=lan_disabled,json=lanDisabled,proto3" json:"lan_disabled,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
- mi := &file_copysync_v1_daemon_proto_msgTypes[18]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[19]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1463,7 +1539,7 @@ func (x *Config) String() string {
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_daemon_proto_msgTypes[18]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[19]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1476,7 +1552,7 @@ func (x *Config) ProtoReflect() protoreflect.Message {
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
- return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{18}
+ return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{19}
}
func (x *Config) GetAutoSyncThresholdBytes() int64 {
@@ -1570,6 +1646,13 @@ func (x *Config) GetLanguage() string {
return ""
}
+func (x *Config) GetLanDisabled() bool {
+ if x != nil {
+ return x.LanDisabled
+ }
+ return false
+}
+
// 最近一轮网络出口探测的结果。
type NetworkInfo struct {
state protoimpl.MessageState `protogen:"open.v1"`
@@ -1578,13 +1661,14 @@ type NetworkInfo struct {
Probed int32 `protobuf:"varint,3,opt,name=probed,proto3" json:"probed,omitempty"` // 探测的服务器数(按 IP 去重后)
Answered int32 `protobuf:"varint,4,opt,name=answered,proto3" json:"answered,omitempty"` // 有响应的服务器数
ProbedAtUnix int64 `protobuf:"varint,5,opt,name=probed_at_unix,json=probedAtUnix,proto3" json:"probed_at_unix,omitempty"`
+ Lan *LanInfo `protobuf:"bytes,6,opt,name=lan,proto3" json:"lan,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *NetworkInfo) Reset() {
*x = NetworkInfo{}
- mi := &file_copysync_v1_daemon_proto_msgTypes[19]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[20]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1596,7 +1680,7 @@ func (x *NetworkInfo) String() string {
func (*NetworkInfo) ProtoMessage() {}
func (x *NetworkInfo) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_daemon_proto_msgTypes[19]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[20]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1609,7 +1693,7 @@ func (x *NetworkInfo) ProtoReflect() protoreflect.Message {
// Deprecated: Use NetworkInfo.ProtoReflect.Descriptor instead.
func (*NetworkInfo) Descriptor() ([]byte, []int) {
- return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{19}
+ return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{20}
}
func (x *NetworkInfo) GetLocalPort() int32 {
@@ -1647,6 +1731,182 @@ func (x *NetworkInfo) GetProbedAtUnix() int64 {
return 0
}
+func (x *NetworkInfo) GetLan() *LanInfo {
+ if x != nil {
+ return x.Lan
+ }
+ return nil
+}
+
+// 局域网直连的诊断信息,见 copysync-cli nat。
+type LanInfo struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
+ Port int32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"` // 局域网信令的 UDP 端口
+ LocalAddresses []string `protobuf:"bytes,3,rep,name=local_addresses,json=localAddresses,proto3" json:"local_addresses,omitempty"`
+ Discovered int32 `protobuf:"varint,4,opt,name=discovered,proto3" json:"discovered,omitempty"` // mDNS 发现的 CopySync 实例数(含未配对的)
+ Peers []*LanPeer `protobuf:"bytes,5,rep,name=peers,proto3" json:"peers,omitempty"`
+ Blocked bool `protobuf:"varint,6,opt,name=blocked,proto3" json:"blocked,omitempty"` // 系统拦下了本机发往局域网的包(macOS 本地网络权限)
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *LanInfo) Reset() {
+ *x = LanInfo{}
+ mi := &file_copysync_v1_daemon_proto_msgTypes[21]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *LanInfo) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LanInfo) ProtoMessage() {}
+
+func (x *LanInfo) ProtoReflect() protoreflect.Message {
+ mi := &file_copysync_v1_daemon_proto_msgTypes[21]
+ if x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use LanInfo.ProtoReflect.Descriptor instead.
+func (*LanInfo) Descriptor() ([]byte, []int) {
+ return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *LanInfo) GetEnabled() bool {
+ if x != nil {
+ return x.Enabled
+ }
+ return false
+}
+
+func (x *LanInfo) GetPort() int32 {
+ if x != nil {
+ return x.Port
+ }
+ return 0
+}
+
+func (x *LanInfo) GetLocalAddresses() []string {
+ if x != nil {
+ return x.LocalAddresses
+ }
+ return nil
+}
+
+func (x *LanInfo) GetDiscovered() int32 {
+ if x != nil {
+ return x.Discovered
+ }
+ return 0
+}
+
+func (x *LanInfo) GetPeers() []*LanPeer {
+ if x != nil {
+ return x.Peers
+ }
+ return nil
+}
+
+func (x *LanInfo) GetBlocked() bool {
+ if x != nil {
+ return x.Blocked
+ }
+ return false
+}
+
+type LanPeer struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ DeviceId string `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
+ DeviceName string `protobuf:"bytes,2,opt,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"`
+ Reachable bool `protobuf:"varint,3,opt,name=reachable,proto3" json:"reachable,omitempty"`
+ Address string `protobuf:"bytes,4,opt,name=address,proto3" json:"address,omitempty"` // 最近一次收到对方消息的地址
+ KnownAddresses []string `protobuf:"bytes,5,rep,name=known_addresses,json=knownAddresses,proto3" json:"known_addresses,omitempty"`
+ LastSeenUnix int64 `protobuf:"varint,6,opt,name=last_seen_unix,json=lastSeenUnix,proto3" json:"last_seen_unix,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *LanPeer) Reset() {
+ *x = LanPeer{}
+ mi := &file_copysync_v1_daemon_proto_msgTypes[22]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *LanPeer) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LanPeer) ProtoMessage() {}
+
+func (x *LanPeer) ProtoReflect() protoreflect.Message {
+ mi := &file_copysync_v1_daemon_proto_msgTypes[22]
+ if x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use LanPeer.ProtoReflect.Descriptor instead.
+func (*LanPeer) Descriptor() ([]byte, []int) {
+ return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *LanPeer) GetDeviceId() string {
+ if x != nil {
+ return x.DeviceId
+ }
+ return ""
+}
+
+func (x *LanPeer) GetDeviceName() string {
+ if x != nil {
+ return x.DeviceName
+ }
+ return ""
+}
+
+func (x *LanPeer) GetReachable() bool {
+ if x != nil {
+ return x.Reachable
+ }
+ return false
+}
+
+func (x *LanPeer) GetAddress() string {
+ if x != nil {
+ return x.Address
+ }
+ return ""
+}
+
+func (x *LanPeer) GetKnownAddresses() []string {
+ if x != nil {
+ return x.KnownAddresses
+ }
+ return nil
+}
+
+func (x *LanPeer) GetLastSeenUnix() int64 {
+ if x != nil {
+ return x.LastSeenUnix
+ }
+ return 0
+}
+
type NetworkEgress struct {
state protoimpl.MessageState `protogen:"open.v1"`
Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` // 本机在这个出口上的公网 ip:port
@@ -1659,7 +1919,7 @@ type NetworkEgress struct {
func (x *NetworkEgress) Reset() {
*x = NetworkEgress{}
- mi := &file_copysync_v1_daemon_proto_msgTypes[20]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[23]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1671,7 +1931,7 @@ func (x *NetworkEgress) String() string {
func (*NetworkEgress) ProtoMessage() {}
func (x *NetworkEgress) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_daemon_proto_msgTypes[20]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[23]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1684,7 +1944,7 @@ func (x *NetworkEgress) ProtoReflect() protoreflect.Message {
// Deprecated: Use NetworkEgress.ProtoReflect.Descriptor instead.
func (*NetworkEgress) Descriptor() ([]byte, []int) {
- return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{20}
+ return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{23}
}
func (x *NetworkEgress) GetAddress() string {
@@ -1724,13 +1984,18 @@ type Status struct {
CacheBytesUsed int64 `protobuf:"varint,5,opt,name=cache_bytes_used,json=cacheBytesUsed,proto3" json:"cache_bytes_used,omitempty"`
PeersOnline int32 `protobuf:"varint,6,opt,name=peers_online,json=peersOnline,proto3" json:"peers_online,omitempty"`
Version string `protobuf:"bytes,7,opt,name=version,proto3" json:"version,omitempty"`
- unknownFields protoimpl.UnknownFields
- sizeCache protoimpl.SizeCache
+ // 设置里填了服务器地址。没填时只在局域网里同步,不算异常。
+ ServerConfigured bool `protobuf:"varint,8,opt,name=server_configured,json=serverConfigured,proto3" json:"server_configured,omitempty"`
+ LanEnabled bool `protobuf:"varint,9,opt,name=lan_enabled,json=lanEnabled,proto3" json:"lan_enabled,omitempty"`
+ // 系统拦下了本机发往局域网的包:macOS 上是没允许「本地网络」权限
+ LanBlocked bool `protobuf:"varint,10,opt,name=lan_blocked,json=lanBlocked,proto3" json:"lan_blocked,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
}
func (x *Status) Reset() {
*x = Status{}
- mi := &file_copysync_v1_daemon_proto_msgTypes[21]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[24]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1742,7 +2007,7 @@ func (x *Status) String() string {
func (*Status) ProtoMessage() {}
func (x *Status) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_daemon_proto_msgTypes[21]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[24]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1755,7 +2020,7 @@ func (x *Status) ProtoReflect() protoreflect.Message {
// Deprecated: Use Status.ProtoReflect.Descriptor instead.
func (*Status) Descriptor() ([]byte, []int) {
- return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{21}
+ return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{24}
}
func (x *Status) GetDeviceId() string {
@@ -1807,6 +2072,27 @@ func (x *Status) GetVersion() string {
return ""
}
+func (x *Status) GetServerConfigured() bool {
+ if x != nil {
+ return x.ServerConfigured
+ }
+ return false
+}
+
+func (x *Status) GetLanEnabled() bool {
+ if x != nil {
+ return x.LanEnabled
+ }
+ return false
+}
+
+func (x *Status) GetLanBlocked() bool {
+ if x != nil {
+ return x.LanBlocked
+ }
+ return false
+}
+
type GetImagePreviewRequest struct {
state protoimpl.MessageState `protogen:"open.v1"`
ClipId string `protobuf:"bytes,1,opt,name=clip_id,json=clipId,proto3" json:"clip_id,omitempty"`
@@ -1817,7 +2103,7 @@ type GetImagePreviewRequest struct {
func (x *GetImagePreviewRequest) Reset() {
*x = GetImagePreviewRequest{}
- mi := &file_copysync_v1_daemon_proto_msgTypes[22]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[25]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1829,7 +2115,7 @@ func (x *GetImagePreviewRequest) String() string {
func (*GetImagePreviewRequest) ProtoMessage() {}
func (x *GetImagePreviewRequest) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_daemon_proto_msgTypes[22]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[25]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1842,7 +2128,7 @@ func (x *GetImagePreviewRequest) ProtoReflect() protoreflect.Message {
// Deprecated: Use GetImagePreviewRequest.ProtoReflect.Descriptor instead.
func (*GetImagePreviewRequest) Descriptor() ([]byte, []int) {
- return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{22}
+ return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{25}
}
func (x *GetImagePreviewRequest) GetClipId() string {
@@ -1870,7 +2156,7 @@ type GetImagePreviewResponse struct {
func (x *GetImagePreviewResponse) Reset() {
*x = GetImagePreviewResponse{}
- mi := &file_copysync_v1_daemon_proto_msgTypes[23]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[26]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1882,7 +2168,7 @@ func (x *GetImagePreviewResponse) String() string {
func (*GetImagePreviewResponse) ProtoMessage() {}
func (x *GetImagePreviewResponse) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_daemon_proto_msgTypes[23]
+ mi := &file_copysync_v1_daemon_proto_msgTypes[26]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1895,7 +2181,7 @@ func (x *GetImagePreviewResponse) ProtoReflect() protoreflect.Message {
// Deprecated: Use GetImagePreviewResponse.ProtoReflect.Descriptor instead.
func (*GetImagePreviewResponse) Descriptor() ([]byte, []int) {
- return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{23}
+ return file_copysync_v1_daemon_proto_rawDescGZIP(), []int{26}
}
func (x *GetImagePreviewResponse) GetPath() string {
@@ -1995,12 +2281,14 @@ const file_copysync_v1_daemon_proto_rawDesc = "" +
"\aclip_id\x18\x01 \x01(\tR\x06clipId\"i\n" +
"\x13ListDevicesResponse\x12'\n" +
"\x04self\x18\x01 \x01(\v2\x13.copysync.v1.DeviceR\x04self\x12)\n" +
- "\x05peers\x18\x02 \x03(\v2\x13.copysync.v1.DeviceR\x05peers\"W\n" +
+ "\x05peers\x18\x02 \x03(\v2\x13.copysync.v1.DeviceR\x05peers\"|\n" +
"\x19CreatePairingCodeResponse\x12\x12\n" +
"\x04code\x18\x01 \x01(\tR\x04code\x12&\n" +
- "\x0fexpires_at_unix\x18\x02 \x01(\x03R\rexpiresAtUnix\".\n" +
+ "\x0fexpires_at_unix\x18\x02 \x01(\x03R\rexpiresAtUnix\x12#\n" +
+ "\rlan_addresses\x18\x03 \x03(\tR\flanAddresses\"H\n" +
"\x18RedeemPairingCodeRequest\x12\x12\n" +
- "\x04code\x18\x01 \x01(\tR\x04code\"m\n" +
+ "\x04code\x18\x01 \x01(\tR\x04code\x12\x18\n" +
+ "\aaddress\x18\x02 \x01(\tR\aaddress\"m\n" +
"\x19RedeemPairingCodeResponse\x12'\n" +
"\x04peer\x18\x01 \x01(\v2\x13.copysync.v1.DeviceR\x04peer\x12'\n" +
"\x0fpairing_session\x18\x02 \x01(\tR\x0epairingSession\"X\n" +
@@ -2008,7 +2296,10 @@ const file_copysync_v1_daemon_proto_rawDesc = "" +
"\x0fpairing_session\x18\x01 \x01(\tR\x0epairingSession\x12\x16\n" +
"\x06accept\x18\x02 \x01(\bR\x06accept\",\n" +
"\rUnpairRequest\x12\x1b\n" +
- "\tdevice_id\x18\x01 \x01(\tR\bdeviceId\"\xfa\x03\n" +
+ "\tdevice_id\x18\x01 \x01(\tR\bdeviceId\"P\n" +
+ "\x17SetDeviceAddressRequest\x12\x1b\n" +
+ "\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12\x18\n" +
+ "\aaddress\x18\x02 \x01(\tR\aaddress\"\x9d\x04\n" +
"\x06Config\x129\n" +
"\x19auto_sync_threshold_bytes\x18\x01 \x01(\x03R\x16autoSyncThresholdBytes\x12.\n" +
"\x13history_ttl_seconds\x18\x02 \x01(\x03R\x11historyTtlSeconds\x12*\n" +
@@ -2025,19 +2316,38 @@ const file_copysync_v1_daemon_proto_rawDesc = "" +
"deviceName\x12#\n" +
"\rsignaling_url\x18\v \x01(\tR\fsignalingUrl\x12\"\n" +
"\ronly_own_stun\x18\f \x01(\bR\vonlyOwnStun\x12\x1a\n" +
- "\blanguage\x18\r \x01(\tR\blanguage\"\xbe\x01\n" +
+ "\blanguage\x18\r \x01(\tR\blanguage\x12!\n" +
+ "\flan_disabled\x18\x0e \x01(\bR\vlanDisabled\"\xe6\x01\n" +
"\vNetworkInfo\x12\x1d\n" +
"\n" +
"local_port\x18\x01 \x01(\x05R\tlocalPort\x126\n" +
"\begresses\x18\x02 \x03(\v2\x1a.copysync.v1.NetworkEgressR\begresses\x12\x16\n" +
"\x06probed\x18\x03 \x01(\x05R\x06probed\x12\x1a\n" +
"\banswered\x18\x04 \x01(\x05R\banswered\x12$\n" +
- "\x0eprobed_at_unix\x18\x05 \x01(\x03R\fprobedAtUnix\"|\n" +
+ "\x0eprobed_at_unix\x18\x05 \x01(\x03R\fprobedAtUnix\x12&\n" +
+ "\x03lan\x18\x06 \x01(\v2\x14.copysync.v1.LanInfoR\x03lan\"\xc6\x01\n" +
+ "\aLanInfo\x12\x18\n" +
+ "\aenabled\x18\x01 \x01(\bR\aenabled\x12\x12\n" +
+ "\x04port\x18\x02 \x01(\x05R\x04port\x12'\n" +
+ "\x0flocal_addresses\x18\x03 \x03(\tR\x0elocalAddresses\x12\x1e\n" +
+ "\n" +
+ "discovered\x18\x04 \x01(\x05R\n" +
+ "discovered\x12*\n" +
+ "\x05peers\x18\x05 \x03(\v2\x14.copysync.v1.LanPeerR\x05peers\x12\x18\n" +
+ "\ablocked\x18\x06 \x01(\bR\ablocked\"\xce\x01\n" +
+ "\aLanPeer\x12\x1b\n" +
+ "\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12\x1f\n" +
+ "\vdevice_name\x18\x02 \x01(\tR\n" +
+ "deviceName\x12\x1c\n" +
+ "\treachable\x18\x03 \x01(\bR\treachable\x12\x18\n" +
+ "\aaddress\x18\x04 \x01(\tR\aaddress\x12'\n" +
+ "\x0fknown_addresses\x18\x05 \x03(\tR\x0eknownAddresses\x12$\n" +
+ "\x0elast_seen_unix\x18\x06 \x01(\x03R\flastSeenUnix\"|\n" +
"\rNetworkEgress\x12\x18\n" +
"\aaddress\x18\x01 \x01(\tR\aaddress\x12%\n" +
"\x0eport_preserved\x18\x02 \x01(\bR\rportPreserved\x12\x18\n" +
"\aguessed\x18\x03 \x01(\bR\aguessed\x12\x10\n" +
- "\x03via\x18\x04 \x03(\tR\x03via\"\xb3\x02\n" +
+ "\x03via\x18\x04 \x03(\tR\x03via\"\xa2\x03\n" +
"\x06Status\x12\x1b\n" +
"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12\x1f\n" +
"\vdevice_name\x18\x02 \x01(\tR\n" +
@@ -2046,7 +2356,13 @@ const file_copysync_v1_daemon_proto_rawDesc = "" +
"\x14clipboard_permission\x18\x04 \x01(\x0e2 .copysync.v1.ClipboardPermissionR\x13clipboardPermission\x12(\n" +
"\x10cache_bytes_used\x18\x05 \x01(\x03R\x0ecacheBytesUsed\x12!\n" +
"\fpeers_online\x18\x06 \x01(\x05R\vpeersOnline\x12\x18\n" +
- "\aversion\x18\a \x01(\tR\aversion\"G\n" +
+ "\aversion\x18\a \x01(\tR\aversion\x12+\n" +
+ "\x11server_configured\x18\b \x01(\bR\x10serverConfigured\x12\x1f\n" +
+ "\vlan_enabled\x18\t \x01(\bR\n" +
+ "lanEnabled\x12\x1f\n" +
+ "\vlan_blocked\x18\n" +
+ " \x01(\bR\n" +
+ "lanBlocked\"G\n" +
"\x16GetImagePreviewRequest\x12\x17\n" +
"\aclip_id\x18\x01 \x01(\tR\x06clipId\x12\x14\n" +
"\x05index\x18\x02 \x01(\x05R\x05index\"W\n" +
@@ -2079,7 +2395,8 @@ const file_copysync_v1_daemon_proto_rawDesc = "" +
"\x1cCLIPBOARD_PERMISSION_DEFAULT\x10\x02\x12\x1c\n" +
"\x18CLIPBOARD_PERMISSION_ASK\x10\x03\x12%\n" +
"!CLIPBOARD_PERMISSION_ALWAYS_ALLOW\x10\x04\x12$\n" +
- " CLIPBOARD_PERMISSION_ALWAYS_DENY\x10\x052\xf5\b\n" +
+ " CLIPBOARD_PERMISSION_ALWAYS_DENY\x10\x052\x8c\n" +
+ "\n" +
"\rDaemonService\x12@\n" +
"\tSubscribe\x12\x1d.copysync.v1.SubscribeRequest\x1a\x12.copysync.v1.Event0\x01\x12P\n" +
"\vListHistory\x12\x1f.copysync.v1.ListHistoryRequest\x1a .copysync.v1.ListHistoryResponse\x12F\n" +
@@ -2091,11 +2408,13 @@ const file_copysync_v1_daemon_proto_rawDesc = "" +
"\x11CreatePairingCode\x12\x12.copysync.v1.Empty\x1a&.copysync.v1.CreatePairingCodeResponse\x12b\n" +
"\x11RedeemPairingCode\x12%.copysync.v1.RedeemPairingCodeRequest\x1a&.copysync.v1.RedeemPairingCodeResponse\x12H\n" +
"\x0eConfirmPairing\x12\".copysync.v1.ConfirmPairingRequest\x1a\x12.copysync.v1.Empty\x128\n" +
- "\x06Unpair\x12\x1a.copysync.v1.UnpairRequest\x1a\x12.copysync.v1.Empty\x124\n" +
+ "\x06Unpair\x12\x1a.copysync.v1.UnpairRequest\x1a\x12.copysync.v1.Empty\x12L\n" +
+ "\x10SetDeviceAddress\x12$.copysync.v1.SetDeviceAddressRequest\x1a\x12.copysync.v1.Empty\x124\n" +
"\tGetConfig\x12\x12.copysync.v1.Empty\x1a\x13.copysync.v1.Config\x128\n" +
"\fUpdateConfig\x12\x13.copysync.v1.Config\x1a\x13.copysync.v1.Config\x124\n" +
"\tGetStatus\x12\x12.copysync.v1.Empty\x1a\x13.copysync.v1.Status\x12D\n" +
- "\x1aRequestClipboardPermission\x12\x12.copysync.v1.Empty\x1a\x12.copysync.v1.Empty\x12:\n" +
+ "\x1aRequestClipboardPermission\x12\x12.copysync.v1.Empty\x1a\x12.copysync.v1.Empty\x12G\n" +
+ "\x1dRequestLocalNetworkPermission\x12\x12.copysync.v1.Empty\x1a\x12.copysync.v1.Empty\x12:\n" +
"\n" +
"GetNetwork\x12\x12.copysync.v1.Empty\x1a\x18.copysync.v1.NetworkInfoB>Z<github.com/baiyuze/copysync/proto/gen/copysync/v1;copysyncv1b\x06proto3"
@@ -2112,7 +2431,7 @@ func file_copysync_v1_daemon_proto_rawDescGZIP() []byte {
}
var file_copysync_v1_daemon_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
-var file_copysync_v1_daemon_proto_msgTypes = make([]protoimpl.MessageInfo, 24)
+var file_copysync_v1_daemon_proto_msgTypes = make([]protoimpl.MessageInfo, 27)
var file_copysync_v1_daemon_proto_goTypes = []any{
(ClipKind)(0), // 0: copysync.v1.ClipKind
(ClipStatus)(0), // 1: copysync.v1.ClipStatus
@@ -2136,12 +2455,15 @@ var file_copysync_v1_daemon_proto_goTypes = []any{
(*RedeemPairingCodeResponse)(nil), // 19: copysync.v1.RedeemPairingCodeResponse
(*ConfirmPairingRequest)(nil), // 20: copysync.v1.ConfirmPairingRequest
(*UnpairRequest)(nil), // 21: copysync.v1.UnpairRequest
- (*Config)(nil), // 22: copysync.v1.Config
- (*NetworkInfo)(nil), // 23: copysync.v1.NetworkInfo
- (*NetworkEgress)(nil), // 24: copysync.v1.NetworkEgress
- (*Status)(nil), // 25: copysync.v1.Status
- (*GetImagePreviewRequest)(nil), // 26: copysync.v1.GetImagePreviewRequest
- (*GetImagePreviewResponse)(nil), // 27: copysync.v1.GetImagePreviewResponse
+ (*SetDeviceAddressRequest)(nil), // 22: copysync.v1.SetDeviceAddressRequest
+ (*Config)(nil), // 23: copysync.v1.Config
+ (*NetworkInfo)(nil), // 24: copysync.v1.NetworkInfo
+ (*LanInfo)(nil), // 25: copysync.v1.LanInfo
+ (*LanPeer)(nil), // 26: copysync.v1.LanPeer
+ (*NetworkEgress)(nil), // 27: copysync.v1.NetworkEgress
+ (*Status)(nil), // 28: copysync.v1.Status
+ (*GetImagePreviewRequest)(nil), // 29: copysync.v1.GetImagePreviewRequest
+ (*GetImagePreviewResponse)(nil), // 30: copysync.v1.GetImagePreviewResponse
}
var file_copysync_v1_daemon_proto_depIdxs = []int32{
0, // 0: copysync.v1.ClipRecord.kind:type_name -> copysync.v1.ClipKind
@@ -2153,51 +2475,57 @@ var file_copysync_v1_daemon_proto_depIdxs = []int32{
8, // 6: copysync.v1.Event.progress:type_name -> copysync.v1.TransferProgress
9, // 7: copysync.v1.Event.device_changed:type_name -> copysync.v1.Device
3, // 8: copysync.v1.Event.permission_changed:type_name -> copysync.v1.ClipboardPermission
- 25, // 9: copysync.v1.Event.status_changed:type_name -> copysync.v1.Status
+ 28, // 9: copysync.v1.Event.status_changed:type_name -> copysync.v1.Status
0, // 10: copysync.v1.ListHistoryRequest.kind_filter:type_name -> copysync.v1.ClipKind
6, // 11: copysync.v1.ListHistoryResponse.records:type_name -> copysync.v1.ClipRecord
9, // 12: copysync.v1.ListDevicesResponse.self:type_name -> copysync.v1.Device
9, // 13: copysync.v1.ListDevicesResponse.peers:type_name -> copysync.v1.Device
9, // 14: copysync.v1.RedeemPairingCodeResponse.peer:type_name -> copysync.v1.Device
- 24, // 15: copysync.v1.NetworkInfo.egresses:type_name -> copysync.v1.NetworkEgress
- 3, // 16: copysync.v1.Status.clipboard_permission:type_name -> copysync.v1.ClipboardPermission
- 7, // 17: copysync.v1.DaemonService.Subscribe:input_type -> copysync.v1.SubscribeRequest
- 11, // 18: copysync.v1.DaemonService.ListHistory:input_type -> copysync.v1.ListHistoryRequest
- 13, // 19: copysync.v1.DaemonService.DeleteHistory:input_type -> copysync.v1.DeleteHistoryRequest
- 14, // 20: copysync.v1.DaemonService.Fetch:input_type -> copysync.v1.FetchRequest
- 15, // 21: copysync.v1.DaemonService.ApplyToClipboard:input_type -> copysync.v1.ApplyToClipboardRequest
- 26, // 22: copysync.v1.DaemonService.GetImagePreview:input_type -> copysync.v1.GetImagePreviewRequest
- 4, // 23: copysync.v1.DaemonService.ListDevices:input_type -> copysync.v1.Empty
- 4, // 24: copysync.v1.DaemonService.CreatePairingCode:input_type -> copysync.v1.Empty
- 18, // 25: copysync.v1.DaemonService.RedeemPairingCode:input_type -> copysync.v1.RedeemPairingCodeRequest
- 20, // 26: copysync.v1.DaemonService.ConfirmPairing:input_type -> copysync.v1.ConfirmPairingRequest
- 21, // 27: copysync.v1.DaemonService.Unpair:input_type -> copysync.v1.UnpairRequest
- 4, // 28: copysync.v1.DaemonService.GetConfig:input_type -> copysync.v1.Empty
- 22, // 29: copysync.v1.DaemonService.UpdateConfig:input_type -> copysync.v1.Config
- 4, // 30: copysync.v1.DaemonService.GetStatus:input_type -> copysync.v1.Empty
- 4, // 31: copysync.v1.DaemonService.RequestClipboardPermission:input_type -> copysync.v1.Empty
- 4, // 32: copysync.v1.DaemonService.GetNetwork:input_type -> copysync.v1.Empty
- 10, // 33: copysync.v1.DaemonService.Subscribe:output_type -> copysync.v1.Event
- 12, // 34: copysync.v1.DaemonService.ListHistory:output_type -> copysync.v1.ListHistoryResponse
- 4, // 35: copysync.v1.DaemonService.DeleteHistory:output_type -> copysync.v1.Empty
- 4, // 36: copysync.v1.DaemonService.Fetch:output_type -> copysync.v1.Empty
- 4, // 37: copysync.v1.DaemonService.ApplyToClipboard:output_type -> copysync.v1.Empty
- 27, // 38: copysync.v1.DaemonService.GetImagePreview:output_type -> copysync.v1.GetImagePreviewResponse
- 16, // 39: copysync.v1.DaemonService.ListDevices:output_type -> copysync.v1.ListDevicesResponse
- 17, // 40: copysync.v1.DaemonService.CreatePairingCode:output_type -> copysync.v1.CreatePairingCodeResponse
- 19, // 41: copysync.v1.DaemonService.RedeemPairingCode:output_type -> copysync.v1.RedeemPairingCodeResponse
- 4, // 42: copysync.v1.DaemonService.ConfirmPairing:output_type -> copysync.v1.Empty
- 4, // 43: copysync.v1.DaemonService.Unpair:output_type -> copysync.v1.Empty
- 22, // 44: copysync.v1.DaemonService.GetConfig:output_type -> copysync.v1.Config
- 22, // 45: copysync.v1.DaemonService.UpdateConfig:output_type -> copysync.v1.Config
- 25, // 46: copysync.v1.DaemonService.GetStatus:output_type -> copysync.v1.Status
- 4, // 47: copysync.v1.DaemonService.RequestClipboardPermission:output_type -> copysync.v1.Empty
- 23, // 48: copysync.v1.DaemonService.GetNetwork:output_type -> copysync.v1.NetworkInfo
- 33, // [33:49] is the sub-list for method output_type
- 17, // [17:33] is the sub-list for method input_type
- 17, // [17:17] is the sub-list for extension type_name
- 17, // [17:17] is the sub-list for extension extendee
- 0, // [0:17] is the sub-list for field type_name
+ 27, // 15: copysync.v1.NetworkInfo.egresses:type_name -> copysync.v1.NetworkEgress
+ 25, // 16: copysync.v1.NetworkInfo.lan:type_name -> copysync.v1.LanInfo
+ 26, // 17: copysync.v1.LanInfo.peers:type_name -> copysync.v1.LanPeer
+ 3, // 18: copysync.v1.Status.clipboard_permission:type_name -> copysync.v1.ClipboardPermission
+ 7, // 19: copysync.v1.DaemonService.Subscribe:input_type -> copysync.v1.SubscribeRequest
+ 11, // 20: copysync.v1.DaemonService.ListHistory:input_type -> copysync.v1.ListHistoryRequest
+ 13, // 21: copysync.v1.DaemonService.DeleteHistory:input_type -> copysync.v1.DeleteHistoryRequest
+ 14, // 22: copysync.v1.DaemonService.Fetch:input_type -> copysync.v1.FetchRequest
+ 15, // 23: copysync.v1.DaemonService.ApplyToClipboard:input_type -> copysync.v1.ApplyToClipboardRequest
+ 29, // 24: copysync.v1.DaemonService.GetImagePreview:input_type -> copysync.v1.GetImagePreviewRequest
+ 4, // 25: copysync.v1.DaemonService.ListDevices:input_type -> copysync.v1.Empty
+ 4, // 26: copysync.v1.DaemonService.CreatePairingCode:input_type -> copysync.v1.Empty
+ 18, // 27: copysync.v1.DaemonService.RedeemPairingCode:input_type -> copysync.v1.RedeemPairingCodeRequest
+ 20, // 28: copysync.v1.DaemonService.ConfirmPairing:input_type -> copysync.v1.ConfirmPairingRequest
+ 21, // 29: copysync.v1.DaemonService.Unpair:input_type -> copysync.v1.UnpairRequest
+ 22, // 30: copysync.v1.DaemonService.SetDeviceAddress:input_type -> copysync.v1.SetDeviceAddressRequest
+ 4, // 31: copysync.v1.DaemonService.GetConfig:input_type -> copysync.v1.Empty
+ 23, // 32: copysync.v1.DaemonService.UpdateConfig:input_type -> copysync.v1.Config
+ 4, // 33: copysync.v1.DaemonService.GetStatus:input_type -> copysync.v1.Empty
+ 4, // 34: copysync.v1.DaemonService.RequestClipboardPermission:input_type -> copysync.v1.Empty
+ 4, // 35: copysync.v1.DaemonService.RequestLocalNetworkPermission:input_type -> copysync.v1.Empty
+ 4, // 36: copysync.v1.DaemonService.GetNetwork:input_type -> copysync.v1.Empty
+ 10, // 37: copysync.v1.DaemonService.Subscribe:output_type -> copysync.v1.Event
+ 12, // 38: copysync.v1.DaemonService.ListHistory:output_type -> copysync.v1.ListHistoryResponse
+ 4, // 39: copysync.v1.DaemonService.DeleteHistory:output_type -> copysync.v1.Empty
+ 4, // 40: copysync.v1.DaemonService.Fetch:output_type -> copysync.v1.Empty
+ 4, // 41: copysync.v1.DaemonService.ApplyToClipboard:output_type -> copysync.v1.Empty
+ 30, // 42: copysync.v1.DaemonService.GetImagePreview:output_type -> copysync.v1.GetImagePreviewResponse
+ 16, // 43: copysync.v1.DaemonService.ListDevices:output_type -> copysync.v1.ListDevicesResponse
+ 17, // 44: copysync.v1.DaemonService.CreatePairingCode:output_type -> copysync.v1.CreatePairingCodeResponse
+ 19, // 45: copysync.v1.DaemonService.RedeemPairingCode:output_type -> copysync.v1.RedeemPairingCodeResponse
+ 4, // 46: copysync.v1.DaemonService.ConfirmPairing:output_type -> copysync.v1.Empty
+ 4, // 47: copysync.v1.DaemonService.Unpair:output_type -> copysync.v1.Empty
+ 4, // 48: copysync.v1.DaemonService.SetDeviceAddress:output_type -> copysync.v1.Empty
+ 23, // 49: copysync.v1.DaemonService.GetConfig:output_type -> copysync.v1.Config
+ 23, // 50: copysync.v1.DaemonService.UpdateConfig:output_type -> copysync.v1.Config
+ 28, // 51: copysync.v1.DaemonService.GetStatus:output_type -> copysync.v1.Status
+ 4, // 52: copysync.v1.DaemonService.RequestClipboardPermission:output_type -> copysync.v1.Empty
+ 4, // 53: copysync.v1.DaemonService.RequestLocalNetworkPermission:output_type -> copysync.v1.Empty
+ 24, // 54: copysync.v1.DaemonService.GetNetwork:output_type -> copysync.v1.NetworkInfo
+ 37, // [37:55] is the sub-list for method output_type
+ 19, // [19:37] is the sub-list for method input_type
+ 19, // [19:19] is the sub-list for extension type_name
+ 19, // [19:19] is the sub-list for extension extendee
+ 0, // [0:19] is the sub-list for field type_name
}
func init() { file_copysync_v1_daemon_proto_init() }
@@ -2220,7 +2548,7 @@ func file_copysync_v1_daemon_proto_init() {
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_copysync_v1_daemon_proto_rawDesc), len(file_copysync_v1_daemon_proto_rawDesc)),
NumEnums: 4,
- NumMessages: 24,
+ NumMessages: 27,
NumExtensions: 0,
NumServices: 1,
},
diff --git a/proto/gen/copysync/v1/daemon_grpc.pb.go b/proto/gen/copysync/v1/daemon_grpc.pb.go
index aa1b941..d3c495b 100644
--- a/proto/gen/copysync/v1/daemon_grpc.pb.go
+++ b/proto/gen/copysync/v1/daemon_grpc.pb.go
@@ -24,22 +24,24 @@ import (
const _ = grpc.SupportPackageIsVersion9
const (
- DaemonService_Subscribe_FullMethodName = "/copysync.v1.DaemonService/Subscribe"
- DaemonService_ListHistory_FullMethodName = "/copysync.v1.DaemonService/ListHistory"
- DaemonService_DeleteHistory_FullMethodName = "/copysync.v1.DaemonService/DeleteHistory"
- DaemonService_Fetch_FullMethodName = "/copysync.v1.DaemonService/Fetch"
- DaemonService_ApplyToClipboard_FullMethodName = "/copysync.v1.DaemonService/ApplyToClipboard"
- DaemonService_GetImagePreview_FullMethodName = "/copysync.v1.DaemonService/GetImagePreview"
- DaemonService_ListDevices_FullMethodName = "/copysync.v1.DaemonService/ListDevices"
- DaemonService_CreatePairingCode_FullMethodName = "/copysync.v1.DaemonService/CreatePairingCode"
- DaemonService_RedeemPairingCode_FullMethodName = "/copysync.v1.DaemonService/RedeemPairingCode"
- DaemonService_ConfirmPairing_FullMethodName = "/copysync.v1.DaemonService/ConfirmPairing"
- DaemonService_Unpair_FullMethodName = "/copysync.v1.DaemonService/Unpair"
- DaemonService_GetConfig_FullMethodName = "/copysync.v1.DaemonService/GetConfig"
- DaemonService_UpdateConfig_FullMethodName = "/copysync.v1.DaemonService/UpdateConfig"
- DaemonService_GetStatus_FullMethodName = "/copysync.v1.DaemonService/GetStatus"
- DaemonService_RequestClipboardPermission_FullMethodName = "/copysync.v1.DaemonService/RequestClipboardPermission"
- DaemonService_GetNetwork_FullMethodName = "/copysync.v1.DaemonService/GetNetwork"
+ DaemonService_Subscribe_FullMethodName = "/copysync.v1.DaemonService/Subscribe"
+ DaemonService_ListHistory_FullMethodName = "/copysync.v1.DaemonService/ListHistory"
+ DaemonService_DeleteHistory_FullMethodName = "/copysync.v1.DaemonService/DeleteHistory"
+ DaemonService_Fetch_FullMethodName = "/copysync.v1.DaemonService/Fetch"
+ DaemonService_ApplyToClipboard_FullMethodName = "/copysync.v1.DaemonService/ApplyToClipboard"
+ DaemonService_GetImagePreview_FullMethodName = "/copysync.v1.DaemonService/GetImagePreview"
+ DaemonService_ListDevices_FullMethodName = "/copysync.v1.DaemonService/ListDevices"
+ DaemonService_CreatePairingCode_FullMethodName = "/copysync.v1.DaemonService/CreatePairingCode"
+ DaemonService_RedeemPairingCode_FullMethodName = "/copysync.v1.DaemonService/RedeemPairingCode"
+ DaemonService_ConfirmPairing_FullMethodName = "/copysync.v1.DaemonService/ConfirmPairing"
+ DaemonService_Unpair_FullMethodName = "/copysync.v1.DaemonService/Unpair"
+ DaemonService_SetDeviceAddress_FullMethodName = "/copysync.v1.DaemonService/SetDeviceAddress"
+ DaemonService_GetConfig_FullMethodName = "/copysync.v1.DaemonService/GetConfig"
+ DaemonService_UpdateConfig_FullMethodName = "/copysync.v1.DaemonService/UpdateConfig"
+ DaemonService_GetStatus_FullMethodName = "/copysync.v1.DaemonService/GetStatus"
+ DaemonService_RequestClipboardPermission_FullMethodName = "/copysync.v1.DaemonService/RequestClipboardPermission"
+ DaemonService_RequestLocalNetworkPermission_FullMethodName = "/copysync.v1.DaemonService/RequestLocalNetworkPermission"
+ DaemonService_GetNetwork_FullMethodName = "/copysync.v1.DaemonService/GetNetwork"
)
// DaemonServiceClient is the client API for DaemonService service.
@@ -62,11 +64,16 @@ type DaemonServiceClient interface {
// 配对双方各自确认指纹后才真正互信
ConfirmPairing(ctx context.Context, in *ConfirmPairingRequest, opts ...grpc.CallOption) (*Empty, error)
Unpair(ctx context.Context, in *UnpairRequest, opts ...grpc.CallOption) (*Empty, error)
+ // 手动告诉后台服务某台设备的局域网地址:跨网段、或两边都换了地址时用
+ SetDeviceAddress(ctx context.Context, in *SetDeviceAddressRequest, opts ...grpc.CallOption) (*Empty, error)
GetConfig(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Config, error)
UpdateConfig(ctx context.Context, in *Config, opts ...grpc.CallOption) (*Config, error)
GetStatus(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Status, error)
// 引导用户授予剪贴板权限(打开系统设置面板)
RequestClipboardPermission(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
+ // 让系统放行局域网访问:macOS 打开「本地网络」设置面板;
+ // Windows 申请管理员权限,在防火墙里放行后台服务。其他平台返回 UNIMPLEMENTED。
+ RequestLocalNetworkPermission(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
// 网络出口与打洞诊断:本机有几个出口、各自的公网地址,见 copysync-cli nat
GetNetwork(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*NetworkInfo, error)
}
@@ -198,6 +205,16 @@ func (c *daemonServiceClient) Unpair(ctx context.Context, in *UnpairRequest, opt
return out, nil
}
+func (c *daemonServiceClient) SetDeviceAddress(ctx context.Context, in *SetDeviceAddressRequest, opts ...grpc.CallOption) (*Empty, error) {
+ cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+ out := new(Empty)
+ err := c.cc.Invoke(ctx, DaemonService_SetDeviceAddress_FullMethodName, in, out, cOpts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
func (c *daemonServiceClient) GetConfig(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Config, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(Config)
@@ -238,6 +255,16 @@ func (c *daemonServiceClient) RequestClipboardPermission(ctx context.Context, in
return out, nil
}
+func (c *daemonServiceClient) RequestLocalNetworkPermission(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) {
+ cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+ out := new(Empty)
+ err := c.cc.Invoke(ctx, DaemonService_RequestLocalNetworkPermission_FullMethodName, in, out, cOpts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
func (c *daemonServiceClient) GetNetwork(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*NetworkInfo, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(NetworkInfo)
@@ -268,11 +295,16 @@ type DaemonServiceServer interface {
// 配对双方各自确认指纹后才真正互信
ConfirmPairing(context.Context, *ConfirmPairingRequest) (*Empty, error)
Unpair(context.Context, *UnpairRequest) (*Empty, error)
+ // 手动告诉后台服务某台设备的局域网地址:跨网段、或两边都换了地址时用
+ SetDeviceAddress(context.Context, *SetDeviceAddressRequest) (*Empty, error)
GetConfig(context.Context, *Empty) (*Config, error)
UpdateConfig(context.Context, *Config) (*Config, error)
GetStatus(context.Context, *Empty) (*Status, error)
// 引导用户授予剪贴板权限(打开系统设置面板)
RequestClipboardPermission(context.Context, *Empty) (*Empty, error)
+ // 让系统放行局域网访问:macOS 打开「本地网络」设置面板;
+ // Windows 申请管理员权限,在防火墙里放行后台服务。其他平台返回 UNIMPLEMENTED。
+ RequestLocalNetworkPermission(context.Context, *Empty) (*Empty, error)
// 网络出口与打洞诊断:本机有几个出口、各自的公网地址,见 copysync-cli nat
GetNetwork(context.Context, *Empty) (*NetworkInfo, error)
mustEmbedUnimplementedDaemonServiceServer()
@@ -318,6 +350,9 @@ func (UnimplementedDaemonServiceServer) ConfirmPairing(context.Context, *Confirm
func (UnimplementedDaemonServiceServer) Unpair(context.Context, *UnpairRequest) (*Empty, error) {
return nil, status.Error(codes.Unimplemented, "method Unpair not implemented")
}
+func (UnimplementedDaemonServiceServer) SetDeviceAddress(context.Context, *SetDeviceAddressRequest) (*Empty, error) {
+ return nil, status.Error(codes.Unimplemented, "method SetDeviceAddress not implemented")
+}
func (UnimplementedDaemonServiceServer) GetConfig(context.Context, *Empty) (*Config, error) {
return nil, status.Error(codes.Unimplemented, "method GetConfig not implemented")
}
@@ -330,6 +365,9 @@ func (UnimplementedDaemonServiceServer) GetStatus(context.Context, *Empty) (*Sta
func (UnimplementedDaemonServiceServer) RequestClipboardPermission(context.Context, *Empty) (*Empty, error) {
return nil, status.Error(codes.Unimplemented, "method RequestClipboardPermission not implemented")
}
+func (UnimplementedDaemonServiceServer) RequestLocalNetworkPermission(context.Context, *Empty) (*Empty, error) {
+ return nil, status.Error(codes.Unimplemented, "method RequestLocalNetworkPermission not implemented")
+}
func (UnimplementedDaemonServiceServer) GetNetwork(context.Context, *Empty) (*NetworkInfo, error) {
return nil, status.Error(codes.Unimplemented, "method GetNetwork not implemented")
}
@@ -545,6 +583,24 @@ func _DaemonService_Unpair_Handler(srv interface{}, ctx context.Context, dec fun
return interceptor(ctx, in, info, handler)
}
+func _DaemonService_SetDeviceAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(SetDeviceAddressRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(DaemonServiceServer).SetDeviceAddress(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: DaemonService_SetDeviceAddress_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(DaemonServiceServer).SetDeviceAddress(ctx, req.(*SetDeviceAddressRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
func _DaemonService_GetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(Empty)
if err := dec(in); err != nil {
@@ -617,6 +673,24 @@ func _DaemonService_RequestClipboardPermission_Handler(srv interface{}, ctx cont
return interceptor(ctx, in, info, handler)
}
+func _DaemonService_RequestLocalNetworkPermission_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(Empty)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(DaemonServiceServer).RequestLocalNetworkPermission(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: DaemonService_RequestLocalNetworkPermission_FullMethodName,
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(DaemonServiceServer).RequestLocalNetworkPermission(ctx, req.(*Empty))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
func _DaemonService_GetNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(Empty)
if err := dec(in); err != nil {
@@ -682,6 +756,10 @@ var DaemonService_ServiceDesc = grpc.ServiceDesc{
MethodName: "Unpair",
Handler: _DaemonService_Unpair_Handler,
},
+ {
+ MethodName: "SetDeviceAddress",
+ Handler: _DaemonService_SetDeviceAddress_Handler,
+ },
{
MethodName: "GetConfig",
Handler: _DaemonService_GetConfig_Handler,
@@ -698,6 +776,10 @@ var DaemonService_ServiceDesc = grpc.ServiceDesc{
MethodName: "RequestClipboardPermission",
Handler: _DaemonService_RequestClipboardPermission_Handler,
},
+ {
+ MethodName: "RequestLocalNetworkPermission",
+ Handler: _DaemonService_RequestLocalNetworkPermission_Handler,
+ },
{
MethodName: "GetNetwork",
Handler: _DaemonService_GetNetwork_Handler,
diff --git a/proto/gen/copysync/v1/wire.pb.go b/proto/gen/copysync/v1/wire.pb.go
index 1e97830..70f93ec 100644
--- a/proto/gen/copysync/v1/wire.pb.go
+++ b/proto/gen/copysync/v1/wire.pb.go
@@ -1,8 +1,9 @@
-// 线上协议:客户端 ↔ 信令服务器,以及设备 ↔ 设备。
+// 线上协议:客户端 ↔ 信令服务器,同一局域网里的设备 ↔ 设备(UDP),
+// 以及连通之后的设备 ↔ 设备(DataChannel)。
//
// 信令服务器只转发、不解密内容,也不存用户——设备靠配对时交换的
-// Ed25519 公钥互相认证。所有经服务器中转的信令都带签名,
-// 防止服务器伪造 peer 身份做中间人。
+// Ed25519 公钥互相认证。所有经服务器或局域网转发的信令都带签名,
+// 防止服务器或同一网络里的其他人伪造 peer 身份做中间人。
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
@@ -192,13 +193,15 @@ type SignalMessage struct {
// 防重放:接收方拒绝时间戳过旧或 nonce 重复的消息
TimestampUnix int64 `protobuf:"varint,1,opt,name=timestamp_unix,json=timestampUnix,proto3" json:"timestamp_unix,omitempty"`
Nonce []byte `protobuf:"bytes,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
- ToDeviceId string `protobuf:"bytes,3,opt,name=to_device_id,json=toDeviceId,proto3" json:"to_device_id,omitempty"`
+ // 接收方只收发给自己的消息:局域网里谁都能把截到的消息转发给第三台设备
+ ToDeviceId string `protobuf:"bytes,3,opt,name=to_device_id,json=toDeviceId,proto3" json:"to_device_id,omitempty"`
// Types that are valid to be assigned to Payload:
//
// *SignalMessage_Offer
// *SignalMessage_Answer
// *SignalMessage_Candidate
// *SignalMessage_Ping
+ // *SignalMessage_LanHello
Payload isSignalMessage_Payload `protobuf_oneof:"payload"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
@@ -298,6 +301,15 @@ func (x *SignalMessage) GetPing() *Ping {
return nil
}
+func (x *SignalMessage) GetLanHello() *LanHello {
+ if x != nil {
+ if x, ok := x.Payload.(*SignalMessage_LanHello); ok {
+ return x.LanHello
+ }
+ }
+ return nil
+}
+
type isSignalMessage_Payload interface {
isSignalMessage_Payload()
}
@@ -318,6 +330,10 @@ type SignalMessage_Ping struct {
Ping *Ping `protobuf:"bytes,13,opt,name=ping,proto3,oneof"`
}
+type SignalMessage_LanHello struct {
+ LanHello *LanHello `protobuf:"bytes,14,opt,name=lan_hello,json=lanHello,proto3,oneof"` // 只走局域网,见下文
+}
+
func (*SignalMessage_Offer) isSignalMessage_Payload() {}
func (*SignalMessage_Answer) isSignalMessage_Payload() {}
@@ -326,6 +342,8 @@ func (*SignalMessage_Candidate) isSignalMessage_Payload() {}
func (*SignalMessage_Ping) isSignalMessage_Payload() {}
+func (*SignalMessage_LanHello) isSignalMessage_Payload() {}
+
type SdpOffer struct {
state protoimpl.MessageState `protogen:"open.v1"`
Sdp string `protobuf:"bytes,1,opt,name=sdp,proto3" json:"sdp,omitempty"`
@@ -1511,6 +1529,395 @@ func (x *ServerError) GetMessage() string {
return ""
}
+type LanPacket struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ // Types that are valid to be assigned to Payload:
+ //
+ // *LanPacket_Signal
+ // *LanPacket_PairRequest
+ // *LanPacket_PairResponse
+ // *LanPacket_PairReject
+ Payload isLanPacket_Payload `protobuf_oneof:"payload"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *LanPacket) Reset() {
+ *x = LanPacket{}
+ mi := &file_copysync_v1_wire_proto_msgTypes[19]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *LanPacket) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LanPacket) ProtoMessage() {}
+
+func (x *LanPacket) ProtoReflect() protoreflect.Message {
+ mi := &file_copysync_v1_wire_proto_msgTypes[19]
+ if x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use LanPacket.ProtoReflect.Descriptor instead.
+func (*LanPacket) Descriptor() ([]byte, []int) {
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *LanPacket) GetPayload() isLanPacket_Payload {
+ if x != nil {
+ return x.Payload
+ }
+ return nil
+}
+
+func (x *LanPacket) GetSignal() *Signed {
+ if x != nil {
+ if x, ok := x.Payload.(*LanPacket_Signal); ok {
+ return x.Signal
+ }
+ }
+ return nil
+}
+
+func (x *LanPacket) GetPairRequest() *LanPairSigned {
+ if x != nil {
+ if x, ok := x.Payload.(*LanPacket_PairRequest); ok {
+ return x.PairRequest
+ }
+ }
+ return nil
+}
+
+func (x *LanPacket) GetPairResponse() *LanPairSigned {
+ if x != nil {
+ if x, ok := x.Payload.(*LanPacket_PairResponse); ok {
+ return x.PairResponse
+ }
+ }
+ return nil
+}
+
+func (x *LanPacket) GetPairReject() *LanPairReject {
+ if x != nil {
+ if x, ok := x.Payload.(*LanPacket_PairReject); ok {
+ return x.PairReject
+ }
+ }
+ return nil
+}
+
+type isLanPacket_Payload interface {
+ isLanPacket_Payload()
+}
+
+type LanPacket_Signal struct {
+ Signal *Signed `protobuf:"bytes,1,opt,name=signal,proto3,oneof"`
+}
+
+type LanPacket_PairRequest struct {
+ PairRequest *LanPairSigned `protobuf:"bytes,2,opt,name=pair_request,json=pairRequest,proto3,oneof"`
+}
+
+type LanPacket_PairResponse struct {
+ PairResponse *LanPairSigned `protobuf:"bytes,3,opt,name=pair_response,json=pairResponse,proto3,oneof"`
+}
+
+type LanPacket_PairReject struct {
+ PairReject *LanPairReject `protobuf:"bytes,4,opt,name=pair_reject,json=pairReject,proto3,oneof"`
+}
+
+func (*LanPacket_Signal) isLanPacket_Payload() {}
+
+func (*LanPacket_PairRequest) isLanPacket_Payload() {}
+
+func (*LanPacket_PairResponse) isLanPacket_Payload() {}
+
+func (*LanPacket_PairReject) isLanPacket_Payload() {}
+
+// 已配对设备之间的上线通知。还没连通时定期发,连通后低频保活。
+// 两端都往对方发,有状态的防火墙(Windows)会放行对方的包。
+type LanHello struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"` // 发送方本机的局域网地址,ip:port
+ ReplyWanted bool `protobuf:"varint,2,opt,name=reply_wanted,json=replyWanted,proto3" json:"reply_wanted,omitempty"` // 收到后回一条,让发送方也知道本端可达
+ IntervalSeconds uint32 `protobuf:"varint,3,opt,name=interval_seconds,json=intervalSeconds,proto3" json:"interval_seconds,omitempty"` // 发送方多久发一次;超过三倍没收到即视为不可达
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *LanHello) Reset() {
+ *x = LanHello{}
+ mi := &file_copysync_v1_wire_proto_msgTypes[20]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *LanHello) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LanHello) ProtoMessage() {}
+
+func (x *LanHello) ProtoReflect() protoreflect.Message {
+ mi := &file_copysync_v1_wire_proto_msgTypes[20]
+ if x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use LanHello.ProtoReflect.Descriptor instead.
+func (*LanHello) Descriptor() ([]byte, []int) {
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *LanHello) GetAddresses() []string {
+ if x != nil {
+ return x.Addresses
+ }
+ return nil
+}
+
+func (x *LanHello) GetReplyWanted() bool {
+ if x != nil {
+ return x.ReplyWanted
+ }
+ return false
+}
+
+func (x *LanHello) GetIntervalSeconds() uint32 {
+ if x != nil {
+ return x.IntervalSeconds
+ }
+ return 0
+}
+
+// payload 是序列化后的 LanPairInfo,signature 用 LanPairInfo.public_key 签名。
+type LanPairSigned struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ Payload []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
+ Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *LanPairSigned) Reset() {
+ *x = LanPairSigned{}
+ mi := &file_copysync_v1_wire_proto_msgTypes[21]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *LanPairSigned) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LanPairSigned) ProtoMessage() {}
+
+func (x *LanPairSigned) ProtoReflect() protoreflect.Message {
+ mi := &file_copysync_v1_wire_proto_msgTypes[21]
+ if x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use LanPairSigned.ProtoReflect.Descriptor instead.
+func (*LanPairSigned) Descriptor() ([]byte, []int) {
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *LanPairSigned) GetPayload() []byte {
+ if x != nil {
+ return x.Payload
+ }
+ return nil
+}
+
+func (x *LanPairSigned) GetSignature() []byte {
+ if x != nil {
+ return x.Signature
+ }
+ return nil
+}
+
+type LanPairInfo struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"` // 请求里是用户输入的配对码;回复里为空
+ DeviceId string `protobuf:"bytes,2,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
+ DeviceName string `protobuf:"bytes,3,opt,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"`
+ Platform string `protobuf:"bytes,4,opt,name=platform,proto3" json:"platform,omitempty"`
+ PublicKey []byte `protobuf:"bytes,5,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
+ Addresses []string `protobuf:"bytes,6,rep,name=addresses,proto3" json:"addresses,omitempty"` // 发送方本机的局域网地址,ip:port
+ TimestampUnix int64 `protobuf:"varint,7,opt,name=timestamp_unix,json=timestampUnix,proto3" json:"timestamp_unix,omitempty"`
+ Nonce []byte `protobuf:"bytes,8,opt,name=nonce,proto3" json:"nonce,omitempty"`
+ RequestNonce []byte `protobuf:"bytes,9,opt,name=request_nonce,json=requestNonce,proto3" json:"request_nonce,omitempty"` // 回复里回显请求的 nonce,把回复绑定到这次请求
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *LanPairInfo) Reset() {
+ *x = LanPairInfo{}
+ mi := &file_copysync_v1_wire_proto_msgTypes[22]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *LanPairInfo) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LanPairInfo) ProtoMessage() {}
+
+func (x *LanPairInfo) ProtoReflect() protoreflect.Message {
+ mi := &file_copysync_v1_wire_proto_msgTypes[22]
+ if x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use LanPairInfo.ProtoReflect.Descriptor instead.
+func (*LanPairInfo) Descriptor() ([]byte, []int) {
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *LanPairInfo) GetCode() string {
+ if x != nil {
+ return x.Code
+ }
+ return ""
+}
+
+func (x *LanPairInfo) GetDeviceId() string {
+ if x != nil {
+ return x.DeviceId
+ }
+ return ""
+}
+
+func (x *LanPairInfo) GetDeviceName() string {
+ if x != nil {
+ return x.DeviceName
+ }
+ return ""
+}
+
+func (x *LanPairInfo) GetPlatform() string {
+ if x != nil {
+ return x.Platform
+ }
+ return ""
+}
+
+func (x *LanPairInfo) GetPublicKey() []byte {
+ if x != nil {
+ return x.PublicKey
+ }
+ return nil
+}
+
+func (x *LanPairInfo) GetAddresses() []string {
+ if x != nil {
+ return x.Addresses
+ }
+ return nil
+}
+
+func (x *LanPairInfo) GetTimestampUnix() int64 {
+ if x != nil {
+ return x.TimestampUnix
+ }
+ return 0
+}
+
+func (x *LanPairInfo) GetNonce() []byte {
+ if x != nil {
+ return x.Nonce
+ }
+ return nil
+}
+
+func (x *LanPairInfo) GetRequestNonce() []byte {
+ if x != nil {
+ return x.RequestNonce
+ }
+ return nil
+}
+
+type LanPairReject struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ RequestNonce []byte `protobuf:"bytes,1,opt,name=request_nonce,json=requestNonce,proto3" json:"request_nonce,omitempty"`
+ Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` // wrong_code / closed / too_many_attempts
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *LanPairReject) Reset() {
+ *x = LanPairReject{}
+ mi := &file_copysync_v1_wire_proto_msgTypes[23]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *LanPairReject) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LanPairReject) ProtoMessage() {}
+
+func (x *LanPairReject) ProtoReflect() protoreflect.Message {
+ mi := &file_copysync_v1_wire_proto_msgTypes[23]
+ if x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use LanPairReject.ProtoReflect.Descriptor instead.
+func (*LanPairReject) Descriptor() ([]byte, []int) {
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{23}
+}
+
+func (x *LanPairReject) GetRequestNonce() []byte {
+ if x != nil {
+ return x.RequestNonce
+ }
+ return nil
+}
+
+func (x *LanPairReject) GetReason() string {
+ if x != nil {
+ return x.Reason
+ }
+ return ""
+}
+
// 控制通道消息
type PeerMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
@@ -1529,7 +1936,7 @@ type PeerMessage struct {
func (x *PeerMessage) Reset() {
*x = PeerMessage{}
- mi := &file_copysync_v1_wire_proto_msgTypes[19]
+ mi := &file_copysync_v1_wire_proto_msgTypes[24]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1541,7 +1948,7 @@ func (x *PeerMessage) String() string {
func (*PeerMessage) ProtoMessage() {}
func (x *PeerMessage) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_wire_proto_msgTypes[19]
+ mi := &file_copysync_v1_wire_proto_msgTypes[24]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1554,7 +1961,7 @@ func (x *PeerMessage) ProtoReflect() protoreflect.Message {
// Deprecated: Use PeerMessage.ProtoReflect.Descriptor instead.
func (*PeerMessage) Descriptor() ([]byte, []int) {
- return file_copysync_v1_wire_proto_rawDescGZIP(), []int{19}
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{24}
}
func (x *PeerMessage) GetPayload() isPeerMessage_Payload {
@@ -1670,7 +2077,7 @@ type LinkInfo struct {
func (x *LinkInfo) Reset() {
*x = LinkInfo{}
- mi := &file_copysync_v1_wire_proto_msgTypes[20]
+ mi := &file_copysync_v1_wire_proto_msgTypes[25]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1682,7 +2089,7 @@ func (x *LinkInfo) String() string {
func (*LinkInfo) ProtoMessage() {}
func (x *LinkInfo) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_wire_proto_msgTypes[20]
+ mi := &file_copysync_v1_wire_proto_msgTypes[25]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1695,7 +2102,7 @@ func (x *LinkInfo) ProtoReflect() protoreflect.Message {
// Deprecated: Use LinkInfo.ProtoReflect.Descriptor instead.
func (*LinkInfo) Descriptor() ([]byte, []int) {
- return file_copysync_v1_wire_proto_rawDescGZIP(), []int{20}
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{25}
}
func (x *LinkInfo) GetRelayed() bool {
@@ -1728,7 +2135,7 @@ type ClipOffer struct {
func (x *ClipOffer) Reset() {
*x = ClipOffer{}
- mi := &file_copysync_v1_wire_proto_msgTypes[21]
+ mi := &file_copysync_v1_wire_proto_msgTypes[26]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1740,7 +2147,7 @@ func (x *ClipOffer) String() string {
func (*ClipOffer) ProtoMessage() {}
func (x *ClipOffer) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_wire_proto_msgTypes[21]
+ mi := &file_copysync_v1_wire_proto_msgTypes[26]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1753,7 +2160,7 @@ func (x *ClipOffer) ProtoReflect() protoreflect.Message {
// Deprecated: Use ClipOffer.ProtoReflect.Descriptor instead.
func (*ClipOffer) Descriptor() ([]byte, []int) {
- return file_copysync_v1_wire_proto_rawDescGZIP(), []int{21}
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{26}
}
func (x *ClipOffer) GetClipId() string {
@@ -1829,7 +2236,7 @@ type PeerFetch struct {
func (x *PeerFetch) Reset() {
*x = PeerFetch{}
- mi := &file_copysync_v1_wire_proto_msgTypes[22]
+ mi := &file_copysync_v1_wire_proto_msgTypes[27]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1841,7 +2248,7 @@ func (x *PeerFetch) String() string {
func (*PeerFetch) ProtoMessage() {}
func (x *PeerFetch) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_wire_proto_msgTypes[22]
+ mi := &file_copysync_v1_wire_proto_msgTypes[27]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1854,7 +2261,7 @@ func (x *PeerFetch) ProtoReflect() protoreflect.Message {
// Deprecated: Use PeerFetch.ProtoReflect.Descriptor instead.
func (*PeerFetch) Descriptor() ([]byte, []int) {
- return file_copysync_v1_wire_proto_rawDescGZIP(), []int{22}
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{27}
}
func (x *PeerFetch) GetClipId() string {
@@ -1874,7 +2281,7 @@ type FetchReject struct {
func (x *FetchReject) Reset() {
*x = FetchReject{}
- mi := &file_copysync_v1_wire_proto_msgTypes[23]
+ mi := &file_copysync_v1_wire_proto_msgTypes[28]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1886,7 +2293,7 @@ func (x *FetchReject) String() string {
func (*FetchReject) ProtoMessage() {}
func (x *FetchReject) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_wire_proto_msgTypes[23]
+ mi := &file_copysync_v1_wire_proto_msgTypes[28]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1899,7 +2306,7 @@ func (x *FetchReject) ProtoReflect() protoreflect.Message {
// Deprecated: Use FetchReject.ProtoReflect.Descriptor instead.
func (*FetchReject) Descriptor() ([]byte, []int) {
- return file_copysync_v1_wire_proto_rawDescGZIP(), []int{23}
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{28}
}
func (x *FetchReject) GetClipId() string {
@@ -1930,7 +2337,7 @@ type TransferHeader struct {
func (x *TransferHeader) Reset() {
*x = TransferHeader{}
- mi := &file_copysync_v1_wire_proto_msgTypes[24]
+ mi := &file_copysync_v1_wire_proto_msgTypes[29]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1942,7 +2349,7 @@ func (x *TransferHeader) String() string {
func (*TransferHeader) ProtoMessage() {}
func (x *TransferHeader) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_wire_proto_msgTypes[24]
+ mi := &file_copysync_v1_wire_proto_msgTypes[29]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1955,7 +2362,7 @@ func (x *TransferHeader) ProtoReflect() protoreflect.Message {
// Deprecated: Use TransferHeader.ProtoReflect.Descriptor instead.
func (*TransferHeader) Descriptor() ([]byte, []int) {
- return file_copysync_v1_wire_proto_rawDescGZIP(), []int{24}
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{29}
}
func (x *TransferHeader) GetClipId() string {
@@ -2006,7 +2413,7 @@ type TransferDone struct {
func (x *TransferDone) Reset() {
*x = TransferDone{}
- mi := &file_copysync_v1_wire_proto_msgTypes[25]
+ mi := &file_copysync_v1_wire_proto_msgTypes[30]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2018,7 +2425,7 @@ func (x *TransferDone) String() string {
func (*TransferDone) ProtoMessage() {}
func (x *TransferDone) ProtoReflect() protoreflect.Message {
- mi := &file_copysync_v1_wire_proto_msgTypes[25]
+ mi := &file_copysync_v1_wire_proto_msgTypes[30]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2031,7 +2438,7 @@ func (x *TransferDone) ProtoReflect() protoreflect.Message {
// Deprecated: Use TransferDone.ProtoReflect.Descriptor instead.
func (*TransferDone) Descriptor() ([]byte, []int) {
- return file_copysync_v1_wire_proto_rawDescGZIP(), []int{25}
+ return file_copysync_v1_wire_proto_rawDescGZIP(), []int{30}
}
func (x *TransferDone) GetClipId() string {
@@ -2077,7 +2484,7 @@ const file_copysync_v1_wire_proto_rawDesc = "" +
"\x06Signed\x12\x18\n" +
"\apayload\x18\x01 \x01(\fR\apayload\x12\x1c\n" +
"\tsignature\x18\x02 \x01(\fR\tsignature\x12$\n" +
- "\x0efrom_device_id\x18\x03 \x01(\tR\ffromDeviceId\"\xbe\x02\n" +
+ "\x0efrom_device_id\x18\x03 \x01(\tR\ffromDeviceId\"\xf4\x02\n" +
"\rSignalMessage\x12%\n" +
"\x0etimestamp_unix\x18\x01 \x01(\x03R\rtimestampUnix\x12\x14\n" +
"\x05nonce\x18\x02 \x01(\fR\x05nonce\x12 \n" +
@@ -2087,7 +2494,8 @@ const file_copysync_v1_wire_proto_rawDesc = "" +
" \x01(\v2\x15.copysync.v1.SdpOfferH\x00R\x05offer\x120\n" +
"\x06answer\x18\v \x01(\v2\x16.copysync.v1.SdpAnswerH\x00R\x06answer\x129\n" +
"\tcandidate\x18\f \x01(\v2\x19.copysync.v1.IceCandidateH\x00R\tcandidate\x12'\n" +
- "\x04ping\x18\r \x01(\v2\x11.copysync.v1.PingH\x00R\x04pingB\t\n" +
+ "\x04ping\x18\r \x01(\v2\x11.copysync.v1.PingH\x00R\x04ping\x124\n" +
+ "\tlan_hello\x18\x0e \x01(\v2\x15.copysync.v1.LanHelloH\x00R\blanHelloB\t\n" +
"\apayload\"n\n" +
"\bSdpOffer\x12\x10\n" +
"\x03sdp\x18\x01 \x01(\tR\x03sdp\x12)\n" +
@@ -2174,7 +2582,36 @@ const file_copysync_v1_wire_proto_rawDesc = "" +
"\apayload\";\n" +
"\vServerError\x12\x12\n" +
"\x04code\x18\x01 \x01(\tR\x04code\x12\x18\n" +
- "\amessage\x18\x02 \x01(\tR\amessage\"\xc1\x02\n" +
+ "\amessage\x18\x02 \x01(\tR\amessage\"\x88\x02\n" +
+ "\tLanPacket\x12-\n" +
+ "\x06signal\x18\x01 \x01(\v2\x13.copysync.v1.SignedH\x00R\x06signal\x12?\n" +
+ "\fpair_request\x18\x02 \x01(\v2\x1a.copysync.v1.LanPairSignedH\x00R\vpairRequest\x12A\n" +
+ "\rpair_response\x18\x03 \x01(\v2\x1a.copysync.v1.LanPairSignedH\x00R\fpairResponse\x12=\n" +
+ "\vpair_reject\x18\x04 \x01(\v2\x1a.copysync.v1.LanPairRejectH\x00R\n" +
+ "pairRejectB\t\n" +
+ "\apayload\"v\n" +
+ "\bLanHello\x12\x1c\n" +
+ "\taddresses\x18\x01 \x03(\tR\taddresses\x12!\n" +
+ "\freply_wanted\x18\x02 \x01(\bR\vreplyWanted\x12)\n" +
+ "\x10interval_seconds\x18\x03 \x01(\rR\x0fintervalSeconds\"G\n" +
+ "\rLanPairSigned\x12\x18\n" +
+ "\apayload\x18\x01 \x01(\fR\apayload\x12\x1c\n" +
+ "\tsignature\x18\x02 \x01(\fR\tsignature\"\x9a\x02\n" +
+ "\vLanPairInfo\x12\x12\n" +
+ "\x04code\x18\x01 \x01(\tR\x04code\x12\x1b\n" +
+ "\tdevice_id\x18\x02 \x01(\tR\bdeviceId\x12\x1f\n" +
+ "\vdevice_name\x18\x03 \x01(\tR\n" +
+ "deviceName\x12\x1a\n" +
+ "\bplatform\x18\x04 \x01(\tR\bplatform\x12\x1d\n" +
+ "\n" +
+ "public_key\x18\x05 \x01(\fR\tpublicKey\x12\x1c\n" +
+ "\taddresses\x18\x06 \x03(\tR\taddresses\x12%\n" +
+ "\x0etimestamp_unix\x18\a \x01(\x03R\rtimestampUnix\x12\x14\n" +
+ "\x05nonce\x18\b \x01(\fR\x05nonce\x12#\n" +
+ "\rrequest_nonce\x18\t \x01(\fR\frequestNonce\"L\n" +
+ "\rLanPairReject\x12#\n" +
+ "\rrequest_nonce\x18\x01 \x01(\fR\frequestNonce\x12\x16\n" +
+ "\x06reason\x18\x02 \x01(\tR\x06reason\"\xc1\x02\n" +
"\vPeerMessage\x12.\n" +
"\x05offer\x18\x01 \x01(\v2\x16.copysync.v1.ClipOfferH\x00R\x05offer\x12.\n" +
"\x05fetch\x18\x02 \x01(\v2\x16.copysync.v1.PeerFetchH\x00R\x05fetch\x122\n" +
@@ -2237,7 +2674,7 @@ func file_copysync_v1_wire_proto_rawDescGZIP() []byte {
}
var file_copysync_v1_wire_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
-var file_copysync_v1_wire_proto_msgTypes = make([]protoimpl.MessageInfo, 26)
+var file_copysync_v1_wire_proto_msgTypes = make([]protoimpl.MessageInfo, 31)
var file_copysync_v1_wire_proto_goTypes = []any{
(Compression)(0), // 0: copysync.v1.Compression
(Packaging)(0), // 1: copysync.v1.Packaging
@@ -2260,50 +2697,60 @@ var file_copysync_v1_wire_proto_goTypes = []any{
(*ServerEnvelope)(nil), // 18: copysync.v1.ServerEnvelope
(*ClientEnvelope)(nil), // 19: copysync.v1.ClientEnvelope
(*ServerError)(nil), // 20: copysync.v1.ServerError
- (*PeerMessage)(nil), // 21: copysync.v1.PeerMessage
- (*LinkInfo)(nil), // 22: copysync.v1.LinkInfo
- (*ClipOffer)(nil), // 23: copysync.v1.ClipOffer
- (*PeerFetch)(nil), // 24: copysync.v1.PeerFetch
- (*FetchReject)(nil), // 25: copysync.v1.FetchReject
- (*TransferHeader)(nil), // 26: copysync.v1.TransferHeader
- (*TransferDone)(nil), // 27: copysync.v1.TransferDone
- (ClipKind)(0), // 28: copysync.v1.ClipKind
- (*ClipItem)(nil), // 29: copysync.v1.ClipItem
+ (*LanPacket)(nil), // 21: copysync.v1.LanPacket
+ (*LanHello)(nil), // 22: copysync.v1.LanHello
+ (*LanPairSigned)(nil), // 23: copysync.v1.LanPairSigned
+ (*LanPairInfo)(nil), // 24: copysync.v1.LanPairInfo
+ (*LanPairReject)(nil), // 25: copysync.v1.LanPairReject
+ (*PeerMessage)(nil), // 26: copysync.v1.PeerMessage
+ (*LinkInfo)(nil), // 27: copysync.v1.LinkInfo
+ (*ClipOffer)(nil), // 28: copysync.v1.ClipOffer
+ (*PeerFetch)(nil), // 29: copysync.v1.PeerFetch
+ (*FetchReject)(nil), // 30: copysync.v1.FetchReject
+ (*TransferHeader)(nil), // 31: copysync.v1.TransferHeader
+ (*TransferDone)(nil), // 32: copysync.v1.TransferDone
+ (ClipKind)(0), // 33: copysync.v1.ClipKind
+ (*ClipItem)(nil), // 34: copysync.v1.ClipItem
}
var file_copysync_v1_wire_proto_depIdxs = []int32{
4, // 0: copysync.v1.SignalMessage.offer:type_name -> copysync.v1.SdpOffer
5, // 1: copysync.v1.SignalMessage.answer:type_name -> copysync.v1.SdpAnswer
6, // 2: copysync.v1.SignalMessage.candidate:type_name -> copysync.v1.IceCandidate
7, // 3: copysync.v1.SignalMessage.ping:type_name -> copysync.v1.Ping
- 10, // 4: copysync.v1.ServerHello.ice_servers:type_name -> copysync.v1.IceServer
- 10, // 5: copysync.v1.IceConfig.ice_servers:type_name -> copysync.v1.IceServer
- 9, // 6: copysync.v1.ServerEnvelope.hello:type_name -> copysync.v1.ServerHello
- 2, // 7: copysync.v1.ServerEnvelope.forwarded:type_name -> copysync.v1.Signed
- 11, // 8: copysync.v1.ServerEnvelope.presence:type_name -> copysync.v1.PeerPresence
- 13, // 9: copysync.v1.ServerEnvelope.pairing_created:type_name -> copysync.v1.PairingCreateResponse
- 15, // 10: copysync.v1.ServerEnvelope.pairing_redeemed_result:type_name -> copysync.v1.PairingRedeemResponse
- 16, // 11: copysync.v1.ServerEnvelope.pairing_redeemed:type_name -> copysync.v1.PairingRedeemed
- 20, // 12: copysync.v1.ServerEnvelope.error:type_name -> copysync.v1.ServerError
- 17, // 13: copysync.v1.ServerEnvelope.ice_config:type_name -> copysync.v1.IceConfig
- 8, // 14: copysync.v1.ClientEnvelope.hello:type_name -> copysync.v1.ClientHello
- 2, // 15: copysync.v1.ClientEnvelope.forward:type_name -> copysync.v1.Signed
- 12, // 16: copysync.v1.ClientEnvelope.pairing_create:type_name -> copysync.v1.PairingCreateRequest
- 14, // 17: copysync.v1.ClientEnvelope.pairing_redeem:type_name -> copysync.v1.PairingRedeemRequest
- 23, // 18: copysync.v1.PeerMessage.offer:type_name -> copysync.v1.ClipOffer
- 24, // 19: copysync.v1.PeerMessage.fetch:type_name -> copysync.v1.PeerFetch
- 25, // 20: copysync.v1.PeerMessage.reject:type_name -> copysync.v1.FetchReject
- 26, // 21: copysync.v1.PeerMessage.header:type_name -> copysync.v1.TransferHeader
- 27, // 22: copysync.v1.PeerMessage.done:type_name -> copysync.v1.TransferDone
- 22, // 23: copysync.v1.PeerMessage.link:type_name -> copysync.v1.LinkInfo
- 28, // 24: copysync.v1.ClipOffer.kind:type_name -> copysync.v1.ClipKind
- 29, // 25: copysync.v1.ClipOffer.items:type_name -> copysync.v1.ClipItem
- 0, // 26: copysync.v1.TransferHeader.compression:type_name -> copysync.v1.Compression
- 1, // 27: copysync.v1.TransferHeader.packaging:type_name -> copysync.v1.Packaging
- 28, // [28:28] is the sub-list for method output_type
- 28, // [28:28] is the sub-list for method input_type
- 28, // [28:28] is the sub-list for extension type_name
- 28, // [28:28] is the sub-list for extension extendee
- 0, // [0:28] is the sub-list for field type_name
+ 22, // 4: copysync.v1.SignalMessage.lan_hello:type_name -> copysync.v1.LanHello
+ 10, // 5: copysync.v1.ServerHello.ice_servers:type_name -> copysync.v1.IceServer
+ 10, // 6: copysync.v1.IceConfig.ice_servers:type_name -> copysync.v1.IceServer
+ 9, // 7: copysync.v1.ServerEnvelope.hello:type_name -> copysync.v1.ServerHello
+ 2, // 8: copysync.v1.ServerEnvelope.forwarded:type_name -> copysync.v1.Signed
+ 11, // 9: copysync.v1.ServerEnvelope.presence:type_name -> copysync.v1.PeerPresence
+ 13, // 10: copysync.v1.ServerEnvelope.pairing_created:type_name -> copysync.v1.PairingCreateResponse
+ 15, // 11: copysync.v1.ServerEnvelope.pairing_redeemed_result:type_name -> copysync.v1.PairingRedeemResponse
+ 16, // 12: copysync.v1.ServerEnvelope.pairing_redeemed:type_name -> copysync.v1.PairingRedeemed
+ 20, // 13: copysync.v1.ServerEnvelope.error:type_name -> copysync.v1.ServerError
+ 17, // 14: copysync.v1.ServerEnvelope.ice_config:type_name -> copysync.v1.IceConfig
+ 8, // 15: copysync.v1.ClientEnvelope.hello:type_name -> copysync.v1.ClientHello
+ 2, // 16: copysync.v1.ClientEnvelope.forward:type_name -> copysync.v1.Signed
+ 12, // 17: copysync.v1.ClientEnvelope.pairing_create:type_name -> copysync.v1.PairingCreateRequest
+ 14, // 18: copysync.v1.ClientEnvelope.pairing_redeem:type_name -> copysync.v1.PairingRedeemRequest
+ 2, // 19: copysync.v1.LanPacket.signal:type_name -> copysync.v1.Signed
+ 23, // 20: copysync.v1.LanPacket.pair_request:type_name -> copysync.v1.LanPairSigned
+ 23, // 21: copysync.v1.LanPacket.pair_response:type_name -> copysync.v1.LanPairSigned
+ 25, // 22: copysync.v1.LanPacket.pair_reject:type_name -> copysync.v1.LanPairReject
+ 28, // 23: copysync.v1.PeerMessage.offer:type_name -> copysync.v1.ClipOffer
+ 29, // 24: copysync.v1.PeerMessage.fetch:type_name -> copysync.v1.PeerFetch
+ 30, // 25: copysync.v1.PeerMessage.reject:type_name -> copysync.v1.FetchReject
+ 31, // 26: copysync.v1.PeerMessage.header:type_name -> copysync.v1.TransferHeader
+ 32, // 27: copysync.v1.PeerMessage.done:type_name -> copysync.v1.TransferDone
+ 27, // 28: copysync.v1.PeerMessage.link:type_name -> copysync.v1.LinkInfo
+ 33, // 29: copysync.v1.ClipOffer.kind:type_name -> copysync.v1.ClipKind
+ 34, // 30: copysync.v1.ClipOffer.items:type_name -> copysync.v1.ClipItem
+ 0, // 31: copysync.v1.TransferHeader.compression:type_name -> copysync.v1.Compression
+ 1, // 32: copysync.v1.TransferHeader.packaging:type_name -> copysync.v1.Packaging
+ 33, // [33:33] is the sub-list for method output_type
+ 33, // [33:33] is the sub-list for method input_type
+ 33, // [33:33] is the sub-list for extension type_name
+ 33, // [33:33] is the sub-list for extension extendee
+ 0, // [0:33] is the sub-list for field type_name
}
func init() { file_copysync_v1_wire_proto_init() }
@@ -2317,6 +2764,7 @@ func file_copysync_v1_wire_proto_init() {
(*SignalMessage_Answer)(nil),
(*SignalMessage_Candidate)(nil),
(*SignalMessage_Ping)(nil),
+ (*SignalMessage_LanHello)(nil),
}
file_copysync_v1_wire_proto_msgTypes[16].OneofWrappers = []any{
(*ServerEnvelope_Hello)(nil),
@@ -2335,6 +2783,12 @@ func file_copysync_v1_wire_proto_init() {
(*ClientEnvelope_PairingRedeem)(nil),
}
file_copysync_v1_wire_proto_msgTypes[19].OneofWrappers = []any{
+ (*LanPacket_Signal)(nil),
+ (*LanPacket_PairRequest)(nil),
+ (*LanPacket_PairResponse)(nil),
+ (*LanPacket_PairReject)(nil),
+ }
+ file_copysync_v1_wire_proto_msgTypes[24].OneofWrappers = []any{
(*PeerMessage_Offer)(nil),
(*PeerMessage_Fetch)(nil),
(*PeerMessage_Reject)(nil),
@@ -2348,7 +2802,7 @@ func file_copysync_v1_wire_proto_init() {
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_copysync_v1_wire_proto_rawDesc), len(file_copysync_v1_wire_proto_rawDesc)),
NumEnums: 2,
- NumMessages: 26,
+ NumMessages: 31,
NumExtensions: 0,
NumServices: 0,
},
diff --git a/ui/lib/gen/copysync/v1/daemon.pb.dart b/ui/lib/gen/copysync/v1/daemon.pb.dart
index e843671..0226f90 100644
--- a/ui/lib/gen/copysync/v1/daemon.pb.dart
+++ b/ui/lib/gen/copysync/v1/daemon.pb.dart
@@ -1225,10 +1225,12 @@ class CreatePairingCodeResponse extends $pb.GeneratedMessage {
factory CreatePairingCodeResponse({
$core.String? code,
$fixnum.Int64? expiresAtUnix,
+ $core.Iterable<$core.String>? lanAddresses,
}) {
final result = CreatePairingCodeResponse._();
if (code != null) result.code = code;
if (expiresAtUnix != null) result.expiresAtUnix = expiresAtUnix;
+ if (lanAddresses != null) result.lanAddresses.addAll(lanAddresses);
return result;
}
@@ -1247,6 +1249,7 @@ class CreatePairingCodeResponse extends $pb.GeneratedMessage {
createEmptyInstance: CreatePairingCodeResponse.$_createMessage)
..aOS(1, _omitFieldNames ? '' : 'code')
..aInt64(2, _omitFieldNames ? '' : 'expiresAtUnix')
+ ..pPS(3, _omitFieldNames ? '' : 'lanAddresses')
..hasRequiredFields = false;
@$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
@@ -1292,14 +1295,23 @@ class CreatePairingCodeResponse extends $pb.GeneratedMessage {
$core.bool hasExpiresAtUnix() => $_has(1);
@$pb.TagNumber(2)
void clearExpiresAtUnix() => $_clearField(2);
+
+ /// 本机的局域网地址,默认路由所在的网卡排第一。不在同一网段时,
+ /// 另一台要在输入配对码的同时输入其中一个。端口是默认值时省略端口。
+ @$pb.TagNumber(3)
+ $pb.PbList<$core.String> get lanAddresses => $_getList(2);
}
+/// 在局域网和服务器上都找不到这个配对码时返回 NOT_FOUND;
+/// 找到了但配对码不对返回 INVALID_ARGUMENT;配对码已失效返回 FAILED_PRECONDITION。
class RedeemPairingCodeRequest extends $pb.GeneratedMessage {
factory RedeemPairingCodeRequest({
$core.String? code,
+ $core.String? address,
}) {
final result = RedeemPairingCodeRequest._();
if (code != null) result.code = code;
+ if (address != null) result.address = address;
return result;
}
@@ -1317,6 +1329,7 @@ class RedeemPairingCodeRequest extends $pb.GeneratedMessage {
package: const $pb.PackageName(_omitMessageNames ? '' : 'copysync.v1'),
createEmptyInstance: RedeemPairingCodeRequest.$_createMessage)
..aOS(1, _omitFieldNames ? '' : 'code')
+ ..aOS(2, _omitFieldNames ? '' : 'address')
..hasRequiredFields = false;
@$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
@@ -1352,6 +1365,16 @@ class RedeemPairingCodeRequest extends $pb.GeneratedMessage {
$core.bool hasCode() => $_has(0);
@$pb.TagNumber(1)
void clearCode() => $_clearField(1);
+
+ /// 可选:对方配对码下面显示的地址(ip 或 ip:port),不在同一网段时填写
+ @$pb.TagNumber(2)
+ $core.String get address => $_getSZ(1);
+ @$pb.TagNumber(2)
+ set address($core.String value) => $_setString(1, value);
+ @$pb.TagNumber(2)
+ $core.bool hasAddress() => $_has(1);
+ @$pb.TagNumber(2)
+ void clearAddress() => $_clearField(2);
}
class RedeemPairingCodeResponse extends $pb.GeneratedMessage {
@@ -1559,6 +1582,77 @@ class UnpairRequest extends $pb.GeneratedMessage {
void clearDeviceId() => $_clearField(1);
}
+class SetDeviceAddressRequest extends $pb.GeneratedMessage {
+ factory SetDeviceAddressRequest({
+ $core.String? deviceId,
+ $core.String? address,
+ }) {
+ final result = SetDeviceAddressRequest._();
+ if (deviceId != null) result.deviceId = deviceId;
+ if (address != null) result.address = address;
+ return result;
+ }
+
+ SetDeviceAddressRequest._();
+
+ factory SetDeviceAddressRequest.fromBuffer($core.List<$core.int> data,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ SetDeviceAddressRequest()..mergeFromBuffer(data, registry);
+ factory SetDeviceAddressRequest.fromJson($core.String json,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ SetDeviceAddressRequest()..mergeFromJson(json, registry);
+
+ static final $pb.BuilderInfo _i = $pb.BuilderInfo(
+ _omitMessageNames ? '' : 'SetDeviceAddressRequest',
+ package: const $pb.PackageName(_omitMessageNames ? '' : 'copysync.v1'),
+ createEmptyInstance: SetDeviceAddressRequest.$_createMessage)
+ ..aOS(1, _omitFieldNames ? '' : 'deviceId')
+ ..aOS(2, _omitFieldNames ? '' : 'address')
+ ..hasRequiredFields = false;
+
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ SetDeviceAddressRequest clone() => deepCopy();
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ SetDeviceAddressRequest copyWith(
+ void Function(SetDeviceAddressRequest) updates) =>
+ super.copyWith((message) => updates(message as SetDeviceAddressRequest))
+ as SetDeviceAddressRequest;
+
+ @$core.override
+ $pb.BuilderInfo get info_ => _i;
+
+ @$core.pragma('dart2js:noInline')
+ @$core.Deprecated(
+ 'Use SetDeviceAddressRequest() / SetDeviceAddressRequest.new instead')
+ static SetDeviceAddressRequest create() => SetDeviceAddressRequest._();
+ static $pb.GeneratedMessage $_createMessage() => SetDeviceAddressRequest._();
+ @$core.override
+ SetDeviceAddressRequest createEmptyInstance() => SetDeviceAddressRequest._();
+ @$core.pragma('dart2js:noInline')
+ static SetDeviceAddressRequest getDefault() => _defaultInstance ??=
+ $pb.GeneratedMessage.$_defaultFor<SetDeviceAddressRequest>(
+ SetDeviceAddressRequest.$_createMessage);
+ static SetDeviceAddressRequest? _defaultInstance;
+
+ @$pb.TagNumber(1)
+ $core.String get deviceId => $_getSZ(0);
+ @$pb.TagNumber(1)
+ set deviceId($core.String value) => $_setString(0, value);
+ @$pb.TagNumber(1)
+ $core.bool hasDeviceId() => $_has(0);
+ @$pb.TagNumber(1)
+ void clearDeviceId() => $_clearField(1);
+
+ @$pb.TagNumber(2)
+ $core.String get address => $_getSZ(1);
+ @$pb.TagNumber(2)
+ set address($core.String value) => $_setString(1, value);
+ @$pb.TagNumber(2)
+ $core.bool hasAddress() => $_has(1);
+ @$pb.TagNumber(2)
+ void clearAddress() => $_clearField(2);
+}
+
class Config extends $pb.GeneratedMessage {
factory Config({
$fixnum.Int64? autoSyncThresholdBytes,
@@ -1574,6 +1668,7 @@ class Config extends $pb.GeneratedMessage {
$core.String? signalingUrl,
$core.bool? onlyOwnStun,
$core.String? language,
+ $core.bool? lanDisabled,
}) {
final result = Config._();
if (autoSyncThresholdBytes != null)
@@ -1591,6 +1686,7 @@ class Config extends $pb.GeneratedMessage {
if (signalingUrl != null) result.signalingUrl = signalingUrl;
if (onlyOwnStun != null) result.onlyOwnStun = onlyOwnStun;
if (language != null) result.language = language;
+ if (lanDisabled != null) result.lanDisabled = lanDisabled;
return result;
}
@@ -1620,6 +1716,7 @@ class Config extends $pb.GeneratedMessage {
..aOS(11, _omitFieldNames ? '' : 'signalingUrl')
..aOB(12, _omitFieldNames ? '' : 'onlyOwnStun')
..aOS(13, _omitFieldNames ? '' : 'language')
+ ..aOB(14, _omitFieldNames ? '' : 'lanDisabled')
..hasRequiredFields = false;
@$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
@@ -1764,6 +1861,17 @@ class Config extends $pb.GeneratedMessage {
$core.bool hasLanguage() => $_has(12);
@$pb.TagNumber(13)
void clearLanguage() => $_clearField(13);
+
+ /// 不在局域网里查找设备、也不接受局域网里的配对请求。
+ /// 默认 false(即开启):写成反向的,旧配置不用迁移。
+ @$pb.TagNumber(14)
+ $core.bool get lanDisabled => $_getBF(13);
+ @$pb.TagNumber(14)
+ set lanDisabled($core.bool value) => $_setBool(13, value);
+ @$pb.TagNumber(14)
+ $core.bool hasLanDisabled() => $_has(13);
+ @$pb.TagNumber(14)
+ void clearLanDisabled() => $_clearField(14);
}
/// 最近一轮网络出口探测的结果。
@@ -1774,6 +1882,7 @@ class NetworkInfo extends $pb.GeneratedMessage {
$core.int? probed,
$core.int? answered,
$fixnum.Int64? probedAtUnix,
+ LanInfo? lan,
}) {
final result = NetworkInfo._();
if (localPort != null) result.localPort = localPort;
@@ -1781,6 +1890,7 @@ class NetworkInfo extends $pb.GeneratedMessage {
if (probed != null) result.probed = probed;
if (answered != null) result.answered = answered;
if (probedAtUnix != null) result.probedAtUnix = probedAtUnix;
+ if (lan != null) result.lan = lan;
return result;
}
@@ -1803,6 +1913,8 @@ class NetworkInfo extends $pb.GeneratedMessage {
..aI(3, _omitFieldNames ? '' : 'probed')
..aI(4, _omitFieldNames ? '' : 'answered')
..aInt64(5, _omitFieldNames ? '' : 'probedAtUnix')
+ ..aOM<LanInfo>(6, _omitFieldNames ? '' : 'lan',
+ subBuilder: LanInfo.$_createMessage)
..hasRequiredFields = false;
@$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
@@ -1865,6 +1977,231 @@ class NetworkInfo extends $pb.GeneratedMessage {
$core.bool hasProbedAtUnix() => $_has(4);
@$pb.TagNumber(5)
void clearProbedAtUnix() => $_clearField(5);
+
+ @$pb.TagNumber(6)
+ LanInfo get lan => $_getN(5);
+ @$pb.TagNumber(6)
+ set lan(LanInfo value) => $_setField(6, value);
+ @$pb.TagNumber(6)
+ $core.bool hasLan() => $_has(5);
+ @$pb.TagNumber(6)
+ void clearLan() => $_clearField(6);
+ @$pb.TagNumber(6)
+ LanInfo ensureLan() => $_ensure(5);
+}
+
+/// 局域网直连的诊断信息,见 copysync-cli nat。
+class LanInfo extends $pb.GeneratedMessage {
+ factory LanInfo({
+ $core.bool? enabled,
+ $core.int? port,
+ $core.Iterable<$core.String>? localAddresses,
+ $core.int? discovered,
+ $core.Iterable<LanPeer>? peers,
+ $core.bool? blocked,
+ }) {
+ final result = LanInfo._();
+ if (enabled != null) result.enabled = enabled;
+ if (port != null) result.port = port;
+ if (localAddresses != null) result.localAddresses.addAll(localAddresses);
+ if (discovered != null) result.discovered = discovered;
+ if (peers != null) result.peers.addAll(peers);
+ if (blocked != null) result.blocked = blocked;
+ return result;
+ }
+
+ LanInfo._();
+
+ factory LanInfo.fromBuffer($core.List<$core.int> data,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanInfo()..mergeFromBuffer(data, registry);
+ factory LanInfo.fromJson($core.String json,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanInfo()..mergeFromJson(json, registry);
+
+ static final $pb.BuilderInfo _i = $pb.BuilderInfo(
+ _omitMessageNames ? '' : 'LanInfo',
+ package: const $pb.PackageName(_omitMessageNames ? '' : 'copysync.v1'),
+ createEmptyInstance: LanInfo.$_createMessage)
+ ..aOB(1, _omitFieldNames ? '' : 'enabled')
+ ..aI(2, _omitFieldNames ? '' : 'port')
+ ..pPS(3, _omitFieldNames ? '' : 'localAddresses')
+ ..aI(4, _omitFieldNames ? '' : 'discovered')
+ ..pPM<LanPeer>(5, _omitFieldNames ? '' : 'peers',
+ subBuilder: LanPeer.$_createMessage)
+ ..aOB(6, _omitFieldNames ? '' : 'blocked')
+ ..hasRequiredFields = false;
+
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanInfo clone() => deepCopy();
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanInfo copyWith(void Function(LanInfo) updates) =>
+ super.copyWith((message) => updates(message as LanInfo)) as LanInfo;
+
+ @$core.override
+ $pb.BuilderInfo get info_ => _i;
+
+ @$core.pragma('dart2js:noInline')
+ @$core.Deprecated('Use LanInfo() / LanInfo.new instead')
+ static LanInfo create() => LanInfo._();
+ static $pb.GeneratedMessage $_createMessage() => LanInfo._();
+ @$core.override
+ LanInfo createEmptyInstance() => LanInfo._();
+ @$core.pragma('dart2js:noInline')
+ static LanInfo getDefault() => _defaultInstance ??=
+ $pb.GeneratedMessage.$_defaultFor<LanInfo>(LanInfo.$_createMessage);
+ static LanInfo? _defaultInstance;
+
+ @$pb.TagNumber(1)
+ $core.bool get enabled => $_getBF(0);
+ @$pb.TagNumber(1)
+ set enabled($core.bool value) => $_setBool(0, value);
+ @$pb.TagNumber(1)
+ $core.bool hasEnabled() => $_has(0);
+ @$pb.TagNumber(1)
+ void clearEnabled() => $_clearField(1);
+
+ @$pb.TagNumber(2)
+ $core.int get port => $_getIZ(1);
+ @$pb.TagNumber(2)
+ set port($core.int value) => $_setSignedInt32(1, value);
+ @$pb.TagNumber(2)
+ $core.bool hasPort() => $_has(1);
+ @$pb.TagNumber(2)
+ void clearPort() => $_clearField(2);
+
+ @$pb.TagNumber(3)
+ $pb.PbList<$core.String> get localAddresses => $_getList(2);
+
+ @$pb.TagNumber(4)
+ $core.int get discovered => $_getIZ(3);
+ @$pb.TagNumber(4)
+ set discovered($core.int value) => $_setSignedInt32(3, value);
+ @$pb.TagNumber(4)
+ $core.bool hasDiscovered() => $_has(3);
+ @$pb.TagNumber(4)
+ void clearDiscovered() => $_clearField(4);
+
+ @$pb.TagNumber(5)
+ $pb.PbList<LanPeer> get peers => $_getList(4);
+
+ @$pb.TagNumber(6)
+ $core.bool get blocked => $_getBF(5);
+ @$pb.TagNumber(6)
+ set blocked($core.bool value) => $_setBool(5, value);
+ @$pb.TagNumber(6)
+ $core.bool hasBlocked() => $_has(5);
+ @$pb.TagNumber(6)
+ void clearBlocked() => $_clearField(6);
+}
+
+class LanPeer extends $pb.GeneratedMessage {
+ factory LanPeer({
+ $core.String? deviceId,
+ $core.String? deviceName,
+ $core.bool? reachable,
+ $core.String? address,
+ $core.Iterable<$core.String>? knownAddresses,
+ $fixnum.Int64? lastSeenUnix,
+ }) {
+ final result = LanPeer._();
+ if (deviceId != null) result.deviceId = deviceId;
+ if (deviceName != null) result.deviceName = deviceName;
+ if (reachable != null) result.reachable = reachable;
+ if (address != null) result.address = address;
+ if (knownAddresses != null) result.knownAddresses.addAll(knownAddresses);
+ if (lastSeenUnix != null) result.lastSeenUnix = lastSeenUnix;
+ return result;
+ }
+
+ LanPeer._();
+
+ factory LanPeer.fromBuffer($core.List<$core.int> data,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanPeer()..mergeFromBuffer(data, registry);
+ factory LanPeer.fromJson($core.String json,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanPeer()..mergeFromJson(json, registry);
+
+ static final $pb.BuilderInfo _i = $pb.BuilderInfo(
+ _omitMessageNames ? '' : 'LanPeer',
+ package: const $pb.PackageName(_omitMessageNames ? '' : 'copysync.v1'),
+ createEmptyInstance: LanPeer.$_createMessage)
+ ..aOS(1, _omitFieldNames ? '' : 'deviceId')
+ ..aOS(2, _omitFieldNames ? '' : 'deviceName')
+ ..aOB(3, _omitFieldNames ? '' : 'reachable')
+ ..aOS(4, _omitFieldNames ? '' : 'address')
+ ..pPS(5, _omitFieldNames ? '' : 'knownAddresses')
+ ..aInt64(6, _omitFieldNames ? '' : 'lastSeenUnix')
+ ..hasRequiredFields = false;
+
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanPeer clone() => deepCopy();
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanPeer copyWith(void Function(LanPeer) updates) =>
+ super.copyWith((message) => updates(message as LanPeer)) as LanPeer;
+
+ @$core.override
+ $pb.BuilderInfo get info_ => _i;
+
+ @$core.pragma('dart2js:noInline')
+ @$core.Deprecated('Use LanPeer() / LanPeer.new instead')
+ static LanPeer create() => LanPeer._();
+ static $pb.GeneratedMessage $_createMessage() => LanPeer._();
+ @$core.override
+ LanPeer createEmptyInstance() => LanPeer._();
+ @$core.pragma('dart2js:noInline')
+ static LanPeer getDefault() => _defaultInstance ??=
+ $pb.GeneratedMessage.$_defaultFor<LanPeer>(LanPeer.$_createMessage);
+ static LanPeer? _defaultInstance;
+
+ @$pb.TagNumber(1)
+ $core.String get deviceId => $_getSZ(0);
+ @$pb.TagNumber(1)
+ set deviceId($core.String value) => $_setString(0, value);
+ @$pb.TagNumber(1)
+ $core.bool hasDeviceId() => $_has(0);
+ @$pb.TagNumber(1)
+ void clearDeviceId() => $_clearField(1);
+
+ @$pb.TagNumber(2)
+ $core.String get deviceName => $_getSZ(1);
+ @$pb.TagNumber(2)
+ set deviceName($core.String value) => $_setString(1, value);
+ @$pb.TagNumber(2)
+ $core.bool hasDeviceName() => $_has(1);
+ @$pb.TagNumber(2)
+ void clearDeviceName() => $_clearField(2);
+
+ @$pb.TagNumber(3)
+ $core.bool get reachable => $_getBF(2);
+ @$pb.TagNumber(3)
+ set reachable($core.bool value) => $_setBool(2, value);
+ @$pb.TagNumber(3)
+ $core.bool hasReachable() => $_has(2);
+ @$pb.TagNumber(3)
+ void clearReachable() => $_clearField(3);
+
+ @$pb.TagNumber(4)
+ $core.String get address => $_getSZ(3);
+ @$pb.TagNumber(4)
+ set address($core.String value) => $_setString(3, value);
+ @$pb.TagNumber(4)
+ $core.bool hasAddress() => $_has(3);
+ @$pb.TagNumber(4)
+ void clearAddress() => $_clearField(4);
+
+ @$pb.TagNumber(5)
+ $pb.PbList<$core.String> get knownAddresses => $_getList(4);
+
+ @$pb.TagNumber(6)
+ $fixnum.Int64 get lastSeenUnix => $_getI64(5);
+ @$pb.TagNumber(6)
+ set lastSeenUnix($fixnum.Int64 value) => $_setInt64(5, value);
+ @$pb.TagNumber(6)
+ $core.bool hasLastSeenUnix() => $_has(5);
+ @$pb.TagNumber(6)
+ void clearLastSeenUnix() => $_clearField(6);
}
class NetworkEgress extends $pb.GeneratedMessage {
@@ -1963,6 +2300,9 @@ class Status extends $pb.GeneratedMessage {
$fixnum.Int64? cacheBytesUsed,
$core.int? peersOnline,
$core.String? version,
+ $core.bool? serverConfigured,
+ $core.bool? lanEnabled,
+ $core.bool? lanBlocked,
}) {
final result = Status._();
if (deviceId != null) result.deviceId = deviceId;
@@ -1974,6 +2314,9 @@ class Status extends $pb.GeneratedMessage {
if (cacheBytesUsed != null) result.cacheBytesUsed = cacheBytesUsed;
if (peersOnline != null) result.peersOnline = peersOnline;
if (version != null) result.version = version;
+ if (serverConfigured != null) result.serverConfigured = serverConfigured;
+ if (lanEnabled != null) result.lanEnabled = lanEnabled;
+ if (lanBlocked != null) result.lanBlocked = lanBlocked;
return result;
}
@@ -1998,6 +2341,9 @@ class Status extends $pb.GeneratedMessage {
..aInt64(5, _omitFieldNames ? '' : 'cacheBytesUsed')
..aI(6, _omitFieldNames ? '' : 'peersOnline')
..aOS(7, _omitFieldNames ? '' : 'version')
+ ..aOB(8, _omitFieldNames ? '' : 'serverConfigured')
+ ..aOB(9, _omitFieldNames ? '' : 'lanEnabled')
+ ..aOB(10, _omitFieldNames ? '' : 'lanBlocked')
..hasRequiredFields = false;
@$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
@@ -2082,6 +2428,35 @@ class Status extends $pb.GeneratedMessage {
$core.bool hasVersion() => $_has(6);
@$pb.TagNumber(7)
void clearVersion() => $_clearField(7);
+
+ /// 设置里填了服务器地址。没填时只在局域网里同步,不算异常。
+ @$pb.TagNumber(8)
+ $core.bool get serverConfigured => $_getBF(7);
+ @$pb.TagNumber(8)
+ set serverConfigured($core.bool value) => $_setBool(7, value);
+ @$pb.TagNumber(8)
+ $core.bool hasServerConfigured() => $_has(7);
+ @$pb.TagNumber(8)
+ void clearServerConfigured() => $_clearField(8);
+
+ @$pb.TagNumber(9)
+ $core.bool get lanEnabled => $_getBF(8);
+ @$pb.TagNumber(9)
+ set lanEnabled($core.bool value) => $_setBool(8, value);
+ @$pb.TagNumber(9)
+ $core.bool hasLanEnabled() => $_has(8);
+ @$pb.TagNumber(9)
+ void clearLanEnabled() => $_clearField(9);
+
+ /// 系统拦下了本机发往局域网的包:macOS 上是没允许「本地网络」权限
+ @$pb.TagNumber(10)
+ $core.bool get lanBlocked => $_getBF(9);
+ @$pb.TagNumber(10)
+ set lanBlocked($core.bool value) => $_setBool(9, value);
+ @$pb.TagNumber(10)
+ $core.bool hasLanBlocked() => $_has(9);
+ @$pb.TagNumber(10)
+ void clearLanBlocked() => $_clearField(10);
}
class GetImagePreviewRequest extends $pb.GeneratedMessage {
diff --git a/ui/lib/gen/copysync/v1/daemon.pbgrpc.dart b/ui/lib/gen/copysync/v1/daemon.pbgrpc.dart
index 227010c..03d1533 100644
--- a/ui/lib/gen/copysync/v1/daemon.pbgrpc.dart
+++ b/ui/lib/gen/copysync/v1/daemon.pbgrpc.dart
@@ -116,6 +116,14 @@ class DaemonServiceClient extends $grpc.Client {
return $createUnaryCall(_$unpair, request, options: options);
}
+ /// 手动告诉后台服务某台设备的局域网地址:跨网段、或两边都换了地址时用
+ $grpc.ResponseFuture<$0.Empty> setDeviceAddress(
+ $0.SetDeviceAddressRequest request, {
+ $grpc.CallOptions? options,
+ }) {
+ return $createUnaryCall(_$setDeviceAddress, request, options: options);
+ }
+
$grpc.ResponseFuture<$0.Config> getConfig(
$0.Empty request, {
$grpc.CallOptions? options,
@@ -146,6 +154,16 @@ class DaemonServiceClient extends $grpc.Client {
options: options);
}
+ /// 让系统放行局域网访问:macOS 打开「本地网络」设置面板;
+ /// Windows 申请管理员权限,在防火墙里放行后台服务。其他平台返回 UNIMPLEMENTED。
+ $grpc.ResponseFuture<$0.Empty> requestLocalNetworkPermission(
+ $0.Empty request, {
+ $grpc.CallOptions? options,
+ }) {
+ return $createUnaryCall(_$requestLocalNetworkPermission, request,
+ options: options);
+ }
+
/// 网络出口与打洞诊断:本机有几个出口、各自的公网地址,见 copysync-cli nat
$grpc.ResponseFuture<$0.NetworkInfo> getNetwork(
$0.Empty request, {
@@ -208,6 +226,11 @@ class DaemonServiceClient extends $grpc.Client {
'/copysync.v1.DaemonService/Unpair',
($0.UnpairRequest value) => value.writeToBuffer(),
$0.Empty.fromBuffer);
+ static final _$setDeviceAddress =
+ $grpc.ClientMethod<$0.SetDeviceAddressRequest, $0.Empty>(
+ '/copysync.v1.DaemonService/SetDeviceAddress',
+ ($0.SetDeviceAddressRequest value) => value.writeToBuffer(),
+ $0.Empty.fromBuffer);
static final _$getConfig = $grpc.ClientMethod<$0.Empty, $0.Config>(
'/copysync.v1.DaemonService/GetConfig',
($0.Empty value) => value.writeToBuffer(),
@@ -225,6 +248,11 @@ class DaemonServiceClient extends $grpc.Client {
'/copysync.v1.DaemonService/RequestClipboardPermission',
($0.Empty value) => value.writeToBuffer(),
$0.Empty.fromBuffer);
+ static final _$requestLocalNetworkPermission =
+ $grpc.ClientMethod<$0.Empty, $0.Empty>(
+ '/copysync.v1.DaemonService/RequestLocalNetworkPermission',
+ ($0.Empty value) => value.writeToBuffer(),
+ $0.Empty.fromBuffer);
static final _$getNetwork = $grpc.ClientMethod<$0.Empty, $0.NetworkInfo>(
'/copysync.v1.DaemonService/GetNetwork',
($0.Empty value) => value.writeToBuffer(),
@@ -322,6 +350,14 @@ abstract class DaemonServiceBase extends $grpc.Service {
false,
($core.List<$core.int> value) => $0.UnpairRequest.fromBuffer(value),
($0.Empty value) => value.writeToBuffer()));
+ $addMethod($grpc.ServiceMethod<$0.SetDeviceAddressRequest, $0.Empty>(
+ 'SetDeviceAddress',
+ setDeviceAddress_Pre,
+ false,
+ false,
+ ($core.List<$core.int> value) =>
+ $0.SetDeviceAddressRequest.fromBuffer(value),
+ ($0.Empty value) => value.writeToBuffer()));
$addMethod($grpc.ServiceMethod<$0.Empty, $0.Config>(
'GetConfig',
getConfig_Pre,
@@ -350,6 +386,13 @@ abstract class DaemonServiceBase extends $grpc.Service {
false,
($core.List<$core.int> value) => $0.Empty.fromBuffer(value),
($0.Empty value) => value.writeToBuffer()));
+ $addMethod($grpc.ServiceMethod<$0.Empty, $0.Empty>(
+ 'RequestLocalNetworkPermission',
+ requestLocalNetworkPermission_Pre,
+ false,
+ false,
+ ($core.List<$core.int> value) => $0.Empty.fromBuffer(value),
+ ($0.Empty value) => value.writeToBuffer()));
$addMethod($grpc.ServiceMethod<$0.Empty, $0.NetworkInfo>(
'GetNetwork',
getNetwork_Pre,
@@ -449,6 +492,14 @@ abstract class DaemonServiceBase extends $grpc.Service {
$async.Future<$0.Empty> unpair(
$grpc.ServiceCall call, $0.UnpairRequest request);
+ $async.Future<$0.Empty> setDeviceAddress_Pre($grpc.ServiceCall $call,
+ $async.Future<$0.SetDeviceAddressRequest> $request) async {
+ return setDeviceAddress($call, await $request);
+ }
+
+ $async.Future<$0.Empty> setDeviceAddress(
+ $grpc.ServiceCall call, $0.SetDeviceAddressRequest request);
+
$async.Future<$0.Config> getConfig_Pre(
$grpc.ServiceCall $call, $async.Future<$0.Empty> $request) async {
return getConfig($call, await $request);
@@ -479,6 +530,14 @@ abstract class DaemonServiceBase extends $grpc.Service {
$async.Future<$0.Empty> requestClipboardPermission(
$grpc.ServiceCall call, $0.Empty request);
+ $async.Future<$0.Empty> requestLocalNetworkPermission_Pre(
+ $grpc.ServiceCall $call, $async.Future<$0.Empty> $request) async {
+ return requestLocalNetworkPermission($call, await $request);
+ }
+
+ $async.Future<$0.Empty> requestLocalNetworkPermission(
+ $grpc.ServiceCall call, $0.Empty request);
+
$async.Future<$0.NetworkInfo> getNetwork_Pre(
$grpc.ServiceCall $call, $async.Future<$0.Empty> $request) async {
return getNetwork($call, await $request);
diff --git a/ui/lib/gen/copysync/v1/daemon.pbjson.dart b/ui/lib/gen/copysync/v1/daemon.pbjson.dart
index 7d1cb2a..19f18c6 100644
--- a/ui/lib/gen/copysync/v1/daemon.pbjson.dart
+++ b/ui/lib/gen/copysync/v1/daemon.pbjson.dart
@@ -441,27 +441,30 @@ const CreatePairingCodeResponse$json = {
'2': [
{'1': 'code', '3': 1, '4': 1, '5': 9, '10': 'code'},
{'1': 'expires_at_unix', '3': 2, '4': 1, '5': 3, '10': 'expiresAtUnix'},
+ {'1': 'lan_addresses', '3': 3, '4': 3, '5': 9, '10': 'lanAddresses'},
],
};
/// Descriptor for `CreatePairingCodeResponse`. Decode as a `google.protobuf.DescriptorProto`.
-final $typed_data.Uint8List createPairingCodeResponseDescriptor =
- $convert.base64Decode(
- 'ChlDcmVhdGVQYWlyaW5nQ29kZVJlc3BvbnNlEhIKBGNvZGUYASABKAlSBGNvZGUSJgoPZXhwaX'
- 'Jlc19hdF91bml4GAIgASgDUg1leHBpcmVzQXRVbml4');
+final $typed_data.Uint8List createPairingCodeResponseDescriptor = $convert.base64Decode(
+ 'ChlDcmVhdGVQYWlyaW5nQ29kZVJlc3BvbnNlEhIKBGNvZGUYASABKAlSBGNvZGUSJgoPZXhwaX'
+ 'Jlc19hdF91bml4GAIgASgDUg1leHBpcmVzQXRVbml4EiMKDWxhbl9hZGRyZXNzZXMYAyADKAlS'
+ 'DGxhbkFkZHJlc3Nlcw==');
@$core.Deprecated('Use redeemPairingCodeRequestDescriptor instead')
const RedeemPairingCodeRequest$json = {
'1': 'RedeemPairingCodeRequest',
'2': [
{'1': 'code', '3': 1, '4': 1, '5': 9, '10': 'code'},
+ {'1': 'address', '3': 2, '4': 1, '5': 9, '10': 'address'},
],
};
/// Descriptor for `RedeemPairingCodeRequest`. Decode as a `google.protobuf.DescriptorProto`.
final $typed_data.Uint8List redeemPairingCodeRequestDescriptor =
$convert.base64Decode(
- 'ChhSZWRlZW1QYWlyaW5nQ29kZVJlcXVlc3QSEgoEY29kZRgBIAEoCVIEY29kZQ==');
+ 'ChhSZWRlZW1QYWlyaW5nQ29kZVJlcXVlc3QSEgoEY29kZRgBIAEoCVIEY29kZRIYCgdhZGRyZX'
+ 'NzGAIgASgJUgdhZGRyZXNz');
@$core.Deprecated('Use redeemPairingCodeResponseDescriptor instead')
const RedeemPairingCodeResponse$json = {
@@ -510,6 +513,21 @@ const UnpairRequest$json = {
final $typed_data.Uint8List unpairRequestDescriptor = $convert.base64Decode(
'Cg1VbnBhaXJSZXF1ZXN0EhsKCWRldmljZV9pZBgBIAEoCVIIZGV2aWNlSWQ=');
+@$core.Deprecated('Use setDeviceAddressRequestDescriptor instead')
+const SetDeviceAddressRequest$json = {
+ '1': 'SetDeviceAddressRequest',
+ '2': [
+ {'1': 'device_id', '3': 1, '4': 1, '5': 9, '10': 'deviceId'},
+ {'1': 'address', '3': 2, '4': 1, '5': 9, '10': 'address'},
+ ],
+};
+
+/// Descriptor for `SetDeviceAddressRequest`. Decode as a `google.protobuf.DescriptorProto`.
+final $typed_data.Uint8List setDeviceAddressRequestDescriptor =
+ $convert.base64Decode(
+ 'ChdTZXREZXZpY2VBZGRyZXNzUmVxdWVzdBIbCglkZXZpY2VfaWQYASABKAlSCGRldmljZUlkEh'
+ 'gKB2FkZHJlc3MYAiABKAlSB2FkZHJlc3M=');
+
@$core.Deprecated('Use configDescriptor instead')
const Config$json = {
'1': 'Config',
@@ -545,6 +563,7 @@ const Config$json = {
{'1': 'signaling_url', '3': 11, '4': 1, '5': 9, '10': 'signalingUrl'},
{'1': 'only_own_stun', '3': 12, '4': 1, '5': 8, '10': 'onlyOwnStun'},
{'1': 'language', '3': 13, '4': 1, '5': 9, '10': 'language'},
+ {'1': 'lan_disabled', '3': 14, '4': 1, '5': 8, '10': 'lanDisabled'},
],
};
@@ -559,7 +578,7 @@ final $typed_data.Uint8List configDescriptor = $convert.base64Decode(
'JgoPbGF1bmNoX2F0X2xvZ2luGAkgASgIUg1sYXVuY2hBdExvZ2luEh8KC2RldmljZV9uYW1lGA'
'ogASgJUgpkZXZpY2VOYW1lEiMKDXNpZ25hbGluZ191cmwYCyABKAlSDHNpZ25hbGluZ1VybBIi'
'Cg1vbmx5X293bl9zdHVuGAwgASgIUgtvbmx5T3duU3R1bhIaCghsYW5ndWFnZRgNIAEoCVIIbG'
- 'FuZ3VhZ2U=');
+ 'FuZ3VhZ2USIQoMbGFuX2Rpc2FibGVkGA4gASgIUgtsYW5EaXNhYmxlZA==');
@$core.Deprecated('Use networkInfoDescriptor instead')
const NetworkInfo$json = {
@@ -577,6 +596,14 @@ const NetworkInfo$json = {
{'1': 'probed', '3': 3, '4': 1, '5': 5, '10': 'probed'},
{'1': 'answered', '3': 4, '4': 1, '5': 5, '10': 'answered'},
{'1': 'probed_at_unix', '3': 5, '4': 1, '5': 3, '10': 'probedAtUnix'},
+ {
+ '1': 'lan',
+ '3': 6,
+ '4': 1,
+ '5': 11,
+ '6': '.copysync.v1.LanInfo',
+ '10': 'lan'
+ },
],
};
@@ -585,7 +612,55 @@ final $typed_data.Uint8List networkInfoDescriptor = $convert.base64Decode(
'CgtOZXR3b3JrSW5mbxIdCgpsb2NhbF9wb3J0GAEgASgFUglsb2NhbFBvcnQSNgoIZWdyZXNzZX'
'MYAiADKAsyGi5jb3B5c3luYy52MS5OZXR3b3JrRWdyZXNzUghlZ3Jlc3NlcxIWCgZwcm9iZWQY'
'AyABKAVSBnByb2JlZBIaCghhbnN3ZXJlZBgEIAEoBVIIYW5zd2VyZWQSJAoOcHJvYmVkX2F0X3'
- 'VuaXgYBSABKANSDHByb2JlZEF0VW5peA==');
+ 'VuaXgYBSABKANSDHByb2JlZEF0VW5peBImCgNsYW4YBiABKAsyFC5jb3B5c3luYy52MS5MYW5J'
+ 'bmZvUgNsYW4=');
+
+@$core.Deprecated('Use lanInfoDescriptor instead')
+const LanInfo$json = {
+ '1': 'LanInfo',
+ '2': [
+ {'1': 'enabled', '3': 1, '4': 1, '5': 8, '10': 'enabled'},
+ {'1': 'port', '3': 2, '4': 1, '5': 5, '10': 'port'},
+ {'1': 'local_addresses', '3': 3, '4': 3, '5': 9, '10': 'localAddresses'},
+ {'1': 'discovered', '3': 4, '4': 1, '5': 5, '10': 'discovered'},
+ {
+ '1': 'peers',
+ '3': 5,
+ '4': 3,
+ '5': 11,
+ '6': '.copysync.v1.LanPeer',
+ '10': 'peers'
+ },
+ {'1': 'blocked', '3': 6, '4': 1, '5': 8, '10': 'blocked'},
+ ],
+};
+
+/// Descriptor for `LanInfo`. Decode as a `google.protobuf.DescriptorProto`.
+final $typed_data.Uint8List lanInfoDescriptor = $convert.base64Decode(
+ 'CgdMYW5JbmZvEhgKB2VuYWJsZWQYASABKAhSB2VuYWJsZWQSEgoEcG9ydBgCIAEoBVIEcG9ydB'
+ 'InCg9sb2NhbF9hZGRyZXNzZXMYAyADKAlSDmxvY2FsQWRkcmVzc2VzEh4KCmRpc2NvdmVyZWQY'
+ 'BCABKAVSCmRpc2NvdmVyZWQSKgoFcGVlcnMYBSADKAsyFC5jb3B5c3luYy52MS5MYW5QZWVyUg'
+ 'VwZWVycxIYCgdibG9ja2VkGAYgASgIUgdibG9ja2Vk');
+
+@$core.Deprecated('Use lanPeerDescriptor instead')
+const LanPeer$json = {
+ '1': 'LanPeer',
+ '2': [
+ {'1': 'device_id', '3': 1, '4': 1, '5': 9, '10': 'deviceId'},
+ {'1': 'device_name', '3': 2, '4': 1, '5': 9, '10': 'deviceName'},
+ {'1': 'reachable', '3': 3, '4': 1, '5': 8, '10': 'reachable'},
+ {'1': 'address', '3': 4, '4': 1, '5': 9, '10': 'address'},
+ {'1': 'known_addresses', '3': 5, '4': 3, '5': 9, '10': 'knownAddresses'},
+ {'1': 'last_seen_unix', '3': 6, '4': 1, '5': 3, '10': 'lastSeenUnix'},
+ ],
+};
+
+/// Descriptor for `LanPeer`. Decode as a `google.protobuf.DescriptorProto`.
+final $typed_data.Uint8List lanPeerDescriptor = $convert.base64Decode(
+ 'CgdMYW5QZWVyEhsKCWRldmljZV9pZBgBIAEoCVIIZGV2aWNlSWQSHwoLZGV2aWNlX25hbWUYAi'
+ 'ABKAlSCmRldmljZU5hbWUSHAoJcmVhY2hhYmxlGAMgASgIUglyZWFjaGFibGUSGAoHYWRkcmVz'
+ 'cxgEIAEoCVIHYWRkcmVzcxInCg9rbm93bl9hZGRyZXNzZXMYBSADKAlSDmtub3duQWRkcmVzc2'
+ 'VzEiQKDmxhc3Rfc2Vlbl91bml4GAYgASgDUgxsYXN0U2VlblVuaXg=');
@$core.Deprecated('Use networkEgressDescriptor instead')
const NetworkEgress$json = {
@@ -628,6 +703,15 @@ const Status$json = {
{'1': 'cache_bytes_used', '3': 5, '4': 1, '5': 3, '10': 'cacheBytesUsed'},
{'1': 'peers_online', '3': 6, '4': 1, '5': 5, '10': 'peersOnline'},
{'1': 'version', '3': 7, '4': 1, '5': 9, '10': 'version'},
+ {
+ '1': 'server_configured',
+ '3': 8,
+ '4': 1,
+ '5': 8,
+ '10': 'serverConfigured'
+ },
+ {'1': 'lan_enabled', '3': 9, '4': 1, '5': 8, '10': 'lanEnabled'},
+ {'1': 'lan_blocked', '3': 10, '4': 1, '5': 8, '10': 'lanBlocked'},
],
};
@@ -638,7 +722,9 @@ final $typed_data.Uint8List statusDescriptor = $convert.base64Decode(
'b25uZWN0ZWQSUwoUY2xpcGJvYXJkX3Blcm1pc3Npb24YBCABKA4yIC5jb3B5c3luYy52MS5DbG'
'lwYm9hcmRQZXJtaXNzaW9uUhNjbGlwYm9hcmRQZXJtaXNzaW9uEigKEGNhY2hlX2J5dGVzX3Vz'
'ZWQYBSABKANSDmNhY2hlQnl0ZXNVc2VkEiEKDHBlZXJzX29ubGluZRgGIAEoBVILcGVlcnNPbm'
- 'xpbmUSGAoHdmVyc2lvbhgHIAEoCVIHdmVyc2lvbg==');
+ 'xpbmUSGAoHdmVyc2lvbhgHIAEoCVIHdmVyc2lvbhIrChFzZXJ2ZXJfY29uZmlndXJlZBgIIAEo'
+ 'CFIQc2VydmVyQ29uZmlndXJlZBIfCgtsYW5fZW5hYmxlZBgJIAEoCFIKbGFuRW5hYmxlZBIfCg'
+ 'tsYW5fYmxvY2tlZBgKIAEoCFIKbGFuQmxvY2tlZA==');
@$core.Deprecated('Use getImagePreviewRequestDescriptor instead')
const GetImagePreviewRequest$json = {
diff --git a/ui/lib/gen/copysync/v1/wire.pb.dart b/ui/lib/gen/copysync/v1/wire.pb.dart
index d42a3ea..527031d 100644
--- a/ui/lib/gen/copysync/v1/wire.pb.dart
+++ b/ui/lib/gen/copysync/v1/wire.pb.dart
@@ -105,7 +105,7 @@ class Signed extends $pb.GeneratedMessage {
void clearFromDeviceId() => $_clearField(3);
}
-enum SignalMessage_Payload { offer, answer, candidate, ping, notSet }
+enum SignalMessage_Payload { offer, answer, candidate, ping, lanHello, notSet }
class SignalMessage extends $pb.GeneratedMessage {
factory SignalMessage({
@@ -116,6 +116,7 @@ class SignalMessage extends $pb.GeneratedMessage {
SdpAnswer? answer,
IceCandidate? candidate,
Ping? ping,
+ LanHello? lanHello,
}) {
final result = SignalMessage._();
if (timestampUnix != null) result.timestampUnix = timestampUnix;
@@ -125,6 +126,7 @@ class SignalMessage extends $pb.GeneratedMessage {
if (answer != null) result.answer = answer;
if (candidate != null) result.candidate = candidate;
if (ping != null) result.ping = ping;
+ if (lanHello != null) result.lanHello = lanHello;
return result;
}
@@ -143,13 +145,14 @@ class SignalMessage extends $pb.GeneratedMessage {
11: SignalMessage_Payload.answer,
12: SignalMessage_Payload.candidate,
13: SignalMessage_Payload.ping,
+ 14: SignalMessage_Payload.lanHello,
0: SignalMessage_Payload.notSet
};
static final $pb.BuilderInfo _i = $pb.BuilderInfo(
_omitMessageNames ? '' : 'SignalMessage',
package: const $pb.PackageName(_omitMessageNames ? '' : 'copysync.v1'),
createEmptyInstance: SignalMessage.$_createMessage)
- ..oo(0, [10, 11, 12, 13])
+ ..oo(0, [10, 11, 12, 13, 14])
..aInt64(1, _omitFieldNames ? '' : 'timestampUnix')
..a<$core.List<$core.int>>(
2, _omitFieldNames ? '' : 'nonce', $pb.PbFieldType.OY)
@@ -162,6 +165,8 @@ class SignalMessage extends $pb.GeneratedMessage {
subBuilder: IceCandidate.$_createMessage)
..aOM<Ping>(13, _omitFieldNames ? '' : 'ping',
subBuilder: Ping.$_createMessage)
+ ..aOM<LanHello>(14, _omitFieldNames ? '' : 'lanHello',
+ subBuilder: LanHello.$_createMessage)
..hasRequiredFields = false;
@$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
@@ -190,12 +195,14 @@ class SignalMessage extends $pb.GeneratedMessage {
@$pb.TagNumber(11)
@$pb.TagNumber(12)
@$pb.TagNumber(13)
+ @$pb.TagNumber(14)
SignalMessage_Payload whichPayload() =>
_SignalMessage_PayloadByTag[$_whichOneof(0)]!;
@$pb.TagNumber(10)
@$pb.TagNumber(11)
@$pb.TagNumber(12)
@$pb.TagNumber(13)
+ @$pb.TagNumber(14)
void clearPayload() => $_clearField($_whichOneof(0));
/// 防重放:接收方拒绝时间戳过旧或 nonce 重复的消息
@@ -217,6 +224,7 @@ class SignalMessage extends $pb.GeneratedMessage {
@$pb.TagNumber(2)
void clearNonce() => $_clearField(2);
+ /// 接收方只收发给自己的消息:局域网里谁都能把截到的消息转发给第三台设备
@$pb.TagNumber(3)
$core.String get toDeviceId => $_getSZ(2);
@$pb.TagNumber(3)
@@ -269,6 +277,17 @@ class SignalMessage extends $pb.GeneratedMessage {
void clearPing() => $_clearField(13);
@$pb.TagNumber(13)
Ping ensurePing() => $_ensure(6);
+
+ @$pb.TagNumber(14)
+ LanHello get lanHello => $_getN(7);
+ @$pb.TagNumber(14)
+ set lanHello(LanHello value) => $_setField(14, value);
+ @$pb.TagNumber(14)
+ $core.bool hasLanHello() => $_has(7);
+ @$pb.TagNumber(14)
+ void clearLanHello() => $_clearField(14);
+ @$pb.TagNumber(14)
+ LanHello ensureLanHello() => $_ensure(7);
}
class SdpOffer extends $pb.GeneratedMessage {
@@ -1800,6 +1819,499 @@ class ServerError extends $pb.GeneratedMessage {
void clearMessage() => $_clearField(2);
}
+enum LanPacket_Payload { signal, pairRequest, pairResponse, pairReject, notSet }
+
+class LanPacket extends $pb.GeneratedMessage {
+ factory LanPacket({
+ Signed? signal,
+ LanPairSigned? pairRequest,
+ LanPairSigned? pairResponse,
+ LanPairReject? pairReject,
+ }) {
+ final result = LanPacket._();
+ if (signal != null) result.signal = signal;
+ if (pairRequest != null) result.pairRequest = pairRequest;
+ if (pairResponse != null) result.pairResponse = pairResponse;
+ if (pairReject != null) result.pairReject = pairReject;
+ return result;
+ }
+
+ LanPacket._();
+
+ factory LanPacket.fromBuffer($core.List<$core.int> data,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanPacket()..mergeFromBuffer(data, registry);
+ factory LanPacket.fromJson($core.String json,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanPacket()..mergeFromJson(json, registry);
+
+ static const $core.Map<$core.int, LanPacket_Payload> _LanPacket_PayloadByTag =
+ {
+ 1: LanPacket_Payload.signal,
+ 2: LanPacket_Payload.pairRequest,
+ 3: LanPacket_Payload.pairResponse,
+ 4: LanPacket_Payload.pairReject,
+ 0: LanPacket_Payload.notSet
+ };
+ static final $pb.BuilderInfo _i = $pb.BuilderInfo(
+ _omitMessageNames ? '' : 'LanPacket',
+ package: const $pb.PackageName(_omitMessageNames ? '' : 'copysync.v1'),
+ createEmptyInstance: LanPacket.$_createMessage)
+ ..oo(0, [1, 2, 3, 4])
+ ..aOM<Signed>(1, _omitFieldNames ? '' : 'signal',
+ subBuilder: Signed.$_createMessage)
+ ..aOM<LanPairSigned>(2, _omitFieldNames ? '' : 'pairRequest',
+ subBuilder: LanPairSigned.$_createMessage)
+ ..aOM<LanPairSigned>(3, _omitFieldNames ? '' : 'pairResponse',
+ subBuilder: LanPairSigned.$_createMessage)
+ ..aOM<LanPairReject>(4, _omitFieldNames ? '' : 'pairReject',
+ subBuilder: LanPairReject.$_createMessage)
+ ..hasRequiredFields = false;
+
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanPacket clone() => deepCopy();
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanPacket copyWith(void Function(LanPacket) updates) =>
+ super.copyWith((message) => updates(message as LanPacket)) as LanPacket;
+
+ @$core.override
+ $pb.BuilderInfo get info_ => _i;
+
+ @$core.pragma('dart2js:noInline')
+ @$core.Deprecated('Use LanPacket() / LanPacket.new instead')
+ static LanPacket create() => LanPacket._();
+ static $pb.GeneratedMessage $_createMessage() => LanPacket._();
+ @$core.override
+ LanPacket createEmptyInstance() => LanPacket._();
+ @$core.pragma('dart2js:noInline')
+ static LanPacket getDefault() => _defaultInstance ??=
+ $pb.GeneratedMessage.$_defaultFor<LanPacket>(LanPacket.$_createMessage);
+ static LanPacket? _defaultInstance;
+
+ @$pb.TagNumber(1)
+ @$pb.TagNumber(2)
+ @$pb.TagNumber(3)
+ @$pb.TagNumber(4)
+ LanPacket_Payload whichPayload() => _LanPacket_PayloadByTag[$_whichOneof(0)]!;
+ @$pb.TagNumber(1)
+ @$pb.TagNumber(2)
+ @$pb.TagNumber(3)
+ @$pb.TagNumber(4)
+ void clearPayload() => $_clearField($_whichOneof(0));
+
+ @$pb.TagNumber(1)
+ Signed get signal => $_getN(0);
+ @$pb.TagNumber(1)
+ set signal(Signed value) => $_setField(1, value);
+ @$pb.TagNumber(1)
+ $core.bool hasSignal() => $_has(0);
+ @$pb.TagNumber(1)
+ void clearSignal() => $_clearField(1);
+ @$pb.TagNumber(1)
+ Signed ensureSignal() => $_ensure(0);
+
+ @$pb.TagNumber(2)
+ LanPairSigned get pairRequest => $_getN(1);
+ @$pb.TagNumber(2)
+ set pairRequest(LanPairSigned value) => $_setField(2, value);
+ @$pb.TagNumber(2)
+ $core.bool hasPairRequest() => $_has(1);
+ @$pb.TagNumber(2)
+ void clearPairRequest() => $_clearField(2);
+ @$pb.TagNumber(2)
+ LanPairSigned ensurePairRequest() => $_ensure(1);
+
+ @$pb.TagNumber(3)
+ LanPairSigned get pairResponse => $_getN(2);
+ @$pb.TagNumber(3)
+ set pairResponse(LanPairSigned value) => $_setField(3, value);
+ @$pb.TagNumber(3)
+ $core.bool hasPairResponse() => $_has(2);
+ @$pb.TagNumber(3)
+ void clearPairResponse() => $_clearField(3);
+ @$pb.TagNumber(3)
+ LanPairSigned ensurePairResponse() => $_ensure(2);
+
+ @$pb.TagNumber(4)
+ LanPairReject get pairReject => $_getN(3);
+ @$pb.TagNumber(4)
+ set pairReject(LanPairReject value) => $_setField(4, value);
+ @$pb.TagNumber(4)
+ $core.bool hasPairReject() => $_has(3);
+ @$pb.TagNumber(4)
+ void clearPairReject() => $_clearField(4);
+ @$pb.TagNumber(4)
+ LanPairReject ensurePairReject() => $_ensure(3);
+}
+
+/// 已配对设备之间的上线通知。还没连通时定期发,连通后低频保活。
+/// 两端都往对方发,有状态的防火墙(Windows)会放行对方的包。
+class LanHello extends $pb.GeneratedMessage {
+ factory LanHello({
+ $core.Iterable<$core.String>? addresses,
+ $core.bool? replyWanted,
+ $core.int? intervalSeconds,
+ }) {
+ final result = LanHello._();
+ if (addresses != null) result.addresses.addAll(addresses);
+ if (replyWanted != null) result.replyWanted = replyWanted;
+ if (intervalSeconds != null) result.intervalSeconds = intervalSeconds;
+ return result;
+ }
+
+ LanHello._();
+
+ factory LanHello.fromBuffer($core.List<$core.int> data,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanHello()..mergeFromBuffer(data, registry);
+ factory LanHello.fromJson($core.String json,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanHello()..mergeFromJson(json, registry);
+
+ static final $pb.BuilderInfo _i = $pb.BuilderInfo(
+ _omitMessageNames ? '' : 'LanHello',
+ package: const $pb.PackageName(_omitMessageNames ? '' : 'copysync.v1'),
+ createEmptyInstance: LanHello.$_createMessage)
+ ..pPS(1, _omitFieldNames ? '' : 'addresses')
+ ..aOB(2, _omitFieldNames ? '' : 'replyWanted')
+ ..aI(3, _omitFieldNames ? '' : 'intervalSeconds',
+ fieldType: $pb.PbFieldType.OU3)
+ ..hasRequiredFields = false;
+
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanHello clone() => deepCopy();
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanHello copyWith(void Function(LanHello) updates) =>
+ super.copyWith((message) => updates(message as LanHello)) as LanHello;
+
+ @$core.override
+ $pb.BuilderInfo get info_ => _i;
+
+ @$core.pragma('dart2js:noInline')
+ @$core.Deprecated('Use LanHello() / LanHello.new instead')
+ static LanHello create() => LanHello._();
+ static $pb.GeneratedMessage $_createMessage() => LanHello._();
+ @$core.override
+ LanHello createEmptyInstance() => LanHello._();
+ @$core.pragma('dart2js:noInline')
+ static LanHello getDefault() => _defaultInstance ??=
+ $pb.GeneratedMessage.$_defaultFor<LanHello>(LanHello.$_createMessage);
+ static LanHello? _defaultInstance;
+
+ @$pb.TagNumber(1)
+ $pb.PbList<$core.String> get addresses => $_getList(0);
+
+ @$pb.TagNumber(2)
+ $core.bool get replyWanted => $_getBF(1);
+ @$pb.TagNumber(2)
+ set replyWanted($core.bool value) => $_setBool(1, value);
+ @$pb.TagNumber(2)
+ $core.bool hasReplyWanted() => $_has(1);
+ @$pb.TagNumber(2)
+ void clearReplyWanted() => $_clearField(2);
+
+ @$pb.TagNumber(3)
+ $core.int get intervalSeconds => $_getIZ(2);
+ @$pb.TagNumber(3)
+ set intervalSeconds($core.int value) => $_setUnsignedInt32(2, value);
+ @$pb.TagNumber(3)
+ $core.bool hasIntervalSeconds() => $_has(2);
+ @$pb.TagNumber(3)
+ void clearIntervalSeconds() => $_clearField(3);
+}
+
+/// payload 是序列化后的 LanPairInfo,signature 用 LanPairInfo.public_key 签名。
+class LanPairSigned extends $pb.GeneratedMessage {
+ factory LanPairSigned({
+ $core.List<$core.int>? payload,
+ $core.List<$core.int>? signature,
+ }) {
+ final result = LanPairSigned._();
+ if (payload != null) result.payload = payload;
+ if (signature != null) result.signature = signature;
+ return result;
+ }
+
+ LanPairSigned._();
+
+ factory LanPairSigned.fromBuffer($core.List<$core.int> data,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanPairSigned()..mergeFromBuffer(data, registry);
+ factory LanPairSigned.fromJson($core.String json,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanPairSigned()..mergeFromJson(json, registry);
+
+ static final $pb.BuilderInfo _i = $pb.BuilderInfo(
+ _omitMessageNames ? '' : 'LanPairSigned',
+ package: const $pb.PackageName(_omitMessageNames ? '' : 'copysync.v1'),
+ createEmptyInstance: LanPairSigned.$_createMessage)
+ ..a<$core.List<$core.int>>(
+ 1, _omitFieldNames ? '' : 'payload', $pb.PbFieldType.OY)
+ ..a<$core.List<$core.int>>(
+ 2, _omitFieldNames ? '' : 'signature', $pb.PbFieldType.OY)
+ ..hasRequiredFields = false;
+
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanPairSigned clone() => deepCopy();
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanPairSigned copyWith(void Function(LanPairSigned) updates) =>
+ super.copyWith((message) => updates(message as LanPairSigned))
+ as LanPairSigned;
+
+ @$core.override
+ $pb.BuilderInfo get info_ => _i;
+
+ @$core.pragma('dart2js:noInline')
+ @$core.Deprecated('Use LanPairSigned() / LanPairSigned.new instead')
+ static LanPairSigned create() => LanPairSigned._();
+ static $pb.GeneratedMessage $_createMessage() => LanPairSigned._();
+ @$core.override
+ LanPairSigned createEmptyInstance() => LanPairSigned._();
+ @$core.pragma('dart2js:noInline')
+ static LanPairSigned getDefault() =>
+ _defaultInstance ??= $pb.GeneratedMessage.$_defaultFor<LanPairSigned>(
+ LanPairSigned.$_createMessage);
+ static LanPairSigned? _defaultInstance;
+
+ @$pb.TagNumber(1)
+ $core.List<$core.int> get payload => $_getN(0);
+ @$pb.TagNumber(1)
+ set payload($core.List<$core.int> value) => $_setBytes(0, value);
+ @$pb.TagNumber(1)
+ $core.bool hasPayload() => $_has(0);
+ @$pb.TagNumber(1)
+ void clearPayload() => $_clearField(1);
+
+ @$pb.TagNumber(2)
+ $core.List<$core.int> get signature => $_getN(1);
+ @$pb.TagNumber(2)
+ set signature($core.List<$core.int> value) => $_setBytes(1, value);
+ @$pb.TagNumber(2)
+ $core.bool hasSignature() => $_has(1);
+ @$pb.TagNumber(2)
+ void clearSignature() => $_clearField(2);
+}
+
+class LanPairInfo extends $pb.GeneratedMessage {
+ factory LanPairInfo({
+ $core.String? code,
+ $core.String? deviceId,
+ $core.String? deviceName,
+ $core.String? platform,
+ $core.List<$core.int>? publicKey,
+ $core.Iterable<$core.String>? addresses,
+ $fixnum.Int64? timestampUnix,
+ $core.List<$core.int>? nonce,
+ $core.List<$core.int>? requestNonce,
+ }) {
+ final result = LanPairInfo._();
+ if (code != null) result.code = code;
+ if (deviceId != null) result.deviceId = deviceId;
+ if (deviceName != null) result.deviceName = deviceName;
+ if (platform != null) result.platform = platform;
+ if (publicKey != null) result.publicKey = publicKey;
+ if (addresses != null) result.addresses.addAll(addresses);
+ if (timestampUnix != null) result.timestampUnix = timestampUnix;
+ if (nonce != null) result.nonce = nonce;
+ if (requestNonce != null) result.requestNonce = requestNonce;
+ return result;
+ }
+
+ LanPairInfo._();
+
+ factory LanPairInfo.fromBuffer($core.List<$core.int> data,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanPairInfo()..mergeFromBuffer(data, registry);
+ factory LanPairInfo.fromJson($core.String json,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanPairInfo()..mergeFromJson(json, registry);
+
+ static final $pb.BuilderInfo _i = $pb.BuilderInfo(
+ _omitMessageNames ? '' : 'LanPairInfo',
+ package: const $pb.PackageName(_omitMessageNames ? '' : 'copysync.v1'),
+ createEmptyInstance: LanPairInfo.$_createMessage)
+ ..aOS(1, _omitFieldNames ? '' : 'code')
+ ..aOS(2, _omitFieldNames ? '' : 'deviceId')
+ ..aOS(3, _omitFieldNames ? '' : 'deviceName')
+ ..aOS(4, _omitFieldNames ? '' : 'platform')
+ ..a<$core.List<$core.int>>(
+ 5, _omitFieldNames ? '' : 'publicKey', $pb.PbFieldType.OY)
+ ..pPS(6, _omitFieldNames ? '' : 'addresses')
+ ..aInt64(7, _omitFieldNames ? '' : 'timestampUnix')
+ ..a<$core.List<$core.int>>(
+ 8, _omitFieldNames ? '' : 'nonce', $pb.PbFieldType.OY)
+ ..a<$core.List<$core.int>>(
+ 9, _omitFieldNames ? '' : 'requestNonce', $pb.PbFieldType.OY)
+ ..hasRequiredFields = false;
+
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanPairInfo clone() => deepCopy();
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanPairInfo copyWith(void Function(LanPairInfo) updates) =>
+ super.copyWith((message) => updates(message as LanPairInfo))
+ as LanPairInfo;
+
+ @$core.override
+ $pb.BuilderInfo get info_ => _i;
+
+ @$core.pragma('dart2js:noInline')
+ @$core.Deprecated('Use LanPairInfo() / LanPairInfo.new instead')
+ static LanPairInfo create() => LanPairInfo._();
+ static $pb.GeneratedMessage $_createMessage() => LanPairInfo._();
+ @$core.override
+ LanPairInfo createEmptyInstance() => LanPairInfo._();
+ @$core.pragma('dart2js:noInline')
+ static LanPairInfo getDefault() =>
+ _defaultInstance ??= $pb.GeneratedMessage.$_defaultFor<LanPairInfo>(
+ LanPairInfo.$_createMessage);
+ static LanPairInfo? _defaultInstance;
+
+ @$pb.TagNumber(1)
+ $core.String get code => $_getSZ(0);
+ @$pb.TagNumber(1)
+ set code($core.String value) => $_setString(0, value);
+ @$pb.TagNumber(1)
+ $core.bool hasCode() => $_has(0);
+ @$pb.TagNumber(1)
+ void clearCode() => $_clearField(1);
+
+ @$pb.TagNumber(2)
+ $core.String get deviceId => $_getSZ(1);
+ @$pb.TagNumber(2)
+ set deviceId($core.String value) => $_setString(1, value);
+ @$pb.TagNumber(2)
+ $core.bool hasDeviceId() => $_has(1);
+ @$pb.TagNumber(2)
+ void clearDeviceId() => $_clearField(2);
+
+ @$pb.TagNumber(3)
+ $core.String get deviceName => $_getSZ(2);
+ @$pb.TagNumber(3)
+ set deviceName($core.String value) => $_setString(2, value);
+ @$pb.TagNumber(3)
+ $core.bool hasDeviceName() => $_has(2);
+ @$pb.TagNumber(3)
+ void clearDeviceName() => $_clearField(3);
+
+ @$pb.TagNumber(4)
+ $core.String get platform => $_getSZ(3);
+ @$pb.TagNumber(4)
+ set platform($core.String value) => $_setString(3, value);
+ @$pb.TagNumber(4)
+ $core.bool hasPlatform() => $_has(3);
+ @$pb.TagNumber(4)
+ void clearPlatform() => $_clearField(4);
+
+ @$pb.TagNumber(5)
+ $core.List<$core.int> get publicKey => $_getN(4);
+ @$pb.TagNumber(5)
+ set publicKey($core.List<$core.int> value) => $_setBytes(4, value);
+ @$pb.TagNumber(5)
+ $core.bool hasPublicKey() => $_has(4);
+ @$pb.TagNumber(5)
+ void clearPublicKey() => $_clearField(5);
+
+ @$pb.TagNumber(6)
+ $pb.PbList<$core.String> get addresses => $_getList(5);
+
+ @$pb.TagNumber(7)
+ $fixnum.Int64 get timestampUnix => $_getI64(6);
+ @$pb.TagNumber(7)
+ set timestampUnix($fixnum.Int64 value) => $_setInt64(6, value);
+ @$pb.TagNumber(7)
+ $core.bool hasTimestampUnix() => $_has(6);
+ @$pb.TagNumber(7)
+ void clearTimestampUnix() => $_clearField(7);
+
+ @$pb.TagNumber(8)
+ $core.List<$core.int> get nonce => $_getN(7);
+ @$pb.TagNumber(8)
+ set nonce($core.List<$core.int> value) => $_setBytes(7, value);
+ @$pb.TagNumber(8)
+ $core.bool hasNonce() => $_has(7);
+ @$pb.TagNumber(8)
+ void clearNonce() => $_clearField(8);
+
+ @$pb.TagNumber(9)
+ $core.List<$core.int> get requestNonce => $_getN(8);
+ @$pb.TagNumber(9)
+ set requestNonce($core.List<$core.int> value) => $_setBytes(8, value);
+ @$pb.TagNumber(9)
+ $core.bool hasRequestNonce() => $_has(8);
+ @$pb.TagNumber(9)
+ void clearRequestNonce() => $_clearField(9);
+}
+
+class LanPairReject extends $pb.GeneratedMessage {
+ factory LanPairReject({
+ $core.List<$core.int>? requestNonce,
+ $core.String? reason,
+ }) {
+ final result = LanPairReject._();
+ if (requestNonce != null) result.requestNonce = requestNonce;
+ if (reason != null) result.reason = reason;
+ return result;
+ }
+
+ LanPairReject._();
+
+ factory LanPairReject.fromBuffer($core.List<$core.int> data,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanPairReject()..mergeFromBuffer(data, registry);
+ factory LanPairReject.fromJson($core.String json,
+ [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+ LanPairReject()..mergeFromJson(json, registry);
+
+ static final $pb.BuilderInfo _i = $pb.BuilderInfo(
+ _omitMessageNames ? '' : 'LanPairReject',
+ package: const $pb.PackageName(_omitMessageNames ? '' : 'copysync.v1'),
+ createEmptyInstance: LanPairReject.$_createMessage)
+ ..a<$core.List<$core.int>>(
+ 1, _omitFieldNames ? '' : 'requestNonce', $pb.PbFieldType.OY)
+ ..aOS(2, _omitFieldNames ? '' : 'reason')
+ ..hasRequiredFields = false;
+
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanPairReject clone() => deepCopy();
+ @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+ LanPairReject copyWith(void Function(LanPairReject) updates) =>
+ super.copyWith((message) => updates(message as LanPairReject))
+ as LanPairReject;
+
+ @$core.override
+ $pb.BuilderInfo get info_ => _i;
+
+ @$core.pragma('dart2js:noInline')
+ @$core.Deprecated('Use LanPairReject() / LanPairReject.new instead')
+ static LanPairReject create() => LanPairReject._();
+ static $pb.GeneratedMessage $_createMessage() => LanPairReject._();
+ @$core.override
+ LanPairReject createEmptyInstance() => LanPairReject._();
+ @$core.pragma('dart2js:noInline')
+ static LanPairReject getDefault() =>
+ _defaultInstance ??= $pb.GeneratedMessage.$_defaultFor<LanPairReject>(
+ LanPairReject.$_createMessage);
+ static LanPairReject? _defaultInstance;
+
+ @$pb.TagNumber(1)
+ $core.List<$core.int> get requestNonce => $_getN(0);
+ @$pb.TagNumber(1)
+ set requestNonce($core.List<$core.int> value) => $_setBytes(0, value);
+ @$pb.TagNumber(1)
+ $core.bool hasRequestNonce() => $_has(0);
+ @$pb.TagNumber(1)
+ void clearRequestNonce() => $_clearField(1);
+
+ @$pb.TagNumber(2)
+ $core.String get reason => $_getSZ(1);
+ @$pb.TagNumber(2)
+ set reason($core.String value) => $_setString(1, value);
+ @$pb.TagNumber(2)
+ $core.bool hasReason() => $_has(1);
+ @$pb.TagNumber(2)
+ void clearReason() => $_clearField(2);
+}
+
enum PeerMessage_Payload { offer, fetch, reject, header, done, link, notSet }
/// 控制通道消息
diff --git a/ui/lib/gen/copysync/v1/wire.pbjson.dart b/ui/lib/gen/copysync/v1/wire.pbjson.dart
index 0081bfc..a8175a6 100644
--- a/ui/lib/gen/copysync/v1/wire.pbjson.dart
+++ b/ui/lib/gen/copysync/v1/wire.pbjson.dart
@@ -103,6 +103,15 @@ const SignalMessage$json = {
'9': 0,
'10': 'ping'
},
+ {
+ '1': 'lan_hello',
+ '3': 14,
+ '4': 1,
+ '5': 11,
+ '6': '.copysync.v1.LanHello',
+ '9': 0,
+ '10': 'lanHello'
+ },
],
'8': [
{'1': 'payload'},
@@ -116,7 +125,8 @@ final $typed_data.Uint8List signalMessageDescriptor = $convert.base64Decode(
'LQoFb2ZmZXIYCiABKAsyFS5jb3B5c3luYy52MS5TZHBPZmZlckgAUgVvZmZlchIwCgZhbnN3ZX'
'IYCyABKAsyFi5jb3B5c3luYy52MS5TZHBBbnN3ZXJIAFIGYW5zd2VyEjkKCWNhbmRpZGF0ZRgM'
'IAEoCzIZLmNvcHlzeW5jLnYxLkljZUNhbmRpZGF0ZUgAUgljYW5kaWRhdGUSJwoEcGluZxgNIA'
- 'EoCzIRLmNvcHlzeW5jLnYxLlBpbmdIAFIEcGluZ0IJCgdwYXlsb2Fk');
+ 'EoCzIRLmNvcHlzeW5jLnYxLlBpbmdIAFIEcGluZxI0CglsYW5faGVsbG8YDiABKAsyFS5jb3B5'
+ 'c3luYy52MS5MYW5IZWxsb0gAUghsYW5IZWxsb0IJCgdwYXlsb2Fk');
@$core.Deprecated('Use sdpOfferDescriptor instead')
const SdpOffer$json = {
@@ -513,6 +523,129 @@ final $typed_data.Uint8List serverErrorDescriptor = $convert.base64Decode(
'CgtTZXJ2ZXJFcnJvchISCgRjb2RlGAEgASgJUgRjb2RlEhgKB21lc3NhZ2UYAiABKAlSB21lc3'
'NhZ2U=');
+@$core.Deprecated('Use lanPacketDescriptor instead')
+const LanPacket$json = {
+ '1': 'LanPacket',
+ '2': [
+ {
+ '1': 'signal',
+ '3': 1,
+ '4': 1,
+ '5': 11,
+ '6': '.copysync.v1.Signed',
+ '9': 0,
+ '10': 'signal'
+ },
+ {
+ '1': 'pair_request',
+ '3': 2,
+ '4': 1,
+ '5': 11,
+ '6': '.copysync.v1.LanPairSigned',
+ '9': 0,
+ '10': 'pairRequest'
+ },
+ {
+ '1': 'pair_response',
+ '3': 3,
+ '4': 1,
+ '5': 11,
+ '6': '.copysync.v1.LanPairSigned',
+ '9': 0,
+ '10': 'pairResponse'
+ },
+ {
+ '1': 'pair_reject',
+ '3': 4,
+ '4': 1,
+ '5': 11,
+ '6': '.copysync.v1.LanPairReject',
+ '9': 0,
+ '10': 'pairReject'
+ },
+ ],
+ '8': [
+ {'1': 'payload'},
+ ],
+};
+
+/// Descriptor for `LanPacket`. Decode as a `google.protobuf.DescriptorProto`.
+final $typed_data.Uint8List lanPacketDescriptor = $convert.base64Decode(
+ 'CglMYW5QYWNrZXQSLQoGc2lnbmFsGAEgASgLMhMuY29weXN5bmMudjEuU2lnbmVkSABSBnNpZ2'
+ '5hbBI/CgxwYWlyX3JlcXVlc3QYAiABKAsyGi5jb3B5c3luYy52MS5MYW5QYWlyU2lnbmVkSABS'
+ 'C3BhaXJSZXF1ZXN0EkEKDXBhaXJfcmVzcG9uc2UYAyABKAsyGi5jb3B5c3luYy52MS5MYW5QYW'
+ 'lyU2lnbmVkSABSDHBhaXJSZXNwb25zZRI9CgtwYWlyX3JlamVjdBgEIAEoCzIaLmNvcHlzeW5j'
+ 'LnYxLkxhblBhaXJSZWplY3RIAFIKcGFpclJlamVjdEIJCgdwYXlsb2Fk');
+
+@$core.Deprecated('Use lanHelloDescriptor instead')
+const LanHello$json = {
+ '1': 'LanHello',
+ '2': [
+ {'1': 'addresses', '3': 1, '4': 3, '5': 9, '10': 'addresses'},
+ {'1': 'reply_wanted', '3': 2, '4': 1, '5': 8, '10': 'replyWanted'},
+ {'1': 'interval_seconds', '3': 3, '4': 1, '5': 13, '10': 'intervalSeconds'},
+ ],
+};
+
+/// Descriptor for `LanHello`. Decode as a `google.protobuf.DescriptorProto`.
+final $typed_data.Uint8List lanHelloDescriptor = $convert.base64Decode(
+ 'CghMYW5IZWxsbxIcCglhZGRyZXNzZXMYASADKAlSCWFkZHJlc3NlcxIhCgxyZXBseV93YW50ZW'
+ 'QYAiABKAhSC3JlcGx5V2FudGVkEikKEGludGVydmFsX3NlY29uZHMYAyABKA1SD2ludGVydmFs'
+ 'U2Vjb25kcw==');
+
+@$core.Deprecated('Use lanPairSignedDescriptor instead')
+const LanPairSigned$json = {
+ '1': 'LanPairSigned',
+ '2': [
+ {'1': 'payload', '3': 1, '4': 1, '5': 12, '10': 'payload'},
+ {'1': 'signature', '3': 2, '4': 1, '5': 12, '10': 'signature'},
+ ],
+};
+
+/// Descriptor for `LanPairSigned`. Decode as a `google.protobuf.DescriptorProto`.
+final $typed_data.Uint8List lanPairSignedDescriptor = $convert.base64Decode(
+ 'Cg1MYW5QYWlyU2lnbmVkEhgKB3BheWxvYWQYASABKAxSB3BheWxvYWQSHAoJc2lnbmF0dXJlGA'
+ 'IgASgMUglzaWduYXR1cmU=');
+
+@$core.Deprecated('Use lanPairInfoDescriptor instead')
+const LanPairInfo$json = {
+ '1': 'LanPairInfo',
+ '2': [
+ {'1': 'code', '3': 1, '4': 1, '5': 9, '10': 'code'},
+ {'1': 'device_id', '3': 2, '4': 1, '5': 9, '10': 'deviceId'},
+ {'1': 'device_name', '3': 3, '4': 1, '5': 9, '10': 'deviceName'},
+ {'1': 'platform', '3': 4, '4': 1, '5': 9, '10': 'platform'},
+ {'1': 'public_key', '3': 5, '4': 1, '5': 12, '10': 'publicKey'},
+ {'1': 'addresses', '3': 6, '4': 3, '5': 9, '10': 'addresses'},
+ {'1': 'timestamp_unix', '3': 7, '4': 1, '5': 3, '10': 'timestampUnix'},
+ {'1': 'nonce', '3': 8, '4': 1, '5': 12, '10': 'nonce'},
+ {'1': 'request_nonce', '3': 9, '4': 1, '5': 12, '10': 'requestNonce'},
+ ],
+};
+
+/// Descriptor for `LanPairInfo`. Decode as a `google.protobuf.DescriptorProto`.
+final $typed_data.Uint8List lanPairInfoDescriptor = $convert.base64Decode(
+ 'CgtMYW5QYWlySW5mbxISCgRjb2RlGAEgASgJUgRjb2RlEhsKCWRldmljZV9pZBgCIAEoCVIIZG'
+ 'V2aWNlSWQSHwoLZGV2aWNlX25hbWUYAyABKAlSCmRldmljZU5hbWUSGgoIcGxhdGZvcm0YBCAB'
+ 'KAlSCHBsYXRmb3JtEh0KCnB1YmxpY19rZXkYBSABKAxSCXB1YmxpY0tleRIcCglhZGRyZXNzZX'
+ 'MYBiADKAlSCWFkZHJlc3NlcxIlCg50aW1lc3RhbXBfdW5peBgHIAEoA1INdGltZXN0YW1wVW5p'
+ 'eBIUCgVub25jZRgIIAEoDFIFbm9uY2USIwoNcmVxdWVzdF9ub25jZRgJIAEoDFIMcmVxdWVzdE'
+ '5vbmNl');
+
+@$core.Deprecated('Use lanPairRejectDescriptor instead')
+const LanPairReject$json = {
+ '1': 'LanPairReject',
+ '2': [
+ {'1': 'request_nonce', '3': 1, '4': 1, '5': 12, '10': 'requestNonce'},
+ {'1': 'reason', '3': 2, '4': 1, '5': 9, '10': 'reason'},
+ ],
+};
+
+/// Descriptor for `LanPairReject`. Decode as a `google.protobuf.DescriptorProto`.
+final $typed_data.Uint8List lanPairRejectDescriptor = $convert.base64Decode(
+ 'Cg1MYW5QYWlyUmVqZWN0EiMKDXJlcXVlc3Rfbm9uY2UYASABKAxSDHJlcXVlc3ROb25jZRIWCg'
+ 'ZyZWFzb24YAiABKAlSBnJlYXNvbg==');
+
@$core.Deprecated('Use peerMessageDescriptor instead')
const PeerMessage$json = {
'1': 'PeerMessage',