PasteFerry (隔空贴): clipboard and file sync across macOS, Windows and Linux. Direct-first, end-to-end encrypted. Optional official access: no server to host. Independent self-hosting remains available.
Dart airdrop-alternativeclipboardclipboard-sharingclipboard-synccopy-pastecross-platformend-to-end-encryptionfile-syncfile-transferfluttergolanglinuxmacosnat-traversalp2pself-hostedtailscaleuniversal-clipboardwebrtcwindows
package webshare
import (
"context"
"fmt"
"io"
"mime"
"os"
"path/filepath"
"strings"
"time"
"github.com/baiyuze/pasteferry/client-core/internal/send"
"github.com/baiyuze/pasteferry/client-core/internal/store"
pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
)
type webTransfer struct {
ID string `json:"id"`
Direction string `json:"direction"`
Status string `json:"status"`
Items []webItem `json:"items"`
Downloaded []bool `json:"downloaded"`
At int64 `json:"at"`
}
func transferWeb(t store.WebTransfer) webTransfer {
w := webTransfer{ID: t.ID, Direction: t.Direction, Status: t.Status, At: t.CreatedAt, Downloaded: t.Downloaded, Items: []webItem{}}
for _, i := range t.Items {
w.Items = append(w.Items, webItem{Name: i.Name, Size: i.Size})
}
return w
}
// QueueFiles snapshots files explicitly selected on the host for this browser.
// A browser never supplies a local path and cannot see another session's queue.
func (s *Server) QueueFiles(ctx context.Context, sessionID string, paths []string) (*pb.Transfer, error) {
s.transferMu.Lock()
defer s.transferMu.Unlock()
sess, err := s.sessionByID(sessionID)
if err != nil {
return nil, err
}
if len(paths) == 0 || len(paths) > maxUploadsPerSession {
return nil, errBadRequest
}
old, err := s.opts.Store.WebTransfers(sessionID)
if err != nil {
return nil, err
}
if len(old) >= 100 {
return nil, errCode("busy", "请先清理网页传输记录")
}
id := randomID(16)
dir := s.transferDir(sessionID, id)
if err := os.MkdirAll(dir, 0700); err != nil {
return nil, err
}
ok := false
defer func() {
if !ok {
_ = os.RemoveAll(dir)
}
}()
t := store.WebTransfer{ID: id, Session: sessionID, Direction: "download", Status: "ready", CreatedAt: s.opts.Now().UnixMilli(), SourcePaths: append([]string(nil), paths...)}
for index, path := range paths {
if err := ctx.Err(); err != nil {
return nil, err
}
f, err := os.Open(path)
if err != nil {
return nil, err
}
info, err := f.Stat()
if err != nil {
f.Close()
return nil, err
}
if !info.Mode().IsRegular() || info.Size() > maxDownloadBytes {
f.Close()
return nil, errTooLarge
}
// Each selected file has its own directory so equal display names survive.
parent := filepath.Join(dir, fmt.Sprint(index))
if err := os.Mkdir(parent, 0700); err != nil {
f.Close()
return nil, err
}
dst := filepath.Join(parent, info.Name())
out, err := os.OpenFile(dst, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600)
if err != nil {
f.Close()
return nil, err
}
n, copyErr := io.Copy(out, io.LimitReader(f, maxDownloadBytes+1))
closeErr := out.Close()
f.Close()
if copyErr != nil {
return nil, copyErr
}
if closeErr != nil {
return nil, closeErr
}
if n != info.Size() {
return nil, errCode("source_changed", "文件已变化,请重新选择")
}
t.Items = append(t.Items, store.Item{Name: info.Name(), Size: n})
t.Paths = append(t.Paths, dst)
t.Downloaded = append(t.Downloaded, false)
}
record, err := s.saveTransfer(t, s.sessionName(sess))
if err != nil {
return nil, err
}
ok = true
return send.TransferProto(*record), nil
}
func (s *Server) transferDir(session, id string) string {
return filepath.Join(s.opts.WorkDir, "transfers", session, id)
}
func (s *Server) finishTransferUploads(sess *session, ids []string, batch string) (any, error) {
s.transferMu.Lock()
defer s.transferMu.Unlock()
if len(batch) < 16 || len(batch) > 64 || strings.Trim(batch, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_") != "" {
return nil, errBadRequest
}
if old, err := s.opts.Store.WebTransfer(sess.id, batch); err == nil {
if old.Direction != "upload" {
return nil, errBadRequest
}
return transferWeb(old), nil
}
if len(ids) == 0 || len(ids) > maxUploadsPerSession {
return nil, errBadRequest
}
old, err := s.opts.Store.WebTransfers(sess.id)
if err != nil {
return nil, err
}
if len(old) >= 100 {
return nil, errCode("busy", "请先清理网页传输记录")
}
var uploads []*upload
defer func() {
for _, u := range uploads {
u.discard()
}
}()
for _, id := range ids {
u, err := s.uploads.take(sess.id, id)
if err != nil {
return nil, err
}
uploads = append(uploads, u)
}
dir := s.opts.LoadConfig().EffectiveReceiveDir()
if err := os.MkdirAll(dir, 0755); err != nil {
return nil, err
}
t := store.WebTransfer{ID: batch, Session: sess.id, Direction: "upload", Status: "done", CreatedAt: s.opts.Now().UnixMilli()}
ok := false
defer func() {
if !ok {
for _, p := range t.Paths {
_ = os.Remove(p)
}
}
}()
for _, u := range uploads {
p, err := moveInto(u.path, dir, u.name)
if err != nil {
return nil, err
}
t.Paths = append(t.Paths, p)
t.Items = append(t.Items, store.Item{Name: filepath.Base(p), Size: u.size})
}
if _, err := s.saveTransfer(t, s.sessionName(sess)); err != nil {
return nil, err
}
ok = true
return transferWeb(t), nil
}
func (s *Server) transferFile(sess *session, id string, item int) (downloadFile, error) {
t, err := s.opts.Store.WebTransfer(sess.id, id)
if err != nil || (t.Status != "ready" && t.Status != "done") || t.Direction != "download" || item < 0 || item >= len(t.Paths) {
return downloadFile{}, errGone
}
f := downloadFile{path: t.Paths[item], name: t.Items[item].Name, size: t.Items[item].Size, mime: mime.TypeByExtension(filepath.Ext(t.Items[item].Name))}
info, err := os.Stat(f.path)
if err != nil || !info.Mode().IsRegular() || info.Size() != f.size {
return downloadFile{}, errGone
}
return f, nil
}
func (s *Server) transferRPC(sess *session, method, id string, item int) (any, error) {
s.transferMu.Lock()
defer s.transferMu.Unlock()
if method == "transfers" {
list, err := s.opts.Store.WebTransfers(sess.id)
out := []webTransfer{}
for _, t := range list {
out = append(out, transferWeb(t))
}
return map[string]any{"transfers": out}, err
}
t, err := s.opts.Store.WebTransfer(sess.id, id)
if err != nil {
return nil, errGone
}
switch method {
case "transfer_file_info":
f, err := s.transferFile(sess, id, item)
if err != nil {
return nil, err
}
return map[string]any{"name": f.name, "size": f.size, "chunks": (f.size + chunkSize - 1) / chunkSize, "mime": f.mime}, nil
case "transfer_downloaded":
if (t.Status != "ready" && t.Status != "done") || t.Direction != "download" || item < 0 || item >= len(t.Downloaded) {
return nil, errBadRequest
}
t.Downloaded[item] = true
t.Status = "done"
for _, done := range t.Downloaded {
if !done {
t.Status = "ready"
}
}
_, err = s.saveTransfer(t, s.sessionName(sess))
return transferWeb(t), err
case "transfer_delete":
if t.Status == "ready" {
t.Status = "cancelled"
if _, err := s.saveTransfer(t, s.sessionName(sess)); err != nil {
return nil, err
}
}
if err := s.opts.Store.DeleteWebTransfer(sess.id, id); err != nil {
return nil, err
}
if t.Direction == "download" {
_ = os.RemoveAll(s.transferDir(sess.id, id))
}
return map[string]bool{}, nil
}
return nil, errBadRequest
}
// saveTransfer uses a session-qualified ID: browser-generated IDs are not global.
func (s *Server) saveTransfer(w store.WebTransfer, name string) (*store.Transfer, error) {
created := time.UnixMilli(w.CreatedAt)
t := store.Transfer{ID: "web:" + w.Session + ":" + w.ID, DeviceID: "web:" + w.Session,
DeviceName: name, Items: w.Items, Paths: w.Paths, FileCount: int64(len(w.Items)),
CreatedAt: created, UpdatedAt: s.opts.Now(), PeerRole: store.RoleSelf,
Direction: store.Outgoing, Status: store.TransferWaiting}
if len(w.SourcePaths) != 0 {
t.Paths = w.SourcePaths
}
if w.Direction == "upload" {
t.Direction = store.Incoming
if len(w.Paths) > 0 {
t.DestDir = filepath.Dir(w.Paths[0])
}
}
for i, item := range w.Items {
t.TotalBytes += item.Size
if w.Direction == "upload" || (i < len(w.Downloaded) && w.Downloaded[i]) {
t.DoneBytes += item.Size
}
}
if w.Status == "done" {
t.Status = store.TransferDone
}
if w.Status == "cancelled" {
t.Status = store.TransferCancelled
}
if store.TransferFinished(t.Status) {
t.FinishedAt = s.opts.Now()
}
saved, err := s.opts.Store.PutWebTransferHistory(w, t)
if err == nil && saved != nil && s.opts.OnTransferChanged != nil {
s.opts.OnTransferChanged(send.TransferProto(*saved))
}
return saved, err
}
// restoreTransferHistory imports 2.8.1 records once, without retransferring files.
func (s *Server) restoreTransferHistory() {
sessions, err := s.opts.Store.WebSessions()
if err != nil {
s.log.Warn("读取网页传输历史失败", "err", err)
return
}
for _, registered := range sessions {
list, err := s.opts.Store.WebTransfers(registered.ID)
if err != nil {
s.log.Warn("读取网页传输历史失败", "err", err)
continue
}
for _, w := range list {
if w.DesktopID != "" {
continue
}
if _, err := s.saveTransfer(w, s.sessionName(&session{name: registered.Name})); err != nil {
s.log.Warn("恢复网页传输记录失败", "err", err)
}
}
}
// A crash between session removal and queue cancellation must not leave a
// permanently waiting desktop row.
pending, err := s.opts.Store.PendingWebTransfers()
if err != nil {
s.log.Warn("读取网页待传记录失败", "err", err)
return
}
for _, t := range pending {
if _, err := s.opts.Store.WebSession(strings.TrimPrefix(t.DeviceID, "web:")); store.IsNotFound(err) {
s.cancelHistory(t)
}
}
}
func (s *Server) cancelHistory(t store.Transfer) {
t.Status, t.UpdatedAt, t.FinishedAt = store.TransferCancelled, s.opts.Now(), s.opts.Now()
if err := s.opts.Store.PutTransfer(t); err != nil {
s.log.Warn("取消网页传输记录失败", "err", err)
return
}
if s.opts.OnTransferChanged != nil {
s.opts.OnTransferChanged(send.TransferProto(t))
}
}
func (s *Server) cancelSessionTransfers(id string) {
list, err := s.opts.Store.PendingWebTransfers()
if err != nil {
s.log.Warn("读取网页待传记录失败", "err", err)
return
}
for _, t := range list {
if t.DeviceID == "web:"+id {
s.cancelHistory(t)
}
}
}
// CancelTransfer cancels a host queue and removes only its private snapshot.
func (s *Server) CancelTransfer(id string) error {
s.transferMu.Lock()
defer s.transferMu.Unlock()
t, err := s.opts.Store.GetTransfer(id)
if err != nil {
return send.ErrNotFound
}
if store.TransferFinished(t.Status) {
return nil
}
parts := strings.Split(id, ":")
if len(parts) != 3 || parts[0] != "web" {
return send.ErrNotFound
}
w, err := s.opts.Store.WebTransfer(parts[1], parts[2])
if err != nil {
return send.ErrNotFound
}
w.Status = "cancelled"
if _, err := s.saveTransfer(w, t.DeviceName); err != nil {
return err
}
_ = os.RemoveAll(s.transferDir(w.Session, w.ID))
return nil
}