d987941e57ed06c307ec26c98435e076db31ea5f
145
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
db4543ad54 | Release v1.4.3 | ||
|
|
4456467c50 |
Fix(client): build on macOS after the pthread_t cast
The macOS client failed to compile at client/IOCPClient.cpp:788: static_cast from 'pthread_t' (aka '_opaque_pthread_t *') to 'uintptr_t' is not allowed. Darwin defines pthread_t as a pointer, while Linux and Android define it as an integer, so routing it through uintptr_t refused to build there. On POSIX the stored value is only a non-null "a worker thread exists" marker: CloseHandle and SAFE_CLOSE_HANDLE are no-ops, and nothing ever dereferences it. reinterpret_cast<HANDLE> accepts both shapes — integer to pointer on Linux/Android, pointer to pointer on macOS — so the same line now compiles everywhere. IOCPUDPClient.cpp had the identical cast and got the same one-line change; it is not in any current build list, but it would hit the same error if it were. Verified with a green Linux client rebuild (integral pthread_t). Not yet built on a real Mac. Co-Authored-By: deepseek-flash |
||
|
|
b743de6747 |
Feat(client): add TLS transport to the macOS client
macOS shares the Linux transport: TlsChannel.h now dispatches __APPLE__ to the OpenSSL implementation, so handshake, pinned trust anchor, reload and removal all come from client/TlsChannelLinux.cpp. Only the platform glue is new: ConfigDir() follows initConfigPaths (HOME, then getpwuid(), then /tmp; no XDG) so the anchor sits next to config.conf, and ExeDir() uses _NSGetExecutablePath. First connect stays plaintext. The operator turns TLS on from the online list: COMMAND_TLS_ENABLE carries the anchor PEM, COMMAND_TLS_DISABLE removes it. macos/main.mm saves the anchor, calls TlsReload() and only reconnects when the transport actually changed, so re-saving the same anchor does not drop a live session. RES_TLS is filled from TlsEnabled() and refreshed on every reconnect; fillLoginInfo clears szReserved first now, because AddReserved appends and it runs twice on a group change. CMake builds arm64 only (deployment target 11.0) and links Homebrew openssl@3 statically when libcrypto.a is present, so the binary carries no Homebrew path dependency. Not built or run on a Mac yet: the Apple branch was syntax-checked under WSL and the login refresh probe-tested; macos/README.txt has the build and verify steps. Co-Authored-By: deepseek-flash |
||
|
|
3d87ec6720 |
Fix(client): detach the receive thread instead of leaking one per connection
CloseHandle and SAFE_CLOSE_HANDLE are empty off Windows, so the POSIX receive thread is never released: nothing detaches it and nothing joins it. Every IOCPClient keeps one thread for good, and each screen, file, shell or log sub-connection constructs a fresh IOCPClient. Once the leak reaches RLIMIT_NPROC, pthread_create returns EAGAIN, std::thread throws, and OnServerReceiving's catch(...) swallows it: every command that spawns a worker goes quiet while COMMAND_SYSTEM keeps working. Observed on a Mac after six weeks: 2048 threads against a 1333 limit. Detach the thread right after creation so it is reclaimed when it returns; the destructor still waits on m_bWorkThread, so nothing else changes. Also log the pthread_create failure that used to be silent, and publish S_STOP as the very last write in WorkThreadProc: the destructor reads it as "thread is gone" and frees this, so the m_bIsRunning that used to follow it could land in freed memory. Two smaller fixes on the same sub-connection path: - common/sub_conn_thread.h never called SetDefaultProto, so sub-connects fell back to plaintext TCP whatever g_SETTINGS.protoType said: behind a reverse proxy the packet dies before the master (no [ConnAuth] on the server, only "waiting for ack timed out" on the client). Android did. - macos/main.mm and linux/main.cpp log the spawn before starting the worker and catch std::system_error, reporting e.code().value() rather than errno, which libc++/libstdc++ never set here. The macOS skeleton also reports ConnectServer failures and a null createHandler. Co-Authored-By: deepseek-flash |
||
|
|
9fadb58c76 |
Fix(client): rotate HELL header encoding across reconnects
A Release client drew one of the twelve HELL header encodings in the constructor and kept it for life. The Go fallback server latches a type from the first packet and only decodes None..V6, so every client that drew V7..V10 could never log in to it — a third of them, at random, for good. The main connection now advances to the next type when it reconnects after a connection that was never login-acked (CMD_MASTERSETTING), and republishes the accepted type into CONNECT_ADDRESS::szFuture. A type that did log in is kept, so a healthy client no longer churns through values the fallback would reject. Sub-connections, including one-shot ones (file/process/screen), inherit the published value at construction and on every reconnect instead of rolling their own dice. Debug keeps its None..V6-only range; the initial Release type now comes from random_device rather than time() % N, which handed a whole batch started in the same second the same value. The slot sits at szFuture+16, after LOCAL_TEST_CLIENT_MAGIC, guarded by static_asserts; it is memory-only and never persisted or sent. Swapping the encoder is a single atomic function-pointer store, so the send and receive threads see either the old or the new encoder and never a dropped object. Co-Authored-By: deepseek-flash |
||
|
|
51747dc0ea |
Feature: Add on-demand TLS transport with hot-switch to the Android client
Reuse the Linux OpenSSL TlsChannel implementation (platform guard widened to __linux__); the trust anchor lives in the app-private filesDir, injected via TlsSetAnchorDir in nativeInit before the connection thread starts. COMMAND_TLS_ENABLE/DISABLE save/remove the anchor, hot-reload and reconnect only when the transport actually changes, so the master menu takes effect within seconds without restarting the app. Login reports RES_TLS, refreshed before each re-login. The reconnect flag is consumed before the drop check and cleared before reconnecting so a switch racing a disconnect cannot cause an extra reconnect/login cycle. Cross-compile OpenSSL 3.5.0 per ABI with build_openssl_android.sh (NDK clang + MSYS2 perl/make), integrated into build_android_libs.ps1 (-OpenSslOnly). Static libs and per-ABI headers are tracked like the existing libzstd/libsign prebuilts; --exclude-libs keeps OpenSSL symbols private to libyama.so, isolated from the Java-layer Conscrypt. Co-Authored-By: Qoder <noreply@qoder.com> |
||
|
|
5501889d33 |
Feature: Add window-relative remote_mouse coords and PTY pipes in terminal_exec
New Windows clients append an optional 20-byte WINDOWINFO_MCP_DESKTOP block (virtual desktop rect, magic 'VDCP') after the window list, so the server can map window-relative coordinates into the capture frame. remote_mouse accepts an optional window_hwnd; x/y and drag x2/y2 are then normalized against the intersection of the window and the virtual desktop, which is exactly the source rect of get_screenshot mode=window. The target window must be foreground by default, and window_hwnd/expect_hwnd must agree when both are given. structuredContent gains coordinateWindow and resolved (frame coords plus the basis rect), so callers can verify the mapping. terminal_exec now allows pipes, && and || in PTY sessions (ConPTY on Windows, POSIX PTY on Linux) because the sentinel runs on its own line; legacy non-PTY sessions still reject & and |. A read-only PeekTermSession lets the server reject unsupported syntax before BeginTermCommand. POSIX still rejects bare background & (&&, &>, 2>&1 stay allowed). Docs: Mcp_Design.md sections 12.1/20.2/22 and Mcp_Terminal_Design.md 4.4/4.6 are synchronized with the protocol, the new validation order, and the basis rect semantics. Co-Authored-By: deepseek-flash |
||
|
|
235a8a622c |
Feature: Add native region, window and monitor capture to get_screenshot
New Windows clients advertise CLIENT_CAP_SCREEN_REGION and accept a 24-byte ScreenPreviewReqEx appended to the existing 8-byte preview request, so get_screenshot can capture a region, a window or a single monitor at 1:1 resolution instead of only the scaled virtual desktop. Successful v2 responses append an optional ScreenCaptureMeta block reporting the source rect and scale, letting callers map coordinates back for remote input. Old clients and old servers keep the v1 byte stream unchanged. The 8192 px per-side bound only applies to native (1:1) capture, where it guards bitmap memory; scaled captures are unaffected so ultra-wide virtual desktops (for example triple 4K) still produce thumbnails and previews. max_width is clamped to [64,1920] as before instead of rejected, matching the documented schema. Co-Authored-By: deepseek-flash |
||
|
|
b2c0d81396 |
Feature: Add window info RPC for foreground checks and window activation
Add a capability-gated main-connection RPC (COMMAND_MCP_WINDOW_INFO=179 / TOKEN_MCP_WINDOW_INFO=180) that returns visible top-level windows with UTF-8 titles, screen rectangles, foreground flag and z-order, so MCP can verify focus before injecting input. New tool get_foreground_window; host_list_windows switches to the richer fields; host_control_window and operate_window gain action=activate; remote_keyboard and remote_mouse gain expect_hwnd, require_foreground and report_foreground. Old clients keep the previous behavior: the RPC is refused up front via CLIENT_CAP_WINDOW_INFO. The client caps a response at 96 windows (about 101 KB, under MAX_SEND_BUFFER). Signal the cut-off in the mode byte (0x80) instead of silently dropping windows: host_list_windows now reports truncated=true and says the list is incomplete, and activate verification reports state=unknown with reason=list_truncated rather than claiming the window is gone. expect_hwnd is checked only after the session is validated, so an invalid session_id no longer burns a window RPC and no longer reports a window error for a session that does not exist. Nullable output fields (foreground, window) are declared as ["object","null"] so strict clients do not reject responses. Co-Authored-By: deepseek-flash |
||
|
|
5eb44307ee |
Feature: Capture the virtual desktop for multi-monitor remote control
The MCP Observe/Act loop requires screenshots and mouse injection to share one coordinate space. Previously the client sent only the primary monitor while injection used virtual-desktop coordinates, so multi-monitor hosts were rejected outright. - Client: COMMAND_SCREEN_SPY param buffer[11] (wire index 12) now forces whole-virtual-desktop GDI capture; preview JPEGs also cover the virtual desktop including negative origins. - Server: advertise CLIENT_CAP_VIRTUAL_DESKTOP, gate multi-monitor remote control on that capability, and pass the flag when starting the session. Linux stays exempt (X root capture/injection are already consistent). |
||
|
|
5bb24d714a |
Fix: Release remotely injected keys the controller never lifted
A browser or native controller can lose a keyup (window blur, tab switch, browser shortcut, in-app dialog, disconnect). The remote OS then keeps Ctrl/Shift/Alt down, later keystrokes turn into shortcuts, and only pressing the modifier again clears it. The web console now tracks the keys it sent down and releases them on blur, visibilitychange, pagehide, dialog, control off, device switch and disconnect; the next keydown/mousedown/wheel reconciles tracked modifiers against the event's real modifier state. Keys held when the socket drops are stashed and released once the screen session is confirmed after reconnect, tagged with the device so they never reach another host. The Ctrl+V bridge flag is reset wherever its physical keyup can be lost. The Windows client tracks injected keys by VK + scan code + extended bit so right-hand modifiers release the key that was pressed, and releases them on session teardown and reconnect; the Linux agent does the same on teardown with XTestFakeKeyEvent. Verified with a 20-scenario headless Chrome harness, group filter regressions, node --check, go build/vet/test, a Debug client build and the WSL Linux build. Not exercised against a real controller and host; the macOS agent is unchanged. Co-Authored-By: deepseek-flash |
||
|
|
2cbed0dcdf |
Fix: Report process uptime and harden the login reserved list
The "启动信息" elapsed time was computed by subtracting a client-formatted wall-clock string from the master's own local time. Windows clients send their local time, Linux/Android/macOS send Beijing time, so a host whose clock runs ahead of the master (UTC+8 clients on a UTC+1 master, a fast CMOS clock) gave a negative difference that was clamped to 0s — permanently, for that host. Add RES_UPTIME to the login reserved list: the client reports its process uptime in seconds, a difference between two readings of the same clock, so timezone and clock skew cancel out. The master adds the connection's alive time to get the current value, and keeps the old string path as the fallback for clients that do not send the field. That fallback now also treats MAC as Beijing time, which was simply missed. AddReserved() now goes through one bounds-checked append. The separator used to be written without any length check (an overflow aborts the client, which installs no invalid parameter handler), and an over-long value now leaves an empty slot instead of dropping its separator, so positional lookups cannot shift. Verified with an ASan/UBSan test over the encoding boundaries and Debug builds of the client and the master. The Linux/Android/macOS clients only append the same field at the end of the list; they were not compiled here. Co-Authored-By: deepseek-flash |
||
|
|
2e34e49186 |
Fix: Keep the captured monitor stable across restarts
GDI and DXGI each kept their own static monitor index, and DXGI committed the index before its initialization had succeeded. When a quality change restarted capture and DXGI fell back to GDI, the next DXGI attempt read the failed attempt's index and jumped to the other monitor. Both backends now share one process-wide index with separate peek and commit steps, and the commit only happens after the backend is actually up. Manual switching is made a one-shot request: InitScreenSpy consumes the flag and RestartScreen only sets it, so an adaptive restart that lands in the middle of a switch no longer drops the request or re-applies it on every later rebuild. Window capture no longer touches the index at all, so leaving window mode returns to the monitor that was on screen. Also: restart capture on a bitrate change only when the target level is still H.264 (switching to RGB565/DIFF never uses the bitrate), and bound the DXGI output fallback so a session without any enumerable output cannot spin forever in InitDXGI. Co-Authored-By: deepseek-flash |
||
|
|
5f40f3726c |
Fix: React to slow-frame congestion and keep remote audio recoverable
The adaptive quality controller counted only complete frames per second, so when a single frame took several seconds to arrive the sample was 0 fps and the throughput criterion abstained forever: Ultra and High kept flipping while a foreground video played. The audio watchdog had the opposite problem: it rebuilt the WASAPI capture every three seconds on an idle endpoint, and its sleep detector measured the whole loop including a blocking send. Sample the last ten seconds in a ring buffer and feed the criterion a windowed rate, guarded so a scroll burst, a stale window or a few KB clock patch is not mistaken for congestion. Apply the same per-frame floor to the one-second fallback and to the post-downgrade local-bottleneck probe. Normalize delayed timer ticks by real elapsed milliseconds, and make the 40 second upgrade-failure window outlast the resolution cooldown it has to cross. On the client, rebuild only when an audio session is actually rendering, and rebuild immediately when the captured endpoint is no longer the default output; refresh the sleep timestamps on failed as well as successful init. Tests cover the window and fallback helpers directly; the full suite passes 845/845, and both the Debug server and Debug client build. Co-Authored-By: deepseek-flash |
||
|
|
7240879792 |
Fix: Bound the Linux TLS handshake with a deadline
The handshake loop retried SSL_do_handshake on SSL_ERROR_WANT_READ and nothing else. IOCPClient arms the socket with SO_RCVTIMEO for the handshake, and a read timeout surfaces as EAGAIN, which OpenSSL reports as WANT_READ rather than a syscall error. A peer that accepted TCP and then went silent therefore put the loop into an endless retry: the handshake never finished, never failed, and logged nothing, while the main loop sat inside the read. Even SIGTERM could not stop the process, because the exit flag is only observed between heartbeats. Observed on a Linux client moving back to 443 when a transfer expired: frps had the connection ESTABLISHED, the server had sent a partial flight, the client's Recv-Q was empty and its log stopped dead at the reconnect line. Reproduced locally against a TCP server that accepts and never replies: one connection in 75 seconds and no output at all. Give the whole handshake a 30 second budget, longer than the 15 second read timeout so a single wake-up still fits, and treat expiry as a failure the caller can retry. The stalled peer now logs "[TLS] handshake timed out after Ns (peer silent), aborting" and the reconnect loop keeps running. Co-Authored-By: deepseek-flash |
||
|
|
3b3aed50e5 |
Feature: Transfer a Linux host to another master
The Linux client ignored COMMAND_ASSIGN_MASTER, so a host could not be moved to a different controller the way the Windows client allows. The payload is host:port:days:shine[:transport]; the parsing, record encoding and address application live in a shared header so a macOS client can reuse them unchanged. An assignment only rewrites the connection target. The running session stays up and the next reconnect - a dropped link or a restart - goes to the new master, matching the Windows behaviour. The target and its expiry are stored in a single "transfer" config key, while the address the process started with is kept in memory only: the config's own master/port entries are never overwritten, so restarting mid-transfer still has the original to fall back to. When the expiry passes the client restores that address, clears the key and reconnects. Malformed payloads and zero-day assignments are rejected outright. The way back depends on an expiry time, so honouring a permanent move would strand a host on an address it cannot leave. Give the POSIX connect() a timeout as well (non-blocking connect plus poll, 10 seconds). A blocking connect waiting for SYN retransmission froze the main loop for about two minutes when the port was filtered, delaying both heartbeats and the expiry restore. The transfer state is initialised after daemonize() for the same reason it is logged: logging before the double fork can leave the child deadlocked on the logger mutex. Co-Authored-By: deepseek-flash |
||
|
|
a190c21217 |
Feature: make remote desktop tuning per client
The tuning switches lived in the master's Advanced menu and were saved globally, so two hosts could not use different settings. The client already sends ScreenSettings when a remote desktop starts, so the state belongs there: the four items now sit in the remote desktop window's system menu, directly below Screen quality, and are saved per client. ScreenSettings had a 40-byte Reserved area at offset 56; four bytes became TuningFlags, keeping the struct at 100 bytes with Capabilities at 96. A new Capabilities bit marks a value written by a versioned master; old clients, and new clients never configured, report 0 and are not trusted. CMD_SCREEN_TUNING now ends with a version byte. A five-byte command comes from an older master that does not know the server-only adaptive bit: the client applies those three bits to the session but does not save them. A fresh client starts at 0, so an old master still gets pre-feature behaviour; the new master's 0xE default is persisted on its first session. The per-client master copy stays as the old-client fallback, and the old global [settings] Tuning* keys are honoured when neither exists, so an explicit opt-out survives the migration. Verified on the Debug server with the in-process test client: a fresh client stored 0xE on first use; toggling VBV wrote 0xF to both sides; after deleting the master copy and reopening, the menu restored VBV from the client report. Co-Authored-By: deepseek-flash |
||
|
|
f96e4a7320 |
Fix: recover remote desktop audio after dropped formats and sleep
The client's audio thread starts before the capture thread sends TOKEN_BITMAPINFO, so its first packet - the only one carrying the AudioFormat - reaches the master before CScreenSpyDlg exists and is dropped as an unknown command. Without a format the master cannot open waveOut, and the client re-announced only on an audio off/on, so a remote desktop opened with audio enabled stayed silent until the toolbar button was toggled twice. The master now asks for a re-announce when data arrives with no format on record (CMD_AUDIO_CTRL enable, persist=0, one request per 2 s, 15 attempts max), and the client attaches the format to its next packet. Entering Modern Standby tears down the render endpoint. The client got AUDCLNT_E_DEVICE_INVALIDATED and rebuilt its loopback capture in that same instant; the new client initialized and started fine but was bound to the dying audio engine, so after resume GetNextPacketSize returned zero packets forever without error, and only a fresh screen session recovered. The audio thread now measures its own loop gap (GetTickCount64 plus wall clock, 2 s; a normal pass is ~10 ms) and rebuilds the capture client after the machine was frozen, waits a second after an invalidation, and rebuilds on an audio off-to-on. The master rebuilds waveOut on resume from WM_POWERBROADCAST. The format recovery was verified live; the resume recovery is build-verified and awaits a field check on a sleeping machine. Co-Authored-By: deepseek-flash |
||
|
|
74d64fec87 |
Fix: keep remote desktop audio alive when the playback device drops
Remote desktop audio could stop permanently after an idle period and only came back by closing and reopening the remote desktop. The ring buffer and WAVEHDRs were shared without locking between the IOCP worker thread (OnAudioData) and the UI thread (MM_WOM_DONE): headers were queued twice (waveOutWrite returning WAVERR_STILLPLAYING 33) and the non-atomic m_nRingDataLen underflowed, leaving the buffer "full" of stale data. Audio state is now serialized by a recursive m_AudioMutex, and opening, resetting and closing the waveOut device happens only on the window's UI thread: waveOutReset/Close can re-enter the MM_WOM_* handlers on that thread, and a lock-holding worker would deadlock against the UI thread. Workers post WM_AUDIO_INIT_DEVICE instead. Rebuilds are triggered by format changes, waveOutWrite failures (throttled to 2 s), MM_WOM_CLOSE with a 1 s guard against our own close notices, and a 2-second retry while audio is enabled. Failed header preparation now tears the device down instead of leaving a handle that rejects every write. The client re-creates its Opus encoder when the endpoint channel count or sample rate changes, downmixes more than two channels, and clamps oversized WASAPI packets to the PCM staging buffer. Web audio forwarding still runs outside the lock and is gated exactly as before. Verified by building the Debug x64 server and client; the silence scenario itself was not reproduced at runtime. Co-Authored-By: deepseek-flash |
||
|
|
4884b080e8 |
Improve: default the x264 bitrate cap off and label it for weak links
The cap is capped CRF (VBV): when a frame needs more bits than the profile's nominal bitrate allows, x264 has to raise QP to stay under the ceiling. Scenes with lots of change (video, scrolling, window dragging) therefore lose detail and look blurry, while static scenes stay sharp - the cap only bites on motion. That trade is worth it on intercontinental or otherwise constrained links, where an uncapped frame can take seconds to transmit and stall everything queued behind it, but it is a pure quality loss on a LAN. The tuning item now defaults to unchecked, so a master sends 0x3 (GDI no-sleep and send pacing) by default; machines that already stored TuningX264Vbv keep their explicit choice. The menu entry is renamed to "x264 码率封顶 (VBV,仅限洲际弱网)" and the en_US, zh_TW and de_DE translations were updated to match the new source string. Only newly opened remote desktops pick up the flag, since CMD_SCREEN_TUNING is sent when the session starts. Verified by rebuilding the Debug x64 server and client, and by finding the new menu and translation strings in the built binary. Co-Authored-By: deepseek-flash |
||
|
|
f77b18aa68 |
Feature: run a test client inside the master from the Advanced menu
The Advanced menu now ends with Run Test Program. It copies the kernel payload that was already read into memory, points its CONNECT_ADDRESS at 127.0.0.1:<listen port>, and loads it with MemoryLoadLibrary inside the master process, so this machine comes online as a controlled host -- no second machine is needed to try remote desktop or file transfer. A worker thread waits for the client to exit, then frees the module and re-enables the item. Only one instance runs at a time: the item is grayed while it does, and stopping it means uninstalling the test host from the online list. The loaded copy carries LOCAL_TEST_CLIENT_MAGIC in szFuture. The client uses that mark to refuse the commands that would otherwise hit the host process or the whole machine: uninstall (no self_del), update, run as admin, ban, share/assign, and shutdown/reboot/logoff. It also skips auth-kernel detection, which GetModuleFileName(NULL) would misjudge inside the master. Renames szFututre to szFuture and documents that the first 16 bytes of the reserved tail are now claimed, with a static_assert so it cannot silently shrink below the magic. Translations for en_US, zh_TW and de_DE, plus the HIDE_MENU_RUN_TEST feature flag and its row in the limits dialog. Verified on a Debug master: the item is last and has its icon, one click brings the host online, a second click is refused, uninstall stops it in about a second and the master survives, re-run works, and exiting the master with a live test client takes 2.6s (3.0s baseline). Co-Authored-By: deepseek-flash |
||
|
|
6a51116873 |
Fix: repair two quality-switch regressions (monitor jump, H264 stall)
Every quality change restarts the capturer on both sides, and two defects showed up along that path. Monitor jump: on a multi-monitor client the view moved to another monitor. switchScreen=false means "reuse the index", but index is the *next* monitor to switch to, not the one being shown. Track `current` and read it on the non-switch path; the switch path still advances. H264 stall: switching from RGB565/DIFF back to H264 froze the view for up to ten seconds. The client encoder kept its reference frames across the gap, so it emitted P frames the server could not decode until the next natural IDR. It is now rebuilt on the first H264 frame after an algorithm or tuning change. The rebuild is requested with an atomic dirty flag that the capture thread consumes in ensureEncoder(), because resetting the encoder from the network thread raced with encode(). On the server, ApplyQualityLevel() only sets m_bResolutionChanging when the client will really restart the capture: it compares the target maxWidth with the client's reported bitmap width (cached atomically on TOKEN_BITMAPINFO) and stays conservative while a previous resize is still in flight. The fallback timeout drops from 5s to 1s, flushes the decoder and asks the client for a keyframe (COMMAND_SCREEN_KEYFRAME_REQ). Verified: Debug client and server build clean; the 1920-wide High->Good switch no longer waits out the gate. Not yet retested on a live session. Co-Authored-By: deepseek-flash |
||
|
|
ca4e85826f |
Feature: remote desktop tuning flags, on by default with per-item opt-out
Adds "Advanced -> Remote desktop tuning" with three independently checkable items, all enabled by default: x264 bitrate cap (VBV) TUNING_X264_VBV 0x1 GDI capture: no slice delay TUNING_GDI_NO_SLEEP 0x2 Send pacing FPS floor TUNING_PACE_FPS_FLOOR 0x4 Unticking an item clears its bit and restores the pre-commit behaviour exactly, so the escape hatch is one click per measure -- no rebuild, no config edit. Each bit is independent; a problem with one does not force turning all three off. Plumbing -------- Menu state -> [settings] Tuning* -> CMy2015RemoteDlg::GetScreenTuningFlags() -> CScreenSpyDlg::SendScreenTuning() (right after TOKEN_BITMAPINFO) -> CMD_SCREEN_TUNING = 178 [cmd:1][flags:4 LE] -> CScreenManager::OnReceive -> m_nTuningFlags -> ScreenCapture::SetTuningFlags Why it is safe to send to old clients: CScreenManager::OnReceive has no default branch in its switch, so an unknown command falls straight out (verified). 178 was unassigned (177 = COMMAND_SET_PROTO, 199 = TOKEN_DECRYPT), and the enum re-anchors explicitly so nothing auto- increments onto it. Flags are sent even when all-zero on purpose: the client's flag lives in CScreenManager, which survives closing and reopening the remote desktop window on the same connection. Without the zero send, unticking the menu would leave the previous flags in effect. Per-measure notes ----------------- VBV: capped CRF (peak = target, 0.5s buffer, init 0.9). The hardware paths already cap via rc_max_rate (1.5x, 1s buffer); this is tighter and only affects x264. After an IDR the buffer drains and takes up to 0.5s to refill, so a brief quality dip follows every keyframe -- if that shows up, relaxing to 1.5x/1s would match NVENC/QSV. GDI: keeps the 50-line BitBlt slicing (large single BitBlts hit driver limits) and only drops the 5ms sleep between slices -- 1080p is 22 slices = a forced 110ms per frame against a 50ms budget at 20fps. Pacing: clamps s0 to 2x the base interval instead of 4x (2fps -> 4fps), taken as max(2x base, 1000/MaxFPS) so it never exceeds the configured MaxFPS. The growth/decay code itself is untouched. This one works against the loop's own congestion signal, so it is the first to untick if a bad link feels laggier rather than smoother. SetTuningFlags only rebuilds the encoder when TUNING_ENCODER_BITS (currently just VBV) changes -- the GDI and pacing bits are read live by the capture and send threads, and rebuilding for them would drop an IDR and visibly flash the picture. Defaults: the on-by-default value lives in the third argument of THIS_CFG.GetInt(), which only applies when the key is absent. A machine that already has an explicit 0 keeps it, so the flip is not retroactive and a test machine can end up with a mixed state. Verified on the Debug build: with no Tuning* keys all three items start checked; unticking VBV alone leaves the other two checked and survives a restart; en_US/de_DE/zh_TW translations all resolve. Not yet measured end to end on a real remote desktop session. |
||
|
|
c66f410831 |
Feature: Embed the server TLS certificate in delivered DLLs
Add a "高级 → DLL内嵌TLS证书" toggle (off by default, persisted as
[settings] EmbedTlsInDll). When it is on, ReadKernelDll patches the server's
current TLS anchor into the ServerDll and ShellCode payloads, so clients that
come online through the loaders start their own session over TLS without
waiting for an online push. The plaintext DLL loader in client/main.c is
untouched; only the DLL's fresh connection is protected. The write happens
after SetServer and before CalcMD5FromBytes, and the anchor records the host
part of the master address rather than "ip:port" because the client matches
the anchor against its configured address set. TinyRun has no anchor block and
keeps working as before.
Toggling the switch, and confirming the certificate dialog, rebuild the six
payloads in place, so no server restart is needed after a certificate change.
The payload pointers are replaced as a whole, and the network threads that read
them (SendServerDll and TOKEN_GETVERSION) now take a dedicated critical section
for the full duration of use.
COMMAND_UPDATE no longer clears the tls_disabled marker on the client. Now that
any delivered DLL may carry the anchor, "the payload has an anchor" no longer
means the operator opted this host into TLS, and clearing the marker would
silently flip a host that was explicitly set to plaintext onto TLS against a
plaintext path. Re-enabling TLS stays an explicit action through
COMMAND_TLS_ENABLE and COMMAND_SET_PROTO, which still clear the marker.
Menu and notice strings were added to en_US, zh_TW and de_DE, and the embedded
TLS design document records the new switch and the revised update semantics.
The new menu entry also takes a feature-limits slot so a subordinate master
can hide it like every other 高级 item (see
|
||
|
|
8b92f32c47 |
fix(config): stop reads from creating empty registry subkeys
iniFile/binFile::GetCachedKey used RegCreateKeyExA for every access, so a plain GetStr/GetInt on a missing section materialised an empty subkey. CScreenManager's constructor calls LoadQualityProfiles() unconditionally, which reads profile0.. profile5 x4 keys, so every client start left six zero-valued subkeys behind: 126 of them on the dev box, all with zero values. The server's HKCU\SoftwareYAMA\quality key is the same artefact. Split the helper by intent: writes go through RegCreateKeyExA, reads through RegOpenKeyExA. Both still ask for KEY_READ|KEY_WRITE, because the handle cache is shared and a read-only cached handle would make a later SetStr on the same section fail. Also fixes a second bug in SaveQualityProfiles: when a level matched the default it simply continued, so a level the operator reset to default kept the old custom values in the registry and the reset never took effect. Add SectionExists() (open-only, never creates) and write the defaults back when the section already exists. |
||
|
|
454d25d37f |
fix(share): carry the transport in the share and assign payloads
The share payload was host:port:shine and carried no transport at all, so a
shared client fell back to its baked-in protoType. Share instances also skip
ApplyProtoSwitch (ClientDll.cpp:810), so a client upgraded to WSS was shared
to a TLS front end as raw TCP and looped on HTTP/1.1 400.
Extend both payloads with an optional trailing transport field:
share : host:port:shine[:transport]
assign : host:port:days:shine[:transport]
The field is omitted when the source protocol is not TCP/WS/WSS, so HTTP/UDP/
KCP hosts keep their previous behaviour instead of being silently downgraded
to plain TCP.
- server: add SelectedShareTransport(), share it between OnOnlineShare and
OnOnlineAssignTo, and accept a tcp:// ws:// wss:// prefix in the address.
- client: parse the field on both paths and persist the assigned value to
settings/master_transport, clearing it when the field is absent.
- share_list: dedup on host:port instead of the whole record, so re-sharing
a host with a different transport replaces the stale entry.
- assign: guard bToken[_MAX_PATH] against the longer payload.
- lang: translate the reworded prompt and the three new messages in en_US,
zh_TW and de_DE.
Transport is pinned at share time and does not follow a later protocol switch
on the master link; the m_bShared gate stays as-is on purpose.
|
||
|
|
951b4072e5 |
Feature: Embed the master's TLS certificate in generated clients
When the server has TLS enabled, the builder can now bake its certificate into the client it produces, so a distributed client speaks TLS on its very first connection instead of waiting for the anchor to be pushed after a plaintext login. The dialog gets a checkbox (IDC_CHECK_TLS_ANCHOR) that is only enabled for payloads and protocols where an embedded anchor makes sense; the choice is remembered even when the control flips to disabled and back, so switching protocols cannot silently undo a deliberate opt-out. Every label variant stays short enough to fit the 196 DLU field, including the German ones. A template that predates the anchor block no longer aborts generation: it warns, clears the checkbox and produces a plain client, so a master upgraded without rebuilding the ghost/ServerDll resources does not block every build. The certificate lands in a fixed 4 KiB block (magic, version, length, FNV-1a hash, master address, PEM) carved out of the payload at build time. The client reads its trust anchor from four sources in order: the tls_disabled marker, the certificate the server pushed into the registry, a PEM file next to the executable, and finally the embedded block. The embedded block only applies to a connection whose target matches the master recorded at generation time, compared as an address set: an exact string match when only one address is configured, or an intersection of resolved IPv4 addresses otherwise. A transferred, shared or parallel instance falls back to the old plaintext first-connect path instead of pinning itself to a certificate it can never verify. That decision is made per connection, not per process: shared and parallel instances are threads inside a single client process, so a process-wide flag let whichever instance connected first decide for all of them, and the first load of the TLS state cached that answer for good. The TLS layer now keeps two cached states (embedded anchor allowed, and not allowed), picks one per handshake, and reports the anchor source of that handshake for the login capability bit. Matching by resolved address also keeps parallel mode working, where the connection goes to the single IP the domain pool selected while the configured master is a domain or a list. Server side, generated and updated payloads get the block written in place; the client reports the capability bit on login so the console can tell which hosts are already TLS-only on first connect. Loading the anchor decodes every PEM block in the chain rather than just the leaf, and an anchor that exists but fails to load keeps the old fail-closed behaviour. A pushed anchor only reconnects when the transport of the live connection actually changes, judged against that connection's own target rather than the process-wide switch. This was verified end to end against a freshly generated client with an empty registry: the first connection was a TLS 1.2 ClientHello 0.2 s after start, and a four-certificate fullchain loaded all four blocks. Re-verified after the per-connection rework with the anchor block patched into a debug client: with a matching master the first bytes are a ClientHello, with a foreign master the client logs the skip and sends plaintext, and a domain master resolves to the IP it connects to and still matches. A master domain that no longer resolves falls back to plaintext within a second and is not looked up again for a minute, instead of stalling every reconnect on a DNS timeout while holding the lock the certificate verification needs. Co-Authored-By: deepseek-flash |
||
|
|
c4021e1fc9 |
Feature: Ship a built-in TLS certificate so encryption works out of the box
A fresh install used to require openssl before the server could speak TLS: two empty paths in [tls] meant the identity failed to load and every ClientHello was refused. TLS is now on by default and, when no custom certificate is configured, the server generates its own self-signed one the first time it needs it -- RSA-2048, SHA-256, CN=yama-server, CA:TRUE, valid for ten years from one day before now. Plaintext clients are untouched, since the device port still splits plaintext from TLS by sniffing the first six bytes of a connection. The certificate and its PKCS#8 private key are stored side by side in the config under [tls] BuiltinCert / BuiltinKey as single-line base64 DER. Single line, because the server has two config backends -- the registry for Release, settings.ini for a Debug master -- and only a line without newlines means the same read/write code serves both. That in turn required fixing the registry reader: iniFile::GetStr copied into a 512 byte stack buffer, so a 1.5 KB value came back as a truncated or empty string. The two-phase dynamic read now lives in common/iniFile.h as ReadRegistryValueSz / ReadRegistrySz, and the copy that client/TlsChannel.cpp had been carrying for its own trust anchor is gone. This also makes the built-in certificate self-checking: Ensure() re-reads what it just wrote and fails loudly if the round trip did not survive. Import has to go through NCRYPT_PKCS8_PRIVATE_KEY_BLOB, matching the import path in BuildIdentityFromDer. NCRYPT_PKCS8_PRIV_KEY_INFO_BLOB, which most samples reach for, is not implemented by the Microsoft Software KSP and returns NTE_INVALID_PARAMETER; a probe confirmed it, and the export type that works is the one the importer already expected. Building an identity is now split into a file front-end (PEM, fullchain, PKCS#1 hints) and a shared DER core, so the built-in and file paths cannot drift apart. That key also exposed a second problem worth fixing here. The identity binds its private key to the certificate by name -- CRYPT_KEY_PROV_INFO with pwszContainerName -- and Schannel resolves that name on every handshake through CryptAcquireCertificatePrivateKey. With the fixed name "YamaServerTlsKey", two server processes under the same Windows user shared one key slot: whichever loaded last overwrote it, and the other process's next handshake picked up a private key that does not match its certificate. That is exactly the debug-plus-release pairing used here, and defaulting to a built-in certificate is what makes it reachable, since the debug instance no longer points at the same PEM as the release instance. The name is now the base name plus the first six bytes of the certificate's SHA-1 thumbprint, e.g. YamaServerTlsKey-c0d469eae8a4: different certificates get different keys, instances sharing one certificate still share one key. MCP picks this up too. The effective name goes to the trace log so a collision is visible without a debugger. A stale key from an older build may still sit in the key store under the old name; nothing references it and it is not deleted automatically, since a running instance of an older build could be using it. The trust anchor still has to be pushed. The client pins exactly one root through an exclusive-root chain engine and checks no host name, so a self-signed CA:TRUE leaf chains cleanly to itself -- but only if the client is told about it. That is the existing 启用 TLS / 切换到 WSS command, which now takes the PEM from ServerTlsIdentity::AnchorPem instead of re-reading the configured cert file, so it reports the same certificate the server actually serves for both sources. Losing the stored certificate (cleared registry, new Windows user) regenerates it, and every client must be re-pushed the anchor. Two places that used to fall back to [tls] CertPath now skip that fallback while the built-in certificate is active: the MCP HTTPS front end at startup and the prefill in its settings dialog. A self-signed certificate cannot pass validation at a public MCP client, and the retained CertPath is only a leftover from switching back to a custom certificate, so pretending to use it would fail later with a worse message. MCP HTTPS with empty paths already fails closed with a log line. The TLS dialog gains a 内置证书 checkbox, ticked by default and unticked when certificate paths are present; ticking it greys out the path rows without clearing them, and shows either "generated on first use" or the expiry date read back from the stored certificate. Saving writes four keys -- Enabled, UseBuiltIn, CertPath, KeyPath -- and an explicit UseBuiltIn keeps the paths from being used as an implicit switch. Every reader of [tls] Enabled now defaults to 1, so the menu check, the dialog and the loader agree on a fresh install. The status bar panes on 无 / 有 grew a third state, 内置, and the pane width is measured across all three. Translations were added to en_US, zh_TW and de_DE; skipping the German file would have left the new dialog text in Chinese there, as de_DE is loaded from disk rather than embedded. Verified with the debug server against openssl s_client. Both the generated built-in certificate (CN=yama-server) and an existing custom one (CN=localhost) complete a TLS 1.2 handshake with the pinned certificate, and their log lines show distinct key names, c0d469eae8a4 and 272f2adfb19c. An unmodified client still runs in plaintext without an anchor, an existing custom certificate deployment behaves exactly as before, and client and server both build clean at Debug x64. Co-Authored-By: deepseek-flash |
||
|
|
e99092ca70 | Release v1.4.2 | ||
|
|
36ae4b3057 |
fix(client): stop the reconnect loops from spinning when the master restarts
On a master restart the client receives SERVER_EXIT and KernelManager sets
g_bExit = S_SERVER_EXIT. IsClientAppRunning() compares against S_CLIENT_NORMAL,
so it flips to false immediately and the worker starts tearing down -- but
g_bThreadExit is only cleared at the very end of StartClient. Throughout that
window TestRun() still sees IsThreadRun() == TRUE and takes its early-return
path.
The loader's reconnect loop deliberately does not wait in the S_SERVER_EXIT case
("reconnect immediately, do not wait for share instances"), and its else branch
was empty, so it re-entered TestRun() with no delay whatsoever. Measured on a
live host: 919 identical "TestRun SetServer[91.99.165.207:443]" lines inside a
single second, 960 on its second instance. The client ring buffer holds 1000
lines, so that burst erased the entire history -- which is why nothing from
before the restart could be inspected afterwards. IsStoped() cannot gate this:
it returns true unconditionally while g_bExit == S_SERVER_EXIT, conflating
"worker exited" with "master restarted".
- test.cpp: sleep 20ms in the S_SERVER_EXIT branch. The sleep runs concurrently
with the worker's teardown rather than after it, so reconnecting is delayed by
at most one 20ms tick.
- ClientDll.cpp TestRun(): log only when SetServer() reports the address really
changed. It returns false for a null address, which also silences AutoRun's
TestRun(NULL, 0) calls. Nothing is lost: the restart itself is already logged
as "======> Server exit" in KernelManager.
- ClientDll.cpp AutoRun(): its do/while had no sleep either. Gate it on "still
in S_SERVER_EXIT and a worker is still running" so the normal path stays
zero-delay.
Together these turn a burst that wiped the log buffer into silence, and cap the
loop at 50 iterations per second instead of roughly 900. A worker that hangs
during teardown still burns a core; curing that needs the thread-alive state
exposed separately from IsStoped(), which is an interface change and is left out.
Co-Authored-By: deepseek-flash
|
||
|
|
96f1bacd43 |
fix(client): use GDI capture when the session has no interactive desktop
A host whose DXGI initialisation hangs never opens the remote desktop window at all. WorkThreadProc runs InitScreenSpy() and SendBitMapInfo() back to back, so a capturer that never finishes constructing means TOKEN_BITMAPINFO is never sent, and the master - which only opens the window on that token - waits forever. On the affected Server 2022 box the screen thread stopped right after logging its type and algorithm, printing neither the DXGI init summary nor the existing "DXGI SPY init failed" fallback, so it was stuck inside the capturer constructor; a healthy machine on the same build reaches the summary in under a second. Six clicks left six stuck threads, each holding a D3D device. DXGI desktop duplication needs a display to duplicate. With no interactive desktop it can return no frames at best, and on some drivers it never returns from the initialisation calls at all. BitBlt has no such dependency and keeps working, which is why switching the screen type to GDI made the same host connect. Detect that up front and pick GDI instead of relying on a hang to be survivable: - IsWorkstationLocked() - the input desktop is Winlogon. Moved out of CKernelManager into Manager.cpp so the capturer can use it too; the manager keeps its private wrapper for the "Locked:"/"Inactive:" activity string. - IsCurrentSessionDisconnected() - the process's own session is WTSDisconnected. That is the state the reported host was actually in: its client runs in session 2, which was disconnected, and the desktop only came back after the master's "RDP session reset" ran tscon. Session 0 has no disconnected state and is left alone. Either condition means the same thing for capture, so both route to the plain GDI capturer. An active session keeps DXGI untouched, so hosts that work today are unaffected; the new log line names which condition fired. Co-Authored-By: deepseek-flash |
||
|
|
389de9d456 |
fix(client): fall back to GDI capture when DXGI duplication yields no frames
Some environments never deliver a frame from IDXGIOutputDuplication::AcquireNextFrame: headless or virtual displays, Session 0 desktops, and drivers that do not push duplication notifications. It returns DXGI_ERROR_WAIT_TIMEOUT forever, even while the desktop is changing. Consequences: - The first screen could not be captured, so the server kept showing "Please wait..." because m_bIsFirst was never cleared. - Adding a GDI fallback for the first screen alone was not enough: the picture appeared but then froze, because ScanNextScreen still polled DXGI and always got nothing back, leaving the encoder without input. Fixes: - Add CaptureByGDI(), which grabs a frame with GetDC(NULL) + CreateDIBSection + BitBlt. GDI does not depend on desktop changes, which is why the plain GDI capture path always worked in these environments. - When the first screen cannot be obtained from DXGI, capture it with GDI and mark the whole session as GDI (m_bGDIFallback = true), releasing the duplication object. All later frames then go through GDI so the picture keeps updating. - Normal machines are unaffected: if DXGI delivers the probe frame or the first screen, the flag stays false and the GDI path is never entered. This also avoids mis-detecting a momentarily static desktop as a broken duplication, which a plain timeout counter would do. - Create the GDI offscreen DIB lazily and reuse it (m_hGdiMemDC, m_hGdiBmp, m_pGdiBits). The fallback is a per-frame path, so allocating and freeing about 15MB every frame would cause visible jitter. - Reuse m_BitmapInfor_Full for CreateDIBSection instead of building a second BITMAPINFO: it is already 32bpp BI_RGB with a positive height (bottom-up) and matches the surface size. - Guard the GDI buffer readiness check. If CreateCompatibleDC or SelectObject fails, drop the bitmap so the next call does not mistake a half-initialized state for a usable one; otherwise BitBlt would silently write nowhere and memcpy would read uninitialized memory. - Restore the previous bitmap before DeleteDC and check for HGDI_ERROR, otherwise DeleteObject on the still-selected bitmap fails and leaks it. The fallback matches the plain GDI capture path (full-size BitBlt plus ScaleBitmap), so a downgraded session performs the same as GDI mode. The only added cost versus DXGI is one BitBlt per frame. |
||
|
|
bc75e1ae99 |
fix(client): fix DXGI black screen on rotated displays and slow first frame
1. Black screen on rotated displays Root cause: with DXGI Desktop Duplication on a rotated output, DXGI_OUTDUPL_DESC.ModeDesc reports the logical desktop size (e.g. 1440x2560) while the surface returned by AcquireNextFrame is the unrotated landscape bitmap (2560x1440). The old code created cpuTexture from the ModeDesc size. On a mismatch ID3D11DeviceContext::CopyResource returns void and silently copies nothing, leaving the destination texture all zeros, so the first screen and every H.264 frame were fully black (IDR was only 5KB). The GDI path does not go through DXGI and was unaffected; the web client uses the DIFF algorithm and was hit too, but looked different. Fixes: - Create cpuTexture from the real D3D11_TEXTURE2D_DESC; when the probe fails, derive the real surface size from Rotation instead of falling back to ModeDesc, which would reintroduce the black screen - Add BlitRotated() to upright the image for ROTATE90/180/270, with a whole-row memcpy fast path for IDENTITY; m_ulFullWidth/Height now hold the upright logical size - Treat DXGI_ERROR_WAIT_TIMEOUT as "no new frame" instead of a failure, so a static desktop reuses the previous frame instead of always returning nullptr - GetFirstScreenData: fix the write offset (start at +1, previously the color channels were all wrong) and report the scaled size instead of the full size, which used to send about 8.5MB of garbage - Validate the frame format against a whitelist; fall back to BGRA and warn for formats that are not 4 bytes per pixel 2. Slow first frame (the probe frame consumed the initial frame) Root cause: the probe frame AcquireNextFrame(500), added to read the real texture description, was released right after use and therefore discarded. But the frame DXGI pushes after DuplicateOutput is often the only frame available on a static desktop. After discarding it, the first-screen AcquireNextFrame always timed out (and that timeout was 1000ms at the time), ScreenManager had already set m_SendFirst = TRUE so it never retried, and the encoder had no input to produce an IDR, so the picture only appeared once the desktop changed. Symptom: MDLL/EXE builds with this fix took a long time to show the remote desktop, while the old build without the probe frame was fast. Fixes: - Keep the probe frame: stash it in m_probeRes without calling ReleaseFrame and let the new ConsumeProbeFrame() fill the first screen once the buffers are allocated, so the first screen no longer depends on the desktop changing - Probe timeout 500 -> 200ms; verify both size and format of the probe frame against cpuTexture and skip consumption on mismatch, otherwise a silently failed CopyResource would be taken as a valid all-black first screen - CaptureFrame: drop "reuseOk ? 100 : 1000" and use a fixed 100ms timeout. The AcquireNextFrame timeout is an upper bound rather than a fixed wait, and blocking on a static desktop only slowed the capture loop down to 1Hz - Retry the first screen up to 3 times on "no new frame" (100ms timeout plus a 20ms gap); skip the capture entirely when the probe frame already filled it - Release m_probeRes in CleanupDXGI and ReinitDuplication so the duplication object can be released 3. Incomplete picture - Add ScreenCapture::FitDefaultSendSize(), which scales proportionally so the long edge stays at or below 1920 and the short edge at or below 1080, for both landscape and portrait. The old min(1920,w) and min(1080,h) clamped the axes independently and broke the aspect ratio: a 1440x2560 portrait desktop was squeezed to 1440x1080, keeping only 42% of the height - Use the same helper for both the GDI and DXGI paths; common landscape resolutions (1920x1080, 2560x1440, 3840x2160, 1280x720) are unchanged 4. Incidental fixes - CaptureFrame leaked desktopResource when QueryInterface failed, one DXGI resource per failure - Drop the frame and warn when the surface size changes, for example after the user changed the resolution, so BlitRotated does not read out of bounds using stale sizes |
||
|
|
46f4bf2dfb |
Fix: Make the WebSocket transport reachable and bounded on every platform
The POSIX clients were built without a connection config - Linux, macOS and Android all construct IOCPClient without the injected CONNECT_ADDRESS - so ConnectServer saw protoType -1 and quietly dialled the master port in plain TCP. Setting protoType to WS in their settings did nothing and logged nothing, and since CLIENT_CAP_PROTO_SWITCH is Windows-only the server could not move them either. Give the client a SetDefaultProto() for that construction path and call it from all three mains before the reconnect loop, with a one-shot log when neither a conn nor a default protocol is available so the silent fallback becomes visible next time. Bound what a peer can make the client read. ReadHeader accepted the 8-byte extended length and rejected only the sign bit, so a frame length of nearly 2^63 kept the connection streaming into a frame that would never end - alive but never delivering another packet. Cap single frames at 256 MB, the same value ServerWsSession already applies to client frames, and drop the connection past it; real traffic is far below that. Stop Reset() from writing the receive thread's frame state. Disconnect() can run from the heartbeat or command thread, not just the receive thread, so Reset() now only flips the atomic ready flag and a new ResetFrames() clears m_remaining, m_masked and m_maskPos from Handshake() alone, before the receive thread starts reading the socket. Those fields keep a single owner without adding a lock to the receive hot path. Finish a dead WS session instead of leaving it to the keepalive timer. When the session had closed but wsState was still WS_Ready, sends were dropped and nothing woke the pending recv, so a peer that closed and then went quiet held the context for the 3-minute keepalive. shutdown() the socket there so the recv returns zero bytes and the normal -2 teardown runs; RemoveStaleContext would deadlock against the caller's own IoRefCount and can hand back a reused context. That shutdown only finishes the connection if a zero-byte read still tears it down, and on the plain path it no longer did. DispatchPlain answers an empty buffer with "handled", so a peer's FIN left the connection in CLOSE_WAIT until keepalive - holding an IOCP context, a pending WSARecv and a rate-limit slot - where the pre-WS code called ParseReceivedData and tore down at once. Restore that teardown on the TLS_Plain branch, matching the other two. Checked against a Debug server: a plain socket that half-closes used to sit in CLOSE_WAIT with the peer's recv timing out, and now disappears immediately with recv returning zero. Two smaller cleanups from the same review. Give the WS upgrade its own prefix buffer (wsPreClassify) instead of borrowing the TLS sniffer's, which was serially reused for two state machines and read as if it were one. And stop deriving the build dialog's protoType from the combo box index: items now carry the protocol value as item data, keyed off the index AddString returns, so inserting an option in the middle can no longer write the wrong number into the generated client without any error. ApplyProtoSwitch loses its bool return, which contradicted its own side effects and was ignored by every caller. Co-Authored-By: deepseek-flash |
||
|
|
50a489e316 |
Fix: Close the gaps the WebSocket transport review found
Three of the findings only bite in deployment. First, the client's TLS and WebSocket handshakes run synchronously on the reconnect thread with no socket timeout, so a peer that accepts TCP and then goes quiet (black-holed proxy upstream, middlebox that only receives) blocks recv() forever and stalls the reconnect loop until the process is restarted. Set a 15 s SO_RCVTIMEO and SO_SNDTIMEO for the handshake window - the same value both server handshake threads use - and clear them once the connection is up so the worker thread's select plus blocking recv keeps working as before. Second, per-IP rate limiting counted the getpeername address before the real device was known. Behind a same-host reverse proxy that address is loopback, which IPWhitelist always trusts, so WS traffic was neither counted nor banned; behind a remote proxy every device shares one bucket, and tripping the threshold disconnected all of them. Count and ban by the forwarded device IP once the upgrade resolves it, mirroring the Go server's limitDirectPeer and handleConnection split. Direct connections keep their accept-time count and are not counted twice. Third, the protocol switch disarmed its five-minute auto-revert as soon as the new entry connected, which only proves TCP/TLS/WS handshaking finished. If login is never accepted there (wrong backend, reverse proxy pointing at some other WS service), the revert could never fire and the client would keep retrying a dead entry. Disarm on the first CMD_MASTERSETTING instead, which the server only sends after adding the host to its online list, and re-check it on every heartbeat so a late one still counts. The smaller items came along: free the handshake parameter when CreateThread fails in both handshake starters, move the WS_Handshaking fail-closed guard ahead of the TLS branch so it also covers WSS (where tlsState is already TLS_Ready), generate the frame mask from a per-channel PRNG inside the send lock instead of an unseeded global rand(), make the transport flags and the WS session's ready flag atomic, drop rather than send unframed application bytes when a WS session has closed, and abort a protocol switch whose PEM fails to load instead of moving to an entry that cannot connect. The Go server now bounds the upgrade sniff even when ReadTimeout is zero, and the design doc records the two-stage limiter, the login-based disarm and the review items that stay as known limits. The protocol switch's input prompt is cut down to "reverse-proxy entry (host:port)" - the label static is only 81 dialog units wide, and the old sentence ran to roughly three times that. The three language files follow: en_US and zh_TW gain the shortened prompt and drop the long key it replaced, the German file gains the protocol-switch block it never had, and its WebSocket tip key is corrected - it had picked up a Go-server clause the source string never carried, so the tip was never translated at all. Co-Authored-By: deepseek-flash |
||
|
|
99db28e2e2 | Feature: Let the operator switch a live client's transport from the online list | ||
|
|
d4f312c9d8 | Feature: Tunnel the device protocol through a reverse proxy over WebSocket | ||
|
|
82f59b2469 |
Fix: Make the x264 opt-out real, and unchain libyuv from it
DISABLE_X264_FOR_TEST never actually removed the x264 dependency. Two separate reasons: 1. X264Encoder.h included <x264/x264.h> unconditionally and only pulled in common/config.h afterwards, so the macro was not even visible at the point where it mattered. The class also carried x264_t / x264_picture_t / x264_param_t members, so the header was required to compile regardless of the switch. Moving the config.h include to the top and splitting the class declaration in two fixes it: with the switch on, the class is a stub with no x264 types at all, and open() returns false so EncoderFactory falls through. The open(x264_param_t*) overload is dropped in that branch; it had no callers outside X264Encoder.cpp. 2. libyuv was collateral damage. Its only #pragma comment(lib) lived inside the #else branch of the x264 switch, but CFFmpegAV1Encoder.cpp and CFFmpegH264Encoder.cpp both call libyuv::RGB24ToI420 / ARGBToNV12 / I420ToNV12 without carrying a pragma of their own. Turning x264 off therefore dropped libyuv too and the link failed with LNK2001 on those three symbols. libyuv is BSD-3 and unrelated to x264: the pragma is now unconditional in X264Encoder.cpp, and CFFmpegH264Encoder.cpp declares it alongside its ffmpeg libs so the encoder pair is self-sufficient. Verified with Release x64 builds of both ServerDll and ghost: switches 0/0, compress/ intact -> builds switch x264=1, compress/x264 deleted -> builds (was LNK2001 before) switches 1/1, both dirs deleted -> builds So a compliant build needs neither the x264 library nor its headers. Note for anyone flipping these switches: do a full rebuild, not an incremental one. config.h reaches X264Encoder.cpp indirectly through X264Encoder.h, which the .tlog dependency tracking does not record, so an incremental build happily links a stale object against a freshly compiled one and reports bogus LNK2001 errors. |
||
|
|
6bfa4294cc |
Feature: Switch a Linux client's transport TLS at runtime
The server's TLS menu already wrote the trust anchor into the Windows client's registry and expected a restart. The Linux client grew the same command handling (166/167) but, like Windows, only read the anchor once at startup, so enabling or disabling TLS still meant restarting it. Both handlers now take effect immediately. TlsChannelLinux.cpp no longer initialises through std::call_once. The process-level state (context, enabled, load error) lives behind a mutex and TlsReload() rebuilds it from whatever anchor file is on disk, so TlsEnabled() reflects the new transport as soon as the anchor is written or removed. In-flight sessions survive the swap because SSL_new increments the SSL_CTX reference count; the unit test pins that down by keeping an established TLS connection open across a reload that frees the old context. A reload that hits a bad anchor keeps the previous state and only logs: one bad push should not brick a working client, and the next start is still fail-closed. The pushed PEM is parsed before it is written for the same reason -- a corrupt anchor on disk would lock the client out of the server with no way to correct it remotely. Only a real transport flip (plaintext <-> TLS) asks for a reconnect. An anchor swap alone, as in a certificate rotation, leaves the current session alone and applies to the next connection. The receive thread never closes the socket itself; it sets g_needReconnect and the main heartbeat loop disconnects so the outer reconnect loop can re-handshake, matching how the heartbeat timeout path already works. IOCPClient now latches the transport per connection (m_useTls) at handshake time instead of consulting TlsEnabled() on every send and receive. Without the latch, the second or so between the reload and the reconnect would push plaintext into an established TLS session, or the reverse, producing protocol errors for no reason. RES_TLS (szReserved[19]) is refreshed right before each login, including the resend after a group change, so the TLS column on the server flips with the transport instead of showing the value from process start. The confirmation dialogs now say what each platform does, with translations in en_US, zh_TW and de_DE; the keys carry the literal \n escape the INI parser understands. Ending a sub-connection is not an error. OpenSSL 3 classifies a peer that closes without close_notify as an unexpected-EOF protocol error, so every terminal or file transfer session logged an SSL_read failure on the real servers even though Recv promises 0 for a plain close and neither side sends close_notify. SSL_OP_IGNORE_UNEXPECTED_EOF restores the intended semantics. Verified with the reload unit test (RELOAD-OK, covering the in-flight connection across a context swap, garbage payload rejection and a broken anchor keeping TLS alive), an abrupt-close test (recv now returns 0 instead of SOCKET_ERROR) and end to end against a protocol-faithful fake server that signs MasterSettings with libsign: plaintext login, 166, TLS reconnect with RES_TLS=1, 167, plaintext reconnect with RES_TLS=0. The Linux client, the Debug Windows client and the Debug MFC server all build. The cost is inherent to taking effect immediately: a remote session in progress is dropped when the transport changes, and the MFC server briefly shows the client as a duplicate login until the old connection is reaped and the standby entry is promoted. Co-Authored-By: deepseek-flash Co-Authored-By: Claude Code <noreply@anthropic.com> |
||
|
|
4c0e86dcc5 |
Feature: Upgrade a Linux client from the server
The Linux client is a standalone ELF with no in-memory loader and no COMMAND_UPDATE handler, so the server's upgrade menu silently did nothing for an LNX host. It can now push a new binary and have the client replace and restart itself. The server grows an LNX branch next to EXE/DLL/SC. It takes the ELF from an explicit settings.ini LinuxClientPath, then ghost_linux_amd64 in the program directory, then res\ghost_linux, then IDR_LINUX_GHOST, the copy the server has always embedded for the client-build dialog, so a server with nothing on disk can still upgrade; a configured path that cannot be read is an error rather than a silent fallback. Only x86_64 ELF64 is accepted. The payload adds a 32-byte MD5 trailer to the existing [cmd][size:8][payload] layout, which the Windows branches keep unchanged. linux/ghost in the tree is still the build from before this change and is not updated here. It has to be refreshed before release: the embedded default is copied from it at build time, and a stale copy would install a client with no COMMAND_UPDATE handler, which can never be upgraded remotely again. The client verifies the declared size, elf magic, e_machine against its own ELF header and the MD5 before touching anything, so a miscopied or corrupted file never lands on disk. It then writes a same-directory temp file with fsync and 0755 (a running executable cannot be truncated in place), renames it over its own path atomically, keeps the replaced inode as .old, removes the PID file, forks a detached child that waits for the old process to exit and execs the new binary with the original argv, and finally exits with S_CLIENT_UPDATE. Doing the rename and the exec in that order avoids ETXTBSY, double connections under one client id, and a new instance that isAlreadyRunning() would refuse to start. Any failure (unwritable install directory, bad payload, fork) leaves the client running on the old version; the reason goes to the client log and to the server's message log through TOKEN_CLIENT_MSG, which required moving that struct out of the Windows-only block in common/commands.h. The shared client source had also stopped compiling off Windows: the unknown-header diagnostic in IOCPClient::OnServerReceiving printed TlsEnabled() and m_tls.IsReady() unconditionally, but TlsChannel and m_tls only exist on Windows. That diagnostic now keeps the TLS details where the channel exists and prints just the buffer dump everywhere else. Verified end to end in WSL against the Debug server, foreground and -d daemon: the PID changes, the installed file matches the pushed MD5, the host reconnects, and ghost.old holds the previous binary. A read-only install directory reports "cannot create ...: Permission denied" in the server log with the client still online. With an invalid file at ghost_linux_amd64 the server refuses it and names that path, which shows the disk source wins; with nothing on disk the update goes through from the embedded ELF. Co-Authored-By: deepseek-flash |
||
|
|
c271911fcb |
Feature: Add copy_files_c2c to transfer files between clients directly
Adds the 54th MCP tool, copy_files_c2c, which asks the source client to push a set of files straight to another online client. Previously the only way to move files between two clients was to download them to the server machine and upload them again, so the data crossed the wire twice and needed free disk on the server. With C2C the server only relays packets and never parses or stores the payload. Protocol. Two new ids in common/commands.h: COMMAND_C2C_SEND_FILES (174), carrying the destination directory followed by a NUL-separated path list, and TOKEN_C2C_SEND_RESULT (175), a fixed 45-byte result packet sent back over the same sub-connection the transfer used. Clients advertise support with the LOGIN_INFOR capability bit CLIENT_CAP_C2C_PATHS (0x0008), exposed server side as Context::SupportsC2CPaths(). File transfer V2 already knew how to push to dstClientID, so the destination side needed no change at all; existing V2 receive paths keep working, and older clients simply do not advertise the bit and are rejected with a clear error instead of hanging. Client. OnC2CSendFiles expands environment variables, collects directories recursively, opens its own sub-connection (with sub-connection auth), and runs FileBatchTransferWorkerV2 in a detached thread, then reports the result on that same connection. Every early exit now reports a structured failure rather than staying silent. The worker needs the process-level InitFileUpload call that the receive path performs lazily, and a source client may never have opened a file manager or received an upload, so the initialization is factored into EnsureV2TransferInited() and called from both paths. Server. copy_files_c2c mirrors the existing upload tool: gates, id parsing, capability checks, path validation, then a session keyed on the source host that WaitC2CDone polls until the result packet arrives. The C2C relay branch used to attach a CDlgFileSend progress dialog to the source's sub-connection; NotifyProc then routed every later packet on that connection to the dialog, which parsed the result packet as a V1 file chunk and dropped it, so the tool always timed out even though the files had arrived. IsC2CTransferPending() now suppresses dialog creation for MCP-driven transfers only, leaving manual Ctrl+V transfers untouched. Errors map to -32001 for a source-side transfer failure, -32010 for access denied, -32009 for a missing path and -32002 for an offline destination. Both hosts must be Windows: the destination is restricted too, because the source embeds dst_dir in each V2 chunk name as an absolute Windows path and only the Windows receiver applies it literally. A Linux or macOS receiver never gets a target directory here (the clipboard flow sets one with COMMAND_C2C_PREPARE, which this path does not send), so it would strip the drive letter and write under / instead. Supporting that needs a prepare packet carrying an explicit path plus an upgrade of those clients, so for now the tool rejects them with -32005 rather than writing somewhere wrong. Verified end to end on the Debug build: three files including a non-ASCII name, an empty directory and a 3 MB binary arrived with matching SHA-256 in 3.2 s, a non-existent destination directory was created, and the negative cases returned the documented codes. mcp_smoke.ps1 passes 41/41 with two new assertions and 27/27 in -SkipHost mode. Design notes, error table and limitations are in docs/Mcp_FileTransfer_Design.md section 14 and docs/Mcp_Design.md section 15. Co-Authored-By: deepseek-flash |
||
|
|
315a0855dc |
Feature: Let the client report structured failures for MCP tools
Four new client-to-server tokens carry a win32/LSTATUS code when a command fails instead of returning empty data: TOKEN_SERVICE_ERROR (170), TOKEN_FILE_LIST_ERROR (171), TOKEN_REG_ERROR (172) and TOKEN_DOWNLOAD_ERROR (173). They sit on byte values that were unused, so existing numbering is untouched. The three data paths that used to collapse "failed" and "empty" into the same packet now distinguish them: OpenSCManager failures, directory enumeration failures and RegOpenKeyEx failures all report the code that was actually returned, and UploadToRemoteV2 reports why it found no file to transfer before the transfer sub-connection is ever created. Every failure branch still sends the packet the old server expects (TOKEN_FILE_LIST, the empty TOKEN_REG_PATH/KEY pair, the ClientMsg popup), so a new client talking to an old server degrades to exactly today's behaviour instead of timing out. Success paths are byte-for- byte unchanged. Co-Authored-By: deepseek-flash |
||
|
|
1c5fab1645 |
Fix: Stop the client dropping chat messages that begin with e
CChatManager::OnReceive opened with the same heartbeat guard the other managers use, `if (szBuffer[0] == TOKEN_HEARTBEAT) return;`, before it looked at the length. TOKEN_HEARTBEAT is 101, which is also the letter e, and this channel carries free text rather than command bytes, so every message starting with e -- "echo", "error", anything -- was silently discarded. The sender never learned: the server's chat dialog had already written the text into its own log, so the two sides disagreed about what was said. The guard is dead code here. Heartbeats travel on the main connection only, as a multi-byte [101][Heartbeat] packet consumed by the main dispatcher; the server never sends one on a chat sub-connection. Delete it and keep the length check that follows. The server keeps prepending a space when the GBK payload starts with 101, because already-deployed clients still carry the guard and losing the message outright is worse than an invisible leading space. Note the same guard, harmless today, still sits in the machine, file, proxy and screen-hide managers. Verified with the Debug instance and a local Debug client: with the server's space temporarily disabled, chat_send "echo test" and "second line" both showed up verbatim in the client dialog (read back with WM_GETTEXT); with the space restored the first arrives as " echo test". Details in docs/Mcp_Chat_Design.md section 5. Co-Authored-By: deepseek-flash |
||
|
|
8f718d9b39 |
Fix: Stop the client file search from overflowing its path buffers
SearchFilesRecursive built "%s\*.*" and "%s\%s" with wsprintf into char[MAX_PATH] buffers and never checked the lengths. The recursion allows 32 levels, so a search from a drive root accumulates paths well past 260 characters and writes off the end of the stack frame. Debug builds raise Run-Time Check Failure #2 and the dialog blocks the search thread; release builds corrupt the stack silently. Check the length before each build and skip the entry when the full path does not fit, so neither the name nor the recursion below it is recorded. The root directory is checked once at function entry, which also stops an over-long root from being enumerated at all. Apply the same guard to the directory listing paths in both file managers, and bound the search pattern built from the incoming keyword. Zero-initialize the buffers filled by ExpandEnvironmentStringsA so a failed expansion is treated as an empty path instead of reading uninitialized stack. Verified against the debug client with a full C:\ scan (10,000 results, finished, no dialog) and a repeated deep search afterwards. Co-Authored-By: deepseek-flash |
||
|
|
cc0e4bbd7a |
Fix: Pass win keys down the hook chain while a chat is locked
During a locked chat the client installs a WH_KEYBOARD_LL hook that swallows Alt+Tab, Alt+F4, Alt+Esc, Ctrl+Esc and the Win keys, so the person sitting at the machine cannot get out of the lock. The hook returned 1 without calling CallNextHookEx. Low-level hooks run last installed first, and this one is installed later than the server's hotkey forwarding hook, so it sits in front of it: returning 1 ended the chain and the forwarding hook never saw those keys. With YAMA running on the same machine as the client, Win shortcuts stopped reaching the remote host for as long as the lock was up. The event is now passed down the chain before it is swallowed. CallNextHookEx hands the event to the other hooks only, not to the system or the shell, so the local shell is still blocked and the lock behaves exactly as before, while the forwarding hook can see the key and act on it. Co-Authored-By: deepseek-flash |
||
|
|
37d0297f07 |
Fix: Keep the keylogger thread pumping so the hook chain stays alive
The low-level keyboard hook callback runs only while the thread that installed it pumps messages, but KeyLogger() gated PeekMessage on IsConnected(). With offline recording enabled (kbrecord=Yes) and no keyboard sub-connection, the hook stayed installed while its thread never pumped, so every keystroke on the machine stalled against LowLevelHooksTimeout (300 ms by default) and the hook was eventually dropped by the system. Because the client installs its hook after YAMA installs its own, the client's hook sits in front of YAMA's in the chain, and the starved events broke the key pairs YAMA needs: Win shortcuts and Ctrl+V forwarding stopped working while ordinary typing was unaffected. Pump messages unconditionally; this code is only reached while the hook is installed, and the offline-record path installs it even without a keyboard sub-connection. Co-Authored-By: deepseek-flash |
||
|
|
434812f87d |
Fix: Show the instant-message popup on packed clients
Clients packaged as SC_AES/sRDI shellcode run the payload image as raw shellcode inside the loader stub, so the instant-message manager was handed the stub's module handle. The stub's resource section carries no IDD_DIALOG, and Windows rejects resource APIs on manually mapped images, so DialogBoxParamA failed (error 1812 on Windows 11) and the bottom-right popup never appeared after the operator sent a message. The popup now falls back to an embedded compiled dialog template generated from the IDD_DIALOG block in Script.rc and verified byte-for-byte against the resource in the built ghost.exe. When the resource lookup fails, the dialog is created with DialogBoxIndirectParamA instead. Deployments where the resource lookup already works keep the original path unchanged. The incoming text is now terminated at the copied length. The server sends the message body without a trailing NUL, so a message that filled the 1024-byte buffer left SetDlgItemText reading past the end. The title is now set with SetWindowTextW before the window is shown. DialogBoxParamA converts the template's UTF-16 caption through the system ANSI code page, so the Chinese title turned into "???" on 1252 systems (verified locally with a caption containing a character outside CP936). The title follows the UI language: Chinese systems keep the Chinese title, everything else shows "Message". The message body still uses the ANSI path, preserving the existing per-ACP semantics. Co-Authored-By: deepseek-flash |
||
|
|
fff7c67af6 |
Fix: Make the remote chat dialog Unicode and loader-independent
Clients packaged as SC_AES/sRDI shellcode run the payload image as raw shellcode inside the loader stub, so the chat manager was handed the stub's module handle. The stub's resource section only carries a manifest, and Windows resource APIs reject manually mapped images outright, so creating IDD_CHAT failed and the chat thread exited before the window ever existed. The chat window now falls back to an embedded compiled dialog template that is byte-identical to the IDD_CHAT resource, and the title-bar icon is rebuilt directly from the module's own resource directory instead of LoadIcon, bypassing the loader on both paths. The PE walking code checks every offset against SizeOfImage and the resource directory size, so a malformed or truncated image returns NULL instead of faulting. Deployments where the resource lookup already works keep the original code path unchanged. The dialog is now created and driven with the wide-character API. The client is still an MBCS build, but an ANSI dialog renders text with the system code page, so GBK chat text turned into mojibake on German and other non-936 systems. Incoming text is converted CP936 to UTF-16 and outgoing text strictly back to CP936; characters GBK cannot represent (emoji, accented letters) are refused with a visible notice instead of silently becoming '?'. Static labels follow the system UI language, and IDD_CHAT now uses the scalable MS Shell Dlg face so font linking can supply CJK glyphs. The window is now positioned explicitly as well. DS_CENTER in the template put it at the work area origin on the three-monitor host: the centred position came out negative there and Windows clamps out-of-range creation coordinates to that origin. It is centred in the work area of the monitor under the cursor instead, falling back to SPI_GETWORKAREA. Teardown no longer leaves a hidden window behind either. The dialog thread blocked in GetMessageW and never saw m_bRun cleared, while the destructor waited for that thread before sending the message that would have destroyed the window, so a close command that never arrived (the sub-connection already gone, or WaitSendIdle timing out before CancelIO) leaked the window, the dialog thread and the manager loop. The destructor now destroys the window first, the loop checks m_bRun before blocking, and it destroys the window itself if it exits first. Co-Authored-By: deepseek-flash |
||
|
|
6c8336b497 |
Fix: Repair task actions and harden machine management
Scheduled task actions never worked end to end: the server built task packets with Unicode-style lengths in a MultiByte build, the client had no dispatch for the run/stop/delete/create commands, and the directory column was derived by replacing every occurrence of the task name, which misplaced tasks whose name also appeared in a parent folder. Packets are now assembled with narrow strings, the four commands are routed to RunOrStopTask/DelTask/CreateTask, and the folder is taken from the task path suffix only. The task list reply is trimmed to its real length instead of sending the whole 32 KB scratch buffer. On the client side, thawing a process resumed a single thread, the inject output path was copied from a narrow string using a wide-character length, and an empty window list dereferenced a NULL buffer. The service list leaked its enumeration block and one service handle per skipped entry, and the description was copied without a bound. Service start and stop now validate every handle, initialize the status structure, and stop synchronously before the start that follows a restart request, which previously always failed because the service was still in STOP_PENDING. Deleting a process used to test only the low byte of the PID and leaked the process handle on early exits, and a failed path conversion kept the previous process image name. The IE history timestamp wrote minutes and seconds in the wrong order, the favorites reader queried and closed an uninitialized registry key, software enumeration never closed its subkeys, and the task scheduler objects were not released after use. The network state list now frees the module, snapshot, and extended tables on every exit path, uses HeapFree for tables allocated on the process heap, and no longer calls an export that may be missing. Growth failures everywhere keep the original buffer instead of overwriting the pointer, the hosts reader rejects an invalid file size, and the COM task walk releases definitions and folders. Co-Authored-By: deepseek-flash |
||
|
|
c208b7368e |
Fix: Format net-state addresses as narrow strings on the client
The client is a MultiByte build, so the destination buffers are char[]
and _T("%s:%u") expands to an ANSI format that expects a char pointer.
The code nevertheless converted inet_ntoa() output to WCHAR* first, and
the ANSI %s stopped at the zero byte that follows the first wide
character. Every address therefore collapsed to its leading digit, so
192.168.0.55:443 was shown as 1 and 0.0.0.0:80 as 0 in the local and
remote address columns of the network connections tab.
Write the address and port straight into the char buffers with
sprintf_s in all four enumeration paths (legacy and Vista APIs, TCP and
UDP), and drop the now unused char2wchar_t helper.
Co-Authored-By: deepseek-flash
|