Files
SimpleRemoter/server/go/protocol/commands_test.go
T
yuanyuanxianganddeepseek-flash d7accf1d30 Feature(Go): list_files over the file-manager sub-connection
The MCP server could not browse a device's file system. It now sends
COMMAND_LIST_DRIVE on the main connection, waits for the client to open
its file-manager sub-connection and report drives, then reuses that same
sub-connection for COMMAND_LIST_FILES with the directory path. Replies
are TOKEN_DRIVE_LIST, TOKEN_FILE_LIST or TOKEN_FILE_LIST_ERROR, decoded
from the same GBK the C++ client writes on every platform.

An empty or missing path returns the drive list, matching the published
tool description. Any other path, including /, lists one level of that
directory; the Win32 server folds / into the drive list, but doing so
would make a POSIX root listing unreachable. Entries carry name, isDir,
size and an mtime converted from FILETIME, and the 500-entry cap matches
the served contract and the Win32 parser; a truncated listing says so in
the summary. The reply is paged with the usual limit/offset window.

Errors are translated like the Win32 server: win32 5 is a permission
error, 2 and 3 are not-found, anything else is internal. Legacy clients
stay silent instead of reporting an error, which surfaces as a timeout
with an explanation.

The sub-connection is a resource the client allocates per call, so one
deferred cancel is the single retirement point: it reports the sub-conn
it saw and that connection is closed on every exit path, including a
call that gives up while the drive list is already queued. Packets that
arrive after the call returned are treated as orphans and retired, and
only the connection that answered the drive-list phase may answer the
directory request.

Also add a uniqueness test over the command and token byte constants,
and SendToConn so sub-connections are written through the hub's framing
path instead of a raw conn write.

Co-Authored-By: deepseek-flash
2026-11-12 22:34:17 +01:00

106 lines
3.2 KiB
Go

package protocol
import (
"go/ast"
"go/parser"
"go/token"
"strconv"
"strings"
"testing"
)
func TestSignMessageHMACVector(t *testing.T) {
// Standard HMAC-SHA256 sanity vector. Anchors that SignMessage matches
// the canonical RFC 4231 algorithm so signatures stay interoperable
// with peers that compute the same digest.
got := SignMessage("key", []byte("hello"))
want := "9307b3b915efb5171ff14d8cb55fbcc798c6c0ef1456d66ded1a6aa723a58b7b"
if got != want {
t.Fatalf("SignMessage(key, hello) = %s, want %s", got, want)
}
}
func TestSignMessageDeterministic(t *testing.T) {
a := SignMessage("test-key", []byte("2026-01-01 12:00:00|123456789"))
b := SignMessage("test-key", []byte("2026-01-01 12:00:00|123456789"))
if a != b {
t.Fatalf("non-deterministic: %s != %s", a, b)
}
if len(a) != 64 {
t.Fatalf("expected 64 hex chars, got %d (%s)", len(a), a)
}
}
func TestIsH264KeyframeBasic(t *testing.T) {
// 4-byte start code + IDR (NAL type 5)
idr := []byte{0x00, 0x00, 0x00, 0x01, 0x65, 0x88}
if !IsH264Keyframe(idr) {
t.Fatal("IDR should be detected as keyframe")
}
// 3-byte start code + SPS (NAL type 7)
sps := []byte{0x00, 0x00, 0x01, 0x67, 0x42}
if !IsH264Keyframe(sps) {
t.Fatal("SPS should be detected as keyframe")
}
// 4-byte start code + non-IDR slice (NAL type 1)
pframe := []byte{0x00, 0x00, 0x00, 0x01, 0x41, 0x9b}
if IsH264Keyframe(pframe) {
t.Fatal("non-IDR slice should not be detected as keyframe")
}
// Garbage
if IsH264Keyframe([]byte{0xde, 0xad, 0xbe, 0xef}) {
t.Fatal("non-H264 bytes should not match")
}
}
// TestCommandTokenConstantsAreUnique guards the command/token byte values in
// commands.go against a silent collision. The tokens are matched against the
// first byte of every inbound packet, so two names sharing a value means the
// wrong handler eats the packet — an added file-manager token that reuses
// TOKEN_LOGIN's value would swallow the device's login. Constants outside the
// Command*/Token*/Cmd* families are skipped: the file also defines field
// offsets, which legitimately repeat small numbers (offset 1 in two packets).
func TestCommandTokenConstantsAreUnique(t *testing.T) {
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, "commands.go", nil, 0)
if err != nil {
t.Fatalf("parse commands.go: %v", err)
}
seen := make(map[int64]string)
ast.Inspect(file, func(n ast.Node) bool {
spec, ok := n.(*ast.ValueSpec)
if !ok {
return true
}
for i, name := range spec.Names {
// A name without its own expression repeats the previous value.
if i >= len(spec.Values) || !isCommandTokenName(name.Name) {
continue
}
lit, ok := spec.Values[i].(*ast.BasicLit)
if !ok || lit.Kind != token.INT {
continue
}
v, err := strconv.ParseInt(lit.Value, 0, 64)
if err != nil {
continue
}
if prev, dup := seen[v]; dup {
t.Errorf("%s and %s both use %d", prev, name.Name, v)
continue
}
seen[v] = name.Name
}
return true
})
if len(seen) < 20 {
t.Fatalf("only %d command/token constants scanned; did commands.go change shape?", len(seen))
}
}
func isCommandTokenName(name string) bool {
return strings.HasPrefix(name, "Command") ||
strings.HasPrefix(name, "Token") ||
strings.HasPrefix(name, "Cmd")
}