Compare commits

...
12 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 10825c1fe0 release: v0.2.54
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-07 19:43:17 +08:00
cnetstandCodex 36fd51a9d6 Fix terminal session termination, ownership and list updates (#197)
Co-authored-by: Codex <codex@localhost>
2026-11-07 19:42:15 +08:00
Mr. Error 9271904be6 fix(privacy): accept the iOS screen-off encoding (#199)
The iOS viewer sends PrivateScreenSettingRequest{enable=0, privacy_type=3}
when the user turns the display off: its enable bit is the picture-mode
switch and the explicit type carries the intent. The host treated enable=0
as off, so the screen was restored instead of turned off.

Normalize that combination for iOS controllers only. Android 4.43.0 was
verified with the field-1 semantics, so keep Android and desktop viewers
unchanged. Record the platform after a desktop session is created, update
it on capture_desktop promotion, and cancel a pending UU_PRIVACY_AUTO even
when the switch is refused.
2026-11-07 18:40:49 +08:00
cnetstandCodex 1004806035 Resolve the iOS default upload directory alias (#198)
Co-authored-by: Codex <codex@localhost>
2026-11-07 11:21:56 +08:00
VallierDevandClaude Opus 5.5 af74af0f83 release: v0.2.53
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-06 11:42:15 +08:00
Jeff Zhang 2dd3280b7e perf(inproc): replace portal pseudo-polling with event-driven frame wait (#193)
* perf(portal): wait for frames without polling

* fix(portal): use monotonic clock for condition variable wait deadline

* fix(portal): compute wait_for_first_frame deadline with monotonic clock
2026-11-06 10:41:21 +08:00
VallierDevandClaude Opus 5.5 13c92d8f68 release: v0.2.52
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-06 07:39:51 +08:00
Jeff Zhang b0015a6c48 perf(input): offload text_input to spawn_blocking preserving order and rebase on main (#189) 2026-11-06 05:39:20 +08:00
Jeff Zhang c60d9f1bfa perf: HEVC RTP 分包零拷贝子切片与 X11 终端检测 100ms 缓存 (#182)
* perf: HEVC RTP 分包零拷贝子切片与 X11 终端检测 100ms 缓存

* fix(x11): 绑定焦点窗口缓存并支持焦点切换即时失效
2026-11-06 04:38:00 +08:00
Jeff Zhang 6032129228 perf: 优化 H.265 IRAP 单趟流式扫描与 CONTROL 通道 JSON 单次解析 (#180) 2026-11-06 03:38:47 +08:00
Jeff Zhang 7ba71a5540 webrtc: single-pass decode_wire for data channel packets and merge loop passes (#191) 2026-11-06 03:38:37 +08:00
Jeff Zhang b774bf6b16 perf: CompleteFrame 使用 bytes::Bytes 消除每帧码流克隆深拷贝 (#184) 2026-11-06 03:38:26 +08:00
25 changed files with 877 additions and 134 deletions

No files matched your search

Generated
+1 -1
View File
@@ -2804,7 +2804,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]] [[package]]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.51" version = "0.2.54"
dependencies = [ dependencies = [
"ab_glyph", "ab_glyph",
"async-trait", "async-trait",
+1 -1
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.51" version = "0.2.54"
edition = "2021" edition = "2021"
default-run = "uuremote-server" default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"] authors = ["uu-remote-linux contributors"]
+2 -2
View File
@@ -80,8 +80,8 @@ Protocol strings and messages that come from the UU servers are shown as the ser
| Viewer annotation | Strokes drawn with 「批注」 (annotate) in the viewer's watch mode appear on the Linux screen and stream back to the viewer (X11, needs a compositing manager; the overlay lets clicks through); cleared when annotation is turned off or the viewer disconnects. Verified with the Mac viewer 4.42.0; mobile viewers untested | | Viewer annotation | Strokes drawn with 「批注」 (annotate) in the viewer's watch mode appear on the Linux screen and stream back to the viewer (X11, needs a compositing manager; the overlay lets clicks through); cleared when annotation is turned off or the viewer disconnects. Verified with the Mac viewer 4.42.0; mobile viewers untested |
| Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; on X11 a resolution choice changes the desktop resolution itself like the official Windows host (xrandr, adding the mode when missing; restored for "original" or on disconnect), `UU_DESKTOP_RESIZE=0` scales in the encoder instead; Wayland scales in the encoder | | Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; on X11 a resolution choice changes the desktop resolution itself like the official Windows host (xrandr, adding the mode when missing; restored for "original" or on disconnect), `UU_DESKTOP_RESIZE=0` scales in the encoder instead; Wayland scales in the encoder |
| Sound | System audio captured from PulseAudio / PipeWire and sent as Opus | | Sound | System audio captured from PulseAudio / PipeWire and sent as Opus |
| File transfer | Upload, download (including folders), create folder, rename, delete | | File transfer | Upload, download (including folders), create folder, rename, delete; iOS quick uploads use the default receive directory (the current user’s home) |
| Terminal | The official "Terminal" tool, PTY sessions, multiple sessions, rename | | Terminal | The official "Terminal" tool, PTY sessions, multiple sessions, rename, termination and automatic list refresh; input and detach messages from an old connection cannot affect a reattached session |
| Lock state and auto unlock | Lock state is reported to the viewer; with "auto unlock" enabled in the client, the password is verified with PAM and the session is unlocked | | Lock state and auto unlock | Lock state is reported to the viewer; with "auto unlock" enabled in the client, the password is verified with PAM and the session is unlocked |
| Lock after remote session | Stored on the host, so it still applies after reconnecting | | Lock after remote session | Stored on the host, so it still applies after reconnecting |
| Mute host while controlled | Host speakers are muted while the viewer still hears the sound; the previous mute state is restored afterwards | | Mute host while controlled | Host speakers are muted while the viewer still hears the sound; the previous mute state is restored afterwards |
+2 -2
View File
@@ -69,8 +69,8 @@ UU_LANG=en uuremote-server
| 观看模式批注 | 控制端观看模式下开启「批注」后画的笔迹显示在 Linux 屏幕上,并随画面传回控制端(X11,需要合成器;覆盖层不拦截鼠标);关闭批注或断开连接时清除。已用 Mac 控制端 4.42.0 实测,手机控制端未测 | | 观看模式批注 | 控制端观看模式下开启「批注」后画的笔迹显示在 Linux 屏幕上,并随画面传回控制端(X11,需要合成器;覆盖层不拦截鼠标);关闭批注或断开连接时清除。已用 Mac 控制端 4.42.0 实测,手机控制端未测 |
| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 | | 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 |
| 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 | | 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 |
| 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除 | | 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除;iOS 直接上传使用默认接收目录(当前用户的主目录) |
| 终端 | 官方「终端」工具,PTY 会话,支持多会话和重命名 | | 终端 | 官方「终端」工具,PTY 会话,支持多会话、重命名、结束会话和列表自动刷新;重连后旧连接的输入和断开消息不会影响当前会话 |
| 锁屏与自动解锁 | 向控制端上报锁屏状态;开启「自动解锁被控端」后,通过 PAM 校验密码并解锁当前会话 | | 锁屏与自动解锁 | 向控制端上报锁屏状态;开启「自动解锁被控端」后,通过 PAM 校验密码并解锁当前会话 |
| 远程结束后自动锁屏 | 设置保存在本机,重连后依然生效 | | 远程结束后自动锁屏 | 设置保存在本机,重连后依然生效 |
| 被控端静音运行 | 主机扬声器静音,控制端照常能听到声音;结束后恢复原来的音量设置 | | 被控端静音运行 | 主机扬声器静音,控制端照常能听到声音;结束后恢复原来的音量设置 |
+37 -2
View File
@@ -558,7 +558,7 @@ static int wait_for_first_frame(struct uu_portal *p) {
while (!p->sequence && !p->error && !open_cancelled(p) && !(p->dma_requested && p->dma_bad)) { while (!p->sequence && !p->error && !open_cancelled(p) && !(p->dma_requested && p->dma_bad)) {
gint64 remaining = deadline - g_get_monotonic_time(); gint64 remaining = deadline - g_get_monotonic_time();
if (remaining <= 0) break; if (remaining <= 0) break;
clock_gettime(CLOCK_REALTIME, &until); clock_gettime(CLOCK_MONOTONIC, &until);
gint64 wait_us = MIN(100000, remaining); gint64 wait_us = MIN(100000, remaining);
until.tv_nsec += wait_us * 1000; until.tv_nsec += wait_us * 1000;
if (until.tv_nsec >= 1000000000) { until.tv_sec++; until.tv_nsec -= 1000000000; } if (until.tv_nsec >= 1000000000) { until.tv_sec++; until.tv_nsec -= 1000000000; }
@@ -616,7 +616,12 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
for (gchar **desktop = desktops; *desktop; desktop++) for (gchar **desktop = desktops; *desktop; desktop++)
if (!g_ascii_strcasecmp(*desktop, "GNOME")) p->absolute_stream_pixels = 1; if (!g_ascii_strcasecmp(*desktop, "GNOME")) p->absolute_stream_pixels = 1;
g_strfreev(desktops); g_strfreev(desktops);
pthread_mutex_init(&p->lock, NULL); pthread_cond_init(&p->changed, NULL); pthread_mutex_init(&p->lock, NULL);
pthread_condattr_t cond_attr;
pthread_condattr_init(&cond_attr);
pthread_condattr_setclock(&cond_attr, CLOCK_MONOTONIC);
pthread_cond_init(&p->changed, &cond_attr);
pthread_condattr_destroy(&cond_attr);
p->context = g_main_context_new(); g_main_context_push_thread_default(p->context); p->context = g_main_context_new(); g_main_context_push_thread_default(p->context);
p->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL); p->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
if (!p->bus) { *error = 1; goto done; } if (!p->bus) { *error = 1; goto done; }
@@ -832,6 +837,36 @@ int uu_portal_capture_alive(struct uu_portal *p) {
pthread_mutex_unlock(&p->lock); pthread_mutex_unlock(&p->lock);
return alive; return alive;
} }
int uu_portal_wait_frame(struct uu_portal *p, int64_t timeout_us) {
if (!p || atomic_load(&p->closed)) return -1;
pthread_mutex_lock(&p->lock);
if (p->error || atomic_load(&p->closed) || stream_stalled(p)) {
pthread_mutex_unlock(&p->lock);
return -1;
}
uint64_t prev_seq = p->sequence;
if (timeout_us <= 0) {
int ready = (p->sequence != prev_seq);
pthread_mutex_unlock(&p->lock);
return ready;
}
struct timespec until;
clock_gettime(CLOCK_MONOTONIC, &until);
until.tv_sec += timeout_us / 1000000LL;
until.tv_nsec += (long)(timeout_us % 1000000LL) * 1000L;
if (until.tv_nsec >= 1000000000L) {
until.tv_sec += 1;
until.tv_nsec -= 1000000000L;
}
while (p->sequence == prev_seq && !p->error && !atomic_load(&p->closed) && !stream_stalled(p)) {
int rc = pthread_cond_timedwait(&p->changed, &p->lock, &until);
if (rc != 0) break; // timeout or error
}
int res = (p->error || atomic_load(&p->closed) || stream_stalled(p)) ? -1 :
(p->sequence != prev_seq) ? 1 : 0;
pthread_mutex_unlock(&p->lock);
return res;
}
void uu_portal_input_dispatch(struct uu_portal *p) { void uu_portal_input_dispatch(struct uu_portal *p) {
if (p->ei) portal_eis_dispatch(p); if (p->ei) portal_eis_dispatch(p);
} }
+3
View File
@@ -25,6 +25,9 @@ int uu_portal_clipboard_set(struct uu_portal *portal, const uint8_t *text, size_
int uu_portal_clipboard_poll(struct uu_portal *portal, uint8_t *text, size_t capacity); int uu_portal_clipboard_poll(struct uu_portal *portal, uint8_t *text, size_t capacity);
int uu_portal_alive(struct uu_portal *portal); int uu_portal_alive(struct uu_portal *portal);
int uu_portal_capture_alive(struct uu_portal *portal); int uu_portal_capture_alive(struct uu_portal *portal);
/* Wait for a new frame or status change with a timeout in microseconds.
* Returns 1 if a new frame or status change occurred, 0 on timeout, <0 on closed/error. */
int uu_portal_wait_frame(struct uu_portal *portal, int64_t timeout_us);
void uu_portal_input_dispatch(struct uu_portal *portal); void uu_portal_input_dispatch(struct uu_portal *portal);
void uu_portal_logical_size(struct uu_portal *portal, uint32_t *width, uint32_t *height); void uu_portal_logical_size(struct uu_portal *portal, uint32_t *width, uint32_t *height);
void uu_portal_reset_frame(struct uu_portal *portal); void uu_portal_reset_frame(struct uu_portal *portal);
+36 -4
View File
@@ -331,12 +331,30 @@ static int class_is_terminal(const char *value) {
return 0; return 0;
} }
/* Returns 1 when the focused window belongs to a terminal emulator, else 0. */ /* Returns 1 when the focused window belongs to a terminal emulator, else 0.
Cached by focused Window with a 1000ms TTL, so key bursts on the same window
avoid redundant 12-level XQueryTree walks, while focus changes invalidate immediately. */
int x11_terminal_shortcut_state(void) { int x11_terminal_shortcut_state(void) {
static Window cached_window = 0;
static int cached_terminal = 0;
static struct timespec last_query = {0, 0};
if (!g_probe && !(g_probe = XOpenDisplay(NULL))) return 0; if (!g_probe && !(g_probe = XOpenDisplay(NULL))) return 0;
Window focus = 0; int revert = 0; Window focus = 0; int revert = 0;
XGetInputFocus(g_probe, &focus, &revert); XGetInputFocus(g_probe, &focus, &revert);
if (focus == None || focus == PointerRoot) return 0; if (focus == None || focus == PointerRoot) {
cached_window = 0;
cached_terminal = 0;
return 0;
}
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
long diff_ms = (now.tv_sec - last_query.tv_sec) * 1000 + (now.tv_nsec - last_query.tv_nsec) / 1000000;
if (focus == cached_window && last_query.tv_sec != 0 && diff_ms >= 0 && diff_ms < 1000) {
return cached_terminal;
}
Window cur = focus; Window cur = focus;
for (int depth = 0; depth < 12 && cur; depth++) { for (int depth = 0; depth < 12 && cur; depth++) {
XClassHint hint = {0}; XClassHint hint = {0};
@@ -344,14 +362,28 @@ int x11_terminal_shortcut_state(void) {
int terminal = class_is_terminal(hint.res_name) || class_is_terminal(hint.res_class); int terminal = class_is_terminal(hint.res_name) || class_is_terminal(hint.res_class);
if (hint.res_name) XFree(hint.res_name); if (hint.res_name) XFree(hint.res_name);
if (hint.res_class) XFree(hint.res_class); if (hint.res_class) XFree(hint.res_class);
cached_window = focus;
cached_terminal = terminal;
last_query = now;
return terminal; return terminal;
} }
Window root, parent, *children = NULL; unsigned int n = 0; Window root, parent, *children = NULL; unsigned int n = 0;
if (!XQueryTree(g_probe, cur, &root, &parent, &children, &n)) return 0; if (!XQueryTree(g_probe, cur, &root, &parent, &children, &n)) {
cached_window = 0;
cached_terminal = 0;
return 0;
}
if (children) XFree(children); if (children) XFree(children);
if (parent == root) return 0; if (parent == root) {
cached_window = 0;
cached_terminal = 0;
return 0;
}
cur = parent; cur = parent;
} }
cached_window = focus;
cached_terminal = 0;
last_query = now;
return 0; return 0;
} }
+2
View File
@@ -79,6 +79,8 @@ is aimed at the virtual output's region. Needs GTK3.
The host answers before switching (the viewer times out with 9998); a failed switch sends ReportError -7. The host answers before switching (the viewer times out with 9998); a failed switch sends ReportError -7.
成功不发送 ReportError;Mac 4.43.0 的 -9 是系统会话变化提示,不是防窥成功通知。 成功不发送 ReportError;Mac 4.43.0 的 -9 是系统会话变化提示,不是防窥成功通知。
Success does not send ReportError; -9 in Mac 4.43.0 reports a system session change, not privacy success. Success does not send ReportError; -9 in Mac 4.43.0 reports a system session change, not privacy success.
- iOS 控制端选“关闭显示器”发 `enable=0, privacy_type=3`:iOS 的 `enable` 是图片模式开关,关屏意图由 `type=3` 表达;iOS“不启用”发 `enable=0, privacy_type=1`。主机只对 iOS 控制端把 `0/3` 归一化为开屏保关屏(日志 `iOS screen-off encoding normalized`),其他控制端(包括已验收的 Android 4.43.0)保持字段 1 的语义。
The iOS viewer sends `enable=0, privacy_type=3` for "turn off the display": its `enable` is the picture-mode switch and `type=3` carries the intent; iOS "off" is `enable=0, privacy_type=1`. The host normalizes `0/3` to screen-off for iOS controllers only (log: `iOS screen-off encoding normalized`); other controllers, including the verified Android 4.43.0, keep the field-1 semantics.
- RPC 25 `update_screen_saver_req` → RpcResponse 21:开启隐私模式前发送,主机回空成功应答,画面仍用本机壁纸。 - RPC 25 `update_screen_saver_req` → RpcResponse 21:开启隐私模式前发送,主机回空成功应答,画面仍用本机壁纸。
Sent before picture mode; answered empty (success), the host keeps its own wallpaper. Sent before picture mode; answered empty (success), the host keeps its own wallpaper.
- FeatureFlag 4 `ff_private_screen` = 2 (ENHANCED_PRIVACY);SettingMetric 4 `private_screen`、7 `private_screen_type` - FeatureFlag 4 `ff_private_screen` = 2 (ENHANCED_PRIVACY);SettingMetric 4 `private_screen`、7 `private_screen_type`
+18
View File
@@ -0,0 +1,18 @@
性能优化版:降低视频推流与输入通道的拷贝和解析开销,功能行为不变。/ Performance release: less copying and parsing on the video and input paths; no behavior change.
### 优化 / Improved
- **编码帧零拷贝(#184)**:编码完成帧改用共享缓冲,去掉每帧码流深拷贝。/ Encoded frames use shared buffers, removing a per-frame bitstream deep copy.
- **H.265 关键帧检测与 RTP 分包(#180、#182)**:IRAP 检测改为单趟流式扫描,HEVC RTP 分包改为零拷贝子切片。/ Single-pass streaming IRAP scan; zero-copy sub-slices for HEVC RTP packetization.
- **数据通道解析(#180、#191)**:数据通道包单次解码、CONTROL 通道 JSON 单次解析。/ Single-pass data-channel decoding and single JSON parse on the CONTROL channel.
- **X11 终端检测缓存(#182)**:100ms 缓存,减少高频查询。/ 100 ms cache for X11 terminal detection.
- **文字输入不阻塞(#189)**:文字输入移到阻塞线程池执行,保持先后顺序。/ Text input runs on the blocking pool while preserving order.
感谢 @ferstar 提交这批优化。/ Thanks to @ferstar for these optimizations.
### 验证范围 / Validation
单元测试与 CI;各 PR 经 Codex 审查。未做实机性能对比与 Mac/手机客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.52_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.52-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.52`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+14
View File
@@ -0,0 +1,14 @@
性能优化版:Wayland(Portal)进程内推流改为事件驱动取帧,功能行为不变。/ Performance release: event-driven frame wait for in-process Wayland (Portal) streaming; no behavior change.
### 优化 / Improved
- **Portal 取帧事件驱动(#193,关闭 #192)**:Portal VAAPI 推流循环由固定间隔休眠轮询改为条件变量等待新帧(单调时钟),新帧到达即编码,空闲时不再空转。/ The Portal VAAPI loop waits on a condition variable (monotonic clock) for new frames instead of sleep-polling, so frames are encoded as soon as they arrive and idle loops no longer spin.
感谢 @ferstar 提交这项优化。/ Thanks to @ferstar for this optimization.
### 验证范围 / Validation
单元测试与 CI;PR 经 Codex 审查。未做 Wayland 实机性能对比与 Mac/手机客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.53_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.53-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.53`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+16
View File
@@ -0,0 +1,16 @@
修复版:终端会话结束/重连归属与列表通知,iOS 上传默认目录与关闭显示器兼容。/ Fix release: terminal session termination, reconnect ownership and list notifications; iOS default upload directory and screen-off compatibility.
### 修复 / Fixed
- **终端会话生命周期(#197)**:结束会话按 JSON `session_id` 选择目标(不再误用帧头请求编号),并清理该 PTY 会话内的全部进程组;Ctrl+C 发往前台进程组;重连后只接受当前附着连接的输入/缩放/信号;会话列表补齐 shell 名称、连接状态与 `last_active_ms`,变更时发送列表通知。/ Terminal close now targets the JSON `session_id` and cleans up all process groups of that PTY session; signals go to the foreground process group; after reconnect only the attached channel may drive the session; the session list gains shell name, attach state and `last_active_ms`, with change notifications.
- **iOS 上传默认目录(#198)**:iOS 直接上传时解析 `:/Default` 默认接收目录。/ iOS direct uploads resolve the `:/Default` receive-directory alias.
- **iOS 关闭显示器(#199)**:兼容 iOS 端 `enable=0,type=3` 的关闭显示器编码。/ Accept the iOS screen-off encoding (`enable=0,type=3`).
感谢 @cnetst、@RiverOnVenus 的贡献。/ Thanks to @cnetst and @RiverOnVenus.
### 验证范围 / Validation
单元测试与 CI;#197 作者在 Ubuntu ARM64 上与官方客户端实测,#199 附 iOS 实机日志。维护方未做 Mac/手机客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.54_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.54-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.54`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+63 -1
View File
@@ -147,6 +147,10 @@ fn io_error(e: &std::io::Error) -> u64 {
/// anything else is rooted at "/". /// anything else is rooted at "/".
pub fn normalize(path: &str) -> PathBuf { pub fn normalize(path: &str) -> PathBuf {
let p = path.replace('\\', "/"); let p = path.replace('\\', "/");
// Official Mac 4.46.0 UURemoteServer (x86_64, 0x10019f8a5–0x10019f9f7)
// resolves :/Default to its receive directory. iOS quick upload sends this alias;
// our receive directory is HOME, also reported in SystemMetrics/RemoteDownloadPath.
if p.trim_end_matches('/') == ":/Default" { return home(); }
// The host registers as a PC, so the viewer builds drive paths ("C:/x", or ":/" when it // The host registers as a PC, so the viewer builds drive paths ("C:/x", or ":/" when it
// knows no drive letter). Linux has a single root: any drive prefix maps to "/". // knows no drive letter). Linux has a single root: any drive prefix maps to "/".
let p = match p.split_once(':') { let p = match p.split_once(':') {
@@ -455,7 +459,10 @@ impl FileSession {
/// Upload to this host. receive_request{1 id,2 path,3 files,4 strategy,5 folder_name,6 list_data,7 task_unique_id} /// Upload to this host. receive_request{1 id,2 path,3 files,4 strategy,5 folder_name,6 list_data,7 task_unique_id}
fn receive_request(&self, rid: u64, f: &[WireField]) { fn receive_request(&self, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f); let id = TaskId::parse(f);
let target = normalize(&get_text(f, 2)); let raw_target = get_text(f, 2);
let target = normalize(&raw_target);
log::info!("File transfer upload destination: default={} exists={}",
raw_target.replace('\\', "/").trim_end_matches('/') == ":/Default", target.is_dir());
let folder = get_text(f, 5); let folder = get_text(f, 5);
let strategy = get_uint(f, 4); let strategy = get_uint(f, 4);
let files = parse_files(get_all(f, 3), get_bytes(f, 6)); let files = parse_files(get_all(f, 3), get_bytes(f, 6));
@@ -715,6 +722,61 @@ mod tests {
assert_eq!(parse_files(vec![], Some(&gz.finish().unwrap())), files); assert_eq!(parse_files(vec![], Some(&gz.finish().unwrap())), files);
} }
#[test] #[test]
fn ios_default_path_resolves_to_the_advertised_receive_directory() {
for path in [":/Default", ":\\Default", ":/Default/"] {
assert_eq!(normalize(path), home());
assert!(!is_this_pc(path));
}
assert_eq!(normalize("/Default"), PathBuf::from("/Default"));
assert_eq!(normalize("C:/Default"), PathBuf::from("/Default"));
assert_eq!(normalize(":/Default-other"), PathBuf::from("/Default-other"));
}
#[test]
fn ios_quick_upload_checks_conflicts_writes_and_completes_in_default_directory() {
let name = format!(".uu-ios-test-{}-{}", std::process::id(),
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos());
let dir = home().join(&name);
std::fs::create_dir(&dir).unwrap();
struct Cleanup(PathBuf);
impl Drop for Cleanup { fn drop(&mut self) { let _ = std::fs::remove_dir_all(&self.0); } }
let _cleanup = Cleanup(dir.clone());
let rel = format!("{name}/x.bin");
std::fs::write(dir.join("x.bin"), b"old").unwrap();
let (tx, mut rx) = mpsc::unbounded_channel();
let s = FileSession::new(tx, Arc::new(AtomicU64::new(1)));
let call = |case: u32, body: Enc| {
let rpc = Enc::default().msg(1, Enc::default().uint(1, 17)).msg(8, Enc::default().msg(case, body));
assert!(s.handle(&decode_wire(&crate::initialization::envelope(1, 1, 21, &rpc.0)).unwrap()));
};
let response = |m: Vec<u8>, case: u32| {
let outer = decode_wire(&m).unwrap();
let rpc = decode_wire(get_bytes(&outer, 22).unwrap()).unwrap();
assert_eq!(get_uint(&decode_wire(get_bytes(&rpc, 1).unwrap()).unwrap(), 1), 17);
let ftp = decode_wire(get_bytes(&rpc, 4).unwrap()).unwrap();
get_bytes(&ftp, case).unwrap().to_vec()
};
call(11, Enc::default().text(1, ":/Default").text(2, &rel));
let exist = response(rx.try_recv().unwrap(), 8);
let exist = decode_wire(&exist).unwrap();
assert_eq!(get_text(&exist, 1), ":/Default");
assert_eq!(get_uint(&decode_wire(get_bytes(&exist, 2).unwrap()).unwrap(), 2), 1);
let id = TaskId { task: 991, index: 1 };
let info = FileInfo { rel_path: rel, size: 6, modified: 0 };
call(1, Enc::default().msg(1, id.enc()).text(2, ":/Default").bytes(6, &list_data(&[info])));
let received = response(rx.try_recv().unwrap(), 1);
assert_eq!(get_uint(&decode_wire(&received).unwrap(), 3), FT_SUCCEEDED);
call(3, Enc::default().msg(1, id.enc()).uint(3, 6));
let confirmed = response(rx.try_recv().unwrap(), 3);
assert_eq!(get_uint(&decode_wire(&confirmed).unwrap(), 3), FT_SUCCEEDED);
call(4, Enc::default().msg(1, id.enc()).bytes(3, b"abcdef"));
let block = response(rx.try_recv().unwrap(), 4);
assert_eq!(get_uint(&decode_wire(&block).unwrap(), 3), FT_SUCCEEDED);
call(9, Enc::default().msg(1, id.enc()).uint(2, FT_SUCCEEDED));
let done = response(rx.try_recv().unwrap(), 6);
assert_eq!(get_uint(&decode_wire(&done).unwrap(), 2), FT_SUCCEEDED);
assert_eq!(std::fs::read(dir.join("x.bin")).unwrap(), b"abcdef");
}
#[test]
fn upload_writes_blocks_and_confirms() { fn upload_writes_blocks_and_confirms() {
let dir = std::env::temp_dir().join(format!("uu-up-{}", std::process::id())); let dir = std::env::temp_dir().join(format!("uu-up-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap(); std::fs::create_dir_all(&dir).unwrap();
+40
View File
@@ -36,6 +36,46 @@ pub fn payload(mtu: usize, annex_b: &[u8]) -> Result<Vec<Bytes>, String> {
Ok(out) Ok(out)
} }
/// Payload HEVC Annex-B bitstream with zero-copy sub-slicing for single NAL units <= MTU.
pub fn payload_bytes(mtu: usize, annex_b: &Bytes) -> Result<Vec<Bytes>, String> {
if mtu < 4 { return Err("HEVC payload MTU too small".into()); }
let mut starts = Vec::new();
let mut i = 0;
let bytes = annex_b.as_ref();
while i + 3 <= bytes.len() {
let prefix = if bytes[i..].starts_with(&[0, 0, 0, 1]) { 4 }
else if bytes[i..].starts_with(&[0, 0, 1]) { 3 } else { i += 1; continue; };
starts.push((i, i + prefix)); i += prefix;
}
if starts.is_empty() { return Err("HEVC access unit has no Annex-B start code".into()); }
let mut out = Vec::new();
for (index, &(_, start)) in starts.iter().enumerate() {
let mut end = starts.get(index + 1).map_or(bytes.len(), |s| s.0);
while end > start && bytes[end - 1] == 0 { end -= 1; } // trailing_zero_8bits
let nal_slice = &bytes[start..end];
if nal_slice.len() < 2 || nal_slice[0] & 0x80 != 0 || nal_slice[1] & 7 == 0 {
return Err("Invalid HEVC NAL header".into());
}
let kind = (nal_slice[0] >> 1) & 63;
if kind >= 48 { return Err("HEVC Annex-B contains RTP packet type".into()); }
if nal_slice.len() <= mtu {
// Zero-copy reference-counted sub-slice:
out.push(annex_b.slice(start..end));
continue;
}
let chunks = nal_slice[2..].chunks(mtu - 3);
let last = chunks.len() - 1;
for (n, chunk) in chunks.enumerate() {
let mut fu = Vec::with_capacity(3 + chunk.len());
// Keep F, LayerId and TID, replacing only the NAL type with FU=49.
fu.extend_from_slice(&[(nal_slice[0] & 0x81) | (49 << 1), nal_slice[1],
kind | if n == 0 { 0x80 } else { 0 } | if n == last { 0x40 } else { 0 }]);
fu.extend_from_slice(chunk); out.push(fu.into());
}
}
Ok(out)
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
+12 -1
View File
@@ -450,7 +450,18 @@ fn run_portal_vaapi(
if dma_disabled { log::info!("Portal VAAPI DMA-BUF disabled by setting; pipeline=host-upload"); } if dma_disabled { log::info!("Portal VAAPI DMA-BUF disabled by setting; pipeline=host-upload"); }
loop { loop {
if stop.load(Ordering::Relaxed) || units.is_closed() { return Ok(()); } if stop.load(Ordering::Relaxed) || units.is_closed() { return Ok(()); }
std::thread::sleep(next_poll.saturating_duration_since(Instant::now()).min(Duration::from_millis(20))); let wait_dur = next_poll.saturating_duration_since(Instant::now());
if wait_dur > Duration::ZERO {
match portal.wait_frame(wait_dur) {
Ok(true) | Ok(false) => (),
Err(_) => {
// Frame wait failed or stream closed/stalled: back off to next_poll
// (preventing 100% core busy-spin) and allow existing recovery in with_dmabuf
// and capture_changed to handle lock/scaling without prematurely aborting the encoder.
std::thread::sleep(wait_dur);
}
}
}
let now = Instant::now(); let now = Instant::now();
if now < next_poll { continue; } if now < next_poll { continue; }
next_poll = (next_poll + interval).max(now); next_poll = (next_poll + interval).max(now);
+17 -6
View File
@@ -81,15 +81,20 @@ fn finger_held(finger: Finger, now: std::time::Instant) -> Option<(i32,i32)> {
/// Viewer platform from the connect header `controller_platform` (website enum: 1 windows, 2 android, /// Viewer platform from the connect header `controller_platform` (website enum: 1 windows, 2 android,
/// 3 ios, 4 macos, 5 tv). /// 3 ios, 4 macos, 5 tv).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Controller { #[default] Other, Mac, Mobile } pub enum Controller { #[default] Other, Mac, Mobile, Ios }
impl Controller { impl Controller {
/// Touch semantics cover both mobile platforms; the iOS RPC 7 screen-off encoding is its own quirk.
pub fn is_mobile(self) -> bool { matches!(self, Self::Mobile | Self::Ios) }
pub fn from_platform(platform: Option<&serde_json::Value>) -> Self { pub fn from_platform(platform: Option<&serde_json::Value>) -> Self {
let Some(v) = platform else { return Self::Other }; let Some(v) = platform else { return Self::Other };
let text = v.as_str().map(str::to_ascii_lowercase); let text = v.as_str().map(str::to_ascii_lowercase);
match v.as_i64().or_else(|| text.as_deref().and_then(|s| s.parse().ok())) { match v.as_i64().or_else(|| text.as_deref().and_then(|s| s.parse().ok())) {
Some(4) => Self::Mac, Some(4) => Self::Mac,
Some(2 | 3) => Self::Mobile, Some(3) => Self::Ios,
_ if text.is_some_and(|s| s.contains("mac") || s.contains("darwin")) => Self::Mac, Some(2) => Self::Mobile,
_ if text.as_deref().is_some_and(|s| s.contains("mac") || s.contains("darwin")) => Self::Mac,
_ if text.as_deref().is_some_and(|s| s.contains("ios") || s.contains("iphone") || s.contains("ipad")) => Self::Ios,
_ if text.as_deref().is_some_and(|s| s.contains("android")) => Self::Mobile,
_ => Self::Other, _ => Self::Other,
} }
} }
@@ -303,7 +308,7 @@ impl InputInjector {
*self.cmd.lock().unwrap() = CmdState::default(); *self.cmd.lock().unwrap() = CmdState::default();
let mut touch = self.touch.lock().unwrap(); let mut touch = self.touch.lock().unwrap();
self.lift_finger(&mut touch); self.lift_finger(&mut touch);
let mode = if controller != Controller::Mobile || self.uinput_pointer { TouchMode::Mouse } else { let mode = if !controller.is_mobile() || self.uinput_pointer { TouchMode::Mouse } else {
match std::env::var("UU_TOUCH_INPUT").as_deref() { Ok("0") => TouchMode::Mouse, Ok("touch") => TouchMode::Touch, _ => TouchMode::Gesture } match std::env::var("UU_TOUCH_INPUT").as_deref() { Ok("0") => TouchMode::Mouse, Ok("touch") => TouchMode::Touch, _ => TouchMode::Gesture }
}; };
*touch = TouchDrag { mode, ..TouchDrag::default() }; *touch = TouchDrag { mode, ..TouchDrag::default() };
@@ -1047,7 +1052,7 @@ mod kernel_pointer_tests {
#[test] #[test]
fn full_uinput_bypasses_portal_binding_and_preserves_move_click_order() { fn full_uinput_bypasses_portal_binding_and_preserves_move_click_order() {
for controller in [Controller::Other, Controller::Mobile] { for controller in [Controller::Other, Controller::Mobile, Controller::Ios] {
let (devices, mut keyboard, mut pointer) = crate::uinput::Devices::recording_for_test(); let (devices, mut keyboard, mut pointer) = crate::uinput::Devices::recording_for_test();
let mut input = InputInjector::without_desktop(); let mut input = InputInjector::without_desktop();
input.uinput = Some(devices); input.uinput = Some(devices);
@@ -1296,7 +1301,13 @@ mod touch_tests {
fn controller_from_platform_numbers_and_mac_strings() { fn controller_from_platform_numbers_and_mac_strings() {
use serde_json::json; use serde_json::json;
assert_eq!(Controller::from_platform(Some(&json!(2))), Controller::Mobile); assert_eq!(Controller::from_platform(Some(&json!(2))), Controller::Mobile);
assert_eq!(Controller::from_platform(Some(&json!("3"))), Controller::Mobile); assert_eq!(Controller::from_platform(Some(&json!("3"))), Controller::Ios);
assert_eq!(Controller::from_platform(Some(&json!("ios"))), Controller::Ios);
assert_eq!(Controller::from_platform(Some(&json!("Android"))), Controller::Mobile);
assert_eq!(Controller::from_platform(Some(&json!("iPadOS"))), Controller::Ios);
assert!(Controller::Ios.is_mobile());
assert!(Controller::Mobile.is_mobile());
assert!(!Controller::Mac.is_mobile());
assert_eq!(Controller::from_platform(Some(&json!(4))), Controller::Mac); assert_eq!(Controller::from_platform(Some(&json!(4))), Controller::Mac);
assert_eq!(Controller::from_platform(Some(&json!("MacOS"))), Controller::Mac); assert_eq!(Controller::from_platform(Some(&json!("MacOS"))), Controller::Mac);
assert_eq!(Controller::from_platform(Some(&json!(1))), Controller::Other); assert_eq!(Controller::from_platform(Some(&json!(1))), Controller::Other);
+2
View File
@@ -1038,6 +1038,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
if desktop { portal_desktop.clone() } else { None }).await { if desktop { portal_desktop.clone() } else { None }).await {
Ok(mut sess) => { Ok(mut sess) => {
sess.controller = controller; sess.controller = controller;
if desktop { crate::privacy_screen::set_viewer_controller(controller); }
if !desktop { if !desktop {
let (requests, peer) = (desktop_requests.clone(), ice.clone()); let (requests, peer) = (desktop_requests.clone(), ice.clone());
sess.on_desktop_request(move || { let _ = requests.send(peer.clone()); }); sess.on_desktop_request(move || { let _ = requests.send(peer.clone()); });
@@ -1119,6 +1120,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
} else { None }; } else { None };
video::warm_auto_probe(); video::check_ffmpeg_usable(); video::warm_auto_probe(); video::check_ffmpeg_usable();
input.set_controller(controller); input.set_controller(controller);
crate::privacy_screen::set_viewer_controller(controller);
input.bind_portal(screen.as_ref().map_or_else(|| sessions[&ice].capture.portal.clone(), |screen| screen.portal.clone())); input.bind_portal(screen.as_ref().map_or_else(|| sessions[&ice].capture.portal.clone(), |screen| screen.portal.clone()));
// One desktop at a time, as for a new desktop offer. Peers offered as desktops // One desktop at a time, as for a new desktop offer. Peers offered as desktops
// close; a promoted tool peer only stops its desktop and keeps its tools. // close; a promoted tool peer only stops its desktop and keeps its tools.
+52 -5
View File
@@ -35,7 +35,7 @@ mod permissions;
#[cfg(all(target_os = "linux", feature = "portal"))] #[cfg(all(target_os = "linux", feature = "portal"))]
mod native { mod native {
use std::{ffi::c_void, ptr::NonNull, sync::{Mutex, MutexGuard, TryLockError}}; use std::{ffi::c_void, ptr::NonNull, sync::{Arc, Mutex, MutexGuard, TryLockError}};
crate::engine_ffi! { crate::engine_plugin::Engine::Portal; crate::engine_ffi! { crate::engine_plugin::Engine::Portal;
fn uu_portal_open_persist(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void; fn uu_portal_open_persist(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
fn uu_portal_open_virtual(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void; fn uu_portal_open_virtual(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
@@ -49,6 +49,7 @@ mod native {
fn uu_portal_close(portal: *mut c_void); fn uu_portal_close(portal: *mut c_void);
fn uu_portal_alive(portal: *mut c_void) -> i32; fn uu_portal_alive(portal: *mut c_void) -> i32;
fn uu_portal_capture_alive(portal: *mut c_void) -> i32; fn uu_portal_capture_alive(portal: *mut c_void) -> i32;
fn uu_portal_wait_frame(portal: *mut c_void, timeout_us: i64) -> i32;
fn uu_portal_input_dispatch(portal: *mut c_void); fn uu_portal_input_dispatch(portal: *mut c_void);
fn uu_portal_reset_frame(portal: *mut c_void); fn uu_portal_reset_frame(portal: *mut c_void);
fn uu_portal_capture_since(portal: *mut c_void, bgra: *mut u8, length: usize, revision: *mut u64) -> i32; fn uu_portal_capture_since(portal: *mut c_void, bgra: *mut u8, length: usize, revision: *mut u64) -> i32;
@@ -68,9 +69,14 @@ mod native {
} }
struct Handle(NonNull<c_void>); struct Handle(NonNull<c_void>);
fn pack(width: u32, height: u32) -> u64 { (u64::from(width) << 32) | u64::from(height) } fn pack(width: u32, height: u32) -> u64 { (u64::from(width) << 32) | u64::from(height) }
// The engine owns callback threads; public calls are serialized by Mutex. // Calls are serialized by Session's mutex except wait_frame, whose C-side
// condition wait synchronizes with callbacks and input through the engine lock.
unsafe impl Send for Handle {} unsafe impl Send for Handle {}
unsafe impl Sync for Handle {}
impl Drop for Handle { fn drop(&mut self) { unsafe { uu_portal_close(self.0.as_ptr()) } } } impl Drop for Handle { fn drop(&mut self) { unsafe { uu_portal_close(self.0.as_ptr()) } } }
fn lease_handle<T>(current: &Mutex<Arc<T>>) -> Result<Arc<T>, String> {
current.lock().map(|handle| Arc::clone(&handle)).map_err(|_| "Portal session lock poisoned".into())
}
fn blank_changed(frame: &mut [u8], version: &mut Option<super::FrameVersion>) -> bool { fn blank_changed(frame: &mut [u8], version: &mut Option<super::FrameVersion>) -> bool {
if *version == Some(super::FrameVersion(0, 0)) { return false; } if *version == Some(super::FrameVersion(0, 0)) { return false; }
super::blank(frame); *version = Some(super::FrameVersion(0, 0)); true super::blank(frame); *version = Some(super::FrameVersion(0, 0)); true
@@ -112,7 +118,7 @@ mod native {
was_locked.store(false, std::sync::atomic::Ordering::Release); was_locked.store(false, std::sync::atomic::Ordering::Release);
} }
} }
pub struct Session { handle: Mutex<Handle>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, size: std::sync::atomic::AtomicU64, monitor: Mutex<Option<String>>, virtual_output: std::sync::atomic::AtomicBool } pub struct Session { handle: Mutex<Arc<Handle>>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, size: std::sync::atomic::AtomicU64, monitor: Mutex<Option<String>>, virtual_output: std::sync::atomic::AtomicBool }
impl Session { impl Session {
fn take_lock_observation(&self) -> Result<bool, String> { fn take_lock_observation(&self) -> Result<bool, String> {
// A recovery in progress must see the lock even if another capture // A recovery in progress must see the lock even if another capture
@@ -260,7 +266,7 @@ mod native {
if wanted.is_some() && granted != wanted { log::warn!("Portal granted a different monitor than requested"); } if wanted.is_some() && granted != wanted { log::warn!("Portal granted a different monitor than requested"); }
// Keep a freshly granted compositor frame regardless of lock state. Discarding it // Keep a freshly granted compositor frame regardless of lock state. Discarding it
// before new damage can leave a static desktop permanently blank (#2). // before new damage can leave a static desktop permanently blank (#2).
Ok(Self { handle: Mutex::new(Handle(handle)), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), size: pack(width, height).into(), monitor: Mutex::new(granted), virtual_output: virtual_output.into() }) Ok(Self { handle: Mutex::new(Arc::new(Handle(handle))), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), size: pack(width, height).into(), monitor: Mutex::new(granted), virtual_output: virtual_output.into() })
} }
/// Frame pixels of the monitor the stream currently follows. /// Frame pixels of the monitor the stream currently follows.
pub fn size(&self) -> (u32, u32) { pub fn size(&self) -> (u32, u32) {
@@ -524,6 +530,17 @@ mod native {
pub fn clipboard_supported(&self) -> bool { pub fn clipboard_supported(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_clipboard_supported(handle.0.as_ptr()) != 0 }) self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_clipboard_supported(handle.0.as_ptr()) != 0 })
} }
pub fn wait_frame(&self, timeout: std::time::Duration) -> Result<bool, String> {
let handle = lease_handle(&self.handle)?;
// Retain sub-millisecond precision across the FFI boundary and clamp to 5s.
let us = (timeout.as_micros().min(5_000_000) as i64).max(1);
let ret = unsafe { uu_portal_wait_frame(handle.0.as_ptr(), us) };
if ret < 0 {
Err("Portal stream closed or failed during frame wait".into())
} else {
Ok(ret > 0)
}
}
pub fn clipboard_ready(&self) -> bool { pub fn clipboard_ready(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_clipboard_ready(handle.0.as_ptr()) != 0 }) self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_clipboard_ready(handle.0.as_ptr()) != 0 })
} }
@@ -601,7 +618,7 @@ mod native {
fn new(physical: (u32, u32)) -> Self { fn new(physical: (u32, u32)) -> Self {
let (_, locked) = tokio::sync::watch::channel(None); let (_, locked) = tokio::sync::watch::channel(None);
Self(ManuallyDrop::new(Session { Self(ManuallyDrop::new(Session {
handle: Mutex::new(Handle(NonNull::dangling())), handle: Mutex::new(Arc::new(Handle(NonNull::dangling()))),
locked, locked,
was_locked: std::sync::atomic::AtomicBool::new(false), was_locked: std::sync::atomic::AtomicBool::new(false),
recovery: Mutex::new(Recovery::default()), recovery: Mutex::new(Recovery::default()),
@@ -640,6 +657,35 @@ mod native {
button_held: bool, button_held: bool,
retirement: Option<(std::sync::mpsc::Sender<()>, std::sync::mpsc::Receiver<()>)>, retirement: Option<(std::sync::mpsc::Sender<()>, std::sync::mpsc::Receiver<()>)>,
} }
#[test]
fn frame_wait_lease_keeps_replaced_handle_alive_without_blocking_input() {
use std::sync::{atomic::{AtomicBool, Ordering}, mpsc::channel};
struct Tracked(Arc<AtomicBool>);
impl Drop for Tracked { fn drop(&mut self) { self.0.store(true, Ordering::SeqCst); } }
let dropped = Arc::new(AtomicBool::new(false));
let current = Arc::new(Mutex::new(Arc::new(Tracked(dropped.clone()))));
let (waiting, ready) = channel();
let (resume, resumed) = channel();
let worker = {
let current = current.clone();
std::thread::spawn(move || {
let lease = lease_handle(&current).unwrap();
waiting.send(()).unwrap();
resumed.recv_timeout(std::time::Duration::from_secs(3)).unwrap();
assert!(!lease.0.load(Ordering::SeqCst));
})
};
ready.recv_timeout(std::time::Duration::from_secs(3)).unwrap();
let old = {
let mut guard = current.try_lock().expect("frame wait must not block input");
std::mem::replace(&mut *guard, Arc::new(Tracked(Arc::new(AtomicBool::new(false)))))
};
drop(old);
assert!(!dropped.load(Ordering::SeqCst));
resume.send(()).unwrap();
worker.join().unwrap();
assert!(dropped.load(Ordering::SeqCst));
}
impl Drop for TestHandle { impl Drop for TestHandle {
fn drop(&mut self) { fn drop(&mut self) {
if let Some((entered, resume)) = self.retirement.take() { if let Some((entered, resume)) = self.retirement.take() {
@@ -896,6 +942,7 @@ impl PortalSession {
pub fn capture(&self, _: &mut [u8]) -> Result<(), String> { Err(error(15)) } pub fn capture(&self, _: &mut [u8]) -> Result<(), String> { Err(error(15)) }
pub fn capture_changed(&self, _: &mut [u8], _: &mut Option<FrameVersion>) -> Result<bool, String> { Err(error(15)) } pub fn capture_changed(&self, _: &mut [u8], _: &mut Option<FrameVersion>) -> Result<bool, String> { Err(error(15)) }
pub fn disable_dmabuf(&self) {} pub fn disable_dmabuf(&self) {}
pub fn wait_frame(&self, _: std::time::Duration) -> Result<bool, String> { Err(error(15)) }
pub fn with_dmabuf<T>(&self, _: &mut Option<FrameVersion>, _: impl FnOnce(&DmaFrame, bool) -> Result<T, String>) -> Result<DmaCapture<T>, String> { pub fn with_dmabuf<T>(&self, _: &mut Option<FrameVersion>, _: impl FnOnce(&DmaFrame, bool) -> Result<T, String>) -> Result<DmaCapture<T>, String> {
Ok(DmaCapture::Unavailable(-1)) Ok(DmaCapture::Unavailable(-1))
} }
+14 -1
View File
@@ -25,8 +25,15 @@ static POINTER: Mutex<Option<[f64; 4]>> = Mutex::new(None);
/// ends. An auto-enable never overrides it, including an RPC that arrives after the connection /// ends. An auto-enable never overrides it, including an RPC that arrives after the connection
/// opens but before `session_started` bumps the counter. /// opens but before `session_started` bumps the counter.
static VIEWER_OVERRIDE: AtomicBool = AtomicBool::new(false); static VIEWER_OVERRIDE: AtomicBool = AtomicBool::new(false);
/// iOS viewers encode "screen off" as `enable=0, type=3`; see
/// `protocol::Request::normalize_ios_screen_off`.
static VIEWER_IOS: AtomicBool = AtomicBool::new(false);
pub fn supported() -> bool { backend::detect().is_some() } pub fn supported() -> bool { backend::detect().is_some() }
/// Record the desktop controller's platform for the iOS RPC 7 encoder quirk.
pub fn set_viewer_controller(controller: crate::input::Controller) {
VIEWER_IOS.store(controller == crate::input::Controller::Ios, Ordering::Relaxed);
}
pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) } pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) }
/// The viewer's privacy_type now in effect. /// The viewer's privacy_type now in effect.
pub fn current_type() -> u8 { pub fn current_type() -> u8 {
@@ -112,7 +119,13 @@ pub struct Accepted { enable: bool, mode: Option<Mode> }
/// (error 9998 + n in its RPC failure handler) and a switch takes longer. A later failure is /// (error 9998 + n in its RPC failure handler) and a switch takes longer. A later failure is
/// reported as ReportError -7, which the viewer handles by resetting its privacy menu. /// reported as ReportError -7, which the viewer handles by resetting its privacy menu.
pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Option<Accepted>)> { pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Option<Accepted>)> {
let (header, request) = protocol::parse(rpc)?; let (header, mut request) = protocol::parse(rpc)?;
if request.normalize_ios_screen_off(VIEWER_IOS.load(Ordering::Relaxed)) {
// The viewer chose a mode even if the switch is refused below; cancel a pending auto-enable
// as an accepted request would.
VIEWER_OVERRIDE.store(true, Ordering::Relaxed);
log::info!("Privacy request: iOS screen-off encoding normalized (enable=0 type=3)");
}
if let Some(e) = refuse(request.enable, request.mode) { if let Some(e) = refuse(request.enable, request.mode) {
log::warn!("Privacy request refused: enable={} mode={:?}: {e}", request.enable, request.mode); log::warn!("Privacy request refused: enable={} mode={:?}: {e}", request.enable, request.mode);
return Some((protocol::response(&header, &request, true, current_type()), None)); return Some((protocol::response(&header, &request, true, current_type()), None));
+35
View File
@@ -5,6 +5,20 @@ use super::Mode;
pub struct Request { pub enable: bool, pub mode: Option<Mode>, requested: u64 } pub struct Request { pub enable: bool, pub mode: Option<Mode>, requested: u64 }
impl Request {
/// iOS viewers encode "turn off the display" as `enable=0, privacy_type=3`: their enable bit is
/// the picture-mode switch, and the explicit screen-off type carries the intent. iOS "off" is
/// `enable=0, type=1` (seen live), so rewrite only this exact combination. Android 4.43.0 was
/// verified with the field-1 semantics, so the rewrite is iOS-only.
pub fn normalize_ios_screen_off(&mut self, ios: bool) -> bool {
if ios && !self.enable && self.mode == Some(Mode::ScreenOff) {
self.enable = true;
return true;
}
false
}
}
pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Request)> { pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Request)> {
use crate::protocol::{decode_wire, WireValue}; use crate::protocol::{decode_wire, WireValue};
let body = |n| rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == n => Some(*b), _ => None }); let body = |n| rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == n => Some(*b), _ => None });
@@ -71,4 +85,25 @@ mod tests {
let saver = crate::protocol::decode_wire(&[10, 2, 8, 7, 0xca, 1, 0]).unwrap(); let saver = crate::protocol::decode_wire(&[10, 2, 8, 7, 0xca, 1, 0]).unwrap();
assert_eq!(screensaver_response(&saver).unwrap(), [10, 2, 8, 7, 0xaa, 1, 0]); assert_eq!(screensaver_response(&saver).unwrap(), [10, 2, 8, 7, 0xaa, 1, 0]);
} }
#[test]
fn normalizes_ios_screen_off_only() {
let screen_off = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 3]).unwrap();
let (_, mut request) = parse(&screen_off).unwrap();
assert!(request.normalize_ios_screen_off(true));
assert!(request.enable);
assert_eq!(request.mode, Some(Mode::ScreenOff));
let (_, mut request) = parse(&screen_off).unwrap();
assert!(!request.normalize_ios_screen_off(false));
assert!(!request.enable);
// An iOS "off" (type 1) and a Mac-style enable (1,3) must stay untouched.
let off = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 1]).unwrap();
let (_, mut request) = parse(&off).unwrap();
assert!(!request.normalize_ios_screen_off(true));
assert!(!request.enable);
let mac = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 1, 16, 3]).unwrap();
let (_, mut request) = parse(&mac).unwrap();
assert!(!request.normalize_ios_screen_off(true));
assert!(request.enable);
}
} }
+306 -21
View File
@@ -9,7 +9,7 @@
use std::collections::{HashMap, VecDeque}; use std::collections::{HashMap, VecDeque};
use std::io::Read; use std::io::Read;
use std::os::fd::{AsRawFd, OwnedFd}; use std::os::fd::{AsRawFd, OwnedFd};
use std::sync::atomic::{AtomicU32, Ordering}; use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, OnceLock}; use std::sync::{Arc, Mutex, OnceLock};
use tokio::sync::mpsc::UnboundedSender; use tokio::sync::mpsc::UnboundedSender;
@@ -67,6 +67,7 @@ struct Session {
id: u32, id: u32,
shell: String, shell: String,
created_ms: u64, created_ms: u64,
last_active_ms: AtomicU64,
master: OwnedFd, master: OwnedFd,
pid: i32, pid: i32,
sink: Mutex<Option<UnboundedSender<Vec<u8>>>>, sink: Mutex<Option<UnboundedSender<Vec<u8>>>>,
@@ -75,9 +76,11 @@ struct Session {
} }
impl Session { impl Session {
fn touch(&self) { self.last_active_ms.fetch_max(now_ms(), Ordering::Relaxed); }
/// Lock order sink → scrollback matches OPEN, so a reattach snapshot sees each /// Lock order sink → scrollback matches OPEN, so a reattach snapshot sees each
/// chunk either in the replay or live, never both. /// chunk either in the replay or live, never both.
fn record_output(&self, data: &[u8]) { fn record_output(&self, data: &[u8]) {
self.touch();
let mut sink = self.sink.lock().unwrap(); let mut sink = self.sink.lock().unwrap();
{ {
let mut sb = self.scrollback.lock().unwrap(); let mut sb = self.scrollback.lock().unwrap();
@@ -123,6 +126,7 @@ impl Session {
}); });
} }
fn write(&self, data: &[u8]) { fn write(&self, data: &[u8]) {
if !data.is_empty() { self.touch(); }
let mut off = 0; let mut off = 0;
while off < data.len() { while off < data.len() {
let n = unsafe { libc::write(self.master.as_raw_fd(), data[off..].as_ptr().cast(), data.len() - off) }; let n = unsafe { libc::write(self.master.as_raw_fd(), data[off..].as_ptr().cast(), data.len() - off) };
@@ -131,6 +135,31 @@ impl Session {
} }
} }
fn signal(&self, sig: i32) { unsafe { libc::kill(-self.pid, sig); } } fn signal(&self, sig: i32) { unsafe { libc::kill(-self.pid, sig); } }
fn signal_foreground(&self, sig: i32) {
self.touch();
// Job-control shells put commands such as top in their own process group.
let pgid = unsafe { libc::tcgetpgrp(self.master.as_raw_fd()) };
if pgid > 0 { unsafe { libc::kill(-pgid, sig); } } else { self.signal(sig); }
}
fn terminate(&self) {
// Job-control shells give foreground/background jobs separate process groups.
// Limit cleanup to this PTY's POSIX session, never other desktop/tool peers.
if self.pid <= 0 { return; }
#[cfg(target_os = "linux")]
if let Ok(entries) = std::fs::read_dir("/proc") {
let mut groups = std::collections::HashSet::new();
for entry in entries.flatten() {
let Some(pid) = entry.file_name().to_str().and_then(|s| s.parse::<i32>().ok()) else { continue; };
if unsafe { libc::getsid(pid) } == self.pid {
let group = unsafe { libc::getpgid(pid) };
if group > 0 && group != self.pid { groups.insert(group); }
}
}
for group in groups { unsafe { libc::kill(-group, libc::SIGKILL); } }
}
self.signal_foreground(libc::SIGKILL);
self.signal(libc::SIGKILL);
}
} }
fn registry() -> &'static Mutex<HashMap<u32, Arc<Session>>> { fn registry() -> &'static Mutex<HashMap<u32, Arc<Session>>> {
@@ -139,6 +168,28 @@ fn registry() -> &'static Mutex<HashMap<u32, Arc<Session>>> {
} }
static NEXT_ID: AtomicU32 = AtomicU32::new(1); static NEXT_ID: AtomicU32 = AtomicU32::new(1);
fn changes() -> &'static tokio::sync::watch::Sender<u64> {
static CHANGES: OnceLock<tokio::sync::watch::Sender<u64>> = OnceLock::new();
CHANGES.get_or_init(|| tokio::sync::watch::channel(0).0)
}
fn notify_changes() { changes().send_modify(|revision| *revision = revision.wrapping_add(1)); }
pub fn subscribe_changes() -> tokio::sync::watch::Receiver<u64> { changes().subscribe() }
pub fn changed_message(sequence: u64, timestamp: u64) -> Vec<u8> {
// Official Mac 4.42.0: Message name map 0x100a1eb98 gives field 28;
// notifyTerminalListInvalidated (0x1001a341c) sends the empty message on BINARY (channel 3).
crate::initialization::envelope(sequence, timestamp, 28, &[])
}
fn remove_session(session: &Arc<Session>) -> bool {
let mut sessions = registry().lock().unwrap();
// An old reader may finish after OPEN has reused the same requested ID.
if sessions.get(&session.id).is_some_and(|current| Arc::ptr_eq(current, session)) {
sessions.remove(&session.id);
drop(sessions);
notify_changes(); true
} else { false }
}
fn now_ms() -> u64 { std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_millis() as u64 } fn now_ms() -> u64 { std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_millis() as u64 }
fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result<Arc<Session>, String> { fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result<Arc<Session>, String> {
@@ -172,9 +223,11 @@ fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result
if id != 0 && !registry().lock().unwrap().contains_key(&id) { break id; } if id != 0 && !registry().lock().unwrap().contains_key(&id) { break id; }
} }
}; };
let session = Arc::new(Session { id, shell: shell.clone(), created_ms: now_ms(), pid: child.id() as i32, let created_ms = now_ms();
let session = Arc::new(Session { id, shell: shell.clone(), created_ms, last_active_ms: AtomicU64::new(created_ms), pid: child.id() as i32,
master: pty.master, sink: Mutex::new(None), scrollback: Mutex::new(VecDeque::new()), size: Mutex::new((cols, rows)) }); master: pty.master, sink: Mutex::new(None), scrollback: Mutex::new(VecDeque::new()), size: Mutex::new((cols, rows)) });
let mut reader = std::fs::File::from(session.master.try_clone().map_err(|e| format!("pty dup failed: {e}"))?); let mut reader = std::fs::File::from(session.master.try_clone().map_err(|e| format!("pty dup failed: {e}"))?);
registry().lock().unwrap().insert(id, session.clone());
let worker = session.clone(); let worker = session.clone();
std::thread::Builder::new().name(format!("uu-term-{id}")).spawn(move || { std::thread::Builder::new().name(format!("uu-term-{id}")).spawn(move || {
let mut buf = vec![0u8; OUTPUT_CHUNK]; let mut buf = vec![0u8; OUTPUT_CHUNK];
@@ -187,9 +240,10 @@ fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result
let code = child.wait().ok().and_then(|s| s.code()).unwrap_or(-1); let code = child.wait().ok().and_then(|s| s.code()).unwrap_or(-1);
log::info!("Terminal session exited: id={} exit_code={}", worker.id, code); log::info!("Terminal session exited: id={} exit_code={}", worker.id, code);
worker.emit(EXIT, serde_json::json!({"exit_code": code}).to_string().as_bytes()); worker.emit(EXIT, serde_json::json!({"exit_code": code}).to_string().as_bytes());
registry().lock().unwrap().remove(&worker.id); remove_session(&worker);
}).map_err(|e| format!("reader thread failed: {e}"))?; }).map_err(|e| {
registry().lock().unwrap().insert(id, session.clone()); remove_session(&session); session.terminate(); format!("reader thread failed: {e}")
})?;
log::info!("Terminal session spawned: id={} cols={} rows={}", id, cols, rows); log::info!("Terminal session spawned: id={} cols={} rows={}", id, cols, rows);
Ok(session) Ok(session)
} }
@@ -201,7 +255,7 @@ pub fn shutdown_all() {
for s in &sessions { s.signal(libc::SIGHUP); } for s in &sessions { s.signal(libc::SIGHUP); }
if !sessions.is_empty() { if !sessions.is_empty() {
std::thread::sleep(std::time::Duration::from_millis(300)); std::thread::sleep(std::time::Duration::from_millis(300));
for s in &sessions { s.signal(libc::SIGKILL); } for s in &sessions { s.terminate(); }
log::info!("Terminal sessions closed on shutdown: count={}", sessions.len()); log::info!("Terminal sessions closed on shutdown: count={}", sessions.len());
} }
} }
@@ -226,13 +280,26 @@ fn signal_number(payload: &[u8]) -> i32 {
fn reply(code: i64, message: &str) -> Vec<u8> { serde_json::json!({"code": code, "message": message}).to_string().into_bytes() } fn reply(code: i64, message: &str) -> Vec<u8> { serde_json::json!({"code": code, "message": message}).to_string().into_bytes() }
/// One viewer connection's terminal endpoint; `out` sends complete frames on BINARY_DATA_CHANNEL. /// One viewer connection's terminal endpoint; `out` sends complete frames on BINARY_DATA_CHANNEL.
pub struct TerminalConn { out: UnboundedSender<Vec<u8>> } pub struct TerminalConn { out: UnboundedSender<Vec<u8>>, closed: AtomicBool }
impl TerminalConn { impl TerminalConn {
pub fn new(out: UnboundedSender<Vec<u8>>) -> Self { Self { out } } pub fn new(out: UnboundedSender<Vec<u8>>) -> Self { Self { out, closed: AtomicBool::new(false) } }
fn send(&self, kind: u8, session: u32, payload: &[u8]) { let _ = self.out.send(encode(kind, session, payload)); } fn send(&self, kind: u8, session: u32, payload: &[u8]) { let _ = self.out.send(encode(kind, session, payload)); }
pub fn disconnect(&self) {
self.closed.store(true, Ordering::Release);
let sessions: Vec<_> = registry().lock().unwrap().values().cloned().collect();
let mut changed = false;
for s in sessions {
let mut sink = s.sink.lock().unwrap();
if sink.as_ref().is_some_and(|tx| tx.same_channel(&self.out)) {
*sink = None; s.touch(); changed = true;
}
}
if changed { notify_changes(); }
}
pub fn handle(&self, data: &[u8]) { pub fn handle(&self, data: &[u8]) {
if self.closed.load(Ordering::Acquire) { return; }
let Some(frame) = decode(data) else { log::warn!("Terminal frame rejected: bytes={}", data.len()); return; }; let Some(frame) = decode(data) else { log::warn!("Terminal frame rejected: bytes={}", data.len()); return; };
if frame.kind != STDIN { log::info!("Terminal frame: type={} session={} payload_bytes={}", frame.kind, frame.session, frame.payload.len()); } if frame.kind != STDIN { log::info!("Terminal frame: type={} session={} payload_bytes={}", frame.kind, frame.session, frame.payload.len()); }
let existing = registry().lock().unwrap().get(&frame.session).cloned(); let existing = registry().lock().unwrap().get(&frame.session).cloned();
@@ -247,6 +314,7 @@ impl TerminalConn {
}; };
match session { match session {
Ok(s) => { Ok(s) => {
s.touch();
// Queue the acknowledgement before the PTY reader can emit live output. // Queue the acknowledgement before the PTY reader can emit live output.
let mut sink = s.sink.lock().unwrap(); let mut sink = s.sink.lock().unwrap();
self.send(OPEN_RESP, s.id, &reply(0, "ok")); self.send(OPEN_RESP, s.id, &reply(0, "ok"));
@@ -257,30 +325,55 @@ impl TerminalConn {
drop(sink); drop(sink);
// The replay tail starts mid-redraw for full-screen programs. // The replay tail starts mid-redraw for full-screen programs.
if reattach { s.force_redraw(); } if reattach { s.force_redraw(); }
notify_changes();
} }
Err(e) => { log::warn!("Terminal open failed: {}", e); self.send(OPEN_RESP, frame.session, &reply(1, &e)); } Err(e) => { log::warn!("Terminal open failed: {}", e); self.send(OPEN_RESP, frame.session, &reply(1, &e)); }
} }
} }
STDIN => if let Some(s) = existing { s.write(&frame.payload) }, STDIN | RESIZE | SIGNAL | CLOSE | DETACH => if let Some(s) = existing {
RESIZE => if let Some(s) = existing { let (c, r) = dims(&json(&frame.payload)); s.resize(c, r) }, let mut sink = s.sink.lock().unwrap();
SIGNAL => if let Some(s) = existing { s.signal(signal_number(&frame.payload)) }, // Reattach transfers ownership. Late input/DETACH from the old viewer
CLOSE => if let Some(s) = existing { *s.sink.lock().unwrap() = None; s.signal(libc::SIGHUP); }, // must not affect the new attachment or inject a second copy of input.
DETACH => if let Some(s) = existing { *s.sink.lock().unwrap() = None }, if !sink.as_ref().is_some_and(|tx| tx.same_channel(&self.out)) { return; }
match frame.kind {
// PTY writes may block during a large paste. Keep output draining.
STDIN => { drop(sink); s.write(&frame.payload); }
RESIZE => { let (c, r) = dims(&json(&frame.payload)); s.resize(c, r); }
SIGNAL => s.signal_foreground(signal_number(&frame.payload)),
CLOSE | DETACH => {
*sink = None; s.touch();
if frame.kind == CLOSE { s.signal(libc::SIGHUP); }
notify_changes();
}
_ => unreachable!(),
}
},
KILL_REQ => { KILL_REQ => {
let id = if frame.session != 0 { frame.session } else { // Official Mac 4.42.0 handleKillSessionReq (0x100189ca0, 0x10018be64):
json(&frame.payload).get("session_id").and_then(|x| x.as_u64()).unwrap_or(0) as u32 // JSON session_id selects the target; the frame header correlates the reply.
let Some(id) = json(&frame.payload).get("session_id").and_then(|x| x.as_u64()).and_then(|id| u32::try_from(id).ok()) else {
self.send(KILL_RESP, frame.session, &reply(400, "Invalid payload")); return;
}; };
let target = registry().lock().unwrap().get(&id).cloned(); let target = registry().lock().unwrap().remove(&id);
match target { match target {
Some(s) => { *s.sink.lock().unwrap() = None; s.signal(libc::SIGHUP); s.signal(libc::SIGKILL); self.send(KILL_RESP, id, &reply(0, "ok")); } Some(s) => {
None => self.send(KILL_RESP, id, &reply(1, "Session not found")), s.terminate();
self.send(KILL_RESP, frame.session, &reply(0, "ok"));
notify_changes();
log::info!("Terminal session terminated: id={} request={}", id, frame.session);
}
None => self.send(KILL_RESP, frame.session, &reply(404, "Session not found")),
} }
} }
LIST_REQ => { LIST_REQ => {
let sessions: Vec<serde_json::Value> = registry().lock().unwrap().values().map(|s| { let sessions: Vec<serde_json::Value> = registry().lock().unwrap().values().map(|s| {
let attached = s.sink.lock().unwrap().is_some(); let attached = s.sink.lock().unwrap().as_ref().is_some_and(|tx| !tx.is_closed());
serde_json::json!({"session_id": s.id, "name": format!("bash-{}", s.id), "shell": s.shell, let name = std::path::Path::new(&s.shell).file_name().and_then(|n| n.to_str()).unwrap_or("shell");
"state": if attached { "running" } else { "detached" }, "created_at_ms": s.created_ms}) // Official Mac 4.42.0 snapshot at 0x1001b82c8–0x1001b8524
// includes last_active_ms even when the session is detached.
serde_json::json!({"session_id": s.id, "name": format!("{}-{}", name, s.id), "shell": s.shell,
"state": if attached { "running" } else { "detached" }, "created_at_ms": s.created_ms,
"last_active_ms": s.last_active_ms.load(Ordering::Relaxed)})
}).collect(); }).collect();
log::info!("Terminal list sessions: count={}", sessions.len()); log::info!("Terminal list sessions: count={}", sessions.len());
// Official Mac 4.42.0 (handleListSessionsReq) sends a bare array with the request's header ID. // Official Mac 4.42.0 (handleListSessionsReq) sends a bare array with the request's header ID.
@@ -323,9 +416,200 @@ mod tests {
} }
} }
#[test] #[test]
fn kill_uses_payload_id_preserves_request_id_and_updates_list_before_reply() {
let victim = spawn(u32::MAX - 5, 80, 24, Some("/bin/sh")).unwrap();
let decoy = spawn(u32::MAX - 6, 80, 24, Some("/bin/sh")).unwrap();
struct Cleanup(Vec<Arc<Session>>);
impl Drop for Cleanup {
fn drop(&mut self) { for s in &self.0 { s.signal(libc::SIGHUP); s.signal(libc::SIGKILL); } }
}
let _cleanup = Cleanup(vec![victim.clone(), decoy.clone()]);
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let conn = TerminalConn::new(tx);
let payload = serde_json::json!({"session_id": victim.id}).to_string();
// A request ID may happen to equal another live session ID. Never kill it.
conn.handle(&encode(KILL_REQ, decoy.id, payload.as_bytes()));
let response = decode(&rx.try_recv().unwrap()).unwrap();
assert_eq!((response.kind, response.session), (KILL_RESP, decoy.id));
assert_eq!(json(&response.payload)["code"], 0);
conn.handle(&encode(LIST_REQ, 123, &[]));
let response = decode(&rx.try_recv().unwrap()).unwrap();
let list = json(&response.payload);
assert!(!list.as_array().unwrap().iter().any(|s| s["session_id"] == victim.id), "terminated session must be absent before acknowledgement");
assert!(list.as_array().unwrap().iter().any(|s| s["session_id"] == decoy.id), "request correlation must not select a session");
assert_eq!(unsafe { libc::kill(decoy.pid, 0) }, 0);
conn.handle(&encode(KILL_REQ, 123, payload.as_bytes()));
let response = decode(&rx.try_recv().unwrap()).unwrap();
assert_eq!(response.session, 123);
assert_eq!(json(&response.payload)["code"], 404);
for invalid in [b"{}".as_slice(), b"", br#"{"session_id":-1}"#, br#"{"session_id":4294967296}"#] {
conn.handle(&encode(KILL_REQ, decoy.id, invalid));
let response = decode(&rx.try_recv().unwrap()).unwrap();
assert_eq!(response.session, decoy.id);
assert_eq!(json(&response.payload)["code"], 400);
assert!(registry().lock().unwrap().contains_key(&decoy.id));
}
}
#[test]
fn session_changed_matches_official_empty_binary_notification() {
use crate::protocol::WireValue;
let message = changed_message(17, 1234);
let fields = crate::protocol::decode_wire(&message).unwrap();
assert_eq!(fields.iter().map(|f| f.number).collect::<Vec<_>>(), vec![1, 2, 28]);
assert_eq!(fields[2].value, WireValue::Bytes(&[]));
}
#[test]
#[cfg(target_os = "linux")]
fn kill_ends_foreground_and_background_jobs() {
let session = spawn(u32::MAX - 8, 80, 24, Some("/bin/sh")).unwrap();
struct Cleanup(Arc<Session>);
impl Drop for Cleanup { fn drop(&mut self) { self.0.terminate(); } }
let _cleanup = Cleanup(session.clone());
session.write(b"sleep 30 & sleep 30\n");
let mut jobs = Vec::new();
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
while std::time::Instant::now() < deadline {
jobs = std::fs::read_to_string(format!("/proc/{}/task/{}/children", session.pid, session.pid)).unwrap_or_default()
.split_whitespace().filter_map(|s| s.parse::<i32>().ok())
.filter(|pid| std::fs::read_to_string(format!("/proc/{pid}/comm")).is_ok_and(|s| s.trim() == "sleep")).collect();
if jobs.len() == 2 { break; }
std::thread::sleep(std::time::Duration::from_millis(10));
}
assert_eq!(jobs.len(), 2, "foreground and background jobs must be running");
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
TerminalConn::new(tx).handle(&encode(KILL_REQ, 123, serde_json::json!({"session_id":session.id}).to_string().as_bytes()));
assert_eq!(json(&decode(&rx.try_recv().unwrap()).unwrap().payload)["code"], 0);
jobs.push(session.pid);
let alive = |pid| std::fs::read_to_string(format!("/proc/{pid}/stat"))
.is_ok_and(|s| s.rsplit_once(") ").is_some_and(|(_, fields)| !fields.starts_with('Z')));
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
while std::time::Instant::now() < deadline && jobs.iter().any(|pid| alive(*pid)) {
std::thread::sleep(std::time::Duration::from_millis(10));
}
assert!(!jobs.iter().any(|pid| alive(*pid)), "termination must end all job-control groups");
}
#[test]
fn reattach_rejects_old_input_and_detach_but_preserves_intentional_repeats() {
let pty = nix::pty::openpty(None, None).unwrap();
let id = u32::MAX - 7;
let mut termios = nix::sys::termios::tcgetattr(&pty.slave).unwrap();
nix::sys::termios::cfmakeraw(&mut termios);
nix::sys::termios::tcsetattr(&pty.slave, nix::sys::termios::SetArg::TCSANOW, &termios).unwrap();
let session = Arc::new(Session { id, shell: "/bin/sh".into(), created_ms: now_ms(), last_active_ms: AtomicU64::new(now_ms()),
master: pty.master, pid: 0, sink: Mutex::new(None), scrollback: Mutex::new(VecDeque::new()), size: Mutex::new((80, 24)) });
registry().lock().unwrap().insert(id, session.clone());
struct Cleanup(Arc<Session>);
impl Drop for Cleanup { fn drop(&mut self) { remove_session(&self.0); } }
let _cleanup = Cleanup(session.clone());
let (old_tx, _old_rx) = tokio::sync::mpsc::unbounded_channel();
let old = TerminalConn::new(old_tx);
let (new_tx, _new_rx) = tokio::sync::mpsc::unbounded_channel();
let new = TerminalConn::new(new_tx);
old.handle(&encode(OPEN, id, b"{}"));
new.handle(&encode(OPEN, id, b"{}"));
old.handle(&encode(STDIN, id, b"stale"));
old.handle(&encode(DETACH, id, &[]));
old.disconnect();
let input = b"\x1b[A";
new.handle(&encode(STDIN, id, input));
new.handle(&encode(STDIN, id, input));
let mut slave = std::fs::File::from(pty.slave);
let mut bytes = [0; 6];
slave.read_exact(&mut bytes).unwrap();
assert!(bytes == input.repeat(2).as_slice(), "only current input should arrive, including intentional repeats");
assert!(session.sink.lock().unwrap().as_ref().is_some_and(|tx| tx.same_channel(&new.out)));
new.disconnect();
assert!(session.sink.lock().unwrap().is_none());
new.handle(&encode(OPEN, id, b"{}"));
assert!(session.sink.lock().unwrap().is_none(), "a closed connection must not reattach");
}
#[test]
fn nonempty_list_matches_official_snapshot_and_survives_reattach() {
// Official Mac 4.42.0 TerminalSession snapshot (0x1001b82c8–0x1001b8524):
// all six fields exist, including the Int64 last_active_ms timestamp.
#[derive(serde::Deserialize)]
struct Snapshot { session_id: u32, name: String, shell: String, state: String,
created_at_ms: i64, last_active_ms: i64 }
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let mut conn = TerminalConn::new(tx);
let id = u32::MAX - 3;
conn.handle(&encode(OPEN, id, br#"{"cols":80,"rows":24,"shell":"/bin/sh"}"#));
assert_eq!(decode(&rx.blocking_recv().unwrap()).unwrap().kind, OPEN_RESP);
struct Cleanup(u32);
impl Drop for Cleanup {
fn drop(&mut self) {
if let Some(s) = registry().lock().unwrap().get(&self.0).cloned() { s.signal(libc::SIGHUP); }
}
}
let _cleanup = Cleanup(id);
let snapshot = |request| {
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
TerminalConn::new(tx).handle(&encode(LIST_REQ, request, &[]));
let reply = decode(&rx.try_recv().unwrap()).unwrap();
assert_eq!((reply.kind, reply.session), (LIST_RESP, request));
serde_json::from_slice::<Vec<Snapshot>>(&reply.payload).expect("official nonempty session schema")
.into_iter().find(|s| s.session_id == id).unwrap()
};
let first = snapshot(100);
assert_eq!(first.state, "running");
assert_eq!(first.shell, "/bin/sh");
assert_eq!(first.name, format!("sh-{id}"));
assert!(first.created_at_ms > 0 && first.last_active_ms >= first.created_at_ms);
for request in [101, 102] {
conn.handle(&encode(DETACH, id, &[]));
let detached = snapshot(request);
assert_eq!(detached.state, "detached");
std::thread::sleep(std::time::Duration::from_millis(5));
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
conn = TerminalConn::new(tx);
conn.handle(&encode(OPEN, id, br#"{"cols":80,"rows":24}"#));
assert_eq!(decode(&rx.blocking_recv().unwrap()).unwrap().kind, OPEN_RESP);
let attached = snapshot(request + 100);
assert_eq!(attached.state, "running");
assert_eq!(attached.created_at_ms, first.created_at_ms);
assert!(attached.last_active_ms > detached.last_active_ms);
}
}
#[test]
#[cfg(target_os = "linux")]
fn interrupt_reaches_foreground_job_without_exiting_shell() {
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let conn = TerminalConn::new(tx);
let id = u32::MAX - 4;
conn.handle(&encode(OPEN, id, br#"{"cols":80,"rows":24,"shell":"/bin/sh"}"#));
assert_eq!(decode(&rx.blocking_recv().unwrap()).unwrap().kind, OPEN_RESP);
let session = registry().lock().unwrap().get(&id).unwrap().clone();
struct Cleanup(Arc<Session>);
impl Drop for Cleanup {
fn drop(&mut self) { self.0.signal_foreground(libc::SIGKILL); self.0.signal(libc::SIGHUP); }
}
let _cleanup = Cleanup(session.clone());
let foreground = || unsafe { libc::tcgetpgrp(session.master.as_raw_fd()) };
// The shell can foreground its child before exec resets inherited signals.
let job_ready = || {
let pgid = foreground();
pgid > 0 && pgid != session.pid &&
std::fs::read_to_string(format!("/proc/{pgid}/comm")).is_ok_and(|name| name.trim() == "sleep")
};
conn.handle(&encode(STDIN, id, b"sleep 30\n"));
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
while std::time::Instant::now() < deadline && !job_ready() {
std::thread::sleep(std::time::Duration::from_millis(10));
}
assert!(job_ready(), "job must be executing in a separate foreground group");
conn.handle(&encode(SIGNAL, id, br#"{"signal":"SIGINT"}"#));
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
while std::time::Instant::now() < deadline && foreground() != session.pid {
std::thread::sleep(std::time::Duration::from_millis(10));
}
assert_eq!(foreground(), session.pid, "interrupt must return control to the shell");
assert_eq!(unsafe { libc::kill(session.pid, 0) }, 0, "shell must stay alive");
}
#[test]
fn force_redraw_shrinks_then_restores_latest_size() { fn force_redraw_shrinks_then_restores_latest_size() {
let pty = nix::pty::openpty(None, None).unwrap(); let pty = nix::pty::openpty(None, None).unwrap();
let session = Arc::new(Session { id: u32::MAX - 2, shell: "/bin/sh".into(), created_ms: now_ms(), let session = Arc::new(Session { id: u32::MAX - 2, shell: "/bin/sh".into(), created_ms: now_ms(),
last_active_ms: AtomicU64::new(now_ms()),
master: pty.master, pid: 0, sink: Mutex::new(None), master: pty.master, pid: 0, sink: Mutex::new(None),
scrollback: Mutex::new(VecDeque::new()), size: Mutex::new((80, 24)) }); scrollback: Mutex::new(VecDeque::new()), size: Mutex::new((80, 24)) });
let rows = |s: &Session| { let rows = |s: &Session| {
@@ -346,6 +630,7 @@ mod tests {
let id = u32::MAX - 1; let id = u32::MAX - 1;
let history: Vec<u8> = (0..SCROLLBACK).map(|n| (n % 251) as u8).collect(); let history: Vec<u8> = (0..SCROLLBACK).map(|n| (n % 251) as u8).collect();
let session = Arc::new(Session { id, shell: "/bin/sh".into(), created_ms: now_ms(), let session = Arc::new(Session { id, shell: "/bin/sh".into(), created_ms: now_ms(),
last_active_ms: AtomicU64::new(now_ms()),
master: pty.master, pid: 0, sink: Mutex::new(None), master: pty.master, pid: 0, sink: Mutex::new(None),
scrollback: Mutex::new(history.iter().copied().collect()), size: Mutex::new((80, 24)) }); scrollback: Mutex::new(history.iter().copied().collect()), size: Mutex::new((80, 24)) });
registry().lock().unwrap().insert(id, session.clone()); registry().lock().unwrap().insert(id, session.clone());
+28 -11
View File
@@ -154,8 +154,25 @@ fn is_independent_frame_for(bytes: &[u8], codec: VideoCodec) -> bool {
match codec { match codec {
VideoCodec::H264 => !nal_offsets_for(bytes, 5, codec).is_empty() && nal_offsets_for(bytes, 1, codec).is_empty(), VideoCodec::H264 => !nal_offsets_for(bytes, 5, codec).is_empty() && nal_offsets_for(bytes, 1, codec).is_empty(),
// BLA/IDR/CRA are IRAP (RFC 7798 §4.1); no leading pictures with our no-B-frame encoder. // BLA/IDR/CRA are IRAP (RFC 7798 §4.1); no leading pictures with our no-B-frame encoder.
VideoCodec::H265 => (16..=21).any(|kind| !nal_offsets_for(bytes, kind, codec).is_empty()) VideoCodec::H265 => {
&& !(0..16).any(|kind| !nal_offsets_for(bytes, kind, codec).is_empty()), let mut has_irap = false;
let mut has_non_irap_vcl = false;
let mut i = 0;
while i + 3 < bytes.len() {
let prefix = if bytes[i..].starts_with(&[0, 0, 0, 1]) { 4 }
else if bytes[i..].starts_with(&[0, 0, 1]) { 3 } else { i += 1; continue };
let header = i + prefix;
if let Some(kind) = hevc_nal_kind(bytes, header) {
if (16..=21).contains(&kind) {
has_irap = true;
} else if kind < 16 {
has_non_irap_vcl = true;
}
}
i += prefix;
}
has_irap && !has_non_irap_vcl
}
} }
} }
#[cfg(test)] #[cfg(test)]
@@ -169,7 +186,7 @@ struct CompleteFrame {
codec: VideoCodec, codec: VideoCodec,
sequence: u64, sequence: u64,
completed_at: Instant, completed_at: Instant,
data: Vec<u8>, data: bytes::Bytes,
_permit: Option<OwnedSemaphorePermit>, _permit: Option<OwnedSemaphorePermit>,
} }
@@ -769,7 +786,7 @@ async fn read_inprocess(
let mut gate = DependencyGate::default(); let mut gate = DependencyGate::default();
while let Some(unit) = units.recv().await { while let Some(unit) = units.recv().await {
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1; let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
gate.submit(&latest, Arc::new(CompleteFrame { source_generation: source.1, source_id: source.0, codec, sequence, completed_at: unit.completed_at, data: unit.data, _permit: Some(unit.permit) })); gate.submit(&latest, Arc::new(CompleteFrame { source_generation: source.1, source_id: source.0, codec, sequence, completed_at: unit.completed_at, data: unit.data.into(), _permit: Some(unit.permit) }));
if latest.is_closed() { break; } if latest.is_closed() { break; }
} }
// Dropping the receiver also unblocks the encoder if it is waiting to send. // Dropping the receiver also unblocks the encoder if it is waiting to send.
@@ -988,7 +1005,7 @@ async fn read_encoder_with(
if aud.len() < 2 { break; } if aud.len() < 2 { break; }
let next = aud[1]; let next = aud[1];
if next > MAX_ACCESS_UNIT { return Err("Encoder access unit exceeds limit".into()); } if next > MAX_ACCESS_UNIT { return Err("Encoder access unit exceeds limit".into()); }
let frame: Vec<u8> = pending.drain(..next).collect(); let frame: bytes::Bytes = pending.drain(..next).collect::<Vec<u8>>().into();
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1; let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
let permit=if wayland {Some(permits_rx.recv().await.ok_or("Capture producer stopped")?)} else {None}; let permit=if wayland {Some(permits_rx.recv().await.ok_or("Capture producer stopped")?)} else {None};
gate.submit(&latest, Arc::new(CompleteFrame { source_generation: settings.source_generation, source_id: settings.source_id, gate.submit(&latest, Arc::new(CompleteFrame { source_generation: settings.source_generation, source_id: settings.source_id,
@@ -1330,7 +1347,7 @@ pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::vid
max_age_ms = max_age_ms.max(frame.completed_at.elapsed().as_millis()); max_age_ms = max_age_ms.max(frame.completed_at.elapsed().as_millis());
// Continue monitoring close even if the network send stalls. // Continue monitoring close even if the network send stalls.
let sample = Sample { let sample = Sample {
data: frame.data.clone().into(), duration, ..Default::default() data: frame.data.clone(), duration, ..Default::default()
}; };
let extensions = [crate::rtp_metadata::capture_index(0), crate::rtp_metadata::new_frame()]; let extensions = [crate::rtp_metadata::capture_index(0), crate::rtp_metadata::new_frame()];
let sent_before=track.revision(); let sent_before=track.revision();
@@ -1480,7 +1497,7 @@ mod tests {
for sequence in 1..=2 { for sequence in 1..=2 {
let permit=budget.clone().acquire_owned().await.unwrap(); let permit=budget.clone().acquire_owned().await.unwrap();
gate.submit(&tx,Arc::new(CompleteFrame { source_generation: 0, source_id: 0,codec:VideoCodec::H264,sequence,completed_at:Instant::now(), gate.submit(&tx,Arc::new(CompleteFrame { source_generation: 0, source_id: 0,codec:VideoCodec::H264,sequence,completed_at:Instant::now(),
data:vec![0,0,1,5,42],_permit:Some(permit)})); data:vec![0,0,1,5,42].into(),_permit:Some(permit)}));
} }
let sending=rx.recv().await.unwrap(); let sending=rx.recv().await.unwrap();
assert_eq!(budget.available_permits(),0); assert_eq!(budget.available_permits(),0);
@@ -1642,7 +1659,7 @@ mod tests {
let (started_tx, started_rx) = tokio::sync::oneshot::channel(); let (started_tx, started_rx) = tokio::sync::oneshot::channel();
let frame = |sequence, idr| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None, let frame = |sequence, idr| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None,
sequence, codec: VideoCodec::H264, completed_at: Instant::now(), sequence, codec: VideoCodec::H264, completed_at: Instant::now(),
data: vec![0, 0, 1, 9, 240, 0, 0, 1, if idr { 5 } else { 1 }, 42], data: vec![0, 0, 1, 9, 240, 0, 0, 1, if idr { 5 } else { 1 }, 42].into(),
}); });
let mut reader = EncoderTask(tokio::spawn(async move { let mut reader = EncoderTask(tokio::spawn(async move {
let _stopped = MarkStopped(old_stopped); let _stopped = MarkStopped(old_stopped);
@@ -1735,7 +1752,7 @@ mod tests {
async fn bounded_queue_never_sends_broken_prediction_chain_after_overload(){ async fn bounded_queue_never_sends_broken_prediction_chain_after_overload(){
let(tx,mut rx)=mpsc::channel(1); let(tx,mut rx)=mpsc::channel(1);
let mut gate=DependencyGate::default(); let mut gate=DependencyGate::default();
let frame=|sequence,idr|Arc::new(CompleteFrame{source_generation:0,source_id:0,_permit:None,sequence,codec:VideoCodec::H264,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42]}); let frame=|sequence,idr|Arc::new(CompleteFrame{source_generation:0,source_id:0,_permit:None,sequence,codec:VideoCodec::H264,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42].into()});
gate.submit(&tx,frame(1,false));assert!(rx.try_recv().is_err()); // no IDR yet gate.submit(&tx,frame(1,false));assert!(rx.try_recv().is_err()); // no IDR yet
gate.submit(&tx,frame(2,true)); gate.submit(&tx,frame(2,true));
gate.submit(&tx,frame(3,false)); // queue full: P3 lost gate.submit(&tx,frame(3,false)); // queue full: P3 lost
@@ -1808,7 +1825,7 @@ mod tests {
let (tx, mut rx) = mpsc::channel(1); let (tx, mut rx) = mpsc::channel(1);
let mut gate = DependencyGate::default(); let mut gate = DependencyGate::default();
let frame = |sequence, irap| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None, codec: VideoCodec::H265, let frame = |sequence, irap| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None, codec: VideoCodec::H265,
sequence, completed_at: Instant::now(), data: vec![0,0,1,if irap { 38 } else { 2 },1,42] }); sequence, completed_at: Instant::now(), data: vec![0,0,1,if irap { 38 } else { 2 },1,42].into() });
gate.submit(&tx, frame(1, false)); gate.submit(&tx, frame(1, false));
assert!(rx.try_recv().is_err()); assert!(rx.try_recv().is_err());
gate.submit(&tx, frame(2, true)); gate.submit(&tx, frame(2, true));
@@ -1855,7 +1872,7 @@ mod screen_frame_tests {
use super::*; use super::*;
#[test] #[test]
fn source_restart_rejects_queued_frames_even_with_same_screen_and_codec() { fn source_restart_rejects_queued_frames_even_with_same_screen_and_codec() {
let frame=CompleteFrame {source_id:0,source_generation:7,codec:VideoCodec::H264,sequence:1,completed_at:Instant::now(),data:vec![],_permit:None}; let frame=CompleteFrame {source_id:0,source_generation:7,codec:VideoCodec::H264,sequence:1,completed_at:Instant::now(),data:vec![].into(),_permit:None};
let mut settings=VideoSettings {source_id:0,source_generation:7,..Default::default()}; let mut settings=VideoSettings {source_id:0,source_generation:7,..Default::default()};
assert!(frame.matches(&settings)); assert!(frame.matches(&settings));
settings.source_generation=9;assert!(!frame.matches(&settings)); settings.source_generation=9;assert!(!frame.matches(&settings));
+1 -1
View File
@@ -57,7 +57,7 @@ impl VideoTrack {
// Leave room for the RTP header and negotiated UU extensions below the 1200 byte MTU. // Leave room for the RTP header and negotiated UU extensions below the 1200 byte MTU.
let payloads = match codec { let payloads = match codec {
VideoCodec::H264 => state.h264.payload(1160, &sample.data).map_err(Error::Rtp)?, VideoCodec::H264 => state.h264.payload(1160, &sample.data).map_err(Error::Rtp)?,
VideoCodec::H265 => crate::hevc::payload(1160, &sample.data).map_err(Error::new)?, VideoCodec::H265 => crate::hevc::payload_bytes(1160, &sample.data).map_err(Error::new)?,
}; };
let count = payloads.len(); let count = payloads.len();
let mut complete = count > 0; let mut complete = count > 0;
+1 -1
View File
@@ -31,7 +31,7 @@ pub(super) async fn encode(latest: mpsc::Sender<Arc<CompleteFrame>>, settings: V
let frame = Arc::new(CompleteFrame { let frame = Arc::new(CompleteFrame {
source_generation: settings.source_generation, source_id: settings.source_id, source_generation: settings.source_generation, source_id: settings.source_id,
codec: settings.codec, sequence: sequence.fetch_add(1, Ordering::Relaxed) + 1, codec: settings.codec, sequence: sequence.fetch_add(1, Ordering::Relaxed) + 1,
completed_at: Instant::now(), data: vec![0, 0, 1, 65, 1, 2], _permit: Some(permit), completed_at: Instant::now(), data: vec![0, 0, 1, 65, 1, 2].into(), _permit: Some(permit),
}); });
if latest.send(frame).await.is_err() { return Ok(()); } if latest.send(frame).await.is_err() { return Ok(()); }
} }
+114 -73
View File
@@ -604,14 +604,33 @@ impl WebRtcSession {
let out_channel = d.clone(); let out_channel = d.clone();
let out_label = label.clone(); let out_label = label.clone();
let outbound_rx = outbound_rx.clone(); let outbound_rx = outbound_rx.clone();
let change_sequence = out_sequence.clone();
let terminal_changes = crate::terminal::subscribe_changes();
let start_drain = move || { let start_drain = move || {
let out_channel = out_channel.clone(); let out_channel = out_channel.clone();
let out_label = out_label.clone(); let out_label = out_label.clone();
let outbound_rx = outbound_rx.clone(); let outbound_rx = outbound_rx.clone();
let change_sequence = change_sequence.clone();
let mut terminal_changes = terminal_changes.clone();
Box::pin(async move { Box::pin(async move {
let Some(mut outbound_rx) = take_outbound_once(&outbound_rx).await else { return; }; let Some(mut outbound_rx) = take_outbound_once(&outbound_rx).await else { return; };
tokio::spawn(async move { tokio::spawn(async move {
while let Some(message) = outbound_rx.recv().await { let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
loop {
let message = tokio::select! {
message = outbound_rx.recv() => match message { Some(message) => message, None => break },
changed = terminal_changes.changed(), if out_label == "BINARY_DATA_CHANNEL" => {
if changed.is_err() { break; }
if out_channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { continue; }
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
crate::terminal::changed_message(change_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts)
},
_ = health.tick(), if out_label == "BINARY_DATA_CHANNEL" => {
use webrtc::data_channel::data_channel_state::RTCDataChannelState;
if matches!(out_channel.ready_state(), RTCDataChannelState::Closing | RTCDataChannelState::Closed) { break; }
continue;
},
};
if let Err(e) = out_channel.send(&bytes::Bytes::from(message)).await { if let Err(e) = out_channel.send(&bytes::Bytes::from(message)).await {
log::warn!("{} send failed: {}", out_label, e); break; log::warn!("{} send failed: {}", out_label, e); break;
} }
@@ -796,6 +815,13 @@ impl WebRtcSession {
(Outbound::Other(tx), "BINARY_DATA_CHANNEL") => Some(Arc::new(crate::terminal::TerminalConn::new(tx.clone()))), (Outbound::Other(tx), "BINARY_DATA_CHANNEL") => Some(Arc::new(crate::terminal::TerminalConn::new(tx.clone()))),
_ => None, _ => None,
}; };
if let Some(terminal) = &terminal_conn {
let closing = terminal.clone();
d.on_close(Box::new(move || {
let closing = closing.clone();
Box::pin(async move { closing.disconnect(); })
}));
}
if label == "CONTROL_DATA_CHANNEL" || label == "TEXT_DATA_CHANNEL" { if label == "CONTROL_DATA_CHANNEL" || label == "TEXT_DATA_CHANNEL" {
let channel = d.clone(); let channel = d.clone();
let initial_sequence = out_sequence.clone(); let initial_sequence = out_sequence.clone();
@@ -1177,7 +1203,8 @@ impl WebRtcSession {
} }
return; return;
} }
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) { let proto_fields = crate::protocol::decode_wire(&msg.data).ok();
if let Some(fields) = proto_fields.as_deref() {
use crate::protocol::WireValue; use crate::protocol::WireValue;
let rpc = fields.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None }); let rpc = fields.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None });
let rpc_fields = rpc.and_then(|r| crate::protocol::decode_wire(r).ok()); let rpc_fields = rpc.and_then(|r| crate::protocol::decode_wire(r).ok());
@@ -1222,18 +1249,18 @@ impl WebRtcSession {
let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response)); let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return; return;
} }
if let Some(response) = rpc.and_then(|r| crate::protocol::decode_wire(r).ok()).and_then(|r| crate::terminal::rpc_response(&r)) { if let Some(response) = rpc_fields.as_deref().and_then(crate::terminal::rpc_response) {
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs(); let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response)); let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return; return;
} }
} }
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) { if let Some(fields) = proto_fields.as_deref() {
if mapping.handle(&fields, &channel_name) { return; } if mapping.handle(fields, &channel_name) { return; }
} }
if let Some(files) = &file_worker { if let Some(files) = &file_worker {
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) { if let Some(fields) = proto_fields.as_deref() {
if files.handle(&fields) { if files.handle(fields) {
static ROUTE: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0); static ROUTE: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if ROUTE.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 20 { if ROUTE.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 20 {
log::info!("File transfer RPC received on {}", channel_name); log::info!("File transfer RPC received on {}", channel_name);
@@ -1259,16 +1286,16 @@ impl WebRtcSession {
} }
} }
shape(&value,0).to_string() shape(&value,0).to_string()
} else if let Ok(fields) = crate::protocol::decode_wire(&msg.data) { } else if let Some(fields) = proto_fields.as_deref() {
format!("protobuf fields={:?}",fields.iter().map(|f|f.number).collect::<Vec<_>>()) format!("protobuf fields={:?}",fields.iter().map(|f|f.number).collect::<Vec<_>>())
} else { "opaque".to_string() }; } else { "opaque".to_string() };
log::info!("Clipboard channel schema: channel={} bytes={} schema={}",channel_name,msg.data.len(),shape); log::info!("Clipboard channel schema: channel={} bytes={} schema={}",channel_name,msg.data.len(),shape);
} }
} }
if channel_name == "CONTROL_DATA_CHANNEL" || channel_name == "TEXT_DATA_CHANNEL" { if channel_name == "CONTROL_DATA_CHANNEL" || channel_name == "TEXT_DATA_CHANNEL" {
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) { if let Some(fields) = proto_fields.as_deref() {
use crate::protocol::WireValue; use crate::protocol::WireValue;
for field in &fields { for field in fields {
if let (22,WireValue::Bytes(payload))=(field.number,&field.value) { if let (22,WireValue::Bytes(payload))=(field.number,&field.value) {
let update=rich_incoming.lock().unwrap().response(payload); let update=rich_incoming.lock().unwrap().response(payload);
match update { match update {
@@ -1285,8 +1312,6 @@ impl WebRtcSession {
} }
} }
} }
}
for field in &fields {
if let (21, WireValue::Bytes(payload)) = (field.number,&field.value) { if let (21, WireValue::Bytes(payload)) = (field.number,&field.value) {
let ids=crate::clipboard_rich::format_ids(payload); let ids=crate::clipboard_rich::format_ids(payload);
if !ids.is_empty(){log::info!("Clipboard offered format IDs: {:?}",ids);} if !ids.is_empty(){log::info!("Clipboard offered format IDs: {:?}",ids);}
@@ -1324,8 +1349,6 @@ impl WebRtcSession {
Err(reason)=>log::warn!("Clipboard RPC rejected: {}",reason), Err(reason)=>log::warn!("Clipboard RPC rejected: {}",reason),
} }
} }
}
for field in &fields {
if let (17, WireValue::Bytes(payload)) = (field.number, &field.value) { if let (17, WireValue::Bytes(payload)) = (field.number, &field.value) {
match clipboard_assembly.lock().unwrap().accept(payload) { match clipboard_assembly.lock().unwrap().accept(payload) {
Ok(Some(text)) => { Ok(Some(text)) => {
@@ -1452,69 +1475,87 @@ impl WebRtcSession {
} }
if let Ok(txt) = std::str::from_utf8(&msg.data) { if let Ok(txt) = std::str::from_utf8(&msg.data) {
log::debug!("DataChannel [{}] received UTF-8 data: {} bytes", channel_name, txt.len()); log::debug!("DataChannel [{}] received UTF-8 data: {} bytes", channel_name, txt.len());
if let Ok(val) = serde_json::from_str::<serde_json::Value>(txt) { if channel_name.contains("CONTROL") {
if !channel_name.contains("CONTROL") { match crate::control_protocol::decode_control(&msg.data) {
// Input JSON on another channel (mobile input-method text was missing from CONTROL, #13/#46): Ok(crate::control_protocol::ControlMessage::Input(event)) => {
// record action names only, once per name, and accept text_input wherever it arrives. // A ready compositor source remains controllable on its lock screen.
if let Some(action) = val.get("action").and_then(serde_json::Value::as_str) { if screen.backend == crate::desktop_backend::DesktopBackend::Portal
static SEEN: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new()); && (screen.init_error.is_some() || !desktop_ready) { return; }
let mut seen = SEEN.lock().unwrap(); if !crate::wayland::input_ready() {return;}
if seen.len() < 32 && action.len() <= 40 && action.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_') && !seen.iter().any(|s| s == action) { use crate::control_protocol::ControlInput;
seen.push(action.to_owned()); // Separate receipt budgets keep motion floods from hiding clicks.
log::info!("JSON action on {} channel: action={}", if channel_name.contains("STREAMER") {"STREAMER"} else if channel_name.contains("TEXT") {"TEXT"} else {"other"}, action); static RECEIPTS: [std::sync::atomic::AtomicUsize; 3] = [const { std::sync::atomic::AtomicUsize::new(0) }; 3];
let (slot, kind) = match &event {
ControlInput::MouseButton {..} | ControlInput::MouseClick {..} => (0, "button"),
ControlInput::Keyboard {..} | ControlInput::KeyboardClick {..} | ControlInput::TextInput {..} => (1, "keyboard"),
_ => (2, "motion"),
};
if RECEIPTS[slot].fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
log::info!("CONTROL input received: kind={}", kind);
} }
} if let Some(session)=message_input_session.as_ref() {
if let Ok(crate::control_protocol::ControlMessage::Input(crate::control_protocol::ControlInput::TextInput {text})) = crate::control_protocol::decode_control(&msg.data) { if matches!(&event, ControlInput::TextInput {..}) {
if let Some(session)=message_input_session.as_ref() { session.with_input(|| {if crate::wayland::input_ready() {input_worker.text_input(&text);}}); } let (session, input, text) = match &event {
ControlInput::TextInput {text} => (session.clone(), input_worker.clone(), text.clone()),
_ => unreachable!(),
};
let _ = tokio::task::spawn_blocking(move || {
session.with_input(|| {
if crate::wayland::input_ready() { input.text_input(&text); }
});
}).await;
} else {
session.with_input(|| {
if !crate::wayland::input_ready() {return;}
match &event {
ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,crate::wayland::input_size(if live_x11 {crate::capture::x11_last_size().unwrap_or(input_size)} else {input_size})),
ControlInput::MouseRelative {dx,dy} => input_worker.mouse_relative(*dx,*dy),
ControlInput::MouseScroll {dx,dy} => input_worker.mouse_scroll(*dx,*dy),
ControlInput::Keyboard {key, pressed} => input_worker.windows_key_event(*key, *pressed),
ControlInput::KeyboardClick {key} => {input_worker.windows_key_event(*key, true);input_worker.windows_key_event(*key, false);},
ControlInput::MouseButton {button,pressed} => input_worker.wire_mouse_button(*button,*pressed),
ControlInput::MouseClick {button} => {input_worker.wire_mouse_button(*button,true);input_worker.wire_mouse_button(*button,false);},
_ => {}
}
});
}
}
},
Ok(crate::control_protocol::ControlMessage::Unsupported(v)) => {
// Action name and key names only, never values (an IME text event would carry typed text).
static UNSUPPORTED: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if UNSUPPORTED.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
let action = v.get("action").and_then(serde_json::Value::as_str)
.filter(|a| a.len() <= 40 && a.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_')).unwrap_or("?");
let keys: Vec<&str> = v.as_object().map(|o| o.keys().map(String::as_str).take(12).collect()).unwrap_or_default();
log::info!("Unsupported CONTROL input: action={action} keys={keys:?}");
}
},
_ => {}
}
} else if let Ok(val) = serde_json::from_str::<serde_json::Value>(txt) {
// Input JSON on another channel (mobile input-method text was missing from CONTROL, #13/#46):
// record action names only, once per name, and accept text_input wherever it arrives.
if let Some(action) = val.get("action").and_then(serde_json::Value::as_str) {
static SEEN: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new());
let mut seen = SEEN.lock().unwrap();
if seen.len() < 32 && action.len() <= 40 && action.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_') && !seen.iter().any(|s| s == action) {
seen.push(action.to_owned());
log::info!("JSON action on {} channel: action={}", if channel_name.contains("STREAMER") {"STREAMER"} else if channel_name.contains("TEXT") {"TEXT"} else {"other"}, action);
} }
} }
if channel_name.contains("CONTROL") { if let Ok(crate::control_protocol::ControlMessage::Input(crate::control_protocol::ControlInput::TextInput {text})) = crate::control_protocol::decode_control(&msg.data) {
match crate::control_protocol::decode_control(&msg.data) { if let Some(session)=message_input_session.as_ref() {
Ok(crate::control_protocol::ControlMessage::Input(event)) => { let (session, input) = (session.clone(), input_worker.clone());
// A ready compositor source remains controllable on its lock screen. let _ = tokio::task::spawn_blocking(move || {
if screen.backend == crate::desktop_backend::DesktopBackend::Portal session.with_input(|| {
&& (screen.init_error.is_some() || !desktop_ready) { return; } if crate::wayland::input_ready() { input.text_input(&text); }
if !crate::wayland::input_ready() {return;} });
use crate::control_protocol::ControlInput; }).await;
// Separate receipt budgets keep motion floods from hiding clicks.
static RECEIPTS: [std::sync::atomic::AtomicUsize; 3] = [const { std::sync::atomic::AtomicUsize::new(0) }; 3];
let (slot, kind) = match &event {
ControlInput::MouseButton {..} | ControlInput::MouseClick {..} => (0, "button"),
ControlInput::Keyboard {..} | ControlInput::KeyboardClick {..} | ControlInput::TextInput {..} => (1, "keyboard"),
_ => (2, "motion"),
};
if RECEIPTS[slot].fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
log::info!("CONTROL input received: kind={}", kind);
}
if let Some(session)=message_input_session.as_ref() {session.with_input(|| {
if !crate::wayland::input_ready() {return;}
match &event {
ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,crate::wayland::input_size(if live_x11 {crate::capture::x11_last_size().unwrap_or(input_size)} else {input_size})),
ControlInput::MouseRelative {dx,dy} => input_worker.mouse_relative(*dx,*dy),
ControlInput::MouseScroll {dx,dy} => input_worker.mouse_scroll(*dx,*dy),
ControlInput::Keyboard {key, pressed} => input_worker.windows_key_event(*key, *pressed),
ControlInput::TextInput {text} => input_worker.text_input(text),
ControlInput::KeyboardClick {key} => {input_worker.windows_key_event(*key, true);input_worker.windows_key_event(*key, false);},
ControlInput::MouseButton {button,pressed} => input_worker.wire_mouse_button(*button,*pressed),
ControlInput::MouseClick {button} => {input_worker.wire_mouse_button(*button,true);input_worker.wire_mouse_button(*button,false);},
_ => {}
}
});}
},
Ok(crate::control_protocol::ControlMessage::Unsupported(v)) => {
// Action name and key names only, never values (an IME text event would carry typed text).
static UNSUPPORTED: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if UNSUPPORTED.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
let action = v.get("action").and_then(serde_json::Value::as_str)
.filter(|a| a.len() <= 40 && a.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_')).unwrap_or("?");
let keys: Vec<&str> = v.as_object().map(|o| o.keys().map(String::as_str).take(12).collect()).unwrap_or_default();
log::info!("Unsupported CONTROL input: action={action} keys={keys:?}");
}
},
_ => {}
} }
} else if channel_name.contains("STREAMER") { }
if channel_name.contains("STREAMER") {
log::debug!("STREAMER channel JSON received"); log::debug!("STREAMER channel JSON received");
if let Some(event)=val.get("connection_period_stats_event") { if let Some(event)=val.get("connection_period_stats_event") {
let nums=crate::viewer_metrics::collect(event); let nums=crate::viewer_metrics::collect(event);
+60 -1
View File
@@ -17,6 +17,11 @@ struct Viewer {
} }
async fn connect(desktop: bool, portal: Option<Arc<crate::desktop_session::PortalDesktop>>) async fn connect(desktop: bool, portal: Option<Arc<crate::desktop_session::PortalDesktop>>)
-> (WebRtcSession, Viewer) {
connect_channels(desktop, portal, &["CONTROL_DATA_CHANNEL"]).await
}
async fn connect_channels(desktop: bool, portal: Option<Arc<crate::desktop_session::PortalDesktop>>, labels: &[&str])
-> (WebRtcSession, Viewer) { -> (WebRtcSession, Viewer) {
let input = Arc::new(InputInjector::without_desktop()); let input = Arc::new(InputInjector::without_desktop());
let (host_setting, viewer_setting, router) = crate::test_network::virtual_network().await; let (host_setting, viewer_setting, router) = crate::test_network::virtual_network().await;
@@ -26,7 +31,7 @@ async fn connect(desktop: bool, portal: Option<Arc<crate::desktop_session::Porta
let pc = Arc::new(APIBuilder::new().with_setting_engine(viewer_setting).build().new_peer_connection(RTCConfiguration::default()).await.unwrap()); let pc = Arc::new(APIBuilder::new().with_setting_engine(viewer_setting).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
let (tx, messages) = mpsc::unbounded_channel(); let (tx, messages) = mpsc::unbounded_channel();
let mut channels = HashMap::new(); let mut channels = HashMap::new();
for label in ["CONTROL_DATA_CHANNEL"] { for &label in labels {
let channel = pc.create_data_channel(label, None).await.unwrap(); let channel = pc.create_data_channel(label, None).await.unwrap();
let (tx, name) = (tx.clone(), label.to_string()); let (tx, name) = (tx.clone(), label.to_string());
channel.on_message(Box::new(move |message| { channel.on_message(Box::new(move |message| {
@@ -227,3 +232,57 @@ async fn tool_peer_applies_capture_settings_without_a_desktop() {
viewer.router.lock().await.stop().await.unwrap(); viewer.router.lock().await.stop().await.unwrap();
}).await.expect("tool capture-setting regression exceeded deadline"); }).await.expect("tool capture-setting regression exceeded deadline");
} }
/// Exercise the locally patched notifications and close handler through real SCTP,
/// alongside the upstream CONTROL drain. No cloud or live host session is used.
#[tokio::test]
async fn terminal_notifications_and_disconnect_preserve_control_channel() {
use crate::terminal::{self, TerminalConn};
tokio::time::timeout(Duration::from_secs(20), async {
let id = u32::MAX - 100;
struct Cleanup(u32);
impl Drop for Cleanup {
fn drop(&mut self) {
let (tx, _rx) = mpsc::unbounded_channel();
TerminalConn::new(tx).handle(&terminal::encode(terminal::KILL_REQ, 999,
serde_json::json!({"session_id": self.0}).to_string().as_bytes()));
}
}
let _cleanup = Cleanup(id);
let (host, mut viewer) = connect_channels(false, None,
&["CONTROL_DATA_CHANNEL", "BINARY_DATA_CHANNEL"]).await;
viewer.channels["BINARY_DATA_CHANNEL"].send(&terminal::encode(terminal::OPEN, id,
br#"{"cols":80,"rows":24,"shell":"/bin/sh"}"#).into()).await.unwrap();
tokio::time::timeout(Duration::from_secs(3), async {
let (mut opened, mut notified) = (false, false);
while !(opened && notified) {
let (label, bytes) = viewer.messages.recv().await.expect("terminal channel closed");
if label != "BINARY_DATA_CHANNEL" { continue; }
if let Some(frame) = terminal::decode(&bytes) {
if frame.kind == terminal::OPEN_RESP && frame.session == id {
assert_eq!(serde_json::from_slice::<serde_json::Value>(&frame.payload).unwrap()["code"], 0);
opened = true;
}
} else if body(&bytes, 28) == Some(&[][..]) { notified = true; }
}
}).await.expect("open response and list notification must both reach the viewer");
let state = || {
let (tx, mut rx) = mpsc::unbounded_channel();
TerminalConn::new(tx).handle(&terminal::encode(terminal::LIST_REQ, 998, &[]));
let frame = terminal::decode(&rx.try_recv().unwrap()).unwrap();
serde_json::from_slice::<Vec<serde_json::Value>>(&frame.payload).unwrap().into_iter()
.find(|s| s["session_id"] == id).unwrap()["state"].as_str().unwrap().to_owned()
};
assert_eq!(state(), "running");
viewer.channels["BINARY_DATA_CHANNEL"].close().await.unwrap();
tokio::time::timeout(Duration::from_secs(3), async {
while state() != "detached" { tokio::time::sleep(Duration::from_millis(20)).await; }
}).await.expect("channel closure must detach its terminal session");
viewer.channels["CONTROL_DATA_CHANNEL"].send(&echo_request(123).into()).await.unwrap();
assert!(receive(&mut viewer.messages, 3, Duration::from_secs(3)).await.is_some(),
"terminal closure must leave CONTROL responsive");
viewer.pc.close().await.unwrap();
host.pc.close().await.unwrap();
viewer.router.lock().await.stop().await.unwrap();
}).await.expect("terminal lifecycle regression exceeded deadline");
}