Skip to content

Show and drive machines that run RDP or RustDesk - #131

Open
avillagran wants to merge 58 commits into
omacom:mainfrom
avillagran:feat/foreign-desktops-pr
Open

avillagran wants to merge 58 commits into
omacom:mainfrom
avillagran:feat/foreign-desktops-pr

Conversation

@avillagran

@avillagran avillagran commented Nov 11, 2026 •

Copy link
Copy Markdown

Stacked PR. This builds on #106, #108 and #109, merged in 71fd013. Only the ten commits from 43c912e on are new here. Once those land, the diff shrinks to them.

The problem

A machine that does not run gliff, such as a Windows PC or one that has only a Remote Desktop server or RustDesk, cannot be shown or driven from gliff. Reaching it means leaving gliff for another client, and losing control from the screen edge.

What this adds

  • RDP and RustDesk machines. rdp://[user@]host[:port] and rustdesk://host[:port] get a tab like any other machine.
    • The tab shows the screen.
    • The mouse button drives the machine from the edge you pick, as --control does. gliff --control right:rdp://… works as well.
  • A protocol badge at the start of the address bar picks SSH, RDP or RustDesk in one click. A scheme typed by hand wins over the badge, and the badge switches to it.
  • Detection. When ssh fails for a new machine, gliff checks its RDP and RustDesk ports and offers to switch. A port counts only if it speaks the protocol; being open is not enough.
  • Passwords.
    • gliff asks for a password once and keeps it in the desktop's keyring through the Secret Service.
    • A password is saved only after the machine accepts it.
    • A refused password is asked for again. Control from the edge stops after one refusal.
  • A new crate, gliff-foreign:
    • RDP through IronRDP. It supports TLS and RemoteFX, and NLA (NTLM) with a fallback to TLS alone, which weston needs. A self-signed certificate is kept on first use and a different one is refused later, as ssh does with host keys.

    • RustDesk by direct IP, on port 21118:

      • RustDesk's login, which sends no password: only a hash salted by the machine's challenge. RustDesk does not encrypt direct IP connections; the login dialog says so before the password is typed.
      • A password login that sends only a hash, salted by the machine's challenge.
      • VP9 and VP8 decoded with the system's libvpx.

      The protobuf messages are written out by field number. No RustDesk code or .proto file, which are AGPL, is copied.

    • A 10-second connection timeout, so a firewall that drops packets fails the tab instead of leaving it on "Connecting…" forever.

    • RustDesk's one-time password: every connection of a session uses the same session id. RustDesk replaces the password as soon as it lets a peer in, so with this the edge control and reconnects still get in.

  • Docs: docs/foreign.md, the README, and a libvpx dependency in the PKGBUILD.

Screenshots

Taken from gliff running on a test laptop, against weston's RDP server on 127.0.0.1 (a throwaway test account).

The protocol badge. One click picks SSH, Remote Desktop or RustDesk for the machine typed after it.

The badge's menu

Logging in. Asked for once, and kept in the keyring only after the machine accepts it.

The RDP login dialog

The machine's desktop in a tab.

weston's desktop shown over RDP

Control from the edge. The mouse button in the header asks which side the machine sits on.

The side picker for edge control

Detection. ssh to nosuchuser@127.0.0.1 fails; gliff finds the RDP server and offers it.

The offer to switch to RDP

RustDesk by direct IP. A RustDesk tab of the same laptop, logged in with its one-time password (the screen inside is that laptop's own, gliff included).

A RustDesk tab

Security notes

  • RustDesk does not encrypt direct IP connections: its direct server skips the key exchange, so the screen and keys cross the network as they are, and nothing proves the machine's identity. gliff warns about this in the login dialog and in docs/foreign.md, and recommends your own network or a VPN. A server that does offer a key gets the encrypted session.
  • RDP to Windows opens a session of its own and locks the screen at the machine itself. The dialog that offers to switch to RDP says so.

Testing

  • scripts/check.sh passes with 343 tests. They include fake RDP and RustDesk servers that cover the encrypted and the direct IP login, a wrong password, decoding a VP9 frame from a fixture, and the probe.
  • By hand, from an aarch64 Arch machine:
    • RDP against weston's RDP backend over the LAN:
      • View, keyboard and mouse, and control from the edge.
      • The password saved in the keyring.
      • The certificate kept on first use, and a changed one refused.
      • The timeout behind a firewall that drops packets.
    • RustDesk 1.5.1 on Linux (VP9, 2560×1600) and RustDesk on Windows: view, input and control from the edge, with both the permanent and the one-time password.
  • Not tried yet: RDP against Windows itself, which takes the NLA path.

- The manifest is written atomically before and after each file, with
  the hash of the file being written as pending. An install that stops part
  way leaves only files gliff recognises as its own and is marked
  unfinished, so the next attempt finishes it even though gliff-server may
  already be on PATH.
- Selecting the machine's tab while gliff is being installed no longer
  starts a connection, which made the install's reconnect stale and could
  offer a second install over the first.
- The desktop file's Exec path is quoted and escaped by the desktop entry
  rules, so a home directory with spaces, quotes or % still launches.
The client offers to install gliff only while ssh cannot find
gliff-server. With gliff-server written second, an install that failed
on the desktop file or the icon left a working server on PATH, so the
offer never came back and the rest stayed missing. It is now written
last, so until everything else is in place the next connection offers
the install again, and the script finishes it over its own files.

A file that cannot be written now reports which one and why, instead of
the temporary file's name, and an unreadable manifest says how to
recover.
gliff --stdio shows the gliff-server whose protocol arrives on stdin and
leaves on stdout. Another machine runs that server and starts this over
ssh with the server's stdout as its stdin, to use this screen as one of
its own; only that machine needs ssh access to this one.

- stdout is kept for the protocol and fd 1 points at stderr, so nothing
  that prints can corrupt the stream.
- Started by ssh outside the desktop session, it finds the user's
  Hyprland session the way gliff-server does.
- The window shows only that session and remembers nothing; it closes
  when the stream ends, since only the other machine can start it again.
- --fullscreen opens the window fullscreen; the header no longer warns
  when the window starts that way.
A headless output always went where Hyprland found room. --position puts
it right, left, above or below this machine's screens, and --align lines
it up with their top or left edges (start), their middles, or their
bottom or right edges (end). The position is worked out from the other
screens' layout each time the output's mode is set, so a resize keeps
it in place beside them.
The header gets a button that adds a headless output here and shows it
on the selected machine with `gliff --stdio --fullscreen` over ssh, and
a settings button for which side of this computer's screens it stands
on and how it lines up. A gliff there without `--stdio` still shows it
through a relay in place of its ssh, with Hyprland making its window
fullscreen. Stopping, the other window closing or this window closing
gives the screen back.
The position comes from the output's logical size, which resize
computed with the requested scale. When Hyprland applies a rounded
scale instead, place the output again at that scale, so it still meets
the other screens on the chosen side and lines up as asked.
The window closes when that stream ends, so a machine opened from its
address bar would close with it. A --stdio window shows neither the +
nor the address bar, and connecting from the bar does nothing there.
A --stdio window that closes on a connection error or an incompatible
server now makes gliff exit with a failure, with the reason as its last
stderr line, so the machine that started it can say why. A window the
user closes, or a stream the other side ends, still exits successfully.
Showing another machine forgets the lent screen's tab as the selection,
and selecting that tab again did not bring it back, so it lost its
highlight and the screen buttons asked for a tab once the screen
stopped. Selecting a tab whose screen is in use now makes it the
selected one, as starting the screen does.
Hyprland places a screen whose position is `auto`, as Omarchy's default
configuration does, after every screen with a fixed one. A fixed
position for the headless output therefore pushed such a screen aside:
on a laptop asked for `--position right`, the laptop screen moved right
of the new output. When placing the output moves another screen, the
placement goes to Hyprland's `auto-right`, `auto-center-right` and
related positions instead. They line up at the start or the center of a
side, so `--align end` is centered there, with a warning.
gliff 0.4.1 opens the GPU decoder whenever VA-API lists H.264, and NVIDIA's
VA-API driver does, but every picture then fails to export, so the screen
lent to such a machine stayed black. That gliff cannot switch to the CPU on
its own, so the relay asks for it with GLIFF_VIDEO=cpu when every render
node belongs to the nvidia driver, unless GLIFF_VIDEO is already set.
A new crate puts a one-pixel layer surface along chosen outer edges of the
layout. When the pointer touches one it locks the pointer there, hides it,
takes the keyboard and inhibits shortcuts, and reports relative motion,
buttons, the wheel, keys, modifiers and the keymap until told to release.
Releasing puts the pointer back just inside that edge, through a new
hypr-ipc move_cursor that speaks both config formats.
--control SIDE skips the picture: after the usual Hello it binds a virtual
keyboard and pointer, with the client's keymap, to the screen on SIDE of the
layout, answers with that screen's size, and injects the client's keys,
motion, buttons and wheel until the client goes. The handshake and the
setup error report are the session's own.
gliff --control SIDE:HOST, given once for each machine, runs with no window:
it keeps a gliff-server --control connection to each machine, reconnecting
with backoff, and arms that side's edge only while the machine answers.
Pushing the pointer past an armed edge carries it onto that machine's
screen, entering at the facing edge where it left this one. Moving back
across that edge, or the release hotkey, returns it at the matching point;
a held button keeps the pointer there. Keys and buttons still held are let
go on the other machine on every return. The release hotkey is matched by
keysym in the local keymap, so it means the same keys in any layout.
# Conflicts:
#	crates/gliff/src/main.rs
A mouse button beside the screen buttons drives the selected machine with
this computer's pointer and keyboard across the edge on its side: the same
side the screen settings keep, asked for the first time as they are, without
the alignment, which only a screen in use needs. Each driven machine runs
its control on a thread of its own, so one machine on each side can be
driven at once; a second machine on a side already taken is refused.

The machine's tab stays selected without its session, says how to cross
over or that it is connecting, and its dot shows whether the machine
answers. The tab's button or the mouse button, now a stop button, ends the
control, which gives the pointer back. A machine is not driven and used as
a screen at once. Closing the window ends every control.

The control loop now stops on a signal from its owner and reports when a
machine connects, drops and why, and when it ends.
While a machine is driven or its screen is in use, the window has nothing
to show, so a button beside the screen buttons hides it. A tray icon (a
StatusNotifierItem over the session bus, which Omarchy's bar and Waybar
show) stands in for it, and a click on the icon brings the window back.
Without a tray to come back from, the window stays. The window also comes
back by itself once nothing runs in the background any more.
A speaker button, shown while the selected machine is driven, moves that
machine's sound to this one: over ssh, pw-record takes what its default
output plays, before its volume, as raw 48 kHz stereo, and pw-play plays it
here. The other machine's output is muted meanwhile and unmuted however the
stream ends. It is muted only once the capture has woken the output,
because WirePlumber restores a suspended output's saved mute as it wakes,
and once more a second later. The choice is kept per machine and applies
the next time it is driven. Stopping the control, or the window, stops the
sound too.
A compiled remote_install.py was committed by mistake with the
recoverable install. Remove it and ignore __pycache__ directories.
The client works out the pointer's extent from the size in HelloAck, but
it got the mode as Hyprland reports it, unrotated, while the server bound
the pointer to the rotated screen. On a portrait screen the pointer could
not reach its bottom. Swap the size for a 90 or 270 degree transform, as
the video session does.
The pointer returned to the edge's screen as it stood when control
started. A screen moved or rescaled meanwhile put it somewhere else,
possibly on the edge again. Read the layout when releasing, and keep the
old one only when it cannot be read.
The script unmuted whichever output was the default when the stream
ended, and read the mute of the default rather than of the output it
muted. If a headset became the default meanwhile, the speakers stayed
muted and the headset was unmuted. Keep the default output at the start
and use that one throughout.
A sound stopped and started again, or stopped with its control and
started with the next one, ends after the new sound began. Its end
cleared the machine's sound by name, which dropped the new one and killed
its ssh. Each sound now has an id, and an end from another run is
ignored.
If the tray's connection failed, its thread ended and the icon went with
it, but the window stayed hidden, leaving no way to stop what ran. A
closed channel from the tray now shows the window, as a click does.
The other machine's keyboard started from a fresh state and followed only
the keys typed into it, so a second layout selected here, or Caps Lock or
Num Lock already on, did not apply there. The client now sends its
layout in effect and locked modifiers, by name, on entering and whenever
they change while captured, in a new KeyboardLocks message. The control
server lists the keyboard-locks feature and applies them to its virtual
keyboard; a server that does not list it is not sent them, and the video
session ignores the message.
Hotkey::parse accepts names such as exclam, but matching looked only at
each key's unshifted symbol, so shift+exclam was accepted and never
matched. A key now matches by its unshifted symbol or by the one it
produces with the modifiers held.
A link whose network went away without closing the connection stayed
up: nothing read had a deadline, so its edge kept taking the pointer to
a machine that was gone, and input queued for a write that never ended.
The link now pings every 2 seconds and is dropped after 6 seconds
without hearing from the other machine, or when a write takes that long;
it then disarms its edge and reconnects as after any drop.
An edge's screen and rectangle were chosen once, so a screen added
farther out left the edge on what was now an inner side, and a moved or
rescaled screen kept the old coordinates. hypr-wl's Outputs now binds
and forgets outputs that come and go, and hypr-edge reads the layout
again after each output's burst, when one goes away, and when the
pointer is given back: an edge whose outermost screen changed is put on
the new one once Wayland has announced it, or after the pointer it holds
is given back. Whether an edge is armed is now kept apart from its
surface, so a surface the compositor closes with its screen is given
again, and events from an edge's previous surface are ignored.
The Omarchy package has no --control yet, so a machine on it failed the
connection and retried for ever, with no hint why. Ask the machine before
driving it, and offer to install this computer's server for that user. The
upload has to run there before it replaces gliff's own file.
The window's clipboard stops at its sessions, so a machine driven from an
edge could neither give nor take a copy. Move the server's bridge to a crate
of its own and run it on both ends of --control. One clipboard here serves
every driven machine: a copy here is offered to them all, and a copy there
is pasted from the machine that made it.
The stream arrives in bursts, and over WiFi one is sometimes 70 ms late,
which left the 30 ms player with nothing to play.
With a machine on each side the screen between them is narrow enough for a
fast return to reach the other edge and leave again.
Installing this computer's gliff-server in ~/.local/bin on a machine whose
system package is older did not help when that machine's ssh PATH puts
/usr/bin first: `gliff-server` still ran the old one, and the update was
offered again every time.

The installer now reports whether `gliff-server` on that machine's PATH is
the one it wrote, both for a fresh install and for an update. The control
flow tries the user install by its own path when the one on PATH cannot be
controlled, before offering the update and again after it, so an older
package first on PATH no longer blocks control, and a machine already
updated is driven without asking again.
gliff-foreign shows and drives a machine through its Remote Desktop
server (IronRDP: TLS, NLA with NTLM, the first self-signed certificate
kept as ssh keeps host keys) or through RustDesk by direct IP (its
encrypted handshake and salted password challenge, VP8 and VP9 through
the system libvpx). Input comes as gliff's own messages and leaves as
each protocol's events, keys by position for the other machine's
platform.
rdp://user@host and rustdesk://host are machines like any other: a tab
shows the screen, and the mouse button drives it across a screen edge,
on the side picked for it. The login is asked for once and kept in the
desktop's keyring; a refused one is asked for again, and an RDP server's
first self-signed certificate is kept like an ssh host key.

A machine added by its ssh name that does not let ssh in is checked for
RDP and RustDesk, and gliff offers to reach it through what answers.
@greptile-apps

greptile-apps Bot commented Nov 11, 2026 •

Copy link
Copy Markdown

RetriggerView in GreptileConfidence Score: 5/5

[High impact] The latest changes appear safe to merge, with no new blocking issue established.

Summary

Adds RDP and RustDesk machines to tabs and screen-edge control, with saved passwords, RDP certificate checks, and protocol detection.

  • RDP and RustDesk machines open in gliff tabs.
  • A pointer and keyboard can cross an edge to control another machine.
  • A remote gliff desktop can act as another local screen.
  • Remote sound can play locally while background work stays available.
  • gliff can install or update remote support on another machine.

Diagram

%%{init: {'theme': 'neutral'}}%%
flowchart TD
    A[Choose a machine] --> B{Protocol}
    B -->|SSH| C[Start gliff-server]
    B -->|RDP| D[Check certificate and log in]
    B -->|RustDesk| E[Log in through direct IP]
    D --> F[Show screen or drive from edge]
    E --> F
    C --> F
Loading

Reviews (4) · Last reviewed commit: "Log in to RustDesk's direct IP access ag..." · Reviewed by Greptile

Comment thread crates/gliff/src/control.rs Resolved
Comment thread crates/gliff-foreign/src/rdp.rs Resolved
…out a key

The 10-second limit covered only the TCP connection: an RDP server that
accepted it and then stopped answering left the tab connecting, and closing
the tab did not end the wait. The whole login now has a deadline (30 s for
RDP, RustDesk's two minutes for a person to accept), and it is dropped as
soon as the tab or the control stops. Input sent meanwhile stays queued.

A RustDesk machine whose identity carries no key, or that opens with the
login challenge, would have taken the password proof, the screen and the
keys over plain TCP. gliff now refuses it.

RustDesk's own encryption uses one key in both directions with a counter
on each side, so a message each way shares a nonce; gliff cannot change
that and stay compatible. docs/foreign.md says so and points to a VPN or
an ssh tunnel on networks you do not trust.
…er runs

Driving an RDP machine from the edge before ever showing it started with
no saved certificate and dropped the one it saw, so each reconnect took
whatever certificate came as the first. The control now holds the server
to the first one it sees and saves it in the config, as the window does.

The config is written beside and renamed over, so the window and a
control saving at once never leave half a file.
@avillagran

Copy link
Copy Markdown
Author

All four findings are addressed in 7d861c4 and 7c56012:

  • Stalled RDP setup: the whole login now has a deadline and stops when the tab or control stops.
  • Unencrypted RustDesk peers: refused before any login data is sent.
  • Edge control certificates: the first certificate seen is kept for reconnects and saved for later runs.
  • RustDesk nonce reuse: inherent to RustDesk's protocol, so it is documented, with a VPN or ssh tunnel recommended.

scripts/check.sh passes (342 tests), with new tests for the login deadline and cancellation and for refusing unencrypted RustDesk servers.

Comment thread crates/gliff/src/control.rs Resolved
Every writer loaded the config, changed it and saved it on its own, so a
control saving a certificate while the window saved its tabs could undo
one or the other, and threads of one process shared a temporary name.
Config::update now loads, changes and saves under a lock, a mutex within
the process and an exclusive flock on config.toml.lock between gliff
processes, and every save uses a temporary file of its own. All the
window's saves and the control's go through it.

A control keeps a new certificate as soon as it is seen, rather than when
the session ends, so stopping it mid-session still leaves it saved.
avillagran added a commit to avillagran/gliff that referenced this pull request Nov 11, 2026
Refusing a RustDesk machine that offers no key turned away every direct IP
connection: RustDesk's direct server never makes the key exchange (it
creates the connection with secure set to false) and opens with the login
challenge. Checked against RustDesk 1.5.1, which gliff could no longer
reach. Such a login goes ahead again, and the login dialog, the offer to
switch and docs/foreign.md now say plainly that RustDesk does not encrypt
direct IP connections, so it belongs on your own network or behind a VPN.
The password still never travels, only a salted hash.
avillagran added a commit to avillagran/gliff that referenced this pull request Nov 11, 2026
avillagran added a commit to avillagran/gliff that referenced this pull request Nov 12, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant