mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-17 01:00:41 +01:00
fix(portal): establish desktop CONTROL while GNOME is locked and auto unlock cold connections (#30)
* fix(portal): establish locked desktop control before capture * test(portal): preserve v4 pixel inventory after deferred capture settings * fix(control): refresh lock state after viewer Echo handshake * fix(portal): announce desktop target before locked capture wait * ci: run the desktop_power native test under ASan/UBSan Co-Authored-By: Claude Sonnet 5.5 <[email protected]> * input: skip the Portal release sweep while no session is bound The first locked connection creates its peer before any Portal exists; the sweep then logged two failed injections and a 'reset incomplete' warning for nothing. Co-Authored-By: Claude Sonnet 5.5 <[email protected]> * docs: describe locked cold connections, auto unlock limits and iPhone status Co-Authored-By: Claude Sonnet 5.5 <[email protected]> * fix(portal): treat a cached screen with a closed Portal session as not ready begin() now marks the state as waiting when the cached session is dead, and permission/video/clipboard consumers honor it instead of reporting Allow and starting the stale video path before maintain() has rebuilt capture. Co-Authored-By: Claude Sonnet 5.5 <[email protected]> * fix(portal): gate input on a ready desktop and share recovery backoff Input dispatch kept only the cached screen and dropped State.waiting, so a closed Portal passed the gate once the screen unlocked. The supervisor's recover() and the encoder's stream-loss recovery now share failure backoff and a terminal-denial flag, so a denied consent is not re-prompted by the other path. Co-Authored-By: Claude Sonnet 5.5 <[email protected]> * fix(control): keep unknown lock state unlocked, stop waits on Closing, never drop capture settings - QuerySystemState with no logind lock state (Xvfb/linger) reports unlocked as before. - The Portal wait loop also exits while the channel is Closing. - Capture-setting requests back-pressure instead of try_send dropping the latest setting. Co-Authored-By: Claude Opus 5.5 <[email protected]> --------- Co-authored-by: Claude Sonnet 5.5 <[email protected]> Co-authored-by: VallierDev <[email protected]>
This commit is contained in:
23 files changed
+2292
-207
No files matched your search
@@ -0,0 +1,154 @@
|
||||
#include <gio/gio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define CALL_TIMEOUT_MS 3000
|
||||
#define MUTTER_DEST "org.gnome.Mutter.DisplayConfig"
|
||||
#define MUTTER_PATH "/org/gnome/Mutter/DisplayConfig"
|
||||
#define SESSION_DEST "org.gnome.SessionManager"
|
||||
#define SESSION_PATH "/org/gnome/SessionManager"
|
||||
#define SESSION_IFACE "org.gnome.SessionManager"
|
||||
|
||||
enum {
|
||||
UU_POWER_OK = 0,
|
||||
UU_POWER_SESSION_BUS = 1,
|
||||
UU_POWER_CALL_FAILED = 2,
|
||||
};
|
||||
|
||||
struct uu_idle_inhibitor {
|
||||
GDBusConnection *connection;
|
||||
guint32 cookie;
|
||||
};
|
||||
|
||||
struct setup_timeout {
|
||||
GMutex lock;
|
||||
GCond cond;
|
||||
gboolean finished;
|
||||
GCancellable *cancellable;
|
||||
};
|
||||
|
||||
static gpointer cancel_setup_on_timeout(gpointer data) {
|
||||
struct setup_timeout *timeout = data;
|
||||
gint64 deadline = g_get_monotonic_time() + CALL_TIMEOUT_MS * G_TIME_SPAN_MILLISECOND;
|
||||
g_mutex_lock(&timeout->lock);
|
||||
while (!timeout->finished &&
|
||||
g_cond_wait_until(&timeout->cond, &timeout->lock, deadline)) {}
|
||||
gboolean expired = !timeout->finished;
|
||||
g_mutex_unlock(&timeout->lock);
|
||||
if (expired) g_cancellable_cancel(timeout->cancellable);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void finish_setup_timeout(struct setup_timeout *timeout, GThread *thread) {
|
||||
g_mutex_lock(&timeout->lock);
|
||||
timeout->finished = TRUE;
|
||||
g_cond_signal(&timeout->cond);
|
||||
g_mutex_unlock(&timeout->lock);
|
||||
g_thread_join(thread);
|
||||
g_cond_clear(&timeout->cond);
|
||||
g_mutex_clear(&timeout->lock);
|
||||
g_object_unref(timeout->cancellable);
|
||||
}
|
||||
|
||||
/* Use a dedicated connection so closing this inhibitor cannot affect another app's bus state. */
|
||||
static GDBusConnection *private_session_bus(int *error_code) {
|
||||
struct setup_timeout timeout = {0};
|
||||
g_mutex_init(&timeout.lock);
|
||||
g_cond_init(&timeout.cond);
|
||||
timeout.cancellable = g_cancellable_new();
|
||||
GThread *timer = g_thread_new("uu-dbus-connect-timeout", cancel_setup_on_timeout, &timeout);
|
||||
|
||||
GError *error = NULL;
|
||||
gchar *address = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SESSION, timeout.cancellable, &error);
|
||||
if (!address) {
|
||||
g_clear_error(&error);
|
||||
finish_setup_timeout(&timeout, timer);
|
||||
*error_code = UU_POWER_SESSION_BUS;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
GDBusConnection *connection = g_dbus_connection_new_for_address_sync(
|
||||
address,
|
||||
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
|
||||
G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
|
||||
NULL, timeout.cancellable, &error);
|
||||
g_free(address);
|
||||
finish_setup_timeout(&timeout, timer);
|
||||
if (!connection) {
|
||||
g_clear_error(&error);
|
||||
*error_code = UU_POWER_SESSION_BUS;
|
||||
return NULL;
|
||||
}
|
||||
g_dbus_connection_set_exit_on_close(connection, FALSE);
|
||||
return connection;
|
||||
}
|
||||
|
||||
static void close_private_bus(GDBusConnection *connection) {
|
||||
if (!connection) return;
|
||||
g_dbus_connection_close(connection, NULL, NULL, NULL);
|
||||
g_object_unref(connection);
|
||||
}
|
||||
|
||||
int uu_desktop_power_wake(void) {
|
||||
int error_code = UU_POWER_OK;
|
||||
GDBusConnection *connection = private_session_bus(&error_code);
|
||||
if (!connection) return error_code;
|
||||
|
||||
GError *error = NULL;
|
||||
GVariant *reply = g_dbus_connection_call_sync(
|
||||
connection, MUTTER_DEST, MUTTER_PATH, "org.freedesktop.DBus.Properties", "Set",
|
||||
g_variant_new("(ssv)", "org.gnome.Mutter.DisplayConfig", "PowerSaveMode",
|
||||
g_variant_new_int32(0)),
|
||||
G_VARIANT_TYPE("()"), G_DBUS_CALL_FLAGS_NONE, CALL_TIMEOUT_MS, NULL, &error);
|
||||
if (!reply) error_code = UU_POWER_CALL_FAILED;
|
||||
if (reply) g_variant_unref(reply);
|
||||
g_clear_error(&error);
|
||||
close_private_bus(connection);
|
||||
return error_code;
|
||||
}
|
||||
|
||||
struct uu_idle_inhibitor *uu_desktop_idle_inhibitor_acquire(int *error_code) {
|
||||
if (!error_code) return NULL;
|
||||
*error_code = UU_POWER_OK;
|
||||
GDBusConnection *connection = private_session_bus(error_code);
|
||||
if (!connection) return NULL;
|
||||
|
||||
GError *error = NULL;
|
||||
GVariant *reply = g_dbus_connection_call_sync(
|
||||
connection, SESSION_DEST, SESSION_PATH, SESSION_IFACE, "Inhibit",
|
||||
g_variant_new("(susu)", "uu-remote-linux", 0u,
|
||||
"Remote desktop session is active", 8u),
|
||||
G_VARIANT_TYPE("(u)"), G_DBUS_CALL_FLAGS_NONE, CALL_TIMEOUT_MS, NULL, &error);
|
||||
if (!reply) {
|
||||
*error_code = UU_POWER_CALL_FAILED;
|
||||
g_clear_error(&error);
|
||||
close_private_bus(connection);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct uu_idle_inhibitor *inhibitor = calloc(1, sizeof(*inhibitor));
|
||||
if (!inhibitor) {
|
||||
*error_code = UU_POWER_CALL_FAILED;
|
||||
g_variant_unref(reply);
|
||||
close_private_bus(connection);
|
||||
return NULL;
|
||||
}
|
||||
g_variant_get(reply, "(u)", &inhibitor->cookie);
|
||||
g_variant_unref(reply);
|
||||
inhibitor->connection = connection;
|
||||
return inhibitor;
|
||||
}
|
||||
|
||||
void uu_desktop_idle_inhibitor_release(struct uu_idle_inhibitor *inhibitor) {
|
||||
if (!inhibitor) return;
|
||||
GError *error = NULL;
|
||||
GVariant *reply = g_dbus_connection_call_sync(
|
||||
inhibitor->connection, SESSION_DEST, SESSION_PATH, SESSION_IFACE, "Uninhibit",
|
||||
g_variant_new("(u)", inhibitor->cookie), G_VARIANT_TYPE("()"),
|
||||
G_DBUS_CALL_FLAGS_NONE, CALL_TIMEOUT_MS, NULL, &error);
|
||||
if (reply) g_variant_unref(reply);
|
||||
g_clear_error(&error);
|
||||
|
||||
/* Closing the private bus also revokes the cookie if Uninhibit failed or the host exits. */
|
||||
close_private_bus(inhibitor->connection);
|
||||
free(inhibitor);
|
||||
}
|
||||
+70
-17
@@ -46,6 +46,8 @@ struct uu_portal {
|
||||
pthread_mutex_t lock;
|
||||
pthread_cond_t changed;
|
||||
atomic_int closed;
|
||||
uu_portal_cancelled_fn cancelled;
|
||||
void *cancel_data;
|
||||
int error;
|
||||
enum pw_stream_state state;
|
||||
int format_valid, stream_started;
|
||||
@@ -71,6 +73,10 @@ static pthread_once_t pw_once = PTHREAD_ONCE_INIT;
|
||||
static atomic_uint token_sequence = 1;
|
||||
static void initialize_pipewire(void) { pw_init(NULL, NULL); }
|
||||
static GVariant *empty_options(void) { return g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0); }
|
||||
static int open_cancelled(struct uu_portal *p) {
|
||||
return p->cancelled && p->cancelled(p->cancel_data);
|
||||
}
|
||||
static int wait_for_first_frame(struct uu_portal *p);
|
||||
#include "portal_eis.inc"
|
||||
static void fail(struct uu_portal *p, int error) {
|
||||
pthread_mutex_lock(&p->lock);
|
||||
@@ -87,6 +93,16 @@ static void response_received(GDBusConnection *bus, const gchar *sender, const g
|
||||
g_variant_get(parameters, "(u@a{sv})", &r->code, &r->results);
|
||||
r->done = 1;
|
||||
}
|
||||
/* Bounded consent wait; cancellation must break it within one poll interval. */
|
||||
static int wait_for_response(struct uu_portal *p, struct response *response, unsigned consent_seconds) {
|
||||
gint64 deadline = g_get_monotonic_time() + consent_seconds * G_TIME_SPAN_SECOND;
|
||||
while (!response->done && !atomic_load(&p->closed) && !open_cancelled(p) &&
|
||||
g_get_monotonic_time() < deadline) {
|
||||
while (g_main_context_iteration(p->context, FALSE)) {}
|
||||
if (!response->done) g_usleep(5000);
|
||||
}
|
||||
return response->done ? 0 : open_cancelled(p) ? 13 : atomic_load(&p->closed) ? 9 : 5;
|
||||
}
|
||||
static void close_request(struct uu_portal *p, const char *path) {
|
||||
if (!path) return;
|
||||
GVariant *r = g_dbus_connection_call_sync(p->bus, DEST, path, REQUEST, "Close",
|
||||
@@ -96,6 +112,7 @@ static void close_request(struct uu_portal *p, const char *path) {
|
||||
/* Subscribe before invocation, using the documented handle_token path. */
|
||||
static GVariant *request(struct uu_portal *p, const char *interface, const char *method,
|
||||
GVariantBuilder *options, int mode, int *error) {
|
||||
if (open_cancelled(p)) { *error = 13; return NULL; }
|
||||
char token[64];
|
||||
snprintf(token, sizeof(token), "uu_%u_%u", (unsigned)getpid(), atomic_fetch_add(&token_sequence, 1));
|
||||
g_variant_builder_add(options, "{sv}", "handle_token", g_variant_new_string(token));
|
||||
@@ -112,7 +129,7 @@ static GVariant *request(struct uu_portal *p, const char *interface, const char
|
||||
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, PATH, interface, method, args,
|
||||
G_VARIANT_TYPE("(o)"), G_DBUS_CALL_FLAGS_NONE, 10000, NULL, NULL);
|
||||
char *actual = NULL;
|
||||
if (!reply) { *error = 3; goto finish; }
|
||||
if (!reply) { *error = open_cancelled(p) ? 13 : 3; goto finish; }
|
||||
const char *handle;
|
||||
g_variant_get(reply, "(&o)", &handle);
|
||||
actual = g_strdup(handle);
|
||||
@@ -125,13 +142,8 @@ static GVariant *request(struct uu_portal *p, const char *interface, const char
|
||||
unsigned long parsed=strtoul(configured_timeout,&end,10);
|
||||
if(end && !*end && parsed>=30 && parsed<=900) consent_seconds=(unsigned)parsed;
|
||||
}
|
||||
gint64 deadline = g_get_monotonic_time() + consent_seconds * G_TIME_SPAN_SECOND;
|
||||
while (!response.done && !atomic_load(&p->closed) && g_get_monotonic_time() < deadline) {
|
||||
while (g_main_context_iteration(p->context, FALSE)) {}
|
||||
if (!response.done) g_usleep(5000);
|
||||
}
|
||||
if (!response.done) *error = atomic_load(&p->closed) ? 9 : 5;
|
||||
else if (response.code != 0) *error = 4;
|
||||
*error = wait_for_response(p, &response, consent_seconds);
|
||||
if (!*error && response.code != 0) *error = 4;
|
||||
finish:
|
||||
if (*error) close_request(p, actual ? actual : expected);
|
||||
g_dbus_connection_signal_unsubscribe(p->bus, subscription);
|
||||
@@ -262,10 +274,16 @@ static const struct pw_stream_events stream_events = {
|
||||
PW_VERSION_STREAM_EVENTS, .state_changed = stream_state, .param_changed = stream_format, .process = stream_process
|
||||
};
|
||||
static int connect_pipewire(struct uu_portal *p) {
|
||||
if (open_cancelled(p)) return 13;
|
||||
GUnixFDList *fds = NULL;
|
||||
GVariant *reply = g_dbus_connection_call_with_unix_fd_list_sync(p->bus, DEST, PATH, SCREEN,
|
||||
"OpenPipeWireRemote", g_variant_new("(o@a{sv})", p->session, empty_options()),
|
||||
G_VARIANT_TYPE("(h)"), G_DBUS_CALL_FLAGS_NONE, 10000, NULL, &fds, NULL, NULL);
|
||||
if (open_cancelled(p)) {
|
||||
if (reply) g_variant_unref(reply);
|
||||
if (fds) g_object_unref(fds);
|
||||
return 13;
|
||||
}
|
||||
if (!reply) return 7;
|
||||
gint32 index; g_variant_get(reply, "(h)", &index);
|
||||
int fd = g_unix_fd_list_get(fds, index, NULL);
|
||||
@@ -297,12 +315,22 @@ static int connect_pipewire(struct uu_portal *p) {
|
||||
if (pw_stream_connect(p->stream, PW_DIRECTION_INPUT, p->node,
|
||||
PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS, params, 2) < 0) return 7;
|
||||
if (pw_thread_loop_start(p->pw_loop) < 0) return 7;
|
||||
struct timespec until; clock_gettime(CLOCK_REALTIME, &until); until.tv_sec += 10;
|
||||
return wait_for_first_frame(p);
|
||||
}
|
||||
static int wait_for_first_frame(struct uu_portal *p) {
|
||||
struct timespec until;
|
||||
gint64 deadline = g_get_monotonic_time() + 10 * G_TIME_SPAN_SECOND;
|
||||
pthread_mutex_lock(&p->lock);
|
||||
while (!p->sequence && !p->error) {
|
||||
if (pthread_cond_timedwait(&p->changed, &p->lock, &until)) break;
|
||||
while (!p->sequence && !p->error && !open_cancelled(p)) {
|
||||
gint64 remaining = deadline - g_get_monotonic_time();
|
||||
if (remaining <= 0) break;
|
||||
clock_gettime(CLOCK_REALTIME, &until);
|
||||
gint64 wait_us = MIN(100000, remaining);
|
||||
until.tv_nsec += wait_us * 1000;
|
||||
if (until.tv_nsec >= 1000000000) { until.tv_sec++; until.tv_nsec -= 1000000000; }
|
||||
pthread_cond_timedwait(&p->changed, &p->lock, &until);
|
||||
}
|
||||
int result = p->error ? p->error : p->sequence ? 0 : 10;
|
||||
int result = p->error ? p->error : open_cancelled(p) ? 13 : p->sequence ? 0 : 10;
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
return result;
|
||||
}
|
||||
@@ -327,10 +355,14 @@ static int read_stream_result(struct uu_portal *p, GVariant *results) {
|
||||
if (streams) g_variant_unref(streams);
|
||||
return error;
|
||||
}
|
||||
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *), void *data, int *error, uint32_t *width, uint32_t *height) {
|
||||
static struct uu_portal *open_persist(const char *restore, void (*save_token)(const char *, void *),
|
||||
void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data,
|
||||
int *error, uint32_t *width, uint32_t *height) {
|
||||
*error = 0; *width = *height = 0;
|
||||
struct uu_portal *p = calloc(1, sizeof(*p));
|
||||
if (!p) { *error = 8; return NULL; }
|
||||
p->cancelled = cancelled;
|
||||
p->cancel_data = cancel_data;
|
||||
/* GNOME forwards NotifyPointerMotionAbsolute into Mutter's stream-to-stage
|
||||
* transform. It expects stream pixels, unlike the compositor-sized KDE path.
|
||||
* Do not apply the compositor scale twice on fractional-scale displays. */
|
||||
@@ -342,7 +374,10 @@ struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)
|
||||
p->context = g_main_context_new(); g_main_context_push_thread_default(p->context);
|
||||
p->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
|
||||
if (!p->bus) { *error = 1; goto done; }
|
||||
if (!has_interface(p, REMOTE) || !has_interface(p, SCREEN)) { *error = 2; goto done; }
|
||||
if (open_cancelled(p)) { *error = 13; goto done; }
|
||||
int interfaces_available = has_interface(p, REMOTE) && has_interface(p, SCREEN);
|
||||
if (open_cancelled(p)) { *error = 13; goto done; }
|
||||
if (!interfaces_available) { *error = 2; goto done; }
|
||||
GVariantBuilder options; GVariant *results;
|
||||
g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT);
|
||||
char token[64]; snprintf(token, sizeof(token), "uu_session_%u_%u", (unsigned)getpid(), atomic_fetch_add(&token_sequence, 1));
|
||||
@@ -405,24 +440,42 @@ struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)
|
||||
fprintf(stderr, "Portal persistence: requested=%d restore_attempted=%d token_returned=%d\n",
|
||||
version >= 2, restore && *restore, p->restore_token && *p->restore_token);
|
||||
}
|
||||
if (!*error && p->restore_token && save_token) save_token(p->restore_token, data);
|
||||
if (!*error && p->restore_token && save_token) save_token(p->restore_token, save_data);
|
||||
g_variant_unref(results);
|
||||
if (*error) goto done;
|
||||
p->main_loop = g_main_loop_new(p->context, FALSE);
|
||||
g_main_context_pop_thread_default(p->context);
|
||||
if (pthread_create(&p->dbus_thread, NULL, run_dbus, p)) { *error = 3; uu_portal_close(p); return NULL; }
|
||||
if (pthread_create(&p->dbus_thread, NULL, run_dbus, p)) {
|
||||
*error = 3; p->cancelled = NULL; p->cancel_data = NULL;
|
||||
uu_portal_close(p); return NULL;
|
||||
}
|
||||
p->dbus_started = 1;
|
||||
*error = connect_pipewire(p);
|
||||
if (*error) { uu_portal_close(p); return NULL; }
|
||||
if (*error) {
|
||||
p->cancelled = NULL; p->cancel_data = NULL;
|
||||
uu_portal_close(p); return NULL;
|
||||
}
|
||||
fprintf(stderr, "Portal pointer geometry: frame=%ux%u compositor=%dx%d absolute=%s\n",
|
||||
p->width, p->height, p->logical_width, p->logical_height,
|
||||
p->absolute_stream_pixels ? "stream-pixels-or-eis" : "compositor-logical");
|
||||
*width = p->width; *height = p->height;
|
||||
p->cancelled = NULL; p->cancel_data = NULL;
|
||||
return p;
|
||||
done:
|
||||
g_main_context_pop_thread_default(p->context);
|
||||
p->cancelled = NULL; p->cancel_data = NULL;
|
||||
uu_portal_close(p); return NULL;
|
||||
}
|
||||
struct uu_portal *uu_portal_open_persist_cancellable(const char *restore,
|
||||
void (*save_token)(const char *, void *), void *save_data,
|
||||
uu_portal_cancelled_fn cancelled, void *cancel_data,
|
||||
int *error, uint32_t *width, uint32_t *height) {
|
||||
return open_persist(restore, save_token, save_data, cancelled, cancel_data, error, width, height);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *),
|
||||
void *data, int *error, uint32_t *width, uint32_t *height) {
|
||||
return open_persist(restore, save_token, data, NULL, NULL, error, width, height);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height) {
|
||||
return uu_portal_open_persist(restore, NULL, NULL, error, width, height);
|
||||
}
|
||||
|
||||
@@ -3,10 +3,13 @@
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
struct uu_portal;
|
||||
typedef int (*uu_portal_cancelled_fn)(void *data);
|
||||
/* One object owns one consent/session and one PipeWire stream. */
|
||||
struct uu_portal *uu_portal_open(int *error, uint32_t *width, uint32_t *height);
|
||||
/* Saves the rotated token immediately after Start, before video initialization. */
|
||||
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *), void *data, int *error, uint32_t *width, uint32_t *height);
|
||||
/* The cancellation callback and data are used only until this call returns. */
|
||||
struct uu_portal *uu_portal_open_persist_cancellable(const char *restore, void (*save_token)(const char *, void *), void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int *error, uint32_t *width, uint32_t *height);
|
||||
struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height);
|
||||
const char *uu_portal_restore_token(struct uu_portal *portal);
|
||||
void uu_portal_close(struct uu_portal *portal);
|
||||
|
||||
Reference in new issue
Block a user