PasteFerry (隔空贴): clipboard and file sync across macOS, Windows and Linux. Direct-first, end-to-end encrypted. Optional official access: no server to host. Independent self-hosting remains available.
Dart airdrop-alternativeclipboardclipboard-sharingclipboard-synccopy-pastecross-platformend-to-end-encryptionfile-syncfile-transferfluttergolanglinuxmacosnat-traversalp2pself-hostedtailscaleuniversal-clipboardwebrtcwindows
// natlab 是 NAT 打洞实验室的驱动程序,配合 tools/natlab/run.sh 在 Linux 网络命名空间里
// 复现真实网络拓扑(多出口、对称 NAT 等),验证两台设备最终走直连还是中转。
//
// natlab infra -http 10.200.0.2:9000 -stun 10.200.1.1,10.200.1.2 -turn 10.200.0.3
// natlab peer -id a -peer b -infra http://10.200.0.2:9000 -stun ... -probe ... -turn ...
// natlab lanpeer -seed a -peer-seed b [-mdns] [-addr ip:port]
//
// infra 扮演「互联网」上的服务:信令转发、若干台 STUN 服务器、一台 TURN 中转。
// peer 用的就是 PasteFerry 真实的 P2P 连接代码,只把信令换成了这里的 HTTP 转发。
// lanpeer 不用服务器,信令与发现走真实的局域网通道(transport/lan)。
package main
import (
"context"
"encoding/json"
"errors"
"flag"
"fmt"
"io"
"log/slog"
"net"
"net/http"
"net/url"
"os"
"strings"
"sync"
"time"
"github.com/pion/stun/v4"
"google.golang.org/protobuf/proto"
"github.com/baiyuze/pasteferry/client-core/internal/transport/p2p"
pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
turnrelay "github.com/baiyuze/pasteferry/server/relay"
)
const turnSecret = "natlab"
func main() {
if len(os.Args) < 2 {
fmt.Fprintln(os.Stderr, "用法: natlab <infra|peer|lanpeer> [参数]")
os.Exit(2)
}
var err error
switch os.Args[1] {
case "infra":
err = runInfra(os.Args[2:])
case "peer":
err = runPeer(os.Args[2:])
case "lanpeer":
err = runLANPeer(os.Args[2:])
default:
err = fmt.Errorf("未知的子命令 %q", os.Args[1])
}
if err != nil {
fmt.Fprintln(os.Stderr, "natlab:", err)
os.Exit(1)
}
}
// ─────────────────────────── infra ───────────────────────────
func runInfra(args []string) error {
fs := flag.NewFlagSet("infra", flag.ExitOnError)
httpAddr := fs.String("http", "", "信令转发的 HTTP 监听地址")
stunIPs := fs.String("stun", "", "STUN 服务器的 IP,逗号分隔,每个 IP 各起一台")
turnIP := fs.String("turn", "", "TURN 中转的 IP")
delay := fs.Duration("delay", 0, "信令转发的延迟:现实里信令要经服务器绕一道,比两台设备之间的包慢")
_ = fs.Parse(args)
for _, ip := range splitList(*stunIPs) {
if err := serveSTUN(ip); err != nil {
return err
}
}
turn, err := turnrelay.New(turnrelay.Options{
PublicIP: *turnIP, ListenIP: *turnIP, Port: 3478, Secret: turnSecret,
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
})
if err != nil {
return fmt.Errorf("启动 TURN: %w", err)
}
relay := &signalRelay{queues: map[string]chan envelope{}, delay: *delay}
mux := http.NewServeMux()
mux.HandleFunc("/send", relay.send)
mux.HandleFunc("/recv", relay.recv)
mux.HandleFunc("/turn", func(w http.ResponseWriter, r *http.Request) {
c := turn.Issue(r.URL.Query().Get("id"))
_ = json.NewEncoder(w).Encode(map[string]any{
"urls": c.URLs, "username": c.Username, "credential": c.Password,
})
})
return http.ListenAndServe(*httpAddr, mux)
}
// serveSTUN 在指定 IP 上起一台最简的 STUN 服务器:只回答 Binding 请求。
// 绑定具体 IP 而不是 0.0.0.0:回包的源地址必须与客户端发往的地址一致。
func serveSTUN(ip string) error {
conn, err := net.ListenPacket("udp4", net.JoinHostPort(ip, "3478"))
if err != nil {
return fmt.Errorf("STUN %s: %w", ip, err)
}
go func() {
buf := make([]byte, 1500)
for {
n, addr, err := conn.ReadFrom(buf)
if err != nil {
return
}
req := &stun.Message{Raw: append([]byte(nil), buf[:n]...)}
if req.Decode() != nil || req.Type != stun.BindingRequest {
continue
}
ua := addr.(*net.UDPAddr)
resp, err := stun.Build(stun.NewTransactionIDSetter(req.TransactionID), stun.BindingSuccess,
&stun.XORMappedAddress{IP: ua.IP, Port: ua.Port}, stun.Fingerprint)
if err == nil {
_, _ = conn.WriteTo(resp.Raw, addr)
}
}
}()
return nil
}
type envelope struct {
from string
body []byte
due time.Time // 到这个时间才交给收件人,见 signalRelay.delay
}
// signalRelay 是最简的信令转发:按收件人排队,收件人长轮询取走。
type signalRelay struct {
mu sync.Mutex
queues map[string]chan envelope
delay time.Duration
}
func (r *signalRelay) queue(id string) chan envelope {
r.mu.Lock()
defer r.mu.Unlock()
q, ok := r.queues[id]
if !ok {
q = make(chan envelope, 256)
r.queues[id] = q
}
return q
}
func (r *signalRelay) send(w http.ResponseWriter, req *http.Request) {
body, _ := io.ReadAll(req.Body)
q := req.URL.Query()
r.queue(q.Get("to")) <- envelope{from: q.Get("from"), body: body, due: time.Now().Add(r.delay)}
}
func (r *signalRelay) recv(w http.ResponseWriter, req *http.Request) {
select {
case e := <-r.queue(req.URL.Query().Get("id")):
// 按入队顺序逐条等到期,消息的先后不变
time.Sleep(time.Until(e.due))
w.Header().Set("X-From", e.from)
_, _ = w.Write(e.body)
case <-time.After(20 * time.Second):
w.WriteHeader(http.StatusNoContent)
case <-req.Context().Done():
}
}
// ─────────────────────────── peer ───────────────────────────
type result struct {
ID string `json:"id"`
State string `json:"state"`
Egress []string `json:"egress"`
Elapsed string `json:"elapsed"`
}
func runPeer(args []string) error {
fs := flag.NewFlagSet("peer", flag.ExitOnError)
id := fs.String("id", "", "本端设备 ID")
peerID := fs.String("peer", "", "对端设备 ID")
infra := fs.String("infra", "", "infra 的 HTTP 地址")
stunList := fs.String("stun", "", "信令服务器下发的 STUN(ip:port,逗号分隔)")
probeList := fs.String("probe", "", "额外的探测服务器,对应真实环境里的公共 STUN")
statePath := fs.String("state", "", "出口历史文件")
legacy := fs.Bool("legacy", false, "用旧版本的候选收集方式(对照实验)")
timeout := fs.Duration("timeout", 40*time.Second, "等待连接的最长时间")
linger := fs.Duration("linger", 4*time.Second, "报完结果后保持连接的时间")
settle := fs.Duration("settle", 0, "连上中转后再等多久,看能否换成直连")
_ = fs.Parse(args)
ctx, cancel := context.WithTimeout(context.Background(), *timeout+*settle+10*time.Second)
defer cancel()
start := time.Now()
states := make(chan p2p.ConnState, 16)
m := p2p.NewManager(p2p.ManagerOptions{
SelfID: *id,
Logger: slog.New(slog.NewTextHandler(os.Stderr, nil)),
ProbeAllowPrivate: true, // 实验室用内网地址扮演公网
DisableEgressProbe: *legacy,
StatePath: *statePath,
ProbeServers: func() []string { return splitList(*probeList) },
SendSignal: func(ctx context.Context, to string, msg *pb.SignalMessage) error {
raw, err := proto.Marshal(msg)
if err != nil {
return err
}
u := fmt.Sprintf("%s/send?from=%s&to=%s", *infra, url.QueryEscape(*id), url.QueryEscape(to))
resp, err := http.Post(u, "application/octet-stream", strings.NewReader(string(raw)))
if err == nil {
resp.Body.Close()
}
return err
},
OnState: func(_ string, s p2p.ConnState) {
select {
case states <- s:
default:
}
},
})
defer m.Close()
servers, err := iceServers(*infra, *id, splitList(*stunList))
if err != nil {
return err
}
m.SetICEServers(servers)
go receiveSignals(ctx, m, *infra, *id)
// 等首轮出口探测结束,免得用一份空结果去握手
if !*legacy {
deadline := time.Now().Add(5 * time.Second)
for time.Now().Before(deadline) && m.Egress().At.IsZero() {
time.Sleep(50 * time.Millisecond)
}
}
if err := m.Connect(ctx, *peerID); err != nil {
return err
}
final := waitFinal(states, m, *peerID, *timeout, *settle)
var egress []string
for _, e := range m.Egress().Egresses {
egress = append(egress, e.Addr.String())
}
err = json.NewEncoder(os.Stdout).Encode(result{
ID: *id, State: final.String(), Egress: egress, Elapsed: time.Since(start).Round(time.Millisecond).String(),
})
// 报完结果再留一会儿:先报完的一端立即退出会关掉连接,另一端还在等稳定状态,
// 读到的就成了「已断开」
time.Sleep(*linger)
return err
}
// waitFinal 等连接建立,再多等一会儿让两端交换 LinkInfo,取稳定后的状态。
// settle 大于零时,若稳定后是中转,再最多等这么久,看能否换成直连。
func waitFinal(states <-chan p2p.ConnState, m *p2p.Manager, peerID string, timeout, settle time.Duration) p2p.ConnState {
deadline := time.After(timeout)
for {
select {
case s := <-states:
if s != p2p.StateDirect && s != p2p.StateRelay {
continue
}
time.Sleep(1500 * time.Millisecond)
until := time.Now().Add(settle)
for m.State(peerID) == p2p.StateRelay && time.Now().Before(until) {
time.Sleep(100 * time.Millisecond)
}
return m.State(peerID)
case <-deadline:
return m.State(peerID)
}
}
}
func iceServers(infra, id string, stunAddrs []string) ([]*pb.IceServer, error) {
resp, err := http.Get(infra + "/turn?id=" + url.QueryEscape(id))
if err != nil {
return nil, fmt.Errorf("获取 TURN 凭证: %w", err)
}
defer resp.Body.Close()
var cred struct {
URLs []string `json:"urls"`
Username string `json:"username"`
Credential string `json:"credential"`
}
if err := json.NewDecoder(resp.Body).Decode(&cred); err != nil {
return nil, err
}
servers := []*pb.IceServer{{Urls: cred.URLs, Username: cred.Username, Credential: cred.Credential}}
if len(stunAddrs) > 0 {
var urls []string
for _, a := range stunAddrs {
urls = append(urls, "stun:"+a)
}
servers = append(servers, &pb.IceServer{Urls: urls})
}
return servers, nil
}
func receiveSignals(ctx context.Context, m *p2p.Manager, infra, id string) {
client := &http.Client{Timeout: 30 * time.Second}
for ctx.Err() == nil {
resp, err := client.Get(infra + "/recv?id=" + url.QueryEscape(id))
if err != nil {
time.Sleep(200 * time.Millisecond)
continue
}
body, _ := io.ReadAll(resp.Body)
resp.Body.Close()
if resp.StatusCode != http.StatusOK {
continue
}
var msg pb.SignalMessage
if err := proto.Unmarshal(body, &msg); err != nil {
continue
}
if err := m.HandleSignal(ctx, resp.Header.Get("X-From"), &msg); err != nil &&
!errors.Is(err, context.Canceled) {
fmt.Fprintln(os.Stderr, "处理信令:", err)
}
}
}
func splitList(s string) []string {
var out []string
for _, v := range strings.Split(s, ",") {
if v = strings.TrimSpace(v); v != "" {
out = append(out, v)
}
}
return out
}