FreeRDP
Loading...
Searching...
No Matches
mutter_shadow.c
1
18
19/* The shadow server for a GNOME session, through Mutter's own D-Bus APIs on
20 * the session bus (no portal, so no permission dialog: only the session's own
21 * user reaches its bus):
22 *
23 * 1. org.gnome.Mutter.DisplayConfig.GetCurrentState the monitors
24 * 2. RemoteDesktop.CreateSession a remote desktop session
25 * 3. ScreenCast.CreateSession, tied to it a screen cast session
26 * 4. ScreenCast.Session.RecordMonitor(connector) a stream of one monitor,
27 * the cursor as metadata (the clients draw it)
28 * 5. RemoteDesktop.Session.Start PipeWireStreamAdded(node)
29 * 6. RemoteDesktop.Session.ConnectToEIS input through libei
30 *
31 * The frames arrive as a PipeWire stream in shared memory, with the damaged
32 * regions and the cursor as buffer metadata. One thread waits on the session
33 * bus, the PipeWire loop and libei; the clients' threads post input to libei
34 * under a lock.
35 */
36
37#include <errno.h>
38#include <fcntl.h>
39#include <math.h>
40#include <poll.h>
41#include <pwd.h>
42#include <stdarg.h>
43#include <string.h>
44#include <time.h>
45#include <unistd.h>
46
47#include <linux/input-event-codes.h>
48
49#include <spa/param/audio/format-utils.h>
50#include <spa/param/video/format-utils.h>
51#include <spa/param/buffers.h>
52#include <spa/buffer/meta.h>
53
54#include <winpr/assert.h>
55#include <winpr/crt.h>
56#include <winpr/collections.h>
57#include <winpr/input.h>
58#include <winpr/interlocked.h>
59#include <winpr/path.h>
60#include <winpr/synch.h>
61#include <winpr/sysinfo.h>
62
63#include <freerdp/server/server-common.h>
64#include <freerdp/codec/audio.h>
65#include <freerdp/codec/color.h>
66#include <freerdp/codec/dsp.h>
67#include <freerdp/codec/region.h>
68#include <freerdp/log.h>
69
70#ifdef WITH_PAM
71#include <security/pam_appl.h>
72#endif
73
74#include "mutter_shadow.h"
75
76#define TAG SERVER_TAG("shadow.mutter")
77
78#define DC_NAME "org.gnome.Mutter.DisplayConfig"
79#define DC_PATH "/org/gnome/Mutter/DisplayConfig"
80#define RD_NAME "org.gnome.Mutter.RemoteDesktop"
81#define RD_PATH "/org/gnome/Mutter/RemoteDesktop"
82#define RD_SESSION_IFACE "org.gnome.Mutter.RemoteDesktop.Session"
83#define SC_NAME "org.gnome.Mutter.ScreenCast"
84#define SC_PATH "/org/gnome/Mutter/ScreenCast"
85#define SC_SESSION_IFACE "org.gnome.Mutter.ScreenCast.Session"
86#define SC_STREAM_IFACE "org.gnome.Mutter.ScreenCast.Stream"
87
88/* ScreenCast cursor mode: the cursor comes as buffer metadata, not painted in */
89#define MUTTER_CURSOR_MODE_EMBEDDED 1u
90#define MUTTER_CURSOR_MODE_METADATA 2u
91#define MUTTER_VIRTUAL_ENV "FREERDP_SHADOW_MUTTER_VIRTUAL"
92/* "0" turns off the check for changes Mutter left out of its damage */
93#define MUTTER_DAMAGE_CHECK_ENV "FREERDP_SHADOW_MUTTER_DAMAGE_CHECK"
94#define MUTTER_CHECK_TILE 64
95#define SCREEN_SAVER_NAME "org.gnome.ScreenSaver"
96#define SCREEN_SAVER_PATH "/org/gnome/ScreenSaver"
97
98/* FREERDP_SHADOW_MUTTER_VIRTUAL=<w>x<h>: TRUE and the size when set and valid */
99WINPR_ATTR_NODISCARD
100static BOOL mutter_virtual_size(UINT32* width, UINT32* height)
101{
102 WINPR_ASSERT(width);
103 WINPR_ASSERT(height);
104
105 *width = 0;
106 *height = 0;
107
108 // NOLINTNEXTLINE(concurrency-mt-unsafe)
109 const char* env = getenv(MUTTER_VIRTUAL_ENV);
110 if (!env)
111 return FALSE;
112
113 errno = 0;
114
115 char* next = nullptr;
116 unsigned long w = strtoul(env, &next, 0);
117 if ((errno != 0) || (w < 64) || (w > 8192))
118 return FALSE;
119 if (!next || (*next != 'x'))
120 return FALSE;
121
122 unsigned long h = strtoul(&next[1], nullptr, 0);
123 if ((errno != 0) || (h < 64) || (h > 8192))
124 return FALSE;
125
126 *width = WINPR_ASSERTING_INT_CAST(UINT32, w);
127 *height = WINPR_ASSERTING_INT_CAST(UINT32, h);
128 return TRUE;
129}
130
131/* cursor metadata: position, hot spot and, when the shape changes, a bitmap;
132 * Mutter's bitmaps are up to 384x384 */
133#define MUTTER_CURSOR_META_SIZE(width, height) \
134 (sizeof(struct spa_meta_cursor) + sizeof(struct spa_meta_bitmap) + 4ull * (width) * (height))
135#define MUTTER_CURSOR_META_MAX 384u
136
137/* the largest pointer sent to the clients */
138#define MUTTER_SHADOW_CURSOR_MAX 96u
139
140/* how long after a client's own pointer motion the server leaves the pointer
141 * position to that client */
142#define MUTTER_SHADOW_CURSOR_QUIET_MS 500u
143
144/* damage rectangles taken from one buuffer */
145#define MUTTER_MAX_DAMAGE 16u
146
147/* how long Mutter may take to offer its API, announce the stream, and give
148 * the stream a format */
149#define MUTTER_NAME_TIMEOUT_MS 10000u
150#define MUTTER_STREAM_TIMEOUT_MS 5000u
151#define MUTTER_FORMAT_TIMEOUT_MS 5000u
152/* after Mutter's node goes away, how long a Closed may take to follow it */
153#define MUTTER_STREAM_GONE_GRACE_MS 250u
154
155/* the messages of the clipboard, to the subsystem thread and its data thread */
156#define MUTTER_MSG_CLIPBOARD_OFFER 0x10001
157#define MUTTER_MSG_CLIPBOARD_READ 0x10002
158#define MUTTER_MSG_CLIPBOARD_PROVIDE 0x10003
159#define MUTTER_MSG_CLIPBOARD_WRITE_DONE 0x10004
160/* a transfer gives up when its application stays silent for this long */
161#define MUTTER_CLIPBOARD_STALL_MS 5000
162#define MUTTER_CLIPBOARD_CALL_USEC (2ull * 1000ull * 1000ull)
163/* the mime types of a selection that the session offers */
164#define MUTTER_CLIPBOARD_MAX_MIMES 64
165
166/* What the clients hear: 48 kHz, 2 channels, 16 bits; PipeWire converts what
167 * the sink plays to it. The build may have no resampler, so every format
168 * offered has that rate and channel count, and 16 bits a sample: rdpsnd sizes
169 * its buffers from the bits and channels of the first one. Opus first, so that
170 * a client that has it takes it (96 kbit/s instead of 1.5 Mbit/s for PCM). Its
171 * block alignment is 1: rdpsnd pads every wave to a multiple of it with zeros,
172 * and an Opus packet with zeros after it no longer decodes. */
173#define MUTTER_AUDIO_RATE 48000u
174#define MUTTER_AUDIO_CHANNELS 2u
175#define MUTTER_AUDIO_FRAME_BYTES (MUTTER_AUDIO_CHANNELS * 2ull)
176/* samples are sent in messages of 20 ms */
177#define MUTTER_AUDIO_MESSAGE_FRAMES (MUTTER_AUDIO_RATE / 50u)
178/* how often the sound statistics are logged (debug level) */
179#define MUTTER_AUDIO_LOG_MS 5000u
180/* a message to the subsystem thread: the virtual monitor takes a client's size */
181#define MUTTER_MSG_VIRTUAL_SIZE 0x10005
182#define MUTTER_MSG_UNLOCK 0x10006
183
184/* How long a client waits for the virtual monitor to take its size */
185#define MUTTER_VIRTUAL_SIZE_WAIT_MS 1000
186
187/* xkbcommon's core modifiers: Lock is Caps Lock, Mod2 is Num Lock in every
188 * stock keymap */
189#define MUTTER_MOD_LOCK (1u << 1)
190#define MUTTER_MOD_NUM (1u << 4)
191
192/* DisplayConfig.GetCurrentState: a physical monitor's connector and the size of
193 * its current mode */
194typedef struct
195{
196 char connector[MUTTER_SHADOW_CONNECTOR_SIZE];
197 INT32 width;
198 INT32 height;
199} MUTTER_MODE;
200
201/* DisplayConfig.GetCurrentState: a logical monitor, where it is in the layout */
202typedef struct
203{
204 INT32 x;
205 INT32 y;
206 double scale;
207 uint32_t transform;
208 int primary;
209 char connector[MUTTER_SHADOW_CONNECTOR_SIZE];
210} MUTTER_LOGICAL;
211
212static const AUDIO_FORMAT mutter_audio_offered_formats[] = {
213 { WAVE_FORMAT_OPUS, MUTTER_AUDIO_CHANNELS, MUTTER_AUDIO_RATE, 12000, 1, 16, 0, nullptr },
214 { WAVE_FORMAT_PCM, MUTTER_AUDIO_CHANNELS, MUTTER_AUDIO_RATE,
215 (MUTTER_AUDIO_RATE * MUTTER_AUDIO_FRAME_BYTES), MUTTER_AUDIO_FRAME_BYTES, 16, 0, nullptr },
216};
217
218/* ------------------------------------------------------------------------ */
219/* D-Bus */
220/* ------------------------------------------------------------------------ */
221
222WINPR_ATTR_NODISCARD
223static BOOL mutter_wait_for_name(sd_bus* bus, const char* name, UINT64 timeoutMs)
224{
225 WINPR_ASSERT(bus);
226 WINPR_ASSERT(name);
227
228 const UINT64 start = GetTickCount64();
229 BOOL logged = FALSE;
230
231 for (;;)
232 {
233 sd_bus_error err = SD_BUS_ERROR_NULL;
234 sd_bus_message* reply = nullptr;
235 int hasOwner = 0;
236
237 const int called =
238 sd_bus_call_method(bus, "org.freedesktop.DBus", "/org/freedesktop/DBus",
239 "org.freedesktop.DBus", "NameHasOwner", &err, &reply, "s", name);
240 const BOOL owned =
241 (called >= 0) && (sd_bus_message_read(reply, "b", &hasOwner) >= 0) && hasOwner;
242 sd_bus_message_unref(reply);
243 sd_bus_error_free(&err);
244 if (owned)
245 return TRUE;
246
247 if (GetTickCount64() - start > timeoutMs)
248 return FALSE;
249 if (!logged)
250 {
251 WLog_INFO(TAG, "waiting for %s on the session bus", name);
252 logged = TRUE;
253 }
254 Sleep(200);
255 }
256}
257
258/* Calls a method that returns one object path; *out gets a copy */
259WINPR_ATTR_NODISCARD
260static BOOL mutter_call_for_path(sd_bus* bus, sd_bus_message* call, const char* what, char** out)
261{
262 WINPR_ASSERT(bus);
263 WINPR_ASSERT(call);
264 WINPR_ASSERT(what);
265 WINPR_ASSERT(out);
266
267 sd_bus_error err = SD_BUS_ERROR_NULL;
268 sd_bus_message* reply = nullptr;
269 const char* path = nullptr;
270
271 const int called = sd_bus_call(bus, call, 0, &err, &reply);
272 if (called < 0)
273 {
274 char buffer[128] = WINPR_C_ARRAY_INIT;
275 WLog_ERR(TAG, "%s failed: %s", what,
276 err.message ? err.message : winpr_strerror(-called, buffer, sizeof(buffer)));
277 sd_bus_error_free(&err);
278 return FALSE;
279 }
280
281 if ((sd_bus_message_read(reply, "o", &path) >= 0) && path)
282 *out = _strdup(path);
283 sd_bus_message_unref(reply);
284 return *out != nullptr;
285}
286
287/* Reads a dictionary, a{sv}: the value of key (of type 'b', 'u' or 's') goes to value
288 * when the key is there, the other entries are skipped */
289WINPR_ATTR_NODISCARD
290static BOOL mutter_read_dict(sd_bus_message* msg, const char* key, char type, void* value)
291{
292 WINPR_ASSERT(msg);
293 WINPR_ASSERT(key);
294 WINPR_ASSERT(value);
295
296 const char contents[2] = { type, '\0' };
297
298 if (sd_bus_message_enter_container(msg, 'a', "{sv}") < 0)
299 return FALSE;
300
301 for (;;)
302 {
303 const int entered = sd_bus_message_enter_container(msg, 'e', "sv");
304 if (entered < 0)
305 return FALSE;
306 if (entered == 0)
307 break;
308
309 const char* name = nullptr;
310 if (sd_bus_message_read(msg, "s", &name) < 0)
311 return FALSE;
312 if (name && (strcmp(name, key) == 0))
313 {
314 if (sd_bus_message_read(msg, "v", contents, value) < 0)
315 return FALSE;
316 }
317 else if (sd_bus_message_skip(msg, "v") < 0)
318 return FALSE;
319
320 if (sd_bus_message_exit_container(msg) < 0)
321 return FALSE;
322 }
323
324 return sd_bus_message_exit_container(msg) >= 0;
325}
326
327/* Reads one physical monitor, ((ssss)a(siiddada{sv})a{sv}): its connector and the
328 * size of its current mode. *more is FALSE after the last one. */
329WINPR_ATTR_NODISCARD
330static BOOL mutter_read_monitor(sd_bus_message* reply, MUTTER_MODE* mode, BOOL* more)
331{
332 WINPR_ASSERT(reply);
333 WINPR_ASSERT(mode);
334 WINPR_ASSERT(more);
335
336 const int entered = sd_bus_message_enter_container(reply, 'r', "(ssss)a(siiddada{sv})a{sv}");
337 if (entered < 0)
338 return FALSE;
339 *more = (entered > 0);
340 if (!*more)
341 return TRUE;
342
343 const char* connector = nullptr;
344 if (sd_bus_message_read(reply, "(ssss)", &connector, nullptr, nullptr, nullptr) < 0)
345 return FALSE;
346 (void)_snprintf(mode->connector, sizeof(mode->connector), "%s", connector ? connector : "");
347
348 if (sd_bus_message_enter_container(reply, 'a', "(siiddada{sv})") < 0)
349 return FALSE;
350 for (;;)
351 {
352 const int modeEntered = sd_bus_message_enter_container(reply, 'r', "siiddada{sv}");
353 if (modeEntered < 0)
354 return FALSE;
355 if (modeEntered == 0)
356 break;
357
358 int32_t width = 0;
359 int32_t height = 0;
360 int current = 0;
361 if ((sd_bus_message_read(reply, "siidd", nullptr, &width, &height, nullptr, nullptr) < 0) ||
362 (sd_bus_message_skip(reply, "ad") < 0) ||
363 !mutter_read_dict(reply, "is-current", 'b', &current) ||
364 (sd_bus_message_exit_container(reply) < 0))
365 return FALSE;
366
367 if (current)
368 {
369 mode->width = width;
370 mode->height = height;
371 }
372 }
373
374 return (sd_bus_message_exit_container(reply) >= 0) && /* the modes */
375 (sd_bus_message_skip(reply, "a{sv}") >= 0) &&
376 (sd_bus_message_exit_container(reply) >= 0);
377}
378
379/* Reads one logical monitor, (iiduba(ssss)a{sv}): where it is and its (first)
380 * connector. *more is FALSE after the last one. */
381WINPR_ATTR_NODISCARD
382static BOOL mutter_read_logical(sd_bus_message* reply, MUTTER_LOGICAL* logical, BOOL* more)
383{
384 WINPR_ASSERT(reply);
385 WINPR_ASSERT(logical);
386 WINPR_ASSERT(more);
387
388 const int entered = sd_bus_message_enter_container(reply, 'r', "iiduba(ssss)a{sv}");
389 if (entered < 0)
390 return FALSE;
391 *more = (entered > 0);
392 if (!*more)
393 return TRUE;
394
395 int32_t x = 0;
396 int32_t y = 0;
397 double scale = 1.0;
398 uint32_t transform = 0;
399 int primary = 0;
400 if ((sd_bus_message_read(reply, "iidub", &x, &y, &scale, &transform, &primary) < 0) ||
401 (sd_bus_message_enter_container(reply, 'a', "(ssss)") < 0))
402 return FALSE;
403
404 const char* connector = nullptr;
405 for (;;)
406 {
407 const char* name = nullptr;
408 const int read = sd_bus_message_read(reply, "(ssss)", &name, nullptr, nullptr, nullptr);
409 if (read < 0)
410 return FALSE;
411 if (read == 0)
412 break;
413 if (!connector)
414 connector = name;
415 }
416
417 logical->x = x;
418 logical->y = y;
419 logical->scale = (scale > 0.0) ? scale : 1.0;
420 logical->transform = transform;
421 logical->primary = primary;
422 (void)_snprintf(logical->connector, sizeof(logical->connector), "%s",
423 connector ? connector : "");
424
425 return (sd_bus_message_exit_container(reply) >= 0) && /* the connectors */
426 (sd_bus_message_skip(reply, "a{sv}") >= 0) &&
427 (sd_bus_message_exit_container(reply) >= 0);
428}
429
430/* Reads GetCurrentState's reply: the physical monitors' modes, the logical
431 * monitors, and the layout mode */
432WINPR_ATTR_NODISCARD
433static BOOL mutter_read_state(sd_bus_message* reply, MUTTER_MODE* modes, size_t* nmodes,
434 MUTTER_LOGICAL* logical, size_t* nlogical, uint32_t* layoutMode)
435{
436 WINPR_ASSERT(reply);
437 WINPR_ASSERT(modes);
438 WINPR_ASSERT(nmodes);
439 WINPR_ASSERT(logical);
440 WINPR_ASSERT(nlogical);
441 WINPR_ASSERT(layoutMode);
442
443 if ((sd_bus_message_read(reply, "u", nullptr) < 0) ||
444 (sd_bus_message_enter_container(reply, 'a', "((ssss)a(siiddada{sv})a{sv})") < 0))
445 return FALSE;
446 for (;;)
447 {
448 MUTTER_MODE mode = WINPR_C_ARRAY_INIT;
449 BOOL more = FALSE;
450 if (!mutter_read_monitor(reply, &mode, &more))
451 return FALSE;
452 if (!more)
453 break;
454 if (*nmodes < MUTTER_SHADOW_MAX_MONITORS)
455 modes[(*nmodes)++] = mode;
456 }
457 if ((sd_bus_message_exit_container(reply) < 0) ||
458 (sd_bus_message_enter_container(reply, 'a', "(iiduba(ssss)a{sv})") < 0))
459 return FALSE;
460
461 for (;;)
462 {
463 MUTTER_LOGICAL entry = WINPR_C_ARRAY_INIT;
464 BOOL more = FALSE;
465 if (!mutter_read_logical(reply, &entry, &more))
466 return FALSE;
467 if (!more)
468 break;
469 if (*nlogical < MUTTER_SHADOW_MAX_MONITORS)
470 logical[(*nlogical)++] = entry;
471 }
472 if (sd_bus_message_exit_container(reply) < 0)
473 return FALSE;
474
475 return mutter_read_dict(reply, "layout-mode", 'u', layoutMode);
476}
477
478/* The logical monitors, in Mutter's layout, primary first. connectors gets
479 * each one's (first) connector. Returns the count. */
480WINPR_ATTR_NODISCARD
481static UINT32 mutter_list_monitors(sd_bus* bus, MONITOR_DEF* monitors,
482 char (*connectors)[MUTTER_SHADOW_CONNECTOR_SIZE], UINT32 max)
483{
484 WINPR_ASSERT(bus);
485 WINPR_ASSERT(monitors);
486
487 sd_bus_error err = SD_BUS_ERROR_NULL;
488 sd_bus_message* reply = nullptr;
489 MUTTER_MODE modes[MUTTER_SHADOW_MAX_MONITORS] = WINPR_C_ARRAY_INIT;
490 MUTTER_LOGICAL logical[MUTTER_SHADOW_MAX_MONITORS] = WINPR_C_ARRAY_INIT;
491 size_t nmodes = 0;
492 size_t nlogical = 0;
493 uint32_t layoutMode = 1; /* logical: sizes are divided by the scale */
494 UINT32 count = 0;
495
496 const int called =
497 sd_bus_call_method(bus, DC_NAME, DC_PATH, DC_NAME, "GetCurrentState", &err, &reply, "");
498 if (called < 0)
499 {
500 char buffer[128] = WINPR_C_ARRAY_INIT;
501 WLog_WARN(TAG, "GetCurrentState failed: %s",
502 err.message ? err.message : winpr_strerror(-called, buffer, sizeof(buffer)));
503 sd_bus_error_free(&err);
504 return 0;
505 }
506
507 const BOOL parsed = mutter_read_state(reply, modes, &nmodes, logical, &nlogical, &layoutMode);
508 sd_bus_message_unref(reply);
509 if (!parsed)
510 WLog_WARN(TAG, "GetCurrentState: unexpected reply");
511
512 /* primary first, then Mutter's order */
513 for (int pass = 0; pass < 2; pass++)
514 {
515 for (size_t x = 0; (x < nlogical) && (count < max); x++)
516 {
517 if ((pass == 0) != (logical[x].primary != 0))
518 continue;
519
520 INT32 width = 0;
521 INT32 height = 0;
522 for (size_t m = 0; m < nmodes; m++)
523 {
524 if (strcmp(modes[m].connector, logical[x].connector) == 0)
525 {
526 width = modes[m].width;
527 height = modes[m].height;
528 }
529 }
530 if ((width <= 0) || (height <= 0))
531 continue;
532
533 /* 90 and 270 degrees, flipped or not */
534 if (logical[x].transform & 1)
535 {
536 const INT32 tmp = width;
537 width = height;
538 height = tmp;
539 }
540 if (layoutMode == 1)
541 {
542 width = (INT32)(width / logical[x].scale + 0.5);
543 height = (INT32)(height / logical[x].scale + 0.5);
544 }
545
546 MONITOR_DEF* monitor = &monitors[count];
547 monitor->left = logical[x].x;
548 monitor->top = logical[x].y;
549 monitor->right = logical[x].x + width - 1;
550 monitor->bottom = logical[x].y + height - 1;
551 monitor->flags = logical[x].primary ? 1 : 0;
552 if (connectors)
553 (void)_snprintf(connectors[count], MUTTER_SHADOW_CONNECTOR_SIZE, "%s",
554 logical[x].connector);
555 count++;
556 }
557 }
558
559 return count;
560}
561
562WINPR_ATTR_NODISCARD
563static UINT32 mutter_shadow_enum_monitors(MONITOR_DEF* monitors, UINT32 maxMonitors)
564{
565 WINPR_ASSERT(monitors);
566
567 UINT32 width = 0;
568 UINT32 height = 0;
569 if ((maxMonitors > 0) && mutter_virtual_size(&width, &height))
570 {
571 /* the monitor this server will add: a GNOME session may have none yet */
572 monitors[0] = (MONITOR_DEF){ 0, 0, (INT32)width - 1, (INT32)height - 1, 1 };
573 return 1;
574 }
575
576 sd_bus* bus = nullptr;
577 const int opened = sd_bus_open_user(&bus);
578 if (opened < 0)
579 {
580 char buffer[128] = WINPR_C_ARRAY_INIT;
581 WLog_WARN(TAG, "cannot connect to the session bus: %s",
582 winpr_strerror(-opened, buffer, sizeof(buffer)));
583 return 0;
584 }
585
586 const UINT32 count = mutter_list_monitors(bus, monitors, nullptr, maxMonitors);
587 WLog_DBG(TAG, "%" PRIu32 " monitors", count);
588 sd_bus_flush_close_unref(bus);
589 return count;
590}
591
592WINPR_ATTR_NODISCARD
593static int mutter_on_stream_added(sd_bus_message* msg, void* data,
594 WINPR_ATTR_UNUSED sd_bus_error* err)
595{
596 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
597 WINPR_ASSERT(msg);
598 WINPR_ASSERT(mutter);
599
600 uint32_t node = 0;
601 if (sd_bus_message_read(msg, "u", &node) >= 0)
602 {
603 mutter->nodeId = node;
604 mutter->haveNode = TRUE;
605 WLog_DBG(TAG, "PipeWire node %" PRIu32, mutter->nodeId);
606 if (mutter->awaitNode)
607 {
608 mutter->awaitNode = FALSE;
609 mutter->reconnect = TRUE;
610 }
611 }
612 return 0;
613}
614
615WINPR_ATTR_NODISCARD
616static int mutter_on_closed(WINPR_ATTR_UNUSED sd_bus_message* msg, void* data,
617 WINPR_ATTR_UNUSED sd_bus_error* err)
618{
619 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
620 WINPR_ASSERT(mutter);
621
622 mutter->closed = TRUE;
623 return 0;
624}
625
626/* GNOME Shell left the session bus (it ended, or crashed): the sessions went with it */
627WINPR_ATTR_NODISCARD
628static int mutter_on_name_owner_changed(sd_bus_message* msg, void* data,
629 WINPR_ATTR_UNUSED sd_bus_error* err)
630{
631 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
632 WINPR_ASSERT(msg);
633 WINPR_ASSERT(mutter);
634
635 const char* name = nullptr;
636 const char* oldOwner = nullptr;
637 const char* newOwner = nullptr;
638 if ((sd_bus_message_read(msg, "sss", &name, &oldOwner, &newOwner) >= 0) && newOwner &&
639 (newOwner[0] == '\0'))
640 {
641 mutter->shellGone = TRUE;
642 mutter->closed = TRUE;
643 }
644 return 0;
645}
646
647/* The stream's "mapping-id" parameter names the libei region of its monitor */
648static void mutter_read_stream_parameters(mutterShadowSubsystem* mutter)
649{
650 WINPR_ASSERT(mutter);
651
652 sd_bus_error err = SD_BUS_ERROR_NULL;
653 sd_bus_message* reply = nullptr;
654 const char* mappingId = nullptr;
655
656 const int got = sd_bus_get_property(mutter->bus, SC_NAME, mutter->streamPath, SC_STREAM_IFACE,
657 "Parameters", &err, &reply, "a{sv}");
658 if (got < 0)
659 {
660 char buffer[128] = WINPR_C_ARRAY_INIT;
661 WLog_DBG(TAG, "no stream parameters: %s",
662 err.message ? err.message : winpr_strerror(-got, buffer, sizeof(buffer)));
663 sd_bus_error_free(&err);
664 return;
665 }
666
667 if (mutter_read_dict(reply, "mapping-id", 's', (void*)(&mappingId)) && mappingId)
668 {
669 /* the client threads look it up when they move the pointer */
670 char* copy = _strdup(mappingId);
671 EnterCriticalSection(&mutter->eiLock);
672 free(mutter->mappingId);
673 mutter->mappingId = copy;
674 LeaveCriticalSection(&mutter->eiLock);
675 }
676 sd_bus_message_unref(reply);
677}
678
679/* A stream of the monitor, in the screen cast session, with the cursor drawn
680 * into the picture.
681 *
682 * With the cursor as metadata instead (the clients would draw it, with no lag),
683 * Mutter 50 records a cursor frame at each stage update and skips the picture
684 * that follows it as "too early": on a stream that has just started, the
685 * stage may keep updating and no picture comes at all, neither the first one
686 * nor later changes (MUTTER_DEBUG=screen-cast: no full frame and about a
687 * thousand skipped in 10 s). Drawn in, there are no cursor frames to skip. */
688WINPR_ATTR_NODISCARD
689static BOOL mutter_record_monitor(mutterShadowSubsystem* mutter, const char* connector)
690{
691 WINPR_ASSERT(mutter);
692 WINPR_ASSERT(connector);
693
694 sd_bus_message* call = nullptr;
695 BOOL rc = FALSE;
696
697 if (mutter->virtualMonitor)
698 {
699 /* a monitor of its own: Mutter records it directly, with no "too early"
700 * skips, so the clients draw the cursor (metadata, no lag) */
701 if ((sd_bus_message_new_method_call(mutter->bus, &call, SC_NAME, mutter->scSessionPath,
702 SC_SESSION_IFACE, "RecordVirtual") < 0) ||
703 (sd_bus_message_append(call, "a{sv}", 1, "cursor-mode", "u",
704 (uint32_t)MUTTER_CURSOR_MODE_METADATA) < 0))
705 goto out;
706 WLog_DBG(TAG, "ScreenCast.Session.RecordVirtual(%" PRIu32 "x%" PRIu32 ")",
707 mutter->virtualWidth, mutter->virtualHeight);
708 if (!mutter_call_for_path(mutter->bus, call, "ScreenCast.Session.RecordVirtual",
709 &mutter->streamPath))
710 goto out;
711 }
712 else
713 {
714 if ((sd_bus_message_new_method_call(mutter->bus, &call, SC_NAME, mutter->scSessionPath,
715 SC_SESSION_IFACE, "RecordMonitor") < 0) ||
716 (sd_bus_message_append(call, "sa{sv}", connector, 1, "cursor-mode", "u",
717 (uint32_t)MUTTER_CURSOR_MODE_EMBEDDED) < 0))
718 goto out;
719 WLog_DBG(TAG, "ScreenCast.Session.RecordMonitor('%s')", connector);
720 if (!mutter_call_for_path(mutter->bus, call, "ScreenCast.Session.RecordMonitor",
721 &mutter->streamPath))
722 goto out;
723 }
724
725 if (sd_bus_match_signal(mutter->bus, &mutter->streamAddedSlot, SC_NAME, mutter->streamPath,
726 SC_STREAM_IFACE, "PipeWireStreamAdded", mutter_on_stream_added,
727 mutter) < 0)
728 {
729 WLog_ERR(TAG, "cannot watch the stream's signals");
730 goto out;
731 }
732 rc = TRUE;
733out:
734 sd_bus_message_unref(call);
735 return rc;
736}
737static void mutter_clipboard_enable(mutterShadowSubsystem* mutter);
738
739WINPR_ATTR_NODISCARD
740static BOOL mutter_setup_sessions(mutterShadowSubsystem* mutter, const char* connector)
741{
742 WINPR_ASSERT(mutter);
743 WINPR_ASSERT(connector);
744
745 sd_bus_error err = SD_BUS_ERROR_NULL;
746 sd_bus_message* call = nullptr;
747 sd_bus_message* reply = nullptr;
748 char* sessionId = nullptr;
749 BOOL rc = FALSE;
750
751 /* 1. the remote desktop session */
752 if (sd_bus_message_new_method_call(mutter->bus, &call, RD_NAME, RD_PATH, RD_NAME,
753 "CreateSession") < 0)
754 goto out;
755 WLog_DBG(TAG, "RemoteDesktop.CreateSession");
756 if (!mutter_call_for_path(mutter->bus, call, "RemoteDesktop.CreateSession",
757 &mutter->rdSessionPath))
758 goto out;
759 call = sd_bus_message_unref(call);
760
761 const int gotId = sd_bus_get_property_string(mutter->bus, RD_NAME, mutter->rdSessionPath,
762 RD_SESSION_IFACE, "SessionId", &err, &sessionId);
763 if (gotId < 0)
764 {
765 char buffer[128] = WINPR_C_ARRAY_INIT;
766 WLog_ERR(TAG, "no SessionId: %s",
767 err.message ? err.message : winpr_strerror(-gotId, buffer, sizeof(buffer)));
768 goto out;
769 }
770
771 /* 2. the screen cast session, tied to it */
772 if ((sd_bus_message_new_method_call(mutter->bus, &call, SC_NAME, SC_PATH, SC_NAME,
773 "CreateSession") < 0) ||
774 (sd_bus_message_append(call, "a{sv}", 1, "remote-desktop-session-id", "s", sessionId) < 0))
775 goto out;
776 WLog_DBG(TAG, "ScreenCast.CreateSession");
777 if (!mutter_call_for_path(mutter->bus, call, "ScreenCast.CreateSession",
778 &mutter->scSessionPath))
779 goto out;
780 call = sd_bus_message_unref(call);
781
782 /* 3. the monitor */
783 if (!mutter_record_monitor(mutter, connector))
784 goto out;
785
786 if ((sd_bus_match_signal(mutter->bus, &mutter->closedSlot, RD_NAME, mutter->rdSessionPath,
787 RD_SESSION_IFACE, "Closed", mutter_on_closed, mutter) < 0) ||
788 (sd_bus_add_match(mutter->bus, &mutter->ownerSlot,
789 "type='signal',sender='org.freedesktop.DBus',"
790 "path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',"
791 "member='NameOwnerChanged',arg0='" RD_NAME "'",
792 mutter_on_name_owner_changed, mutter) < 0))
793 {
794 WLog_ERR(TAG, "cannot watch the stream's signals");
795 goto out;
796 }
797
798 /* 4. start, then wait for the PipeWire node */
799 WLog_DBG(TAG, "RemoteDesktop.Session.Start");
800 const int started = sd_bus_call_method(mutter->bus, RD_NAME, mutter->rdSessionPath,
801 RD_SESSION_IFACE, "Start", &err, nullptr, "");
802 if (started < 0)
803 {
804 char buffer[128] = WINPR_C_ARRAY_INIT;
805 WLog_ERR(TAG, "RemoteDesktop.Session.Start failed: %s",
806 err.message ? err.message : winpr_strerror(-started, buffer, sizeof(buffer)));
807 goto out;
808 }
809 mutter->started = TRUE;
810
811 const UINT64 start = GetTickCount64();
812 while (!mutter->haveNode)
813 {
814 const int processed = sd_bus_process(mutter->bus, nullptr);
815 if (processed < 0)
816 goto out;
817 if (processed > 0)
818 continue;
819 if (GetTickCount64() - start > MUTTER_STREAM_TIMEOUT_MS)
820 {
821 WLog_ERR(TAG, "Mutter announced no PipeWire stream");
822 goto out;
823 }
824 (void)sd_bus_wait(mutter->bus, 100ull * 1000ull);
825 }
826 mutter_read_stream_parameters(mutter);
827
828 /* 5. input */
829 int fd = -1;
830 const int connected =
831 sd_bus_call_method(mutter->bus, RD_NAME, mutter->rdSessionPath, RD_SESSION_IFACE,
832 "ConnectToEIS", &err, &reply, "a{sv}", 0);
833 if ((connected < 0) || (sd_bus_message_read(reply, "h", &fd) < 0))
834 {
835 WLog_WARN(TAG, "ConnectToEIS failed: %s: the clients can only watch",
836 err.message ? err.message : "bad reply");
837 }
838 else
839 {
840 /* the reply owns the fd */
841 fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
842 mutter->ei = ei_new_sender(mutter);
843 if (mutter->ei)
844 {
845 ei_configure_name(mutter->ei, "FreeRDP shadow server");
846 if (ei_setup_backend_fd(mutter->ei, fd) != 0)
847 {
848 WLog_WARN(TAG, "libei setup failed: the clients can only watch");
849 mutter->ei = ei_unref(mutter->ei);
850 }
851 }
852 else
853 close(fd);
854 }
855
856 mutter_clipboard_enable(mutter);
857
858 rc = TRUE;
859out:
860 sd_bus_error_free(&err);
861 sd_bus_message_unref(reply);
862 sd_bus_message_unref(call);
863 free(sessionId);
864 return rc;
865}
866
867/* ------------------------------------------------------------------------ */
868/* the cursor */
869/* ------------------------------------------------------------------------ */
870
871static void mutter_cursor_msg_free(UINT32 id, SHADOW_MSG_OUT* msg)
872{
873 if (msg && (id == SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE_ID))
874 {
876 free(shape->xorMaskData);
877 free(shape->andMaskData);
878 }
879 free(msg);
880}
881
882WINPR_ATTR_NODISCARD
883static UINT32 mutter_cursor_hash(const BYTE* pixels, UINT32 width, UINT32 height, UINT32 xHot,
884 UINT32 yHot)
885{
886 WINPR_ASSERT(pixels);
887
888 /* FNV-1a over the size, the hot spot and the pixels */
889 UINT32 hash = 2166136261u;
890 const UINT32 header[] = { width, height, xHot, yHot };
891 const BYTE* parts[] = { (const BYTE*)header, pixels };
892 const size_t sizes[] = { sizeof(header), 4ull * width * height };
893 for (size_t p = 0; p < ARRAYSIZE(parts); p++)
894 {
895 for (size_t x = 0; x < sizes[p]; x++)
896 {
897 hash ^= parts[p][x];
898 hash *= 16777619u;
899 }
900 }
901 return hash;
902}
903
904static void mutter_cursor_send_shape(mutterShadowSubsystem* mutter, const BYTE* pixels,
905 UINT32 width, UINT32 height, UINT32 xHot, UINT32 yHot)
906{
907 WINPR_ASSERT(mutter);
908 WINPR_ASSERT(pixels);
909
910 const UINT32 hash = mutter_cursor_hash(pixels, width, height, xHot, yHot);
911 WLog_DBG(TAG, "pointer shape %" PRIu32 "x%" PRIu32 ", resend %d", width, height,
912 mutter->cursorResend);
913 if (mutter->cursorKnown && !mutter->cursorResend && (hash == mutter->cursorHash))
914 return;
915
917 calloc(1, sizeof(SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE));
918 if (!msg)
919 return;
920
921 msg->xHot = xHot;
922 msg->yHot = yHot;
923 msg->width = width;
924 msg->height = height;
925 /* Mutter's bitmaps are premultiplied RGBA */
926 if (shadow_subsystem_pointer_convert_alpha_pointer_data_to_format(pixels, PIXEL_FORMAT_RGBA32,
927 TRUE, width, height, msg) < 0)
928 {
929 free(msg);
930 return;
931 }
932
933 msg->common.Free = mutter_cursor_msg_free;
934 if (shadow_client_boardcast_msg(mutter->common.server, nullptr,
935 SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE_ID, &msg->common,
936 nullptr) >= 0)
937 {
938 mutter->cursorHash = hash;
939 mutter->cursorKnown = TRUE;
940 mutter->cursorResend = FALSE;
941 }
942}
943
944static void mutter_cursor_send_position(mutterShadowSubsystem* mutter, INT32 x, INT32 y)
945{
946 WINPR_ASSERT(mutter);
947
948 if ((x == mutter->cursorX) && (y == mutter->cursorY))
949 return;
950 mutter->cursorX = x;
951 mutter->cursorY = y;
952
953 /* while a client moves the pointer, it already knows where it is */
954 EnterCriticalSection(&mutter->eiLock);
955 const UINT64 input = mutter->pointerInput;
956 LeaveCriticalSection(&mutter->eiLock);
957 if (GetTickCount64() - input < MUTTER_SHADOW_CURSOR_QUIET_MS)
958 return;
959
960 if ((x < 0) || (y < 0) || ((UINT32)x >= mutter->width) || ((UINT32)y >= mutter->height))
961 return;
962
963 mutter->common.pointerX = (UINT32)x;
964 mutter->common.pointerY = (UINT32)y;
965
968 if (!msg)
969 return;
970 msg->xPos = (UINT32)x;
971 msg->yPos = (UINT32)y;
972 msg->common.Free = mutter_cursor_msg_free;
973 /* the message is freed with its last reference, also when no client took it */
974 if (shadow_client_boardcast_msg(mutter->common.server, nullptr,
975 SHADOW_MSG_OUT_POINTER_POSITION_UPDATE_ID, &msg->common,
976 nullptr) < 0)
977 WLog_DBG(TAG, "the pointer position was not sent");
978}
979
980/* Mutter sends a shape only when it changes, so a client that connects later would
981 * have no pointer until something else changed it */
982static void mutter_cursor_remember(mutterShadowSubsystem* mutter, const BYTE* pixels, UINT32 width,
983 UINT32 height, UINT32 xHot, UINT32 yHot)
984{
985 WINPR_ASSERT(mutter);
986 WINPR_ASSERT(pixels);
987
988 const size_t size = 4ull * width * height;
989 BYTE* copy = malloc(size);
990 if (!copy)
991 return;
992 memcpy(copy, pixels, size);
993
994 free(mutter->cursorPixels);
995 mutter->cursorPixels = copy;
996 mutter->cursorWidth = width;
997 mutter->cursorHeight = height;
998 mutter->cursorXHot = xHot;
999 mutter->cursorYHot = yHot;
1000}
1001
1002/* Until Mutter has sent a shape, which it may not do for long: an arrow, so a client is
1003 * never left with no pointer */
1004static void mutter_cursor_send_default(mutterShadowSubsystem* mutter)
1005{
1006 static const char* const arrow[] = { "X ", "XX ", "X.X ", "X..X ",
1007 "X...X ", "X....X ", "X.....X ", "X......X ",
1008 "X.......X ", "X........X ", "X.....XXXXX", "X..X..X ",
1009 "X.X X..X ", "XX X..X ", "X X..X ", " X..X ",
1010 " XX " };
1011 enum
1012 {
1013 ARROW_WIDTH = 11,
1014 ARROW_HEIGHT = ARRAYSIZE(arrow)
1015 };
1016 BYTE pixels[4ull * ARROW_WIDTH * ARROW_HEIGHT] = WINPR_C_ARRAY_INIT;
1017 for (size_t y = 0; y < ARROW_HEIGHT; y++)
1018 {
1019 for (size_t x = 0; x < ARROW_WIDTH; x++)
1020 {
1021 BYTE* pixel = &pixels[4ull * (y * ARROW_WIDTH + x)];
1022 if (arrow[y][x] == ' ')
1023 continue;
1024 const BYTE value = (arrow[y][x] == '.') ? 0xff : 0x00;
1025 pixel[0] = pixel[1] = pixel[2] = value;
1026 pixel[3] = 0xff;
1027 }
1028 }
1029 mutter_cursor_send_shape(mutter, pixels, ARROW_WIDTH, ARROW_HEIGHT, 0, 0);
1030}
1031
1032/* The cursor in a buffer's metadata: its position, and its shape when it changed */
1033static void mutter_cursor_update(mutterShadowSubsystem* mutter, struct spa_buffer* buf)
1034{
1035 WINPR_ASSERT(mutter);
1036 WINPR_ASSERT(buf);
1037
1038 struct spa_meta* meta = spa_buffer_find_meta(buf, SPA_META_Cursor);
1039 if (!meta || (meta->size < sizeof(struct spa_meta_cursor)))
1040 return;
1041
1042 const struct spa_meta_cursor* mc = (const struct spa_meta_cursor*)meta->data;
1043 if (mc->id == 0)
1044 return; /* no cursor in this buffer */
1045
1046 if (mc->bitmap_offset != 0)
1047 {
1048 if ((size_t)mc->bitmap_offset + sizeof(struct spa_meta_bitmap) > meta->size)
1049 return;
1050
1051 const struct spa_meta_bitmap* mb =
1052 SPA_PTROFF(mc, mc->bitmap_offset, const struct spa_meta_bitmap);
1053 if ((mb->format == 0) || (mb->offset == 0) || (mb->size.width == 0) ||
1054 (mb->size.height == 0))
1055 {
1056 /* Mutter sends an empty bitmap for a hidden pointer */
1057 const BYTE transparent[4] = WINPR_C_ARRAY_INIT;
1058 mutter_cursor_remember(mutter, transparent, 1, 1, 0, 0);
1059 mutter_cursor_send_shape(mutter, transparent, 1, 1, 0, 0);
1060 }
1061 else
1062 {
1063 const UINT32 width = mb->size.width;
1064 const UINT32 height = mb->size.height;
1065 const UINT32 stride = (mb->stride > 0) ? (UINT32)mb->stride : width * 4;
1066 if ((mb->format != SPA_VIDEO_FORMAT_RGBA) || (width > MUTTER_CURSOR_META_MAX) ||
1067 (height > MUTTER_CURSOR_META_MAX) || (stride < width * 4) ||
1068 ((size_t)mc->bitmap_offset + mb->offset + (size_t)stride * height > meta->size))
1069 {
1070 WLog_DBG(TAG,
1071 "unusable pointer bitmap (format %" PRIu32 ", %" PRIu32 "x%" PRIu32 ")",
1072 mb->format, width, height);
1073 }
1074 else
1075 {
1076 const BYTE* src = SPA_PTROFF(mb, mb->offset, const BYTE);
1077
1078 /* a pointer larger than the clients take is shrunk, nearest pixel */
1079 const UINT32 side = MAX(width, height);
1080 const UINT32 scaled = MIN(side, MUTTER_SHADOW_CURSOR_MAX);
1081 const UINT32 outW = MAX(1, width * scaled / side);
1082 const UINT32 outH = MAX(1, height * scaled / side);
1083 BYTE* pixels = calloc(4ull * outW, outH);
1084 if (pixels)
1085 {
1086 for (UINT32 y = 0; y < outH; y++)
1087 {
1088 const BYTE* row = src + (size_t)(y * side / scaled) * stride;
1089 for (UINT32 x = 0; x < outW; x++)
1090 memcpy(&pixels[4ull * (y * outW + x)], &row[4ull * (x * side / scaled)],
1091 4);
1092 }
1093 const UINT32 xHot =
1094 MIN((UINT32)MAX(mc->hotspot.x, 0) * scaled / side, outW - 1);
1095 const UINT32 yHot =
1096 MIN((UINT32)MAX(mc->hotspot.y, 0) * scaled / side, outH - 1);
1097 mutter_cursor_remember(mutter, pixels, outW, outH, xHot, yHot);
1098 mutter_cursor_send_shape(mutter, pixels, outW, outH, xHot, yHot);
1099 free(pixels);
1100 }
1101 }
1102 }
1103 }
1104
1105 mutter_cursor_send_position(mutter, mc->position.x, mc->position.y);
1106}
1107
1108/* ------------------------------------------------------------------------ */
1109/* PipeWire */
1110/* ------------------------------------------------------------------------ */
1111
1112static void mutter_set_monitor_size(mutterShadowSubsystem* mutter)
1113{
1114 WINPR_ASSERT(mutter);
1115
1116 rdpShadowSubsystem* subsystem = &mutter->common;
1117 MONITOR_DEF* monitor = &subsystem->monitors[subsystem->selectedMonitor];
1118
1119 /* the surface has the size of the frames */
1120 monitor->right = monitor->left + (INT32)mutter->width - 1;
1121 monitor->bottom = monitor->top + (INT32)mutter->height - 1;
1122
1123 MONITOR_DEF* virtualScreen = &subsystem->virtualScreen;
1124 *virtualScreen = subsystem->monitors[0];
1125 for (UINT32 x = 1; x < subsystem->numMonitors; x++)
1126 {
1127 const MONITOR_DEF* m = &subsystem->monitors[x];
1128 virtualScreen->left = MIN(virtualScreen->left, m->left);
1129 virtualScreen->top = MIN(virtualScreen->top, m->top);
1130 virtualScreen->right = MAX(virtualScreen->right, m->right);
1131 virtualScreen->bottom = MAX(virtualScreen->bottom, m->bottom);
1132 }
1133 virtualScreen->flags = 1;
1134}
1135
1136static void mutter_on_param_changed(void* data, uint32_t id, const struct spa_pod* param)
1137{
1138 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
1139 WINPR_ASSERT(mutter);
1140
1141 struct spa_video_info_raw info = WINPR_C_ARRAY_INIT;
1142 uint8_t podBuffer[1024] = WINPR_C_ARRAY_INIT;
1143 struct spa_pod_builder b = SPA_POD_BUILDER_INIT(podBuffer, sizeof(podBuffer));
1144 const struct spa_pod* params[4] = WINPR_C_ARRAY_INIT;
1145
1146 if (!param || (id != SPA_PARAM_Format))
1147 return;
1148 if (spa_format_video_raw_parse(param, &info) < 0)
1149 {
1150 WLog_ERR(TAG, "cannot parse the stream format");
1151 return;
1152 }
1153
1154 const BOOL sized = mutter->haveFormat;
1155 const BOOL changed = (info.size.width != mutter->width) || (info.size.height != mutter->height);
1156 mutter->width = info.size.width;
1157 mutter->height = info.size.height;
1158 mutter->format =
1159 (info.format == SPA_VIDEO_FORMAT_BGRA) ? PIXEL_FORMAT_BGRA32 : PIXEL_FORMAT_BGRX32;
1160 mutter->haveFormat = TRUE;
1161 mutter->fullPaint = TRUE;
1162 WLog_INFO(TAG, "stream: %" PRIu32 "x%" PRIu32 " %s", mutter->width, mutter->height,
1163 (info.format == SPA_VIDEO_FORMAT_BGRA) ? "BGRA" : "BGRx");
1164
1165 if (sized && changed)
1166 {
1167 /* the monitor changed its mode: the clients get the new size */
1168 mutter_set_monitor_size(mutter);
1169 if (!shadow_screen_resize(mutter->common.server->screen))
1170 WLog_ERR(TAG, "cannot resize the screen to %" PRIu32 "x%" PRIu32, mutter->width,
1171 mutter->height);
1172 }
1173
1174 WINPR_PRAGMA_DIAG_PUSH
1175 WINPR_PRAGMA_DIAG("-Wgnu-statement-expression-from-macro-expansion")
1176 /* shared memory only (no dma-buf), with the damage and the cursor */
1177 const int32_t stride = (int32_t)mutter->width * 4;
1178 params[0] = spa_pod_builder_add_object(
1179 &b, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers, SPA_PARAM_BUFFERS_buffers,
1180 SPA_POD_CHOICE_RANGE_Int(4, 2, 16), SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
1181 SPA_PARAM_BUFFERS_size, SPA_POD_Int(stride * (int32_t)mutter->height),
1182 SPA_PARAM_BUFFERS_stride, SPA_POD_Int(stride), SPA_PARAM_BUFFERS_dataType,
1183 SPA_POD_CHOICE_FLAGS_Int((1 << SPA_DATA_MemFd) | (1 << SPA_DATA_MemPtr)));
1184 params[1] = spa_pod_builder_add_object(&b, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
1185 SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
1186 SPA_PARAM_META_size,
1187 SPA_POD_Int(sizeof(struct spa_meta_header)));
1188 params[2] = spa_pod_builder_add_object(
1189 &b, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta, SPA_PARAM_META_type,
1190 SPA_POD_Id(SPA_META_VideoDamage), SPA_PARAM_META_size,
1191 SPA_POD_CHOICE_RANGE_Int(sizeof(struct spa_meta_region) * MUTTER_MAX_DAMAGE,
1192 sizeof(struct spa_meta_region),
1193 sizeof(struct spa_meta_region) * MUTTER_MAX_DAMAGE));
1194 params[3] = spa_pod_builder_add_object(
1195 &b, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta, SPA_PARAM_META_type,
1196 SPA_POD_Id(SPA_META_Cursor), SPA_PARAM_META_size,
1197 SPA_POD_CHOICE_RANGE_Int(
1198 MUTTER_CURSOR_META_SIZE(64, 64), MUTTER_CURSOR_META_SIZE(1, 1),
1199 MUTTER_CURSOR_META_SIZE(MUTTER_CURSOR_META_MAX, MUTTER_CURSOR_META_MAX)));
1200 WINPR_PRAGMA_DIAG_POP
1201
1202 (void)
1203 pw_stream_update_params(mutter->stream, params, ARRAYSIZE(params));
1204}
1205
1206/* Copies one rectangle of a frame to the surface and marks it changed */
1207static void mutter_copy_rect(mutterShadowSubsystem* mutter, rdpShadowSurface* surface,
1208 const BYTE* src, UINT32 stride, INT32 x, INT32 y, INT32 width,
1209 INT32 height)
1210{
1211 WINPR_ASSERT(mutter);
1212 WINPR_ASSERT(surface);
1213 WINPR_ASSERT(src);
1214
1215 const INT32 maxW = (INT32)MIN(mutter->width, surface->width);
1216 const INT32 maxH = (INT32)MIN(mutter->height, surface->height);
1217 const INT32 left = MAX(x, 0);
1218 const INT32 top = MAX(y, 0);
1219 const INT32 right = MIN(x + width, maxW);
1220 const INT32 bottom = MIN(y + height, maxH);
1221 if ((right <= left) || (bottom <= top))
1222 return;
1223
1224 if (!freerdp_image_copy_no_overlap(surface->data, surface->format, surface->scanline,
1225 (UINT32)left, (UINT32)top, (UINT32)(right - left),
1226 (UINT32)(bottom - top), src, mutter->format, stride,
1227 (UINT32)left, (UINT32)top, nullptr, FREERDP_FLIP_NONE))
1228 {
1229 WLog_ERR(TAG, "cannot copy the frame to the surface");
1230 return;
1231 }
1232 const RECTANGLE_16 rect = { (UINT16)left, (UINT16)top, (UINT16)right, (UINT16)bottom };
1233 if (!region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &rect))
1234 WLog_ERR(TAG, "cannot mark the changed region");
1235}
1236
1237/* Mutter's damage metadata now and then leaves out a change: a window that opens or closes, the
1238 * clock in the top bar. Nothing repaints it later, so the client kept the old picture there.
1239 * Compare the buffer with the surface in tiles after the damage was copied, and copy the tiles that
1240 * still differ. When the damage was right, every tile is equal and nothing is copied. Returns the
1241 * tiles copied. */
1242static UINT32 mutter_repair_missed_damage(mutterShadowSubsystem* mutter, rdpShadowSurface* surface,
1243 const BYTE* src, UINT32 stride)
1244{
1245 WINPR_ASSERT(mutter);
1246 WINPR_ASSERT(surface);
1247 WINPR_ASSERT(src);
1248
1249 const UINT32 width = MIN(mutter->width, surface->width);
1250 const UINT32 height = MIN(mutter->height, surface->height);
1251 /* the same format is copied byte for byte; otherwise compare the colour (alpha is undefined
1252 * in BGRx) */
1253 const BOOL sameFormat = (mutter->format == surface->format);
1254 UINT32 tiles = 0;
1255
1256 for (UINT32 ty = 0; ty < height; ty += MUTTER_CHECK_TILE)
1257 {
1258 const UINT32 th = MIN(MUTTER_CHECK_TILE, height - ty);
1259 for (UINT32 tx = 0; tx < width; tx += MUTTER_CHECK_TILE)
1260 {
1261 const UINT32 tw = MIN(MUTTER_CHECK_TILE, width - tx);
1262 BOOL dirty = FALSE;
1263 for (UINT32 y = ty; (y < ty + th) && !dirty; y++)
1264 {
1265 const BYTE* a = &src[1ull * y * stride + 4ull * tx];
1266 const BYTE* b = &surface->data[1ull * y * surface->scanline + 4ull * tx];
1267 if (sameFormat)
1268 dirty = (memcmp(a, b, 4ull * tw) != 0);
1269 else
1270 {
1271 for (UINT32 x = 0; (x < tw) && !dirty; x++)
1272 dirty = (memcmp(&a[4ull * x], &b[4ull * x], 3) != 0);
1273 }
1274 }
1275 if (dirty)
1276 {
1277 mutter_copy_rect(mutter, surface, src, stride, (INT32)tx, (INT32)ty, (INT32)tw,
1278 (INT32)th);
1279 tiles++;
1280 }
1281 }
1282 }
1283 return tiles;
1284}
1285
1286/* counts and logs what mutter_repair_missed_damage found */
1287static void mutter_damage_stats(mutterShadowSubsystem* mutter, UINT32 tiles)
1288{
1289 WINPR_ASSERT(mutter);
1290
1291 mutter->damageFrames++;
1292 mutter->damageTiles += tiles;
1293 if ((tiles > 0) && !mutter->damageMissSeen)
1294 {
1295 mutter->damageMissSeen = TRUE;
1296 WLog_INFO(TAG,
1297 "Mutter left changes out of its damage: %" PRIu32
1298 " tile(s) copied, the check stays on (" MUTTER_DAMAGE_CHECK_ENV
1299 "=0 turns it off)",
1300 tiles);
1301 }
1302 const UINT64 now = GetTickCount64();
1303 if (now - mutter->damageLogged >= 5000)
1304 {
1305 WLog_DBG(TAG, "damage check: %" PRIu64 " tile(s) Mutter left out, in %" PRIu64 " frame(s)",
1306 mutter->damageTiles, mutter->damageFrames);
1307 mutter->damageTiles = 0;
1308 mutter->damageFrames = 0;
1309 mutter->damageLogged = now;
1310 }
1311}
1312
1313static void mutter_on_process(void* data)
1314{
1315 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
1316 WINPR_ASSERT(mutter);
1317
1318 rdpShadowServer* server = mutter->common.server;
1319 if (!server || !server->surface)
1320 return;
1321 rdpShadowSurface* surface = server->surface;
1322 BOOL painted = FALSE;
1323 struct pw_buffer* pb = nullptr;
1324
1325 /* every queued buffer: no damage is lost when frames come faster */
1326 while ((pb = pw_stream_dequeue_buffer(mutter->stream)) != nullptr)
1327 {
1328 struct spa_buffer* buf = pb->buffer;
1329 struct spa_data* d = &buf->datas[0]; // codespell:ignore datas
1330
1331 mutter_cursor_update(mutter, buf);
1332
1333 const struct spa_meta_header* h =
1334 spa_buffer_find_meta_data(buf, SPA_META_Header, sizeof(struct spa_meta_header));
1335 if ((h && (h->flags & SPA_META_HEADER_FLAG_CORRUPTED)) || !d->data || !d->chunk ||
1336 (d->chunk->size == 0))
1337 {
1338 /* no picture in this buffer (only the cursor moved) */
1339 (void)pw_stream_queue_buffer(mutter->stream, pb);
1340 continue;
1341 }
1342
1343 const BYTE* src = (const BYTE*)d->data + d->chunk->offset;
1344 const UINT32 stride = (d->chunk->stride > 0) ? (UINT32)d->chunk->stride : mutter->width * 4;
1345
1346 EnterCriticalSection(&surface->lock);
1347 struct spa_meta* dm = spa_buffer_find_meta(buf, SPA_META_VideoDamage);
1348 if (!dm || mutter->fullPaint)
1349 {
1350 mutter_copy_rect(mutter, surface, src, stride, 0, 0, (INT32)mutter->width,
1351 (INT32)mutter->height);
1352 mutter->fullPaint = FALSE;
1353 }
1354 else
1355 {
1356 struct spa_meta_region* r = nullptr;
1357 spa_meta_for_each(r, dm)
1358 {
1359 if (!spa_meta_region_is_valid(r))
1360 break;
1361 mutter_copy_rect(mutter, surface, src, stride, r->region.position.x,
1362 r->region.position.y, (INT32)r->region.size.width,
1363 (INT32)r->region.size.height);
1364 }
1365 if (mutter->damageCheck)
1366 mutter_damage_stats(mutter,
1367 mutter_repair_missed_damage(mutter, surface, src, stride));
1368 }
1369 LeaveCriticalSection(&surface->lock);
1370 painted = TRUE;
1371 (void)pw_stream_queue_buffer(mutter->stream, pb);
1372 }
1373
1374 if (!painted)
1375 return;
1376
1377 /* Not under the clients list lock: the frame update waits until every client has encoded
1378 * the frame (an AV2 frame takes 40 to 120 ms, a key frame up to 800 ms), and the sound
1379 * thread needs the lock for each chunk it hands to the clients; it stalled, and PipeWire
1380 * dropped the sound. The update has a subscriber list of its own (see win_shadow.c). */
1381 if (ArrayList_Count(server->clients) > 0)
1382 shadow_subsystem_frame_update(&mutter->common);
1383
1384 EnterCriticalSection(&surface->lock);
1385 region16_clear(&surface->invalidRegion);
1386 LeaveCriticalSection(&surface->lock);
1387}
1388
1389static void mutter_on_state_changed(WINPR_ATTR_UNUSED void* data,
1390 WINPR_ATTR_UNUSED enum pw_stream_state old,
1391 enum pw_stream_state state, const char* error)
1392{
1393 WLog_DBG(TAG, "stream %s%s%s", pw_stream_state_as_string(state), error ? ": " : "",
1394 error ? error : "");
1395}
1396
1397static const struct pw_stream_events mutter_stream_events = {
1398 PW_VERSION_STREAM_EVENTS,
1399 .state_changed = mutter_on_state_changed,
1400 .param_changed = mutter_on_param_changed,
1401 .process = mutter_on_process,
1402};
1403
1404static void mutter_on_core_error(WINPR_ATTR_UNUSED void* data, uint32_t id,
1405 WINPR_ATTR_UNUSED int seq, WINPR_ATTR_UNUSED int res,
1406 const char* message)
1407{
1408 WLog_ERR(TAG, "PipeWire error on %" PRIu32 ": %s", id, message);
1409}
1410
1411static const struct pw_core_events mutter_core_events = {
1412 PW_VERSION_CORE_EVENTS,
1413 .error = mutter_on_core_error,
1414};
1415
1416/* Mutter ends a monitor's stream when the monitor's layout changes (its scale,
1417 * its rotation, its position): it removes the node, and the session goes on
1418 * without a picture. No D-Bus signal says so; PipeWire's registry does. */
1419static void mutter_on_global_remove(void* data, uint32_t id)
1420{
1421 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
1422 WINPR_ASSERT(mutter);
1423
1424 if (mutter->haveNode && (id == mutter->nodeId))
1425 {
1426 mutter->haveNode = FALSE;
1427 mutter->streamGone = TRUE;
1428 mutter->streamGoneAt = GetTickCount64();
1429 }
1430}
1431
1432static const struct pw_registry_events mutter_registry_events = {
1433 PW_VERSION_REGISTRY_EVENTS,
1434 .global_remove = mutter_on_global_remove,
1435};
1436
1437WINPR_ATTR_NODISCARD
1438static BOOL mutter_stream_connect_node(mutterShadowSubsystem* mutter);
1439
1440WINPR_ATTR_NODISCARD
1441static BOOL mutter_connect_stream(mutterShadowSubsystem* mutter)
1442{
1443 WINPR_ASSERT(mutter);
1444
1445 pw_init(nullptr, nullptr);
1446 mutter->loop = pw_loop_new(nullptr);
1447 if (!mutter->loop)
1448 return FALSE;
1449 mutter->context = pw_context_new(mutter->loop, nullptr, 0);
1450 if (!mutter->context)
1451 return FALSE;
1452 /* the session's PipeWire daemon, through XDG_RUNTIME_DIR */
1453 mutter->core = pw_context_connect(mutter->context, nullptr, 0);
1454 if (!mutter->core)
1455 {
1456 char buffer[128] = WINPR_C_ARRAY_INIT;
1457 WLog_ERR(TAG, "cannot connect to PipeWire: %s",
1458 winpr_strerror(errno, buffer, sizeof(buffer)));
1459 return FALSE;
1460 }
1461 pw_core_add_listener(mutter->core, &mutter->coreListener, &mutter_core_events, mutter);
1462
1463 mutter->registry = pw_core_get_registry(mutter->core, PW_VERSION_REGISTRY, 0);
1464 if (!mutter->registry)
1465 return FALSE;
1466 pw_registry_add_listener(mutter->registry, &mutter->registryListener, &mutter_registry_events,
1467 mutter);
1468
1469 if (!mutter_stream_connect_node(mutter))
1470 return FALSE;
1471
1472 /* the surface needs the stream's size before the server starts */
1473 const UINT64 start = GetTickCount64();
1474 while (!mutter->haveFormat)
1475 {
1476 if (GetTickCount64() - start > MUTTER_FORMAT_TIMEOUT_MS)
1477 {
1478 WLog_ERR(TAG, "the stream got no format");
1479 return FALSE;
1480 }
1481 pw_loop_enter(mutter->loop);
1482 (void)pw_loop_iterate(mutter->loop, 100);
1483 pw_loop_leave(mutter->loop);
1484 }
1485 return TRUE;
1486}
1487
1488/* The format the stream asks for, size being what a virtual monitor takes */
1489WINPR_ATTR_NODISCARD
1490static const struct spa_pod* mutter_stream_format(struct spa_pod_builder* b,
1491 const struct spa_rectangle* size)
1492{
1493 const struct spa_rectangle minSize = SPA_RECTANGLE(1, 1);
1494 const struct spa_rectangle maxSize = SPA_RECTANGLE(8192, 8192);
1495 const struct spa_fraction rate = SPA_FRACTION(0, 1);
1496 const struct spa_fraction maxRate = SPA_FRACTION(60, 1);
1497 const struct spa_fraction minRate = SPA_FRACTION(1, 1);
1498
1499 WINPR_PRAGMA_DIAG_PUSH
1500 WINPR_PRAGMA_DIAG("-Wgnu-statement-expression-from-macro-expansion")
1501
1502 /* no modifiers offered: Mutter sends frames in shared memory */
1503 WINPR_PRAGMA_DIAG_PUSH
1504 WINPR_PRAGMA_DIAG("-Wgnu-statement-expression-from-macro-expansion")
1505 return spa_pod_builder_add_object(
1506 b, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat, SPA_FORMAT_mediaType,
1507 SPA_POD_Id(SPA_MEDIA_TYPE_video), SPA_FORMAT_mediaSubtype,
1508 SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw), SPA_FORMAT_VIDEO_format,
1509 SPA_POD_CHOICE_ENUM_Id(3, SPA_VIDEO_FORMAT_BGRx, SPA_VIDEO_FORMAT_BGRx,
1510 SPA_VIDEO_FORMAT_BGRA),
1511 SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle(size, &minSize, &maxSize),
1512 SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&rate), SPA_FORMAT_VIDEO_maxFramerate,
1513 SPA_POD_CHOICE_RANGE_Fraction(&maxRate, &minRate, &maxRate));
1514 WINPR_PRAGMA_DIAG_POP
1515}
1516
1517/* A new stream, connected to Mutter's node mutter->nodeId. Each node gets a
1518 * stream of its own: a stream connected again keeps its first target. */
1519WINPR_ATTR_NODISCARD
1520static BOOL mutter_stream_connect_node(mutterShadowSubsystem* mutter)
1521{
1522 WINPR_ASSERT(mutter);
1523 WINPR_ASSERT(mutter->core);
1524
1525 if (mutter->stream)
1526 pw_stream_destroy(mutter->stream);
1527 mutter->stream =
1528 pw_stream_new(mutter->core, "FreeRDP shadow server",
1529 pw_properties_new(PW_KEY_MEDIA_TYPE, "Video", PW_KEY_MEDIA_CATEGORY,
1530 "Capture", PW_KEY_MEDIA_ROLE, "Screen", nullptr));
1531 if (!mutter->stream)
1532 return FALSE;
1533 pw_stream_add_listener(mutter->stream, &mutter->streamListener, &mutter_stream_events, mutter);
1534
1535 uint8_t podBuffer[1024] = WINPR_C_ARRAY_INIT;
1536 struct spa_pod_builder b = SPA_POD_BUILDER_INIT(podBuffer, sizeof(podBuffer));
1537 /* a virtual monitor takes the size the stream asks for */
1538 const struct spa_rectangle size =
1539 mutter->virtualMonitor ? SPA_RECTANGLE(mutter->virtualWidth, mutter->virtualHeight)
1540 : SPA_RECTANGLE(1920, 1080);
1541 const struct spa_pod* params[] = { mutter_stream_format(&b, &size) };
1542
1543 if (pw_stream_connect(
1544 mutter->stream, PW_DIRECTION_INPUT, mutter->nodeId,
1545 (enum pw_stream_flags)(PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS), params,
1546 ARRAYSIZE(params)) < 0)
1547 {
1548 WLog_ERR(TAG, "pw_stream_connect failed");
1549 return FALSE;
1550 }
1551 return TRUE;
1552}
1553
1554/* Subsystem thread: ask for another size, Mutter resizes the virtual monitor and
1555 * mutter_stream_param_changed takes it from there */
1556static void mutter_virtual_resize(mutterShadowSubsystem* mutter, UINT32 width, UINT32 height)
1557{
1558 WINPR_ASSERT(mutter);
1559
1560 if (!mutter->stream)
1561 return;
1562
1563 mutter->virtualWidth = width;
1564 mutter->virtualHeight = height;
1565
1566 uint8_t podBuffer[1024] = WINPR_C_ARRAY_INIT;
1567 struct spa_pod_builder b = SPA_POD_BUILDER_INIT(podBuffer, sizeof(podBuffer));
1568 const struct spa_rectangle size = SPA_RECTANGLE(width, height);
1569 const struct spa_pod* params[] = { mutter_stream_format(&b, &size) };
1570 if (pw_stream_update_params(mutter->stream, params, ARRAYSIZE(params)) < 0)
1571 WLog_WARN(TAG, "cannot ask for %" PRIu32 "x%" PRIu32, width, height);
1572}
1573
1574/* ------------------------------------------------------------------------ */
1575/* sound */
1576/* ------------------------------------------------------------------------ */
1577
1578static void mutter_audio_msg_free(WINPR_ATTR_UNUSED UINT32 id, SHADOW_MSG_OUT* msg)
1579{
1581 if (samples)
1582 free(samples->buf);
1583 free(samples);
1584}
1585
1586/* Sends what s holds to every client, as one message */
1587static void mutter_audio_post(mutterShadowSubsystem* mutter, wStream* s)
1588{
1589 WINPR_ASSERT(mutter);
1590 WINPR_ASSERT(s);
1591
1592 const size_t size = Stream_GetPosition(s);
1593 Stream_ResetPosition(s);
1594 if (size == 0)
1595 return;
1596
1597 rdpShadowServer* server = mutter->common.server;
1598 if (!server || !server->clients || (ArrayList_Count(server->clients) == 0))
1599 return;
1600
1602 if (!msg)
1603 return;
1604
1605 msg->buf = malloc(size);
1606 if (!msg->buf)
1607 {
1608 free(msg);
1609 return;
1610 }
1611
1612 memcpy(msg->buf, Stream_Buffer(s), size);
1613 mutter->audioMessages++;
1614 msg->common.Free = mutter_audio_msg_free;
1615 msg->audio_format = &mutter->audioSourceFormat;
1616 msg->nFrames = size / MUTTER_AUDIO_FRAME_BYTES;
1617 msg->wTimestamp = (UINT16)(GetTickCount64() & 0xFFFF);
1618 /* the message is freed with its last reference, also when no client took it */
1619 if (shadow_client_boardcast_msg(server, nullptr, SHADOW_MSG_OUT_AUDIO_OUT_SAMPLES_ID,
1620 &msg->common, nullptr) < 0)
1621 WLog_DBG(TAG, "sound: a message was not sent");
1622}
1623
1624static void mutter_audio_stats(mutterShadowSubsystem* mutter, size_t frames)
1625{
1626 WINPR_ASSERT(mutter);
1627
1628 const UINT64 now = GetTickCount64();
1629 if (mutter->audioLogged == 0)
1630 {
1631 WLog_INFO(TAG, "sound: capturing what the default sink plays");
1632 mutter->audioLogged = now;
1633 }
1634 else if (now - mutter->audioLogged >= MUTTER_AUDIO_LOG_MS)
1635 {
1636 WLog_DBG(TAG,
1637 "sound: %" PRIu64 " frames captured, %" PRIu64
1638 " messages sent, peak %.3f in the last %" PRIu64 " ms",
1639 mutter->audioFrames, mutter->audioMessages, (double)mutter->audioPeak,
1640 now - mutter->audioLogged);
1641 mutter->audioFrames = 0;
1642 mutter->audioMessages = 0;
1643 mutter->audioPeak = 0.0f;
1644 mutter->audioLogged = now;
1645 }
1646 mutter->audioFrames += frames;
1647}
1648
1649static void mutter_on_audio_process(void* data)
1650{
1651 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
1652 WINPR_ASSERT(mutter);
1653
1654 struct pw_buffer* pb = nullptr;
1655
1656 while ((pb = pw_stream_dequeue_buffer(mutter->audio)) != nullptr)
1657 {
1658 const struct spa_data* d = &pb->buffer->datas[0]; // codespell:ignore datas
1659 if (d->data && d->chunk && (d->chunk->size > 0) &&
1660 ((size_t)d->chunk->offset + d->chunk->size <= d->maxsize))
1661 {
1662 const BYTE* bdata = d->data;
1663 const BYTE* offset = &bdata[d->chunk->offset];
1664 const INT16* samples = WINPR_PACKED_ALIGN_CAST(const INT16*, offset);
1665 const size_t frames = d->chunk->size / MUTTER_AUDIO_FRAME_BYTES;
1666 mutter_audio_stats(mutter, frames);
1667
1668 wStream* s = mutter->audioStream;
1669 for (size_t f = 0; f < frames; f++)
1670 {
1671 for (size_t c = 0; c < MUTTER_AUDIO_CHANNELS; c++)
1672 {
1673 const INT16 value = samples[f * MUTTER_AUDIO_CHANNELS + c];
1674 mutter->audioPeak =
1675 MAX(mutter->audioPeak, fabsf((float)value / (float)INT16_MAX));
1676 Stream_Write_INT16(s, value);
1677 }
1678
1679 if (Stream_GetPosition(s) >= MUTTER_AUDIO_MESSAGE_FRAMES * MUTTER_AUDIO_FRAME_BYTES)
1680 mutter_audio_post(mutter, s);
1681 }
1682 }
1683 (void)pw_stream_queue_buffer(mutter->audio, pb);
1684 }
1685}
1686
1687static const struct pw_stream_events mutter_audio_events = {
1688 PW_VERSION_STREAM_EVENTS,
1689 .process = mutter_on_audio_process,
1690};
1691
1692/* The formats offered to the clients, and a capture of the default sink's
1693 * monitor, inactive until a client connects. Without it there is no sound,
1694 * and the rest works. */
1695WINPR_ATTR_NODISCARD
1696static BOOL mutter_audio_init(mutterShadowSubsystem* mutter)
1697{
1698 WINPR_ASSERT(mutter);
1699
1700 uint8_t podBuffer[1024] = WINPR_C_ARRAY_INIT;
1701 struct spa_pod_builder b = SPA_POD_BUILDER_INIT(podBuffer, sizeof(podBuffer));
1702
1703 AUDIO_FORMAT* formats = audio_formats_new(ARRAYSIZE(mutter_audio_offered_formats));
1704 if (!formats)
1705 return FALSE;
1706
1707 size_t count = 0;
1708 for (size_t x = 0; x < ARRAYSIZE(mutter_audio_offered_formats); x++)
1709 {
1710 const AUDIO_FORMAT* format = &mutter_audio_offered_formats[x];
1711 if (freerdp_dsp_supports_format(format, TRUE))
1712 formats[count++] = *format;
1713 }
1714
1715 mutter->audioStream =
1716 Stream_New(nullptr, MUTTER_AUDIO_MESSAGE_FRAMES * MUTTER_AUDIO_FRAME_BYTES);
1717 if (!mutter->audioStream || (count == 0))
1718 goto fail;
1719
1720 mutter->audio =
1721 pw_stream_new(mutter->core, "FreeRDP shadow server sound",
1722 pw_properties_new(PW_KEY_MEDIA_TYPE, "Audio", PW_KEY_MEDIA_CATEGORY,
1723 "Capture", PW_KEY_MEDIA_ROLE, "Screen",
1724 PW_KEY_STREAM_CAPTURE_SINK, "true", nullptr));
1725 if (!mutter->audio)
1726 goto fail;
1727 pw_stream_add_listener(mutter->audio, &mutter->audioListener, &mutter_audio_events, mutter);
1728
1729 struct spa_audio_info_raw info = WINPR_C_ARRAY_INIT;
1730 info.format = SPA_AUDIO_FORMAT_S16_LE;
1731 info.rate = MUTTER_AUDIO_RATE;
1732 info.channels = MUTTER_AUDIO_CHANNELS;
1733 info.position[0] = SPA_AUDIO_CHANNEL_FL;
1734 info.position[1] = SPA_AUDIO_CHANNEL_FR;
1735 const struct spa_pod* params[] = { spa_format_audio_raw_build(&b, SPA_PARAM_EnumFormat,
1736 &info) };
1737
1738 /* PipeWire links it to the default sink's monitor and converts to our format */
1739 if (pw_stream_connect(mutter->audio, PW_DIRECTION_INPUT, PW_ID_ANY,
1740 (enum pw_stream_flags)(PW_STREAM_FLAG_AUTOCONNECT |
1741 PW_STREAM_FLAG_MAP_BUFFERS |
1742 PW_STREAM_FLAG_INACTIVE),
1743 params, ARRAYSIZE(params)) < 0)
1744 goto fail;
1745
1746 mutter->common.rdpsndFormats = formats;
1747 mutter->common.nRdpsndFormats = count;
1748 return TRUE;
1749
1750fail:
1751 if (mutter->audio)
1752 pw_stream_destroy(mutter->audio);
1753 mutter->audio = nullptr;
1754 Stream_Free(mutter->audioStream, TRUE);
1755 mutter->audioStream = nullptr;
1756 audio_formats_free(formats, ARRAYSIZE(mutter_audio_offered_formats));
1757 return FALSE;
1758}
1759
1760static void mutter_audio_uninit(mutterShadowSubsystem* mutter)
1761{
1762 WINPR_ASSERT(mutter);
1763
1764 if (mutter->audio)
1765 pw_stream_destroy(mutter->audio);
1766 mutter->audio = nullptr;
1767 mutter->audioActive = FALSE;
1768 audio_formats_free(mutter->common.rdpsndFormats, mutter->common.nRdpsndFormats);
1769 mutter->common.rdpsndFormats = nullptr;
1770 mutter->common.nRdpsndFormats = 0;
1771 Stream_Free(mutter->audioStream, TRUE);
1772 mutter->audioStream = nullptr;
1773}
1774
1775/* in the subsystem thread: capture only while clients are connected */
1776static void mutter_audio_follow_clients(mutterShadowSubsystem* mutter)
1777{
1778 WINPR_ASSERT(mutter);
1779
1780 if (!mutter->audio)
1781 return;
1782
1783 const BOOL active = InterlockedCompareExchange(&mutter->clients, 0, 0) > 0;
1784 if (active == mutter->audioActive)
1785 return;
1786
1787 if (pw_stream_set_active(mutter->audio, active) < 0)
1788 {
1789 WLog_WARN(TAG, "sound: cannot %s the capture", active ? "start" : "stop");
1790 return;
1791 }
1792 mutter->audioActive = active;
1793 if (!active)
1794 Stream_ResetPosition(mutter->audioStream);
1795 WLog_DBG(TAG, "sound: capture %s", active ? "started" : "stopped");
1796}
1797
1798/* ------------------------------------------------------------------------ */
1799/* libei */
1800/* ------------------------------------------------------------------------ */
1801
1802/* under eiLock */
1803static void mutter_process_ei_events(mutterShadowSubsystem* mutter)
1804{
1805 WINPR_ASSERT(mutter);
1806
1807 struct ei_event* e = nullptr;
1808
1809 ei_dispatch(mutter->ei);
1810 while ((e = ei_get_event(mutter->ei)) != nullptr)
1811 {
1812 struct ei_device* dev = ei_event_get_device(e);
1813
1814 switch (ei_event_get_type(e))
1815 {
1816 case EI_EVENT_SEAT_ADDED:
1817 ei_seat_bind_capabilities(ei_event_get_seat(e), EI_DEVICE_CAP_POINTER_ABSOLUTE,
1818 EI_DEVICE_CAP_KEYBOARD, EI_DEVICE_CAP_BUTTON,
1819 EI_DEVICE_CAP_SCROLL, nullptr);
1820 break;
1821 case EI_EVENT_DEVICE_ADDED:
1822 if (ei_device_has_capability(dev, EI_DEVICE_CAP_KEYBOARD) && !mutter->keyboard)
1823 {
1824 mutter->keyboard = ei_device_ref(dev);
1825 WLog_DBG(TAG, "libei keyboard '%s'", ei_device_get_name(dev));
1826 }
1827 if (ei_device_has_capability(dev, EI_DEVICE_CAP_POINTER_ABSOLUTE) &&
1828 !mutter->pointer)
1829 {
1830 mutter->pointer = ei_device_ref(dev);
1831 WLog_DBG(TAG, "libei pointer '%s'", ei_device_get_name(dev));
1832 }
1833 break;
1834 case EI_EVENT_DEVICE_RESUMED:
1835 ei_device_start_emulating(dev, ++mutter->sequence);
1836 if (dev == mutter->keyboard)
1837 mutter->keyboardReady = TRUE;
1838 if (dev == mutter->pointer)
1839 mutter->pointerReady = TRUE;
1840 break;
1841 case EI_EVENT_DEVICE_PAUSED:
1842 if (dev == mutter->keyboard)
1843 mutter->keyboardReady = FALSE;
1844 if (dev == mutter->pointer)
1845 mutter->pointerReady = FALSE;
1846 break;
1847 case EI_EVENT_DEVICE_REMOVED:
1848 if (dev == mutter->keyboard)
1849 {
1850 mutter->keyboard = ei_device_unref(mutter->keyboard);
1851 mutter->keyboardReady = FALSE;
1852 }
1853 if (dev == mutter->pointer)
1854 {
1855 mutter->pointer = ei_device_unref(mutter->pointer);
1856 mutter->pointerReady = FALSE;
1857 }
1858 break;
1859 case EI_EVENT_KEYBOARD_MODIFIERS:
1860 mutter->lockedMods = ei_event_keyboard_get_xkb_mods_locked(e);
1861 mutter->lockedModsKnown = TRUE;
1862 WLog_DBG(TAG, "keyboard: locked modifiers 0x%08" PRIx32, mutter->lockedMods);
1863 break;
1864 case EI_EVENT_DISCONNECT:
1865 WLog_WARN(TAG, "libei disconnected: the clients can only watch");
1866 break;
1867 default:
1868 break;
1869 }
1870 ei_event_unref(e);
1871 }
1872}
1873
1874/* under eiLock */
1875static void mutter_key(mutterShadowSubsystem* mutter, uint32_t code, BOOL down)
1876{
1877 WINPR_ASSERT(mutter);
1878
1879 if (!mutter->keyboard || !mutter->keyboardReady)
1880 return;
1881 /* Mutter keeps the modifier state itself, as for a real keyboard */
1882 ei_device_keyboard_key(mutter->keyboard, code, down);
1883 ei_device_frame(mutter->keyboard, ei_now(mutter->ei));
1884
1885 /* Mutter reports the new locks later, through libei: until then, follow the
1886 * lock keys pressed here, or a Synchronize that comes first (clients send one
1887 * on each focus) would tap them again and undo them */
1888 if (down && (code == KEY_CAPSLOCK))
1889 mutter->lockedMods ^= MUTTER_MOD_LOCK;
1890 if (down && (code == KEY_NUMLOCK))
1891 mutter->lockedMods ^= MUTTER_MOD_NUM;
1892}
1893
1894WINPR_ATTR_NODISCARD
1895static BOOL mutter_shadow_input_synchronize_event(rdpShadowSubsystem* subsystem,
1896 rdpShadowClient* client, UINT32 flags)
1897{
1898 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
1899 if (!mutter || !client)
1900 return FALSE;
1901
1902 EnterCriticalSection(&mutter->eiLock);
1903 WLog_DBG(TAG, "synchronize: client caps %d num %d, session %s 0x%08" PRIx32,
1904 (flags & KBD_SYNC_CAPS_LOCK) ? 1 : 0, (flags & KBD_SYNC_NUM_LOCK) ? 1 : 0,
1905 mutter->lockedModsKnown ? "locked" : "unknown", mutter->lockedMods);
1906 if (mutter->ei && mutter->lockedModsKnown)
1907 {
1908 /* the client's lock keys win: tap each one that differs */
1909 const BOOL caps = (flags & KBD_SYNC_CAPS_LOCK) != 0;
1910 const BOOL num = (flags & KBD_SYNC_NUM_LOCK) != 0;
1911 if (caps != ((mutter->lockedMods & MUTTER_MOD_LOCK) != 0))
1912 {
1913 mutter_key(mutter, KEY_CAPSLOCK, TRUE);
1914 mutter_key(mutter, KEY_CAPSLOCK, FALSE);
1915 }
1916 if (num != ((mutter->lockedMods & MUTTER_MOD_NUM) != 0))
1917 {
1918 mutter_key(mutter, KEY_NUMLOCK, TRUE);
1919 mutter_key(mutter, KEY_NUMLOCK, FALSE);
1920 }
1921 }
1922 LeaveCriticalSection(&mutter->eiLock);
1923 return TRUE;
1924}
1925
1926WINPR_ATTR_NODISCARD
1927static BOOL mutter_shadow_input_keyboard_event(rdpShadowSubsystem* subsystem,
1928 rdpShadowClient* client, UINT16 flags, UINT8 code)
1929{
1930 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
1931 if (!mutter || !client)
1932 return FALSE;
1933
1934 DWORD scancode = code;
1935 if (flags & KBD_FLAGS_EXTENDED)
1936 scancode |= KBDEXT;
1937
1938 DWORD vkcode = GetVirtualKeyCodeFromVirtualScanCode(scancode, WINPR_KBD_TYPE_IBM_ENHANCED);
1939 if (flags & KBD_FLAGS_EXTENDED)
1940 vkcode |= KBDEXT;
1941 /* WinPR's evdev table is indexed by the Linux input codes libei takes */
1942 const DWORD keycode = GetKeycodeFromVirtualKeyCode(vkcode, WINPR_KEYCODE_TYPE_EVDEV);
1943 if (keycode == 0)
1944 {
1945 WLog_DBG(TAG, "no key for scancode 0x%04" PRIx32, scancode);
1946 return TRUE;
1947 }
1948
1949 /* a key is pressed unless the release flag is set (KBD_FLAGS_DOWN marks a repeat) */
1950 const BOOL down = (flags & KBD_FLAGS_RELEASE) == 0;
1951
1952 EnterCriticalSection(&mutter->eiLock);
1953 if (mutter->ei)
1954 mutter_key(mutter, keycode, down);
1955 LeaveCriticalSection(&mutter->eiLock);
1956 return TRUE;
1957}
1958
1959WINPR_ATTR_NODISCARD
1960static BOOL mutter_shadow_input_unicode_keyboard_event(rdpShadowSubsystem* subsystem,
1961 rdpShadowClient* client, UINT16 flags,
1962 UINT16 code)
1963{
1964 if (!subsystem || !client)
1965 return FALSE;
1966
1967 /* libei sends key codes only; typing a character needs a key in the keymap */
1968 WLog_DBG(TAG, "unicode key U+%04" PRIX16 " (flags 0x%04" PRIx16 ") not supported", code, flags);
1969 return TRUE;
1970}
1971
1972/* under eiLock: the client's surface position into Mutter's layout, in the
1973 * libei region of the shared monitor */
1974static void mutter_pointer_move(mutterShadowSubsystem* mutter, UINT16 x, UINT16 y)
1975{
1976 WINPR_ASSERT(mutter);
1977
1978 struct ei_region* region = nullptr;
1979 struct ei_region* first = nullptr;
1980
1981 for (size_t index = 0;; index++)
1982 {
1983 struct ei_region* r = ei_device_get_region(mutter->pointer, index);
1984 if (!r)
1985 break;
1986 if (!first)
1987 first = r;
1988 const char* id = ei_region_get_mapping_id(r);
1989 if (mutter->mappingId && id && (strcmp(id, mutter->mappingId) == 0))
1990 {
1991 region = r;
1992 break;
1993 }
1994 }
1995 if (!region)
1996 region = first;
1997
1998 mutter->pointerInput = GetTickCount64();
1999 double px = x;
2000 double py = y;
2001 if (region && (mutter->width > 0) && (mutter->height > 0))
2002 {
2003 px = ei_region_get_x(region) + (double)x * ei_region_get_width(region) / mutter->width;
2004 py = ei_region_get_y(region) + (double)y * ei_region_get_height(region) / mutter->height;
2005 }
2006 WLog_VRB(TAG,
2007 "pointer %" PRIu16 ",%" PRIu16 " -> %.1f,%.1f (region %s %" PRIu32 ",%" PRIu32
2008 " %" PRIu32 "x%" PRIu32 ")",
2009 x, y, px, py,
2010 region ? (ei_region_get_mapping_id(region) ? ei_region_get_mapping_id(region) : "-")
2011 : "none",
2012 region ? ei_region_get_x(region) : 0, region ? ei_region_get_y(region) : 0,
2013 region ? ei_region_get_width(region) : 0, region ? ei_region_get_height(region) : 0);
2014 ei_device_pointer_motion_absolute(mutter->pointer, px, py);
2015 ei_device_frame(mutter->pointer, ei_now(mutter->ei));
2016}
2017
2018/* under eiLock */
2019static void mutter_pointer_button(mutterShadowSubsystem* mutter, uint32_t button, BOOL down)
2020{
2021 WINPR_ASSERT(mutter);
2022
2023 if (!ei_device_has_capability(mutter->pointer, EI_DEVICE_CAP_BUTTON))
2024 return;
2025 ei_device_button_button(mutter->pointer, button, down);
2026 ei_device_frame(mutter->pointer, ei_now(mutter->ei));
2027}
2028
2029/* under eiLock; 120 is one notch, as in RDP */
2030static void mutter_pointer_wheel(mutterShadowSubsystem* mutter, UINT16 flags, BOOL horizontal)
2031{
2032 WINPR_ASSERT(mutter);
2033
2034 if (!ei_device_has_capability(mutter->pointer, EI_DEVICE_CAP_SCROLL))
2035 return;
2036
2037 INT32 value = flags & 0xFF;
2038 if (flags & PTR_FLAGS_WHEEL_NEGATIVE)
2039 value -= 0x100;
2040
2041 /* RDP: positive turns away from the user (up) or to the right; libei:
2042 * positive scrolls down or to the right */
2043 if (horizontal)
2044 ei_device_scroll_discrete(mutter->pointer, value, 0);
2045 else
2046 ei_device_scroll_discrete(mutter->pointer, 0, -value);
2047 ei_device_frame(mutter->pointer, ei_now(mutter->ei));
2048}
2049
2050WINPR_ATTR_NODISCARD
2051static BOOL mutter_shadow_input_mouse_event(rdpShadowSubsystem* subsystem, rdpShadowClient* client,
2052 UINT16 flags, UINT16 x, UINT16 y)
2053{
2054 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
2055 if (!mutter || !client)
2056 return FALSE;
2057
2058 EnterCriticalSection(&mutter->eiLock);
2059 if (mutter->ei && mutter->pointer && mutter->pointerReady)
2060 {
2061 if (flags & PTR_FLAGS_WHEEL)
2062 mutter_pointer_wheel(mutter, flags, FALSE);
2063 else if (flags & PTR_FLAGS_HWHEEL)
2064 mutter_pointer_wheel(mutter, flags, TRUE);
2065 else
2066 {
2067 /* button events carry the position too */
2068 mutter_pointer_move(mutter, x, y);
2069
2070 const BOOL down = (flags & PTR_FLAGS_DOWN) != 0;
2071 if (flags & PTR_FLAGS_BUTTON1)
2072 mutter_pointer_button(mutter, BTN_LEFT, down);
2073 else if (flags & PTR_FLAGS_BUTTON2)
2074 mutter_pointer_button(mutter, BTN_RIGHT, down);
2075 else if (flags & PTR_FLAGS_BUTTON3)
2076 mutter_pointer_button(mutter, BTN_MIDDLE, down);
2077 }
2078 }
2079 LeaveCriticalSection(&mutter->eiLock);
2080 return TRUE;
2081}
2082
2083WINPR_ATTR_NODISCARD
2084static BOOL mutter_shadow_input_extended_mouse_event(rdpShadowSubsystem* subsystem,
2085 rdpShadowClient* client, UINT16 flags,
2086 UINT16 x, UINT16 y)
2087{
2088 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
2089 if (!mutter || !client)
2090 return FALSE;
2091
2092 EnterCriticalSection(&mutter->eiLock);
2093 if (mutter->ei && mutter->pointer && mutter->pointerReady)
2094 {
2095 mutter_pointer_move(mutter, x, y);
2096
2097 const BOOL down = (flags & PTR_XFLAGS_DOWN) != 0;
2098 if ((flags & PTR_XFLAGS_BUTTON1) != 0)
2099 mutter_pointer_button(mutter, BTN_SIDE, down);
2100 else if ((flags & PTR_XFLAGS_BUTTON2) != 0)
2101 mutter_pointer_button(mutter, BTN_EXTRA, down);
2102 }
2103 LeaveCriticalSection(&mutter->eiLock);
2104 return TRUE;
2105}
2106
2107/* ------------------------------------------------------------------------ */
2108/* login */
2109/* ------------------------------------------------------------------------ */
2110
2111#ifdef WITH_PAM
2112typedef struct
2113{
2114 const char* user;
2115 const char* password;
2116} MUTTER_SHADOW_PAM_DATA;
2117
2118WINPR_ATTR_NODISCARD
2119static int mutter_shadow_pam_conv(int num_msg, const struct pam_message** msg,
2120 struct pam_response** resp, void* appdata_ptr)
2121{
2122 const MUTTER_SHADOW_PAM_DATA* data = (const MUTTER_SHADOW_PAM_DATA*)appdata_ptr;
2123
2124 if ((num_msg <= 0) || !msg || !resp || !data)
2125 return PAM_CONV_ERR;
2126
2127 struct pam_response* response = calloc((size_t)num_msg, sizeof(struct pam_response));
2128 if (!response)
2129 return PAM_BUF_ERR;
2130
2131 for (int index = 0; index < num_msg; index++)
2132 {
2133 const char* answer = nullptr;
2134 switch (msg[index]->msg_style)
2135 {
2136 case PAM_PROMPT_ECHO_ON:
2137 answer = data->user;
2138 break;
2139 case PAM_PROMPT_ECHO_OFF:
2140 answer = data->password;
2141 break;
2142 default:
2143 continue;
2144 }
2145
2146 response[index].resp = _strdup(answer);
2147 if (!response[index].resp)
2148 {
2149 for (int x = 0; x < index; x++)
2150 free(response[x].resp);
2151 free(response);
2152 return PAM_BUF_ERR;
2153 }
2154 }
2155
2156 *resp = response;
2157 return PAM_SUCCESS;
2158}
2159
2160/* The session shared belongs to the user running the server: only that user
2161 * may log in, with the password of their account. */
2162WINPR_ATTR_NODISCARD
2163static int mutter_shadow_pam_authenticate(WINPR_ATTR_UNUSED rdpShadowSubsystem* subsystem,
2164 WINPR_ATTR_UNUSED rdpShadowClient* client,
2165 const char* user, WINPR_ATTR_UNUSED const char* domain,
2166 const char* password)
2167{
2168 if (!user || !password)
2169 return -1;
2170
2171 struct passwd pbuffer = WINPR_C_ARRAY_INIT;
2172 struct passwd* owner = nullptr;
2173
2174 /* -1 means no fixed limit: the usual size */
2175 long buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
2176 if (buflen <= 0)
2177 buflen = 16384;
2178 char* buf = calloc((size_t)buflen, sizeof(char));
2179 if (!buf)
2180 {
2181 WLog_ERR(TAG, "login as '%s' refused: no memory for the session's account", user);
2182 return -1;
2183 }
2184 const int rc = getpwuid_r(getuid(), &pbuffer, buf, (size_t)buflen, &owner);
2185 if (rc != 0)
2186 {
2187 char msg[128] = WINPR_C_ARRAY_INIT;
2188 WLog_ERR(TAG, "login as '%s' refused: the session's account: %s", user,
2189 winpr_strerror(rc, msg, sizeof(msg)));
2190 free(buf);
2191 return -1;
2192 }
2193 if (!owner || !owner->pw_name || (strcmp(owner->pw_name, user) != 0))
2194 {
2195 WLog_ERR(TAG, "login as '%s' refused: this session belongs to '%s'", user,
2196 (owner && owner->pw_name) ? owner->pw_name : "?");
2197 free(buf);
2198 return -1;
2199 }
2200
2201 MUTTER_SHADOW_PAM_DATA data = { .user = user, .password = password };
2202 const struct pam_conv conv = { .conv = mutter_shadow_pam_conv, .appdata_ptr = &data };
2203 pam_handle_t* handle = nullptr;
2204
2205 /* a service of our own if the system has one, else the console login's */
2206 const char* service =
2207 winpr_PathFileExists("/etc/pam.d/freerdp-shadow") ? "freerdp-shadow" : "login";
2208 int status = pam_start(service, user, &conv, &handle);
2209 if (status != PAM_SUCCESS)
2210 {
2211 WLog_ERR(TAG, "pam_start(%s) failure: %s", service, pam_strerror(handle, status));
2212 free(buf);
2213 return -1;
2214 }
2215
2216 status = pam_authenticate(handle, 0);
2217 if (status == PAM_SUCCESS)
2218 status = pam_acct_mgmt(handle, 0);
2219 if (status != PAM_SUCCESS)
2220 WLog_ERR(TAG, "login as '%s' failed: %s", user, pam_strerror(handle, status));
2221
2222 pam_end(handle, status);
2223 free(buf);
2224 return (status == PAM_SUCCESS) ? 1 : -1;
2225}
2226#endif
2227
2228/* ------------------------------------------------------------------------ */
2229/* the subsystem */
2230/* ------------------------------------------------------------------------ */
2231
2232static void mutter_shadow_refresh(mutterShadowSubsystem* mutter)
2233{
2234 WINPR_ASSERT(mutter);
2235
2236 /* the next frame goes out whole; Mutter sends one when asked for nothing
2237 * else only once something changes, so ask the clients' surface again */
2238 mutter->fullPaint = TRUE;
2239 mutter->cursorResend = TRUE;
2240
2241 /* the picture carries the cursor: the clients hide their own pointer */
2242 if (!mutter->virtualMonitor)
2243 {
2244 static const BYTE clear[4] = { 0 };
2245 mutter_cursor_send_shape(mutter, clear, 1, 1, 0, 0);
2246 }
2247 else if (mutter->cursorPixels)
2248 mutter_cursor_send_shape(mutter, mutter->cursorPixels, mutter->cursorWidth,
2249 mutter->cursorHeight, mutter->cursorXHot, mutter->cursorYHot);
2250 else
2251 mutter_cursor_send_default(mutter);
2252
2253 rdpShadowServer* server = mutter->common.server;
2254 rdpShadowSurface* surface = server ? server->surface : nullptr;
2255 if (!surface)
2256 return;
2257
2258 EnterCriticalSection(&surface->lock);
2259 const RECTANGLE_16 all = { 0, 0, (UINT16)surface->width, (UINT16)surface->height };
2260 if (!region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &all))
2261 WLog_ERR(TAG, "cannot mark the screen changed");
2262 LeaveCriticalSection(&surface->lock);
2263
2264 /* not under the clients list lock, as in mutter_on_process */
2265 if (ArrayList_Count(server->clients) > 0)
2266 shadow_subsystem_frame_update(&mutter->common);
2267
2268 EnterCriticalSection(&surface->lock);
2269 region16_clear(&surface->invalidRegion);
2270 LeaveCriticalSection(&surface->lock);
2271}
2272
2273/* ------------------------------------------------------------------------- */
2274/* Clipboard: the session's side of shadow_cliprdr.c, through the selection */
2275/* calls of RemoteDesktop.Session. Mutter hands out a pipe for each transfer. */
2276/* ------------------------------------------------------------------------- */
2277
2278typedef struct
2279{
2280 char** mimes; /* nullptr terminated */
2281 char* mime;
2282 UINT32 serial;
2283 BYTE* data;
2284 size_t size;
2285 BOOL ok;
2286 int fd;
2287} mutterClipboardJob;
2288
2289static void mutter_clipboard_job_free(mutterClipboardJob* job)
2290{
2291 if (!job)
2292 return;
2293 if (job->mimes)
2294 {
2295 for (char** mime = job->mimes; *mime; mime++)
2296 free(*mime);
2297 }
2298 free((void*)job->mimes);
2299 free(job->mime);
2300 free(job->data);
2301 if (job->fd >= 0)
2302 (void)close(job->fd);
2303 free(job);
2304}
2305
2306WINPR_ATTR_MALLOC(mutter_clipboard_job_free, 1)
2307static mutterClipboardJob* mutter_clipboard_job_new(void)
2308{
2309 mutterClipboardJob* job = calloc(1, sizeof(mutterClipboardJob));
2310 if (job)
2311 job->fd = -1;
2312 return job;
2313}
2314
2315static void mutter_clipboard_message_free(wMessage* message)
2316{
2317 WINPR_ASSERT(message);
2318 mutter_clipboard_job_free(message->context);
2319}
2320
2321WINPR_ATTR_NODISCARD
2322static BOOL mutter_clipboard_post(wMessageQueue* queue, UINT32 id, mutterClipboardJob* job)
2323{
2324 WINPR_ASSERT(queue);
2325 WINPR_ASSERT(job);
2326
2327 wMessage message = WINPR_C_ARRAY_INIT;
2328 message.context = job;
2329 message.id = id;
2330 message.Free = mutter_clipboard_message_free;
2331 if (MessageQueue_Dispatch(queue, &message))
2332 return TRUE;
2333 mutter_clipboard_job_free(job);
2334 return FALSE;
2335}
2336
2337/* The hooks of shadow_cliprdr.c: any thread, so the work goes to the subsystem's */
2338WINPR_ATTR_NODISCARD
2339static BOOL mutter_clipboard_offer(rdpShadowSubsystem* subsystem, const char* const* mimeTypes,
2340 size_t count)
2341{
2342 WINPR_ASSERT(subsystem);
2343 WINPR_ASSERT(subsystem->MsgPipe);
2344
2345 mutterClipboardJob* job = mutter_clipboard_job_new();
2346 if (!job)
2347 return FALSE;
2348
2349 job->mimes = (char**)calloc(count + 1, sizeof(char*));
2350 if (!job->mimes)
2351 goto fail;
2352 for (size_t x = 0; x < count; x++)
2353 {
2354 job->mimes[x] = _strdup(mimeTypes[x]);
2355 if (!job->mimes[x])
2356 goto fail;
2357 }
2358 return mutter_clipboard_post(subsystem->MsgPipe->In, MUTTER_MSG_CLIPBOARD_OFFER, job);
2359
2360fail:
2361 mutter_clipboard_job_free(job);
2362 return FALSE;
2363}
2364
2365WINPR_ATTR_NODISCARD
2366static BOOL mutter_clipboard_read(rdpShadowSubsystem* subsystem, const char* mimeType)
2367{
2368 WINPR_ASSERT(subsystem);
2369 WINPR_ASSERT(subsystem->MsgPipe);
2370 WINPR_ASSERT(mimeType);
2371
2372 mutterClipboardJob* job = mutter_clipboard_job_new();
2373 if (!job)
2374 return FALSE;
2375
2376 job->mime = _strdup(mimeType);
2377 if (!job->mime)
2378 {
2379 mutter_clipboard_job_free(job);
2380 return FALSE;
2381 }
2382 return mutter_clipboard_post(subsystem->MsgPipe->In, MUTTER_MSG_CLIPBOARD_READ, job);
2383}
2384
2385WINPR_ATTR_NODISCARD
2386static BOOL mutter_clipboard_provide(rdpShadowSubsystem* subsystem, UINT32 request,
2387 const BYTE* data, size_t size)
2388{
2389 WINPR_ASSERT(subsystem);
2390 WINPR_ASSERT(subsystem->MsgPipe);
2391
2392 mutterClipboardJob* job = mutter_clipboard_job_new();
2393 if (!job)
2394 return FALSE;
2395
2396 job->serial = request;
2397 if (data)
2398 {
2399 job->data = malloc(size);
2400 if (!job->data)
2401 {
2402 mutter_clipboard_job_free(job);
2403 return FALSE;
2404 }
2405 memcpy(job->data, data, size);
2406 job->size = size;
2407 job->ok = TRUE;
2408 }
2409 return mutter_clipboard_post(subsystem->MsgPipe->In, MUTTER_MSG_CLIPBOARD_PROVIDE, job);
2410}
2411
2412/* @return the pipe Mutter answers with, ours to close, or -1 */
2413WINPR_ATTR_NODISCARD
2414static int mutter_clipboard_call_for_fd(mutterShadowSubsystem* mutter, const char* method,
2415 const char* types, ...)
2416{
2417 WINPR_ASSERT(mutter);
2418
2419 sd_bus_error err = SD_BUS_ERROR_NULL;
2420 sd_bus_message* call = nullptr;
2421 sd_bus_message* reply = nullptr;
2422 int fd = -1;
2423
2424 if (sd_bus_message_new_method_call(mutter->bus, &call, RD_NAME, mutter->rdSessionPath,
2425 RD_SESSION_IFACE, method) < 0)
2426 return -1;
2427
2428 va_list ap = WINPR_C_ARRAY_INIT;
2429 va_start(ap, types);
2430 const int appended = sd_bus_message_appendv(call, types, ap);
2431 va_end(ap);
2432
2433 if ((appended >= 0) &&
2434 (sd_bus_call(mutter->bus, call, MUTTER_CLIPBOARD_CALL_USEC, &err, &reply) >= 0) &&
2435 (sd_bus_message_read(reply, "h", &fd) >= 0))
2436 fd = fcntl(fd, F_DUPFD_CLOEXEC, 3); /* the reply owns the fd */
2437 else
2438 {
2439 WLog_WARN(TAG, "clipboard: %s failed: %s", method, err.message ? err.message : "bad reply");
2440 fd = -1;
2441 }
2442
2443 sd_bus_error_free(&err);
2444 sd_bus_message_unref(reply);
2445 sd_bus_message_unref(call);
2446 return fd;
2447}
2448
2449static void mutter_clipboard_write_done(mutterShadowSubsystem* mutter, UINT32 serial, BOOL ok)
2450{
2451 WINPR_ASSERT(mutter);
2452
2453 const int rc =
2454 sd_bus_call_method(mutter->bus, RD_NAME, mutter->rdSessionPath, RD_SESSION_IFACE,
2455 "SelectionWriteDone", nullptr, nullptr, "ub", serial, ok ? 1 : 0);
2456 if (rc < 0)
2457 {
2458 char buffer[128] = WINPR_C_ARRAY_INIT;
2459 WLog_WARN(TAG, "clipboard: SelectionWriteDone failed: %s",
2460 winpr_strerror(-rc, buffer, sizeof(buffer)));
2461 }
2462}
2463
2464/* subsystem thread: a client's clipboard becomes the session's selection */
2465static void mutter_clipboard_set_selection(mutterShadowSubsystem* mutter,
2466 const mutterClipboardJob* job)
2467{
2468 WINPR_ASSERT(mutter);
2469 WINPR_ASSERT(job);
2470 WINPR_ASSERT(job->mimes);
2471
2472 sd_bus_error err = SD_BUS_ERROR_NULL;
2473 sd_bus_message* call = nullptr;
2474
2475 /* without mime types, Mutter ends the session's ownership */
2476 int rc = sd_bus_message_new_method_call(mutter->bus, &call, RD_NAME, mutter->rdSessionPath,
2477 RD_SESSION_IFACE, "SetSelection");
2478 if (rc >= 0)
2479 rc = sd_bus_message_open_container(call, 'a', "{sv}");
2480 if ((rc >= 0) && job->mimes[0])
2481 {
2482 rc = sd_bus_message_open_container(call, 'e', "sv");
2483 if (rc >= 0)
2484 rc = sd_bus_message_append(call, "s", "mime-types");
2485 if (rc >= 0)
2486 rc = sd_bus_message_open_container(call, 'v', "as");
2487 if (rc >= 0)
2488 rc = sd_bus_message_append_strv(call, job->mimes);
2489 if (rc >= 0)
2490 rc = sd_bus_message_close_container(call);
2491 if (rc >= 0)
2492 rc = sd_bus_message_close_container(call);
2493 }
2494 if (rc >= 0)
2495 rc = sd_bus_message_close_container(call);
2496 if (rc >= 0)
2497 rc = sd_bus_call(mutter->bus, call, MUTTER_CLIPBOARD_CALL_USEC, &err, nullptr);
2498 if (rc < 0)
2499 {
2500 char buffer[128] = WINPR_C_ARRAY_INIT;
2501 WLog_WARN(TAG, "clipboard: SetSelection failed: %s",
2502 err.message ? err.message : winpr_strerror(-rc, buffer, sizeof(buffer)));
2503 }
2504
2505 sd_bus_error_free(&err);
2506 sd_bus_message_unref(call);
2507}
2508
2509/* subsystem thread: a client pastes */
2510static void mutter_clipboard_start_read(mutterShadowSubsystem* mutter, wMessage* message)
2511{
2512 WINPR_ASSERT(mutter);
2513 WINPR_ASSERT(message);
2514
2515 mutterClipboardJob* job = message->context;
2516 WINPR_ASSERT(job);
2517
2518 job->fd = mutter_clipboard_call_for_fd(mutter, "SelectionRead", "s", job->mime);
2519 if ((job->fd >= 0) && mutter->clipboardJobs)
2520 {
2521 message->Free = nullptr; /* the data thread has it now */
2522 if (mutter_clipboard_post(mutter->clipboardJobs, MUTTER_MSG_CLIPBOARD_READ, job))
2523 return;
2524 }
2525 if (!shadow_clipboard_session_data(mutter->common.server, nullptr, 0))
2526 WLog_DBG(TAG, "clipboard: no read was waiting");
2527}
2528
2529/* subsystem thread: the session pastes, here is the client's data */
2530static void mutter_clipboard_start_write(mutterShadowSubsystem* mutter, wMessage* message)
2531{
2532 WINPR_ASSERT(mutter);
2533 WINPR_ASSERT(message);
2534
2535 mutterClipboardJob* job = message->context;
2536 WINPR_ASSERT(job);
2537
2538 if (job->ok)
2539 {
2540 job->fd = mutter_clipboard_call_for_fd(mutter, "SelectionWrite", "u", job->serial);
2541 if ((job->fd >= 0) && mutter->clipboardJobs)
2542 {
2543 const UINT32 serial = job->serial;
2544 message->Free = nullptr; /* the data thread has it now */
2545 if (mutter_clipboard_post(mutter->clipboardJobs, MUTTER_MSG_CLIPBOARD_PROVIDE, job))
2546 return;
2547 mutter_clipboard_write_done(mutter, serial, FALSE);
2548 return;
2549 }
2550 }
2551 mutter_clipboard_write_done(mutter, job->serial, FALSE);
2552}
2553
2554/* @return the revents of fd, 0 on a stall or a stop */
2555WINPR_ATTR_NODISCARD
2556static short mutter_clipboard_wait(mutterShadowSubsystem* mutter, int fd, short events)
2557{
2558 WINPR_ASSERT(mutter);
2559
2560 struct pollfd fds[2] = { { fd, events, 0 },
2561 { GetEventFileDescriptor(mutter->stopEvent), POLLIN, 0 } };
2562 int ready = 0;
2563 do
2564 {
2565 ready = poll(fds, ARRAYSIZE(fds), MUTTER_CLIPBOARD_STALL_MS);
2566 } while ((ready < 0) && (errno == EINTR));
2567
2568 if ((ready <= 0) || (fds[1].revents != 0))
2569 return 0;
2570 return fds[0].revents;
2571}
2572
2573/* data thread: everything the session's application writes to the pipe */
2574WINPR_ATTR_NODISCARD
2575static BOOL mutter_clipboard_read_all(mutterShadowSubsystem* mutter, mutterClipboardJob* job)
2576{
2577 WINPR_ASSERT(mutter);
2578 WINPR_ASSERT(job);
2579
2580 if (fcntl(job->fd, F_SETFL, fcntl(job->fd, F_GETFL) | O_NONBLOCK) < 0)
2581 return FALSE;
2582
2583 size_t capacity = 0;
2584 while (1)
2585 {
2586 if (job->size + 4096 > capacity)
2587 {
2588 const size_t wanted = capacity ? capacity * 2 : 64ull * 1024ull;
2589 if (wanted > SHADOW_CLIPBOARD_MAX_SIZE)
2590 {
2591 WLog_WARN(TAG, "clipboard: the selection is too large");
2592 return FALSE;
2593 }
2594 BYTE* grown = realloc(job->data, wanted);
2595 if (!grown)
2596 return FALSE;
2597 job->data = grown;
2598 capacity = wanted;
2599 }
2600
2601 if (mutter_clipboard_wait(mutter, job->fd, POLLIN) == 0)
2602 return FALSE;
2603
2604 const ssize_t got = read(job->fd, &job->data[job->size], capacity - job->size);
2605 if (got == 0)
2606 return TRUE;
2607 if (got > 0)
2608 job->size += (size_t)got;
2609 else if ((errno != EAGAIN) && (errno != EINTR))
2610 return FALSE;
2611 }
2612}
2613
2614/* data thread: all of the client's data into the pipe to the session's application */
2615WINPR_ATTR_NODISCARD
2616static BOOL mutter_clipboard_write_all(mutterShadowSubsystem* mutter, mutterClipboardJob* job)
2617{
2618 WINPR_ASSERT(mutter);
2619 WINPR_ASSERT(job);
2620
2621 if (fcntl(job->fd, F_SETFL, fcntl(job->fd, F_GETFL) | O_NONBLOCK) < 0)
2622 return FALSE;
2623
2624 size_t done = 0;
2625 while (done < job->size)
2626 {
2627 if (mutter_clipboard_wait(mutter, job->fd, POLLOUT) == 0)
2628 return FALSE;
2629
2630 const ssize_t put = write(job->fd, &job->data[done], job->size - done); /* SIGPIPE: off */
2631 if (put > 0)
2632 done += (size_t)put;
2633 else if ((errno != EAGAIN) && (errno != EINTR))
2634 return FALSE;
2635 }
2636 return TRUE;
2637}
2638
2639WINPR_ATTR_NODISCARD
2640static DWORD WINAPI mutter_clipboard_thread(LPVOID arg)
2641{
2642 mutterShadowSubsystem* mutter = arg;
2643 WINPR_ASSERT(mutter);
2644
2645 while (MessageQueue_Wait(mutter->clipboardJobs))
2646 {
2647 wMessage message = WINPR_C_ARRAY_INIT;
2648 if (!MessageQueue_Peek(mutter->clipboardJobs, &message, TRUE))
2649 continue;
2650 if (message.id == WMQ_QUIT)
2651 break;
2652
2653 mutterClipboardJob* job = message.context;
2654 WINPR_ASSERT(job);
2655
2656 if (message.id == MUTTER_MSG_CLIPBOARD_READ)
2657 {
2658 const BOOL ok = mutter_clipboard_read_all(mutter, job);
2659 if (!ok)
2660 WLog_WARN(TAG, "clipboard: reading %s failed", job->mime);
2661 if (!shadow_clipboard_session_data(mutter->common.server, ok ? job->data : nullptr,
2662 job->size))
2663 WLog_DBG(TAG, "clipboard: no read was waiting");
2664 mutter_clipboard_job_free(job);
2665 }
2666 else
2667 {
2668 job->ok = mutter_clipboard_write_all(mutter, job);
2669 if (!job->ok)
2670 WLog_WARN(TAG, "clipboard: writing to the session failed");
2671 (void)close(job->fd); /* the end of the data to the application */
2672 job->fd = -1;
2673 if (!mutter_clipboard_post(mutter->common.MsgPipe->In, MUTTER_MSG_CLIPBOARD_WRITE_DONE,
2674 job))
2675 WLog_WARN(TAG, "clipboard: cannot finish a transfer");
2676 }
2677 }
2678
2679 ExitThread(0);
2680 return 0;
2681}
2682
2683/* The mime types are documented as "as"; GNOME Shell 50 sends "(as)". */
2684WINPR_ATTR_NODISCARD
2685static size_t mutter_clipboard_read_mimes(sd_bus_message* msg,
2686 const char* mimes[MUTTER_CLIPBOARD_MAX_MIMES])
2687{
2688 WINPR_ASSERT(msg);
2689
2690 const char* contents = nullptr;
2691 char type = 0;
2692 if ((sd_bus_message_peek_type(msg, &type, &contents) <= 0) || !contents)
2693 return 0;
2694
2695 const BOOL inStruct = contents[0] == '(';
2696 if ((strcmp(contents, "as") != 0) && (strcmp(contents, "(as)") != 0))
2697 {
2698 (void)sd_bus_message_skip(msg, "v");
2699 return 0;
2700 }
2701
2702 size_t count = 0;
2703 if (sd_bus_message_enter_container(msg, 'v', contents) <= 0)
2704 return 0;
2705 if (inStruct && (sd_bus_message_enter_container(msg, 'r', "as") <= 0))
2706 return 0;
2707 if (sd_bus_message_enter_container(msg, 'a', "s") > 0)
2708 {
2709 const char* mime = nullptr;
2710 while (sd_bus_message_read(msg, "s", &mime) > 0)
2711 {
2712 if (count < MUTTER_CLIPBOARD_MAX_MIMES)
2713 mimes[count++] = mime;
2714 }
2715 (void)sd_bus_message_exit_container(msg);
2716 }
2717 if (inStruct)
2718 (void)sd_bus_message_exit_container(msg);
2719 (void)sd_bus_message_exit_container(msg);
2720 return count;
2721}
2722
2723WINPR_ATTR_NODISCARD
2724static int mutter_on_selection_owner_changed(sd_bus_message* msg, void* data,
2725 WINPR_ATTR_UNUSED sd_bus_error* err)
2726{
2727 mutterShadowSubsystem* mutter = data;
2728 WINPR_ASSERT(mutter);
2729
2730 const char* mimes[MUTTER_CLIPBOARD_MAX_MIMES] = WINPR_C_ARRAY_INIT;
2731 size_t count = 0;
2732 int sessionIsOwner = 0;
2733
2734 if (sd_bus_message_enter_container(msg, 'a', "{sv}") <= 0)
2735 return 0;
2736 while (sd_bus_message_enter_container(msg, 'e', "sv") > 0)
2737 {
2738 const char* key = nullptr;
2739 if (sd_bus_message_read(msg, "s", &key) < 0)
2740 break;
2741
2742 if (strcmp(key, "mime-types") == 0)
2743 count = mutter_clipboard_read_mimes(msg, mimes);
2744 else if (strcmp(key, "session-is-owner") == 0)
2745 (void)sd_bus_message_read(msg, "v", "b", &sessionIsOwner);
2746 else
2747 (void)sd_bus_message_skip(msg, "v");
2748 (void)sd_bus_message_exit_container(msg);
2749 }
2750
2751 /* that is what a client copied, coming back */
2752 if (sessionIsOwner)
2753 return 0;
2754
2755 WLog_DBG(TAG, "clipboard: the session offers %" PRIuz " mime types", count);
2756 if (!shadow_clipboard_session_changed(mutter->common.server, mimes, count))
2757 WLog_WARN(TAG, "clipboard: cannot announce the session's clipboard");
2758 return 0;
2759}
2760
2761WINPR_ATTR_NODISCARD
2762static int mutter_on_selection_transfer(sd_bus_message* msg, void* data,
2763 WINPR_ATTR_UNUSED sd_bus_error* err)
2764{
2765 mutterShadowSubsystem* mutter = data;
2766 WINPR_ASSERT(mutter);
2767
2768 const char* mime = nullptr;
2769 uint32_t serial = 0;
2770 if (sd_bus_message_read(msg, "su", &mime, &serial) < 0)
2771 return 0;
2772
2773 if (!shadow_clipboard_session_request(mutter->common.server, serial, mime))
2774 mutter_clipboard_write_done(mutter, serial, FALSE);
2775 return 0;
2776}
2777
2778/* Without it the rest works: the clients simply get no clipboard channel. */
2779static void mutter_clipboard_enable(mutterShadowSubsystem* mutter)
2780{
2781 WINPR_ASSERT(mutter);
2782
2783 sd_bus_error err = SD_BUS_ERROR_NULL;
2784 if ((sd_bus_match_signal(mutter->bus, &mutter->selectionOwnerSlot, RD_NAME,
2785 mutter->rdSessionPath, RD_SESSION_IFACE, "SelectionOwnerChanged",
2786 mutter_on_selection_owner_changed, mutter) < 0) ||
2787 (sd_bus_match_signal(mutter->bus, &mutter->selectionTransferSlot, RD_NAME,
2788 mutter->rdSessionPath, RD_SESSION_IFACE, "SelectionTransfer",
2789 mutter_on_selection_transfer, mutter) < 0))
2790 WLog_WARN(TAG, "cannot watch the session's clipboard: no clipboard");
2791 else
2792 {
2793 /* Mutter answers with a SelectionOwnerChanged for what the session holds now */
2794 const int enabled =
2795 sd_bus_call_method(mutter->bus, RD_NAME, mutter->rdSessionPath, RD_SESSION_IFACE,
2796 "EnableClipboard", &err, nullptr, "a{sv}", 0);
2797 if (enabled < 0)
2798 {
2799 char buffer[128] = WINPR_C_ARRAY_INIT;
2800 WLog_WARN(TAG, "EnableClipboard failed: %s: no clipboard",
2801 err.message ? err.message : winpr_strerror(-enabled, buffer, sizeof(buffer)));
2802 }
2803 else
2804 {
2805 mutter->clipboardEnabled = TRUE;
2806 mutter->common.ClipboardOffer = mutter_clipboard_offer;
2807 mutter->common.ClipboardRead = mutter_clipboard_read;
2808 mutter->common.ClipboardProvide = mutter_clipboard_provide;
2809 }
2810 }
2811 sd_bus_error_free(&err);
2812}
2813
2814/* subsystem thread. A client gets here with the user's password, and a session with a
2815 * monitor of its own has no real screen anyone could be sitting at: a lock screen would
2816 * only ask for the same password again. A real screen stays locked. */
2817static void mutter_unlock_screen(mutterShadowSubsystem* mutter)
2818{
2819 WINPR_ASSERT(mutter);
2820
2821 sd_bus_error err = SD_BUS_ERROR_NULL;
2822 sd_bus_message* reply = nullptr;
2823 int locked = 0;
2824 int rc = sd_bus_call_method(mutter->bus, SCREEN_SAVER_NAME, SCREEN_SAVER_PATH,
2825 SCREEN_SAVER_NAME, "GetActive", &err, &reply, "");
2826 if (rc >= 0)
2827 rc = sd_bus_message_read(reply, "b", &locked);
2828 sd_bus_message_unref(reply);
2829
2830 if ((rc >= 0) && locked)
2831 {
2832 rc = sd_bus_call_method(mutter->bus, SCREEN_SAVER_NAME, SCREEN_SAVER_PATH,
2833 SCREEN_SAVER_NAME, "SetActive", &err, nullptr, "b", 0);
2834 if (rc >= 0)
2835 WLog_INFO(TAG, "the login unlocked the session");
2836 }
2837 if (rc < 0)
2838 {
2839 char buffer[128] = WINPR_C_ARRAY_INIT;
2840 WLog_WARN(TAG, "the screen stays as it is: %s",
2841 err.message ? err.message : winpr_strerror(-rc, buffer, sizeof(buffer)));
2842 }
2843 sd_bus_error_free(&err);
2844}
2845
2846static void mutter_shadow_process_message(mutterShadowSubsystem* mutter, wMessage* message)
2847{
2848 WINPR_ASSERT(mutter);
2849 WINPR_ASSERT(message);
2850
2851 switch (message->id)
2852 {
2853 case SHADOW_MSG_IN_REFRESH_REQUEST_ID:
2854 mutter_shadow_refresh(mutter);
2855 break;
2856
2857 case MUTTER_MSG_CLIPBOARD_OFFER:
2858 mutter_clipboard_set_selection(mutter, message->context);
2859 break;
2860
2861 case MUTTER_MSG_CLIPBOARD_READ:
2862 mutter_clipboard_start_read(mutter, message);
2863 break;
2864
2865 case MUTTER_MSG_CLIPBOARD_PROVIDE:
2866 mutter_clipboard_start_write(mutter, message);
2867 break;
2868
2869 case MUTTER_MSG_CLIPBOARD_WRITE_DONE:
2870 {
2871 const mutterClipboardJob* job = message->context;
2872 WINPR_ASSERT(job);
2873 mutter_clipboard_write_done(mutter, job->serial, job->ok);
2874 }
2875 break;
2876
2877 case MUTTER_MSG_VIRTUAL_SIZE:
2878 mutter_virtual_resize(mutter, (UINT32)(size_t)message->wParam,
2879 (UINT32)(size_t)message->lParam);
2880 break;
2881
2882 case MUTTER_MSG_UNLOCK:
2883 mutter_unlock_screen(mutter);
2884 break;
2885
2886 default:
2887 WLog_ERR(TAG, "Unknown message id: %" PRIu32 "", message->id);
2888 break;
2889 }
2890
2891 if (message->Free)
2892 message->Free(message);
2893}
2894
2895/* Mutter ended the stream: record the same monitor again in the running
2896 * session. Its node comes with PipeWireStreamAdded (see mutter_reconnect). */
2897static void mutter_record_again(mutterShadowSubsystem* mutter)
2898{
2899 WINPR_ASSERT(mutter);
2900
2901 mutter->streamGone = FALSE;
2902 const char* connector = mutter->connectors[mutter->common.selectedMonitor];
2903 WLog_INFO(TAG, "Mutter ended the stream of %s (its layout changed): recording it again",
2904 connector[0] ? connector : "the primary monitor");
2905
2906 mutter->streamAddedSlot = sd_bus_slot_unref(mutter->streamAddedSlot);
2907 free(mutter->streamPath);
2908 mutter->streamPath = nullptr;
2909
2910 sd_bus_error err = SD_BUS_ERROR_NULL;
2911 int started = -1;
2912 if (mutter_record_monitor(mutter, connector))
2913 {
2914 mutter->awaitNode = TRUE;
2915 started = sd_bus_call_method(mutter->bus, SC_NAME, mutter->streamPath, SC_STREAM_IFACE,
2916 "Start", &err, nullptr, "");
2917 if (started < 0)
2918 {
2919 char buffer[128] = WINPR_C_ARRAY_INIT;
2920 WLog_ERR(TAG, "ScreenCast.Stream.Start failed: %s",
2921 err.message ? err.message : winpr_strerror(-started, buffer, sizeof(buffer)));
2922 }
2923 }
2924 sd_bus_error_free(&err);
2925
2926 if (started < 0)
2927 {
2928 /* the session closed meanwhile, or the monitor is gone (unplugged, or
2929 * disabled): nothing left to share either way */
2930 mutter->awaitNode = FALSE;
2931 while (sd_bus_process(mutter->bus, nullptr) > 0)
2932 {
2933 }
2934 if (!mutter->closed)
2935 mutter->monitorGone = TRUE;
2936 mutter->closed = TRUE;
2937 }
2938}
2939
2940/* The new node is there: the same PipeWire stream connects to it */
2941static void mutter_reconnect(mutterShadowSubsystem* mutter)
2942{
2943 WINPR_ASSERT(mutter);
2944
2945 mutter->reconnect = FALSE;
2946 if (!mutter_stream_connect_node(mutter))
2947 {
2948 mutter->monitorGone = TRUE;
2949 mutter->closed = TRUE;
2950 return;
2951 }
2952 mutter_read_stream_parameters(mutter);
2953 mutter->fullPaint = TRUE;
2954 WLog_INFO(TAG, "sharing again from PipeWire node %" PRIu32, mutter->nodeId);
2955}
2956
2957WINPR_ATTR_NODISCARD
2958static DWORD WINAPI mutter_shadow_subsystem_thread(LPVOID arg)
2959{
2960 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)arg;
2961 WINPR_ASSERT(mutter);
2962
2963 wMessagePipe* MsgPipe = mutter->common.MsgPipe;
2964 HANDLE events[6] = WINPR_C_ARRAY_INIT;
2965 DWORD count = 0;
2966
2967 HANDLE busEvent = CreateFileDescriptorEventA(nullptr, FALSE, FALSE, sd_bus_get_fd(mutter->bus),
2968 WINPR_FD_READ);
2969 HANDLE pwEvent = CreateFileDescriptorEventA(nullptr, FALSE, FALSE, pw_loop_get_fd(mutter->loop),
2970 WINPR_FD_READ);
2971 HANDLE eiEvent = mutter->ei ? CreateFileDescriptorEventA(nullptr, FALSE, FALSE,
2972 ei_get_fd(mutter->ei), WINPR_FD_READ)
2973 : nullptr;
2974 if (!busEvent || !pwEvent || (mutter->ei && !eiEvent))
2975 {
2976 WLog_ERR(TAG, "cannot wait on the session's connections");
2977 goto out;
2978 }
2979
2980 events[count++] = mutter->stopEvent;
2981 events[count++] = MessageQueue_Event(MsgPipe->In);
2982 events[count++] = mutter->clientsEvent;
2983 events[count++] = busEvent;
2984 events[count++] = pwEvent;
2985 if (eiEvent)
2986 events[count++] = eiEvent;
2987
2988 while (1)
2989 {
2990 /* sd-bus may want to run before its fd is readable (a queued message, a
2991 * call's deadline): its timeout is an absolute CLOCK_MONOTONIC time */
2992 uint64_t usec = UINT64_MAX;
2993 DWORD timeout = 1000;
2994 if ((sd_bus_get_timeout(mutter->bus, &usec) >= 0) && (usec != UINT64_MAX))
2995 {
2996 struct timespec ts = WINPR_C_ARRAY_INIT;
2997 (void)clock_gettime(CLOCK_MONOTONIC, &ts);
2998 const uint64_t now = (uint64_t)ts.tv_sec * 1000000ull + (uint64_t)ts.tv_nsec / 1000ull;
2999 const uint64_t waitMs = (usec > now) ? (usec - now + 999) / 1000 : 0;
3000 timeout = (DWORD)MIN(waitMs, 1000);
3001 }
3002 if (mutter->streamGone)
3003 timeout = MIN(timeout, 50);
3004
3005 const DWORD status = WaitForMultipleObjects(count, events, FALSE, timeout);
3006 if ((status == WAIT_FAILED) || (WaitForSingleObject(mutter->stopEvent, 0) == WAIT_OBJECT_0))
3007 break;
3008
3009 while (sd_bus_process(mutter->bus, nullptr) > 0)
3010 {
3011 }
3012 (void)sd_bus_flush(mutter->bus);
3013 if (mutter->closed && !mutter->closedLogged)
3014 {
3015 /* The user stopped the sharing (GNOME's screen sharing indicator, or anything
3016 * that inhibits remote access), or GNOME Shell is gone. The server ends with
3017 * success, so a service restarted on failure does not share the screen again
3018 * against the user's choice. */
3019 if (mutter->shellGone)
3020 WLog_WARN(TAG, "GNOME Shell left the session: the server ends");
3021 else if (mutter->monitorGone)
3022 WLog_WARN(TAG, "the shared monitor is gone: the server ends");
3023 else
3024 WLog_WARN(TAG, "the GNOME session stopped the sharing (its user did, or GNOME "
3025 "Shell is ending): the server ends");
3026 mutter->closedLogged = TRUE;
3027 if (mutter->common.server)
3028 (void)SetEvent(mutter->common.server->StopEvent);
3029 }
3030
3031 if (WaitForSingleObject(mutter->clientsEvent, 0) == WAIT_OBJECT_0)
3032 {
3033 /* reset before reading the count: a change after this sets it again */
3034 (void)ResetEvent(mutter->clientsEvent);
3035 mutter_audio_follow_clients(mutter);
3036 }
3037
3038 pw_loop_enter(mutter->loop);
3039 (void)pw_loop_iterate(mutter->loop, 0);
3040 pw_loop_leave(mutter->loop);
3041
3042 /* a Closed that follows the node's end (the user stopped the sharing)
3043 * wins over recording the monitor again */
3044 if (mutter->streamGone && !mutter->closed &&
3045 (GetTickCount64() - mutter->streamGoneAt >= MUTTER_STREAM_GONE_GRACE_MS))
3046 mutter_record_again(mutter);
3047 if (mutter->reconnect && !mutter->closed)
3048 mutter_reconnect(mutter);
3049
3050 if (mutter->ei)
3051 {
3052 EnterCriticalSection(&mutter->eiLock);
3053 mutter_process_ei_events(mutter);
3054 LeaveCriticalSection(&mutter->eiLock);
3055 }
3056
3057 wMessage message = WINPR_C_ARRAY_INIT;
3058 while (MessageQueue_Peek(MsgPipe->In, &message, TRUE))
3059 {
3060 if (message.id == WMQ_QUIT)
3061 goto out;
3062 mutter_shadow_process_message(mutter, &message);
3063 }
3064 }
3065
3066out:
3067 if (busEvent)
3068 (void)CloseHandle(busEvent);
3069 if (pwEvent)
3070 (void)CloseHandle(pwEvent);
3071 if (eiEvent)
3072 (void)CloseHandle(eiEvent);
3073 ExitThread(0);
3074 return 0;
3075}
3076
3077WINPR_ATTR_NODISCARD
3078static BOOL mutter_shadow_client_resize(rdpShadowSubsystem* subsystem, rdpShadowClient* client,
3079 UINT32 width, UINT32 height);
3080
3081WINPR_ATTR_NODISCARD
3082static int mutter_shadow_subsystem_init(rdpShadowSubsystem* subsystem)
3083{
3084 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3085 WINPR_ASSERT(mutter);
3086
3087 const int opened = sd_bus_open_user(&mutter->bus);
3088 if (opened < 0)
3089 {
3090 char buffer[128] = WINPR_C_ARRAY_INIT;
3091 WLog_ERR(TAG,
3092 "cannot connect to the session bus: %s (start the server inside the GNOME "
3093 "session, as its user)",
3094 winpr_strerror(-opened, buffer, sizeof(buffer)));
3095 return -1;
3096 }
3097
3098 if (!mutter_wait_for_name(mutter->bus, RD_NAME, MUTTER_NAME_TIMEOUT_MS))
3099 {
3100 WLog_ERR(TAG, "%s is not on the session bus: is this a GNOME session?", RD_NAME);
3101 return -1;
3102 }
3103
3104 UINT32 count = 0;
3105 mutter->virtualMonitor = mutter_virtual_size(&mutter->virtualWidth, &mutter->virtualHeight);
3106 {
3107 /* on unless "0" */
3108 // NOLINTNEXTLINE(concurrency-mt-unsafe)
3109 const char* check = getenv(MUTTER_DAMAGE_CHECK_ENV);
3110 mutter->damageCheck = !check || (strcmp(check, "0") != 0);
3111 if (!mutter->damageCheck)
3112 WLog_INFO(TAG, "the check for changes Mutter left out of its damage is off");
3113 }
3114 if (mutter->virtualMonitor)
3115 {
3116 mutter->common.ClientResize = mutter_shadow_client_resize;
3117 /* one monitor, this server's own */
3118 subsystem->monitors[0] = (MONITOR_DEF){ 0, 0, (INT32)mutter->virtualWidth - 1,
3119 (INT32)mutter->virtualHeight - 1, 1 };
3120 mutter->connectors[0][0] = '\0';
3121 count = 1;
3122 }
3123 else
3124 {
3125 WLog_DBG(TAG, "DisplayConfig.GetCurrentState");
3126 count = mutter_list_monitors(mutter->bus, subsystem->monitors, mutter->connectors,
3127 MUTTER_SHADOW_MAX_MONITORS);
3128 }
3129 if (count == 0)
3130 {
3131 /* no layout: the primary monitor, sized by its stream */
3132 WLog_WARN(TAG, "no monitor layout from Mutter: sharing the primary monitor");
3133 subsystem->monitors[0] = (MONITOR_DEF){ 0, 0, 0, 0, 1 };
3134 mutter->connectors[0][0] = '\0';
3135 count = 1;
3136 }
3137 subsystem->numMonitors = count;
3138 if (subsystem->selectedMonitor >= count)
3139 subsystem->selectedMonitor = 0;
3140
3141 const char* connector = mutter->connectors[subsystem->selectedMonitor];
3142 if (!mutter_setup_sessions(mutter, connector))
3143 return -1;
3144 if (!mutter_connect_stream(mutter))
3145 return -1;
3146
3147 mutter_set_monitor_size(mutter);
3148
3149 if (!mutter_audio_init(mutter))
3150 WLog_WARN(TAG, "sound: no capture of the default sink: no sound");
3151
3152 /* mirrored monitors carry the cursor in their frames and the clients get a
3153 * transparent shape; a virtual monitor sends the cursor's shapes. Either way
3154 * shapes go out, which needs ShowMouseCursor (otherwise only set by
3155 * /server-side-cursor) */
3156 if (subsystem->server)
3157 subsystem->server->ShowMouseCursor = TRUE;
3158
3159 if (mutter->virtualMonitor)
3160 WLog_INFO(TAG, "sharing a virtual monitor of its own: %" PRIu32 "x%" PRIu32 ", input %s",
3161 mutter->width, mutter->height, mutter->ei ? "through libei" : "off");
3162 else
3163 WLog_INFO(TAG,
3164 "sharing monitor %s (%" PRIu32 " of %" PRIu32 "): %" PRIu32 "x%" PRIu32
3165 ", input %s",
3166 connector[0] ? connector : "(primary)", subsystem->selectedMonitor, count,
3167 mutter->width, mutter->height, mutter->ei ? "through libei" : "off");
3168 return 1;
3169}
3170
3171WINPR_ATTR_NODISCARD
3172static int mutter_shadow_subsystem_uninit(rdpShadowSubsystem* subsystem)
3173{
3174 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3175 if (!mutter)
3176 return -1;
3177
3178 mutter_audio_uninit(mutter);
3179 if (mutter->stream)
3180 pw_stream_destroy(mutter->stream);
3181 mutter->stream = nullptr;
3182 if (mutter->registry)
3183 {
3184 spa_hook_remove(&mutter->registryListener);
3185 pw_proxy_destroy((struct pw_proxy*)mutter->registry);
3186 }
3187 mutter->registry = nullptr;
3188 if (mutter->core)
3189 pw_core_disconnect(mutter->core);
3190 mutter->core = nullptr;
3191 if (mutter->context)
3192 pw_context_destroy(mutter->context);
3193 mutter->context = nullptr;
3194 if (mutter->loop)
3195 pw_loop_destroy(mutter->loop);
3196 mutter->loop = nullptr;
3197
3198 EnterCriticalSection(&mutter->eiLock);
3199 mutter->keyboard = ei_device_unref(mutter->keyboard);
3200 mutter->pointer = ei_device_unref(mutter->pointer);
3201 mutter->ei = ei_unref(mutter->ei);
3202 mutter->keyboardReady = FALSE;
3203 mutter->pointerReady = FALSE;
3204 LeaveCriticalSection(&mutter->eiLock);
3205
3206 if (mutter->bus)
3207 {
3208 if (mutter->started && !mutter->closed && mutter->rdSessionPath)
3209 (void)sd_bus_call_method(mutter->bus, RD_NAME, mutter->rdSessionPath, RD_SESSION_IFACE,
3210 "Stop", nullptr, nullptr, "");
3211 mutter->streamAddedSlot = sd_bus_slot_unref(mutter->streamAddedSlot);
3212 mutter->closedSlot = sd_bus_slot_unref(mutter->closedSlot);
3213 mutter->ownerSlot = sd_bus_slot_unref(mutter->ownerSlot);
3214 mutter->selectionOwnerSlot = sd_bus_slot_unref(mutter->selectionOwnerSlot);
3215 mutter->selectionTransferSlot = sd_bus_slot_unref(mutter->selectionTransferSlot);
3216 mutter->bus = sd_bus_flush_close_unref(mutter->bus);
3217 }
3218 mutter->started = FALSE;
3219
3220 free(mutter->rdSessionPath);
3221 mutter->rdSessionPath = nullptr;
3222 free(mutter->scSessionPath);
3223 mutter->scSessionPath = nullptr;
3224 free(mutter->streamPath);
3225 mutter->streamPath = nullptr;
3226 free(mutter->mappingId);
3227 mutter->mappingId = nullptr;
3228 return 1;
3229}
3230
3231WINPR_ATTR_NODISCARD
3232static int mutter_shadow_subsystem_start(rdpShadowSubsystem* subsystem)
3233{
3234 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3235 if (!mutter || !mutter->bus || !mutter->loop)
3236 return -1;
3237
3238 (void)ResetEvent(mutter->stopEvent);
3239 if (mutter->clipboardEnabled)
3240 {
3241 mutter->clipboardJobs = MessageQueue_New(nullptr);
3242 if (mutter->clipboardJobs)
3243 mutter->clipboardThread =
3244 CreateThread(nullptr, 0, mutter_clipboard_thread, mutter, 0, nullptr);
3245 if (!mutter->clipboardThread)
3246 {
3247 WLog_ERR(TAG, "Failed to create the clipboard thread");
3248 return -1;
3249 }
3250 }
3251
3252 mutter->thread = CreateThread(nullptr, 0, mutter_shadow_subsystem_thread, mutter, 0, nullptr);
3253 if (!mutter->thread)
3254 {
3255 WLog_ERR(TAG, "Failed to create thread");
3256 return -1;
3257 }
3258 return 1;
3259}
3260
3261WINPR_ATTR_NODISCARD
3262static int mutter_shadow_subsystem_stop(rdpShadowSubsystem* subsystem)
3263{
3264 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3265 if (!mutter)
3266 return -1;
3267
3268 if (mutter->thread)
3269 {
3270 (void)SetEvent(mutter->stopEvent);
3271 (void)WaitForSingleObject(mutter->thread, INFINITE);
3272 (void)CloseHandle(mutter->thread);
3273 mutter->thread = nullptr;
3274 }
3275
3276 if (mutter->clipboardThread)
3277 {
3278 (void)SetEvent(mutter->stopEvent); /* a transfer ends at once */
3279 if (!MessageQueue_PostQuit(mutter->clipboardJobs, 0))
3280 WLog_WARN(TAG, "cannot stop the clipboard thread");
3281 (void)WaitForSingleObject(mutter->clipboardThread, INFINITE);
3282 (void)CloseHandle(mutter->clipboardThread);
3283 mutter->clipboardThread = nullptr;
3284 }
3285 MessageQueue_Free(mutter->clipboardJobs);
3286 mutter->clipboardJobs = nullptr;
3287 return 1;
3288}
3289
3290/* A virtual monitor is nobody else's: it takes the size the client asked for, before
3291 * the client is activated, so it does not get a window of the old size first. On a
3292 * timeout the client is resized when Mutter answers, or stays with the size it has. */
3293/* even sizes: the 4:2:0 encoders need them */
3294static UINT32 mutter_virtual_side(UINT32 side, UINT32 least)
3295{
3296 return MIN(MAX(side, least), 8192) & ~1u;
3297}
3298
3299WINPR_ATTR_NODISCARD
3300static BOOL mutter_virtual_request(mutterShadowSubsystem* mutter, UINT32 width, UINT32 height)
3301{
3302 WINPR_ASSERT(mutter);
3303 WINPR_ASSERT(mutter->common.MsgPipe);
3304 return MessageQueue_Post(mutter->common.MsgPipe->In, nullptr, MUTTER_MSG_VIRTUAL_SIZE,
3305 (void*)(size_t)width, (void*)(size_t)height);
3306}
3307
3308static void mutter_virtual_follow_client(mutterShadowSubsystem* mutter, rdpShadowClient* client)
3309{
3310 WINPR_ASSERT(mutter);
3311 WINPR_ASSERT(client);
3312
3313 const rdpSettings* settings = client->context.settings;
3314 const UINT32 width =
3315 mutter_virtual_side(freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth), 320);
3316 const UINT32 height =
3317 mutter_virtual_side(freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight), 200);
3318
3319 if ((width == mutter->width) && (height == mutter->height))
3320 return;
3321
3322 if (!mutter_virtual_request(mutter, width, height))
3323 return;
3324
3325 const UINT64 end = GetTickCount64() + MUTTER_VIRTUAL_SIZE_WAIT_MS;
3326 while ((GetTickCount64() < end) && ((mutter->width != width) || (mutter->height != height)))
3327 Sleep(10);
3328 WLog_INFO(TAG,
3329 "the virtual monitor for a %" PRIu32 "x%" PRIu32 " client is %" PRIu32 "x%" PRIu32,
3330 width, height, mutter->width, mutter->height);
3331}
3332
3333/* The newest connection decides: an older one may be a laptop that was closed, and
3334 * nothing tells the server for a while yet */
3335WINPR_ATTR_NODISCARD
3336static BOOL mutter_shadow_client_resize(rdpShadowSubsystem* subsystem, rdpShadowClient* client,
3337 UINT32 width, UINT32 height)
3338{
3339 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3340 WINPR_ASSERT(mutter);
3341
3342 const void* newest = InterlockedCompareExchangePointer(&mutter->sizeClient, nullptr, nullptr);
3343 if (newest && (newest != client))
3344 return TRUE;
3345
3346 WLog_INFO(TAG, "the client asks for %" PRIu32 "x%" PRIu32, width, height);
3347 return mutter_virtual_request(mutter, mutter_virtual_side(width, 320),
3348 mutter_virtual_side(height, 200));
3349}
3350
3351/* A desktop that went idle shows a black screen until someone touches it, and a client
3352 * can only take that for a broken picture: a move to where the pointer already is counts
3353 * as a touch. Runs after the login. */
3354static void mutter_wake_screen(mutterShadowSubsystem* mutter)
3355{
3356 WINPR_ASSERT(mutter);
3357
3358 if ((mutter->width == 0) || (mutter->height == 0))
3359 return;
3360
3361 /* the client that just connected may have made the desktop smaller */
3362 const UINT32 x = MIN(mutter->common.pointerX, MIN(mutter->width, UINT16_MAX + 1u) - 1u);
3363 const UINT32 y = MIN(mutter->common.pointerY, MIN(mutter->height, UINT16_MAX + 1u) - 1u);
3364
3365 EnterCriticalSection(&mutter->eiLock);
3366 if (mutter->ei && mutter->pointer && mutter->pointerReady)
3367 mutter_pointer_move(mutter, (UINT16)x, (UINT16)y);
3368 LeaveCriticalSection(&mutter->eiLock);
3369}
3370
3371WINPR_ATTR_NODISCARD
3372static BOOL mutter_shadow_client_connect(rdpShadowSubsystem* subsystem, rdpShadowClient* client)
3373{
3374 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3375 WINPR_ASSERT(mutter);
3376
3377 /* a new client gets the cursor shape with the next one seen */
3378 mutter->cursorResend = TRUE;
3379 (void)InterlockedIncrement(&mutter->clients);
3380 (void)SetEvent(mutter->clientsEvent);
3381 void* older = nullptr;
3382 do
3383 {
3384 older = mutter->sizeClient;
3385 } while (InterlockedCompareExchangePointer(&mutter->sizeClient, client, older) != older);
3386 if (mutter->virtualMonitor)
3387 mutter_virtual_follow_client(mutter, client);
3388 if (client->mayInteract)
3389 {
3390 mutter_wake_screen(mutter);
3391 if (mutter->virtualMonitor && mutter->common.server->authentication &&
3392 !MessageQueue_Post(mutter->common.MsgPipe->In, nullptr, MUTTER_MSG_UNLOCK, nullptr,
3393 nullptr))
3394 WLog_WARN(TAG, "cannot ask for the session to unlock");
3395 }
3396 return TRUE;
3397}
3398
3399static void mutter_shadow_client_disconnect(rdpShadowSubsystem* subsystem, rdpShadowClient* client)
3400{
3401 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3402 WINPR_ASSERT(mutter);
3403
3404 (void)InterlockedCompareExchangePointer(&mutter->sizeClient, nullptr, client);
3405 (void)InterlockedDecrement(&mutter->clients);
3406 (void)SetEvent(mutter->clientsEvent);
3407}
3408
3409static void mutter_shadow_subsystem_free(rdpShadowSubsystem* subsystem)
3410{
3411 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3412 if (!mutter)
3413 return;
3414
3415 if (mutter_shadow_subsystem_stop(subsystem) < 0)
3416 WLog_WARN(TAG, "the subsystem thread did not stop");
3417 if (mutter_shadow_subsystem_uninit(subsystem) < 0)
3418 WLog_WARN(TAG, "the subsystem was not uninitialized");
3419 DeleteCriticalSection(&mutter->eiLock);
3420 if (mutter->stopEvent)
3421 (void)CloseHandle(mutter->stopEvent);
3422 if (mutter->clientsEvent)
3423 (void)CloseHandle(mutter->clientsEvent);
3424 free(mutter->cursorPixels);
3425 free(mutter);
3426}
3427
3428WINPR_ATTR_NODISCARD
3429static rdpShadowSubsystem* mutter_shadow_subsystem_new(void)
3430{
3431 mutterShadowSubsystem* mutter = calloc(1, sizeof(mutterShadowSubsystem));
3432 if (!mutter)
3433 return nullptr;
3434
3435 if (!InitializeCriticalSectionAndSpinCount(&mutter->eiLock, 4000))
3436 {
3437 free(mutter);
3438 return nullptr;
3439 }
3440
3441 mutter->stopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
3442 /* manual reset: WinPR has no auto-reset events (it creates a manual-reset one and
3443 * logs an error), so the thread resets it */
3444 mutter->clientsEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
3445 if (!mutter->stopEvent || !mutter->clientsEvent)
3446 {
3447 mutter_shadow_subsystem_free(&mutter->common);
3448 return nullptr;
3449 }
3450
3451 mutter->cursorX = -1;
3452 mutter->cursorY = -1;
3453 mutter->audioSourceFormat.wFormatTag = WAVE_FORMAT_PCM;
3454 mutter->audioSourceFormat.nChannels = MUTTER_AUDIO_CHANNELS;
3455 mutter->audioSourceFormat.nSamplesPerSec = MUTTER_AUDIO_RATE;
3456 mutter->audioSourceFormat.nAvgBytesPerSec = MUTTER_AUDIO_RATE * MUTTER_AUDIO_FRAME_BYTES;
3457 mutter->audioSourceFormat.nBlockAlign = MUTTER_AUDIO_FRAME_BYTES;
3458 mutter->audioSourceFormat.wBitsPerSample = 16;
3459 mutter->common.SynchronizeEvent = mutter_shadow_input_synchronize_event;
3460 mutter->common.KeyboardEvent = mutter_shadow_input_keyboard_event;
3461 mutter->common.UnicodeKeyboardEvent = mutter_shadow_input_unicode_keyboard_event;
3462 mutter->common.MouseEvent = mutter_shadow_input_mouse_event;
3463 mutter->common.ExtendedMouseEvent = mutter_shadow_input_extended_mouse_event;
3464 mutter->common.ClientConnect = mutter_shadow_client_connect;
3465 mutter->common.ClientDisconnect = mutter_shadow_client_disconnect;
3466#ifdef WITH_PAM
3467 mutter->common.Authenticate = mutter_shadow_pam_authenticate;
3468#endif
3469 return &mutter->common;
3470}
3471
3472FREERDP_ENTRY_POINT(WINPR_ATTR_NODISCARD const char* MutterShadowSubsystemName(void))
3473{
3474 return "Mutter";
3475}
3476
3477FREERDP_ENTRY_POINT(
3478 WINPR_ATTR_NODISCARD int MutterShadowSubsystemEntry(RDP_SHADOW_ENTRY_POINTS* pEntryPoints))
3479{
3480 WINPR_ASSERT(pEntryPoints);
3481
3482 pEntryPoints->New = mutter_shadow_subsystem_new;
3483 pEntryPoints->Free = mutter_shadow_subsystem_free;
3484 pEntryPoints->Init = mutter_shadow_subsystem_init;
3485 pEntryPoints->Uninit = mutter_shadow_subsystem_uninit;
3486 pEntryPoints->Start = mutter_shadow_subsystem_start;
3487 pEntryPoints->Stop = mutter_shadow_subsystem_stop;
3488 pEntryPoints->EnumMonitors = mutter_shadow_enum_monitors;
3489 return 1;
3490}
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.