528 lines
19 KiB
Go
528 lines
19 KiB
Go
package cliprdr
|
||
|
||
import (
|
||
"bytes"
|
||
"encoding/binary"
|
||
"fmt"
|
||
"testing"
|
||
)
|
||
|
||
// capturedPDU 是 fakeSender 捕获的一条完整 CLIPRDR PDU。
|
||
type capturedPDU struct {
|
||
msgType uint16
|
||
flags uint16
|
||
body []byte
|
||
}
|
||
|
||
// fakeSender 捕获所有发出通道的数据，供断言。
|
||
type fakeSender struct{ pdus []capturedPDU }
|
||
|
||
func (f *fakeSender) SendToChannel(_ string, data []byte) (int, error) {
|
||
cp := make([]byte, len(data))
|
||
copy(cp, data)
|
||
if len(cp) < 8 {
|
||
return len(cp), nil
|
||
}
|
||
f.pdus = append(f.pdus, capturedPDU{
|
||
msgType: binary.LittleEndian.Uint16(cp[0:]),
|
||
flags: binary.LittleEndian.Uint16(cp[2:]),
|
||
body: cp[8:],
|
||
})
|
||
return len(cp), nil
|
||
}
|
||
|
||
func (f *fakeSender) last() capturedPDU { return f.pdus[len(f.pdus)-1] }
|
||
|
||
// newFileTestHandler 构造带 fakeSender 且 serverFileClip=true 的 handler
|
||
// （模拟服务器 caps 已声明 CB_STREAM_FILECLIP_ENABLED）。
|
||
func newFileTestHandler(t *testing.T) (*CliprdrHandler, *fakeSender) {
|
||
t.Helper()
|
||
h := NewHandler(nil, nil)
|
||
fs := &fakeSender{}
|
||
h.Sender(fs)
|
||
caps := &bytes.Buffer{}
|
||
binary.Write(caps, binary.LittleEndian, uint16(1)) // cCapSets
|
||
binary.Write(caps, binary.LittleEndian, uint16(0)) // pad
|
||
binary.Write(caps, binary.LittleEndian, uint16(CB_CAPSTYPE_GENERAL))
|
||
binary.Write(caps, binary.LittleEndian, uint16(12))
|
||
binary.Write(caps, binary.LittleEndian, uint32(CB_CAPS_VERSION_2))
|
||
binary.Write(caps, binary.LittleEndian, uint32(CB_USE_LONG_FORMAT_NAMES|CB_STREAM_FILECLIP_ENABLED))
|
||
h.processClipCaps(caps.Bytes())
|
||
if !h.serverFileClip {
|
||
t.Fatal("serverFileClip should be set after caps with CB_STREAM_FILECLIP_ENABLED")
|
||
}
|
||
return h, fs
|
||
}
|
||
|
||
func TestBuildParseDropfilesRoundTrip(t *testing.T) {
|
||
names := []string{`C:\Users\测试\报告 最终版.docx`, "plain.txt", "数据 - 副本 (2).xlsx"}
|
||
b := BuildDropfiles(names)
|
||
if binary.LittleEndian.Uint32(b[0:]) != dropfilesHeaderLen {
|
||
t.Fatalf("pFiles = %d, want %d", binary.LittleEndian.Uint32(b[0:]), dropfilesHeaderLen)
|
||
}
|
||
if binary.LittleEndian.Uint32(b[16:]) != 1 {
|
||
t.Fatal("fWide should be 1 (Unicode)")
|
||
}
|
||
got, err := ParseDropfiles(b)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if len(got) != len(names) {
|
||
t.Fatalf("got %d names, want %d: %q", len(got), len(names), got)
|
||
}
|
||
for i := range names {
|
||
if got[i] != names[i] {
|
||
t.Fatalf("name[%d] = %q, want %q", i, got[i], names[i])
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestParseDropfilesASCII(t *testing.T) {
|
||
// fWide=0 的 ASCII 变体（FreeRDP 老服务器可能使用）
|
||
list := []byte("a.txt\x00b.bin\x00\x00")
|
||
body := make([]byte, dropfilesHeaderLen+len(list))
|
||
binary.LittleEndian.PutUint32(body[0:], dropfilesHeaderLen)
|
||
binary.LittleEndian.PutUint32(body[16:], 0)
|
||
copy(body[dropfilesHeaderLen:], list)
|
||
got, err := ParseDropfiles(body)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if len(got) != 2 || got[0] != "a.txt" || got[1] != "b.bin" {
|
||
t.Fatalf("got %q", got)
|
||
}
|
||
}
|
||
|
||
func TestParseDropfilesRejectsBad(t *testing.T) {
|
||
if _, err := ParseDropfiles(make([]byte, 8)); err == nil {
|
||
t.Fatal("short body should fail")
|
||
}
|
||
bad := make([]byte, dropfilesHeaderLen)
|
||
binary.LittleEndian.PutUint32(bad[0:], 1<<20) // pFiles 越界
|
||
if _, err := ParseDropfiles(bad); err == nil {
|
||
t.Fatal("out-of-range pFiles should fail")
|
||
}
|
||
}
|
||
|
||
func serverFormatListWithHDrop(t *testing.T, h *CliprdrHandler) {
|
||
t.Helper()
|
||
// long-name Format List：CF_HDROP(id 15) + CF_UNICODETEXT
|
||
b := &bytes.Buffer{}
|
||
binary.Write(b, binary.LittleEndian, uint32(CF_HDROP))
|
||
b.Write(encodeUTF16LE("")) // 标准格式空名
|
||
b.Write([]byte{0, 0})
|
||
binary.Write(b, binary.LittleEndian, uint32(CF_UNICODETEXT))
|
||
b.Write(encodeUTF16LE(""))
|
||
b.Write([]byte{0, 0})
|
||
h.processFormatList(b.Bytes(), 0)
|
||
}
|
||
|
||
func TestServerFormatListTriggersHDropRequest(t *testing.T) {
|
||
h, fs := newFileTestHandler(t)
|
||
serverFormatListWithHDrop(t, h)
|
||
// 第一条：Format List Response OK；第二条：Format Data Request(CF_HDROP)
|
||
if len(fs.pdus) < 2 {
|
||
t.Fatalf("expected FORMAT_LIST_RESPONSE + FORMAT_DATA_REQUEST, got %d", len(fs.pdus))
|
||
}
|
||
req := fs.pdus[1]
|
||
if req.msgType != CB_FORMAT_DATA_REQUEST {
|
||
t.Fatalf("msgType=%#x, want FORMAT_DATA_REQUEST", req.msgType)
|
||
}
|
||
if id := binary.LittleEndian.Uint32(req.body); id != CF_HDROP {
|
||
t.Fatalf("requested format=%d, want %d", id, CF_HDROP)
|
||
}
|
||
if h.lastRequestedFormat != CF_HDROP {
|
||
t.Fatalf("lastRequestedFormat=%d", h.lastRequestedFormat)
|
||
}
|
||
}
|
||
|
||
func TestRemoteFilesReceivedViaFormatDataResponse(t *testing.T) {
|
||
h, _ := newFileTestHandler(t)
|
||
var gotNames []string
|
||
h.SetFileCallbacks(func(names []string) { gotNames = names }, nil, nil)
|
||
serverFormatListWithHDrop(t, h)
|
||
|
||
payload := BuildDropfiles([]string{`D:\share\a.pdf`, `D:\share\b.pdf`})
|
||
h.processFormatDataResponse(payload, CB_RESPONSE_OK)
|
||
if len(gotNames) != 2 || gotNames[0] != `D:\share\a.pdf` {
|
||
t.Fatalf("onRemoteFiles got %q", gotNames)
|
||
}
|
||
if names := h.RemoteFileNames(); len(names) != 2 {
|
||
t.Fatalf("RemoteFileNames = %q", names)
|
||
}
|
||
}
|
||
|
||
func TestFormatDataRequestServesStagedFiles(t *testing.T) {
|
||
h, fs := newFileTestHandler(t)
|
||
h.SetLocalFiles([]LocalFile{{Name: "x.bin", Data: []byte{1, 2, 3}}})
|
||
|
||
req := make([]byte, 4)
|
||
binary.LittleEndian.PutUint32(req, CF_FILE_GROUP_DESCRIPTORW)
|
||
h.processFormatDataRequest(req)
|
||
|
||
resp := fs.last()
|
||
if resp.msgType != CB_FORMAT_DATA_RESPONSE || resp.flags != CB_RESPONSE_OK {
|
||
t.Fatalf("msgType=%#x flags=%#x", resp.msgType, resp.flags)
|
||
}
|
||
names, sizes, err := ParseFileGroupDescriptorW(resp.body)
|
||
if err != nil || len(names) != 1 || names[0] != "x.bin" || sizes[0] != 3 {
|
||
t.Fatalf("FileGroupDescriptorW parse=%q %v err=%v", names, sizes, err)
|
||
}
|
||
}
|
||
|
||
func TestFormatDataRequestNoFilesFails(t *testing.T) {
|
||
h, fs := newFileTestHandler(t)
|
||
req := make([]byte, 4)
|
||
binary.LittleEndian.PutUint32(req, CF_FILE_GROUP_DESCRIPTORW)
|
||
h.processFormatDataRequest(req)
|
||
if fs.last().flags != CB_RESPONSE_FAIL {
|
||
t.Fatal("expected FAIL when no staged files")
|
||
}
|
||
}
|
||
|
||
// TestBuildParseFileGroupDescriptorWRoundTrip：编码→解码保持名称与大小。
|
||
func TestBuildParseFileGroupDescriptorWRoundTrip(t *testing.T) {
|
||
files := []LocalFile{
|
||
{Name: "报 告 最终版.docx", Data: make([]byte, 5)},
|
||
{Name: "小.txt", Data: []byte("hi")},
|
||
}
|
||
payload := BuildFileGroupDescriptorW(files)
|
||
if len(payload) != 4+2*fileDescriptorSize {
|
||
t.Fatalf("payload=%d bytes, want %d", len(payload), 4+2*fileDescriptorSize)
|
||
}
|
||
names, sizes, err := ParseFileGroupDescriptorW(payload)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if len(names) != 2 {
|
||
t.Fatalf("names=%q", names)
|
||
}
|
||
if names[0] != "报 告 最终版.docx" || names[1] != "小.txt" {
|
||
t.Fatalf("names=%q", names)
|
||
}
|
||
if sizes[0] != 5 || sizes[1] != 2 {
|
||
t.Fatalf("sizes=%v", sizes)
|
||
}
|
||
}
|
||
|
||
// TestServerFileDescriptorListFlow：服务器通告 "FileGroupDescriptorW" 时
|
||
// 应以其 ID 请求格式数据，并用描述符填充远端文件列表（含大小）。
|
||
func TestServerFileDescriptorListFlow(t *testing.T) {
|
||
h, fs := newFileTestHandler(t)
|
||
var gotNames []string
|
||
h.SetFileCallbacks(func(names []string) { gotNames = names }, nil, nil)
|
||
|
||
// 服务器 Format List：FileGroupDescriptorW(id 0xC181) + FileContents + DropEffect
|
||
b := &bytes.Buffer{}
|
||
writeNamed := func(id uint32, name string) {
|
||
binary.Write(b, binary.LittleEndian, id)
|
||
b.Write(encodeUTF16LE(name))
|
||
b.Write([]byte{0, 0})
|
||
}
|
||
writeNamed(0xC181, FormatNameFileGroupDescriptorW)
|
||
writeNamed(0xC182, FormatNameFileContents)
|
||
writeNamed(0xC17E, FormatNameDropEffect)
|
||
h.processFormatList(b.Bytes(), 0)
|
||
|
||
req := fs.last()
|
||
if req.msgType != CB_FORMAT_DATA_REQUEST ||
|
||
binary.LittleEndian.Uint32(req.body) != 0xC181 {
|
||
t.Fatalf("expected FormatDataRequest(0xC181), got %#x id=%d",
|
||
req.msgType, binary.LittleEndian.Uint32(req.body))
|
||
}
|
||
|
||
payload := BuildFileGroupDescriptorW([]LocalFile{{Name: `C:\doc\a.pdf`, Data: make([]byte, 9)}})
|
||
h.processFormatDataResponse(payload, CB_RESPONSE_OK)
|
||
if len(gotNames) != 1 || gotNames[0] != `C:\doc\a.pdf` {
|
||
t.Fatalf("onRemoteFiles got %q", gotNames)
|
||
}
|
||
|
||
// 已知大小：RequestRemoteFile 应直接发 RANGE(0) 而非 SIZE
|
||
if err := h.RequestRemoteFile(0); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
fr := fs.last()
|
||
if binary.LittleEndian.Uint32(fr.body[8:]) != FILECONTENTS_RANGE ||
|
||
binary.LittleEndian.Uint32(fr.body[12:]) != 0 {
|
||
t.Fatalf("want direct RANGE(0), flags=%d pos=%d",
|
||
binary.LittleEndian.Uint32(fr.body[8:]), binary.LittleEndian.Uint32(fr.body[12:]))
|
||
}
|
||
}
|
||
|
||
// TestDropEffectRequest：资源管理器右键菜单查询 "Preferred DropEffect"，
|
||
// 有暂存文件时必须回 OK + DROPEFFECT_COPY，否则"粘贴"被置灰。
|
||
func TestDropEffectRequest(t *testing.T) {
|
||
h, fs := newFileTestHandler(t)
|
||
req := make([]byte, 4)
|
||
binary.LittleEndian.PutUint32(req, CF_DROP_EFFECT)
|
||
h.processFormatDataRequest(req)
|
||
if fs.last().flags != CB_RESPONSE_FAIL {
|
||
t.Fatal("no staged files: expected FAIL for DropEffect")
|
||
}
|
||
|
||
h.SetLocalFiles([]LocalFile{{Name: "a.txt", Data: []byte("hi")}})
|
||
h.processFormatDataRequest(req)
|
||
resp := fs.last()
|
||
if resp.msgType != CB_FORMAT_DATA_RESPONSE || resp.flags != CB_RESPONSE_OK {
|
||
t.Fatalf("msgType=%#x flags=%#x", resp.msgType, resp.flags)
|
||
}
|
||
if v := binary.LittleEndian.Uint32(resp.body); v != DROPEFFECT_COPY {
|
||
t.Fatalf("DropEffect=%d, want %d", v, DROPEFFECT_COPY)
|
||
}
|
||
}
|
||
|
||
func TestFormatListAdvertisesDropEffectWithFiles(t *testing.T) {
|
||
h, fs := newFileTestHandler(t)
|
||
h.SetLocalFiles([]LocalFile{{Name: "a.txt", Data: []byte("hi")}})
|
||
body := fs.last().body
|
||
if !bytes.Contains(body, encodeUTF16LE(FormatNameDropEffect)) {
|
||
t.Fatal("staged Format List should advertise Preferred DropEffect")
|
||
}
|
||
}
|
||
|
||
func TestFileContentsRequestServesSizeAndRange(t *testing.T) {
|
||
h, fs := newFileTestHandler(t)
|
||
data := bytes.Repeat([]byte{0xA5}, 300*1024) // 跨两个 RANGE 段
|
||
h.SetLocalFiles([]LocalFile{{Name: "big.bin", Data: data}})
|
||
|
||
// SIZE 请求
|
||
szReq := make([]byte, 24)
|
||
binary.LittleEndian.PutUint32(szReq[0:], 7) // streamId
|
||
binary.LittleEndian.PutUint32(szReq[4:], 0) // lindex
|
||
binary.LittleEndian.PutUint32(szReq[8:], FILECONTENTS_SIZE)
|
||
binary.LittleEndian.PutUint32(szReq[20:], 8)
|
||
h.processFileContentsRequest(szReq)
|
||
resp := fs.last()
|
||
if resp.msgType != CB_FILECONTENTS_RESPONSE || resp.flags != CB_RESPONSE_OK {
|
||
t.Fatalf("SIZE: msgType=%#x flags=%#x", resp.msgType, resp.flags)
|
||
}
|
||
if sid := binary.LittleEndian.Uint32(resp.body); sid != 7 {
|
||
t.Fatalf("SIZE: streamId=%d", sid)
|
||
}
|
||
if size := binary.LittleEndian.Uint64(resp.body[4:]); size != uint64(len(data)) {
|
||
t.Fatalf("SIZE: got %d want %d", size, len(data))
|
||
}
|
||
|
||
// RANGE 请求（尾段裁剪到文件末尾）
|
||
rng := make([]byte, 24)
|
||
binary.LittleEndian.PutUint32(rng[0:], 7)
|
||
binary.LittleEndian.PutUint32(rng[8:], FILECONTENTS_RANGE)
|
||
binary.LittleEndian.PutUint32(rng[12:], 290*1024) // pos
|
||
binary.LittleEndian.PutUint32(rng[20:], 1<<20) // 请求远超末尾
|
||
h.processFileContentsRequest(rng)
|
||
resp = fs.last()
|
||
got := resp.body[4:]
|
||
if len(got) != 10*1024 {
|
||
t.Fatalf("RANGE: got %d bytes, want clamped %d", len(got), 10*1024)
|
||
}
|
||
if got[0] != 0xA5 {
|
||
t.Fatal("RANGE: wrong payload")
|
||
}
|
||
|
||
// 越界 lindex → FAIL 且带 streamId
|
||
bad := make([]byte, 24)
|
||
binary.LittleEndian.PutUint32(bad[0:], 9)
|
||
binary.LittleEndian.PutUint32(bad[4:], 5)
|
||
binary.LittleEndian.PutUint32(bad[8:], FILECONTENTS_SIZE)
|
||
h.processFileContentsRequest(bad)
|
||
resp = fs.last()
|
||
if resp.flags != CB_RESPONSE_FAIL || len(resp.body) != 4 ||
|
||
binary.LittleEndian.Uint32(resp.body) != 9 {
|
||
t.Fatalf("unknown lindex: flags=%#x body=% X", resp.flags, resp.body)
|
||
}
|
||
}
|
||
|
||
// TestRemoteFileTransferChain 走完 SIZE→RANGE→完成的完整拉取链，
|
||
// 并验证服务器裁剪返回段时按实际长度推进。
|
||
func TestRemoteFileTransferChain(t *testing.T) {
|
||
h, fs := newFileTestHandler(t)
|
||
var resultName string
|
||
var resultData []byte
|
||
var progGot, progTotal int64
|
||
h.SetFileCallbacks(func(names []string) {},
|
||
func(index int, name string, data []byte) { resultName, resultData = name, data },
|
||
func(index int, received, total int64) { progGot, progTotal = received, total })
|
||
|
||
serverFormatListWithHDrop(t, h)
|
||
payload := BuildDropfiles([]string{`E:\doc\说明 书.pdf`})
|
||
h.processFormatDataResponse(payload, CB_RESPONSE_OK)
|
||
|
||
file := bytes.Repeat([]byte{0x5A}, fileRangeChunk+1000)
|
||
if err := h.RequestRemoteFile(0); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
|
||
// 1) SIZE 请求
|
||
req := fs.last()
|
||
if req.msgType != CB_FILECONTENTS_REQUEST ||
|
||
binary.LittleEndian.Uint32(req.body[8:]) != FILECONTENTS_SIZE {
|
||
t.Fatalf("step1: msgType=%#x flags=%#x", req.msgType, binary.LittleEndian.Uint32(req.body[8:]))
|
||
}
|
||
sid := binary.LittleEndian.Uint32(req.body[0:])
|
||
// SIZE 响应 → 应发出 RANGE(0, fileRangeChunk)
|
||
h.processFileContentsResponse(append(u32le(sid), u64le(uint64(len(file)))...), CB_RESPONSE_OK)
|
||
req = fs.last()
|
||
if binary.LittleEndian.Uint32(req.body[8:]) != FILECONTENTS_RANGE ||
|
||
binary.LittleEndian.Uint32(req.body[12:]) != 0 ||
|
||
binary.LittleEndian.Uint32(req.body[20:]) != fileRangeChunk {
|
||
t.Fatalf("step2: want RANGE(0,%d), got pos=%d cb=%d", fileRangeChunk,
|
||
binary.LittleEndian.Uint32(req.body[12:]), binary.LittleEndian.Uint32(req.body[20:]))
|
||
}
|
||
// RANGE 响应（服务器只回一半）→ 应从实际到达位置续传
|
||
h.processFileContentsResponse(append(u32le(sid), file[:fileRangeChunk/2]...), CB_RESPONSE_OK)
|
||
req = fs.last()
|
||
if p := binary.LittleEndian.Uint32(req.body[12:]); p != fileRangeChunk/2 {
|
||
t.Fatalf("step3: want resume pos=%d, got %d", fileRangeChunk/2, p)
|
||
}
|
||
if progGot != fileRangeChunk/2 || progTotal != int64(len(file)) {
|
||
t.Fatalf("progress got=%d total=%d", progGot, progTotal)
|
||
}
|
||
// 剩余数据 → 完成回调
|
||
h.processFileContentsResponse(append(u32le(sid), file[fileRangeChunk/2:]...), CB_RESPONSE_OK)
|
||
if resultName != `E:\doc\说明 书.pdf` {
|
||
t.Fatalf("result name=%q", resultName)
|
||
}
|
||
if !bytes.Equal(resultData, file) {
|
||
t.Fatalf("result %d bytes, want %d", len(resultData), len(file))
|
||
}
|
||
}
|
||
|
||
func TestRemoteFileTransferFailure(t *testing.T) {
|
||
h, fs := newFileTestHandler(t)
|
||
var failData []byte
|
||
var failName string
|
||
h.SetFileCallbacks(func(names []string) {},
|
||
func(index int, name string, data []byte) { failName, failData = name, data },
|
||
nil)
|
||
serverFormatListWithHDrop(t, h)
|
||
h.processFormatDataResponse(BuildDropfiles([]string{"gone.txt"}), CB_RESPONSE_OK)
|
||
if err := h.RequestRemoteFile(0); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
sid := binary.LittleEndian.Uint32(fs.last().body[0:])
|
||
h.processFileContentsResponse(u32le(sid), CB_RESPONSE_FAIL)
|
||
if failName != "gone.txt" || failData != nil {
|
||
t.Fatalf("failure delivery: name=%q data=%v", failName, failData)
|
||
}
|
||
}
|
||
|
||
// TestServerLocalDropEffectId：Windows 用它本地的 "Preferred DropEffect"
|
||
// 注册格式 ID（实测 0xC17E）查询而非我方广告 ID，需按 DropEffect 应答。
|
||
func TestServerLocalDropEffectId(t *testing.T) {
|
||
h, fs := newFileTestHandler(t)
|
||
h.SetLocalFiles([]LocalFile{{Name: "a.txt", Data: []byte("hi")}})
|
||
|
||
req := make([]byte, 4)
|
||
binary.LittleEndian.PutUint32(req, 0xC17E)
|
||
h.processFormatDataRequest(req)
|
||
resp := fs.last()
|
||
if resp.flags != CB_RESPONSE_OK || len(resp.body) != 4 ||
|
||
binary.LittleEndian.Uint32(resp.body) != DROPEFFECT_COPY {
|
||
t.Fatalf("heuristic DropEffect reply failed: flags=%#x body=% X", resp.flags, resp.body)
|
||
}
|
||
|
||
// 服务器通告过名称后，精确匹配其本地 ID
|
||
h2, fs2 := newFileTestHandler(t)
|
||
b := &bytes.Buffer{}
|
||
binary.Write(b, binary.LittleEndian, uint32(0xC17E))
|
||
b.Write(encodeUTF16LE(FormatNameDropEffect))
|
||
b.Write([]byte{0, 0})
|
||
h2.processFormatList(b.Bytes(), 0)
|
||
h2.SetLocalFiles([]LocalFile{{Name: "a.txt", Data: []byte("hi")}})
|
||
h2.processFormatDataRequest(req)
|
||
if fs2.last().flags != CB_RESPONSE_OK {
|
||
t.Fatal("learned serverDropEffectId should be answered with OK")
|
||
}
|
||
// 无文件时 FAIL
|
||
h3, fs3 := newFileTestHandler(t)
|
||
b3 := &bytes.Buffer{}
|
||
binary.Write(b3, binary.LittleEndian, uint32(0xC17E))
|
||
b3.Write(encodeUTF16LE(FormatNameDropEffect))
|
||
b3.Write([]byte{0, 0})
|
||
h3.processFormatList(b3.Bytes(), 0)
|
||
h3.processFormatDataRequest(req)
|
||
if fs3.last().flags != CB_RESPONSE_FAIL {
|
||
t.Fatal("no staged files: server-local DropEffect should FAIL")
|
||
}
|
||
}
|
||
|
||
func TestRequestRemoteFileOutOfRange(t *testing.T) {
|
||
h, _ := newFileTestHandler(t)
|
||
if err := h.RequestRemoteFile(3); err == nil {
|
||
t.Fatal("expected error for out-of-range index")
|
||
}
|
||
}
|
||
|
||
func TestFormatListAdvertisesFileFormatsWhenStaged(t *testing.T) {
|
||
h, fs := newFileTestHandler(t) // long-name 模式
|
||
h.sendFormatList()
|
||
body := fs.last().body
|
||
if bytes.Contains(body, encodeUTF16LE(FormatNameFileGroupDescriptorW)) {
|
||
t.Fatal("file formats must not be advertised before staging files")
|
||
}
|
||
h.SetLocalFiles([]LocalFile{{Name: "a.txt", Data: []byte("hi")}})
|
||
body = fs.last().body
|
||
if !bytes.Contains(body, encodeUTF16LE(FormatNameFileGroupDescriptorW)) ||
|
||
!bytes.Contains(body, encodeUTF16LE(FormatNameFileContents)) ||
|
||
!bytes.Contains(body, encodeUTF16LE(FormatNameDropEffect)) {
|
||
t.Fatal("staged Format List should advertise FileGroupDescriptorW/FileContents/DropEffect")
|
||
}
|
||
// short-name 模式（名称为原始 ASCII 字节）
|
||
h2, fs2 := newFileTestHandler(t)
|
||
h2.useLongFormatNames = false
|
||
h2.SetLocalFiles([]LocalFile{{Name: "a.txt", Data: []byte("hi")}})
|
||
body = fs2.last().body
|
||
if !bytes.Contains(body, []byte("FileGroupDescriptorW")) {
|
||
t.Fatalf("short-name Format List should carry FileGroupDescriptorW: % X", body[:min(80, len(body))])
|
||
}
|
||
}
|
||
|
||
func u64le(v uint64) []byte {
|
||
b := make([]byte, 8)
|
||
binary.LittleEndian.PutUint64(b, v)
|
||
return b
|
||
}
|
||
|
||
// TestParseFileGroupDescriptorWLargeDirectory：远端复制含数千文件的目录
|
||
// 是正常操作（曾因固定 1024 项上限整单被拒）；超过防御性上限才拒绝。
|
||
func TestParseFileGroupDescriptorWLargeDirectory(t *testing.T) {
|
||
build := func(n uint32) []byte {
|
||
body := make([]byte, 4+int(n)*fileDescriptorSize)
|
||
binary.LittleEndian.PutUint32(body[0:], n)
|
||
for i := uint32(0); i < n; i++ {
|
||
d := body[4+int(i)*fileDescriptorSize:]
|
||
binary.LittleEndian.PutUint32(d[0:], FD_ATTRIBUTES|FD_FILESIZE|FD_PROGRESSUI)
|
||
binary.LittleEndian.PutUint32(d[68:], 7) // 大小低 32 位
|
||
copy(d[72:], asciiUTF16(fmt.Sprintf("f%d.txt", i)))
|
||
}
|
||
return body
|
||
}
|
||
// 5000 项：必须接受
|
||
names, _, err := ParseFileGroupDescriptorW(build(5000))
|
||
if err != nil || len(names) != 5000 {
|
||
t.Fatalf("5000 items: err=%v names=%d", err, len(names))
|
||
}
|
||
if names[4999] != "f4999.txt" {
|
||
t.Fatalf("last name=%q", names[4999])
|
||
}
|
||
// 超过 maxDescriptorItems：拒绝
|
||
if _, _, err := ParseFileGroupDescriptorW(build(maxDescriptorItems + 1)); err == nil {
|
||
t.Fatal("over-limit cItems should be rejected")
|
||
}
|
||
// cItems 声明与载荷不符：拒绝
|
||
short := build(3)[:4+2*fileDescriptorSize]
|
||
binary.LittleEndian.PutUint32(short[0:], 3)
|
||
if _, _, err := ParseFileGroupDescriptorW(short); err == nil {
|
||
t.Fatal("truncated payload should be rejected")
|
||
}
|
||
}
|
||
|
||
// asciiUTF16 把纯 ASCII 名编码为 UTF-16LE（NUL 结尾），供构造描述符用。
|
||
func asciiUTF16(s string) []byte {
|
||
b := make([]byte, 0, (len(s)+1)*2)
|
||
for _, c := range []byte(s) {
|
||
b = append(b, c, 0)
|
||
}
|
||
return append(b, 0, 0)
|
||
}
|