FreeRDP
Loading...
Searching...
No Matches
pf_update.c
1
24#include <freerdp/display.h>
25#include <freerdp/message.h>
26#include <freerdp/session.h>
27#include <winpr/assert.h>
28#include <winpr/image.h>
29#include <winpr/sysinfo.h>
30
31#include <freerdp/server/proxy/proxy_log.h>
32
33#include "pf_update.h"
34#include "pf_client.h"
35#include "pf_server.h"
36#include <freerdp/server/proxy/proxy_context.h>
37#include "proxy_modules.h"
38
39#define TAG PROXY_TAG("update")
40
41WINPR_ATTR_NODISCARD
42static BOOL pf_server_refresh_rect(rdpContext* context, BYTE count, const RECTANGLE_16* areas)
43{
44 pServerContext* ps = (pServerContext*)context;
45 WINPR_ASSERT(ps);
46 WINPR_ASSERT(ps->pdata);
47
48 pClientContext* pc = proxy_data_get_client_context(ps->pdata);
49 WINPR_ASSERT(pc);
50
51 /* The proxy client thread owns the connection to the server, only it may send on it */
52 RECTANGLE_16* copy = nullptr;
53 if (count > 0)
54 {
55 copy = calloc(count, sizeof(RECTANGLE_16));
56 if (!copy)
57 return FALSE;
58
59 CopyMemory(copy, areas, sizeof(RECTANGLE_16) * count);
60 }
61
62 return pf_client_post_message(pc, MakeMessageId(Update, RefreshRect), count, copy);
63}
64
65WINPR_ATTR_NODISCARD
66static BOOL pf_server_suppress_output(rdpContext* context, BYTE allow, const RECTANGLE_16* area)
67{
68 pServerContext* ps = (pServerContext*)context;
69 WINPR_ASSERT(ps);
70 WINPR_ASSERT(ps->pdata);
71
72 pClientContext* pc = proxy_data_get_client_context(ps->pdata);
73 WINPR_ASSERT(pc);
74
75 /* The proxy client thread owns the connection to the server, only it may send on it */
76 RECTANGLE_16* copy = nullptr;
77 if (area)
78 {
79 copy = calloc(1, sizeof(RECTANGLE_16));
80 if (!copy)
81 return FALSE;
82
83 CopyMemory(copy, area, sizeof(RECTANGLE_16));
84 }
85
86 return pf_client_post_message(pc, MakeMessageId(Update, SuppressOutput), allow, copy);
87}
88
89BOOL pf_client_process_update_message(pClientContext* pc, const wMessage* msg)
90{
91 WINPR_ASSERT(pc);
92 WINPR_ASSERT(msg);
93
94 rdpContext* context = &pc->cctx.context;
95 if (!freerdp_is_active_state(context))
96 return TRUE;
97
98 WINPR_ASSERT(context->update);
99 switch (GetMessageType(msg->id))
100 {
101 case Update_RefreshRect:
102 WINPR_ASSERT(context->update->RefreshRect);
103 return context->update->RefreshRect(context, (BYTE)(size_t)msg->wParam,
104 (const RECTANGLE_16*)msg->lParam);
105 case Update_SuppressOutput:
106 WINPR_ASSERT(context->update->SuppressOutput);
107 return context->update->SuppressOutput(context, (BYTE)(size_t)msg->wParam,
108 (const RECTANGLE_16*)msg->lParam);
109 default:
110 return FALSE;
111 }
112}
113
114/* Proxy from PC to PS */
115
120WINPR_ATTR_NODISCARD
121static BOOL pf_client_begin_paint(rdpContext* context)
122{
123 pClientContext* pc = (pClientContext*)context;
124 WINPR_ASSERT(pc);
125
126 proxyData* pdata = pc->pdata;
127 WINPR_ASSERT(pdata);
128
129 pServerContext* ps = proxy_data_get_server_context(pdata);
130 WINPR_ASSERT(ps);
131
132 WINPR_ASSERT(ps->context.update);
133 WINPR_ASSERT(ps->context.update->BeginPaint);
134 WLog_DBG(TAG, "called");
135 return ps->context.update->BeginPaint(&ps->context);
136}
137
143WINPR_ATTR_NODISCARD
144static BOOL pf_client_end_paint(rdpContext* context)
145{
146 pClientContext* pc = (pClientContext*)context;
147 WINPR_ASSERT(pc);
148
149 proxyData* pdata = pc->pdata;
150 WINPR_ASSERT(pdata);
151
152 pServerContext* ps = proxy_data_get_server_context(pdata);
153 WINPR_ASSERT(ps);
154 WINPR_ASSERT(ps->context.update);
155 WINPR_ASSERT(ps->context.update->EndPaint);
156
157 WLog_DBG(TAG, "called");
158
159 /* proxy end paint */
160 if (!ps->context.update->EndPaint(&ps->context))
161 return FALSE;
162
163 if (!pf_modules_run_hook(pdata->module, HOOK_TYPE_CLIENT_END_PAINT, pdata, context))
164 return FALSE;
165
166 return TRUE;
167}
168
169WINPR_ATTR_NODISCARD
170static BOOL pf_client_bitmap_update(rdpContext* context, const BITMAP_UPDATE* bitmap)
171{
172 pClientContext* pc = (pClientContext*)context;
173 WINPR_ASSERT(pc);
174
175 proxyData* pdata = pc->pdata;
176 WINPR_ASSERT(pdata);
177
178 pServerContext* ps = proxy_data_get_server_context(pdata);
179 WINPR_ASSERT(ps);
180 WINPR_ASSERT(ps->context.update);
181 WINPR_ASSERT(ps->context.update->BitmapUpdate);
182 WLog_DBG(TAG, "called");
183 return ps->context.update->BitmapUpdate(&ps->context, bitmap);
184}
185
186WINPR_ATTR_NODISCARD
187static BOOL pf_client_desktop_resize(rdpContext* context)
188{
189 pClientContext* pc = (pClientContext*)context;
190 WINPR_ASSERT(pc);
191
192 proxyData* pdata = pc->pdata;
193 WINPR_ASSERT(pdata);
194
195 pServerContext* ps = proxy_data_get_server_context(pdata);
196 WINPR_ASSERT(ps);
197 WINPR_ASSERT(ps->context.update);
198 WINPR_ASSERT(ps->context.update->DesktopResize);
199 WINPR_ASSERT(context->settings);
200 WINPR_ASSERT(ps->context.settings);
201 WLog_DBG(TAG, "called");
202 if (!freerdp_settings_copy_item(ps->context.settings, context->settings, FreeRDP_DesktopWidth))
203 return FALSE;
204 if (!freerdp_settings_copy_item(ps->context.settings, context->settings, FreeRDP_DesktopHeight))
205 return FALSE;
206 return ps->context.update->DesktopResize(&ps->context);
207}
208
209WINPR_ATTR_NODISCARD
210static BOOL pf_client_remote_monitors(rdpContext* context, UINT32 count,
211 const MONITOR_DEF* monitors)
212{
213 pClientContext* pc = (pClientContext*)context;
214 WINPR_ASSERT(pc);
215
216 proxyData* pdata = pc->pdata;
217 WINPR_ASSERT(pdata);
218
219 pServerContext* ps = proxy_data_get_server_context(pdata);
220 WINPR_ASSERT(ps);
221 WLog_DBG(TAG, "called");
222 return freerdp_display_send_monitor_layout(&ps->context, count, monitors);
223}
224
225WINPR_ATTR_NODISCARD
226static BOOL pf_client_send_pointer_system(rdpContext* context,
227 const POINTER_SYSTEM_UPDATE* pointer_system)
228{
229 pClientContext* pc = (pClientContext*)context;
230 WINPR_ASSERT(pc);
231
232 proxyData* pdata = pc->pdata;
233 WINPR_ASSERT(pdata);
234
235 pServerContext* ps = proxy_data_get_server_context(pdata);
236 WINPR_ASSERT(ps);
237 WINPR_ASSERT(ps->context.update);
238 WINPR_ASSERT(ps->context.update->pointer);
239 WINPR_ASSERT(ps->context.update->pointer->PointerSystem);
240 WLog_DBG(TAG, "called");
241 return ps->context.update->pointer->PointerSystem(&ps->context, pointer_system);
242}
243
244WINPR_ATTR_NODISCARD
245static BOOL pf_client_send_pointer_position(rdpContext* context,
246 const POINTER_POSITION_UPDATE* pointerPosition)
247{
248 pClientContext* pc = (pClientContext*)context;
249 WINPR_ASSERT(pc);
250
251 proxyData* pdata = pc->pdata;
252 WINPR_ASSERT(pdata);
253
254 pServerContext* ps = proxy_data_get_server_context(pdata);
255 WINPR_ASSERT(ps);
256 WINPR_ASSERT(ps->context.update);
257 WINPR_ASSERT(ps->context.update->pointer);
258 WINPR_ASSERT(ps->context.update->pointer->PointerPosition);
259 WLog_DBG(TAG, "called");
260 return ps->context.update->pointer->PointerPosition(&ps->context, pointerPosition);
261}
262
263WINPR_ATTR_NODISCARD
264static BOOL pf_client_send_pointer_color(rdpContext* context,
265 const POINTER_COLOR_UPDATE* pointer_color)
266{
267 pClientContext* pc = (pClientContext*)context;
268 WINPR_ASSERT(pc);
269
270 proxyData* pdata = pc->pdata;
271 WINPR_ASSERT(pdata);
272
273 pServerContext* ps = proxy_data_get_server_context(pdata);
274 WINPR_ASSERT(ps);
275 WINPR_ASSERT(ps->context.update);
276 WINPR_ASSERT(ps->context.update->pointer);
277 WINPR_ASSERT(ps->context.update->pointer->PointerColor);
278 WLog_DBG(TAG, "called");
279 return ps->context.update->pointer->PointerColor(&ps->context, pointer_color);
280}
281
282WINPR_ATTR_NODISCARD
283static BOOL pf_client_send_pointer_large(rdpContext* context,
284 const POINTER_LARGE_UPDATE* pointer_large)
285{
286 pClientContext* pc = (pClientContext*)context;
287 WINPR_ASSERT(pc);
288
289 proxyData* pdata = pc->pdata;
290 WINPR_ASSERT(pdata);
291
292 pServerContext* ps = proxy_data_get_server_context(pdata);
293 WINPR_ASSERT(ps);
294 WINPR_ASSERT(ps->context.update);
295 WINPR_ASSERT(ps->context.update->pointer);
296 WINPR_ASSERT(ps->context.update->pointer->PointerLarge);
297 WLog_DBG(TAG, "called");
298 return ps->context.update->pointer->PointerLarge(&ps->context, pointer_large);
299}
300
301WINPR_ATTR_NODISCARD
302static BOOL pf_client_send_pointer_new(rdpContext* context, const POINTER_NEW_UPDATE* pointer_new)
303{
304 pClientContext* pc = (pClientContext*)context;
305 WINPR_ASSERT(pc);
306
307 proxyData* pdata = pc->pdata;
308 WINPR_ASSERT(pdata);
309
310 pServerContext* ps = proxy_data_get_server_context(pdata);
311 WINPR_ASSERT(ps);
312 WINPR_ASSERT(ps->context.update);
313 WINPR_ASSERT(ps->context.update->pointer);
314 WINPR_ASSERT(ps->context.update->pointer->PointerNew);
315 WLog_DBG(TAG, "called");
316 return ps->context.update->pointer->PointerNew(&ps->context, pointer_new);
317}
318
319WINPR_ATTR_NODISCARD
320static BOOL pf_client_send_pointer_cached(rdpContext* context,
321 const POINTER_CACHED_UPDATE* pointer_cached)
322{
323 pClientContext* pc = (pClientContext*)context;
324 WINPR_ASSERT(pc);
325
326 proxyData* pdata = pc->pdata;
327 WINPR_ASSERT(pdata);
328
329 pServerContext* ps = proxy_data_get_server_context(pdata);
330 WINPR_ASSERT(ps);
331 WINPR_ASSERT(ps->context.update);
332 WINPR_ASSERT(ps->context.update->pointer);
333 WINPR_ASSERT(ps->context.update->pointer->PointerCached);
334 WLog_DBG(TAG, "called");
335 return ps->context.update->pointer->PointerCached(&ps->context, pointer_cached);
336}
337
338WINPR_ATTR_NODISCARD
339static BOOL pf_client_save_session_info(rdpContext* context, UINT32 type, const void* data)
340{
341 const logon_info* logonInfo = nullptr;
342 pClientContext* pc = (pClientContext*)context;
343 WINPR_ASSERT(pc);
344
345 proxyData* pdata = pc->pdata;
346 WINPR_ASSERT(pdata);
347
348 pServerContext* ps = proxy_data_get_server_context(pdata);
349 WINPR_ASSERT(ps);
350 WINPR_ASSERT(ps->context.update);
351 WINPR_ASSERT(ps->context.update->SaveSessionInfo);
352
353 WLog_DBG(TAG, "called");
354
355 switch (type)
356 {
357 case INFO_TYPE_LOGON:
358 case INFO_TYPE_LOGON_LONG:
359 {
360 logonInfo = (const logon_info*)data;
361 PROXY_LOG_INFO(TAG, pc, "client logon info: Username: %s, Domain: %s",
362 logonInfo->username, logonInfo->domain);
363 break;
364 }
365
366 default:
367 break;
368 }
369
370 return ps->context.update->SaveSessionInfo(&ps->context, type, data);
371}
372
373WINPR_ATTR_NODISCARD
374static BOOL pf_client_server_status_info(rdpContext* context, UINT32 status)
375{
376 pClientContext* pc = (pClientContext*)context;
377 WINPR_ASSERT(pc);
378
379 proxyData* pdata = pc->pdata;
380 WINPR_ASSERT(pdata);
381 pServerContext* ps = proxy_data_get_server_context(pdata);
382 WINPR_ASSERT(ps);
383 WINPR_ASSERT(ps->context.update);
384 WINPR_ASSERT(ps->context.update->ServerStatusInfo);
385
386 WLog_DBG(TAG, "called");
387 return ps->context.update->ServerStatusInfo(&ps->context, status);
388}
389
390WINPR_ATTR_NODISCARD
391static BOOL pf_client_set_keyboard_indicators(rdpContext* context, UINT16 led_flags)
392{
393 pClientContext* pc = (pClientContext*)context;
394 WINPR_ASSERT(pc);
395
396 proxyData* pdata = pc->pdata;
397 WINPR_ASSERT(pdata);
398
399 pServerContext* ps = proxy_data_get_server_context(pdata);
400 WINPR_ASSERT(ps);
401 WINPR_ASSERT(ps->context.update);
402 WINPR_ASSERT(ps->context.update->SetKeyboardIndicators);
403
404 WLog_DBG(TAG, "called");
405 return ps->context.update->SetKeyboardIndicators(&ps->context, led_flags);
406}
407
408WINPR_ATTR_NODISCARD
409static BOOL pf_client_set_keyboard_ime_status(rdpContext* context, UINT16 imeId, UINT32 imeState,
410 UINT32 imeConvMode)
411{
412 pClientContext* pc = (pClientContext*)context;
413 WINPR_ASSERT(pc);
414
415 proxyData* pdata = pc->pdata;
416 WINPR_ASSERT(pdata);
417
418 pServerContext* ps = proxy_data_get_server_context(pdata);
419 WINPR_ASSERT(ps);
420 WINPR_ASSERT(ps->context.update);
421 WINPR_ASSERT(ps->context.update->SetKeyboardImeStatus);
422
423 WLog_DBG(TAG, "called");
424 return ps->context.update->SetKeyboardImeStatus(&ps->context, imeId, imeState, imeConvMode);
425}
426
427WINPR_ATTR_NODISCARD
428static BOOL pf_client_SurfaceBits(rdpContext* context,
429 const SURFACE_BITS_COMMAND* surfaceBitsCommand)
430{
431 pClientContext* pc = (pClientContext*)context;
432 WINPR_ASSERT(pc);
433
434 proxyData* pdata = pc->pdata;
435 WINPR_ASSERT(pdata);
436
437 pServerContext* ps = proxy_data_get_server_context(pdata);
438 WINPR_ASSERT(ps);
439
440 WINPR_ASSERT(ps->context.update);
441 WINPR_ASSERT(ps->context.update->SurfaceBits);
442
443 WLog_DBG(TAG, "called");
444 return ps->context.update->SurfaceBits(&ps->context, surfaceBitsCommand);
445}
446
447WINPR_ATTR_NODISCARD
448static BOOL pf_client_SurfaceFrameMarker(rdpContext* context,
449 const SURFACE_FRAME_MARKER* surfaceFrameMarker)
450{
451 pClientContext* pc = (pClientContext*)context;
452 WINPR_ASSERT(pc);
453
454 proxyData* pdata = pc->pdata;
455 WINPR_ASSERT(pdata);
456
457 pServerContext* ps = proxy_data_get_server_context(pdata);
458 WINPR_ASSERT(ps);
459
460 WINPR_ASSERT(ps->context.update);
461 WINPR_ASSERT(ps->context.update->SurfaceFrameMarker);
462
463 WLog_DBG(TAG, "called");
464 return ps->context.update->SurfaceFrameMarker(&ps->context, surfaceFrameMarker);
465}
466
467WINPR_ATTR_NODISCARD
468static BOOL pf_client_window_create(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
469 const WINDOW_STATE_ORDER* windowState)
470{
471 pClientContext* pc = (pClientContext*)context;
472 WINPR_ASSERT(pc);
473
474 proxyData* pdata = pc->pdata;
475 WINPR_ASSERT(pdata);
476
477 pServerContext* ps = proxy_data_get_server_context(pdata);
478 WINPR_ASSERT(ps);
479 WINPR_ASSERT(ps->context.update);
480 WINPR_ASSERT(ps->context.update->window);
481 WINPR_ASSERT(ps->context.update->window->WindowCreate);
482
483 WLog_DBG(TAG, "called");
484 rdp_update_lock(ps->context.update);
485 const BOOL rc = ps->context.update->window->WindowCreate(&ps->context, orderInfo, windowState);
486 rdp_update_unlock(ps->context.update);
487 return rc;
488}
489
490WINPR_ATTR_NODISCARD
491static BOOL pf_client_window_update(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
492 const WINDOW_STATE_ORDER* windowState)
493{
494 pClientContext* pc = (pClientContext*)context;
495 WINPR_ASSERT(pc);
496
497 proxyData* pdata = pc->pdata;
498 WINPR_ASSERT(pdata);
499
500 pServerContext* ps = proxy_data_get_server_context(pdata);
501 WINPR_ASSERT(ps);
502 WINPR_ASSERT(ps->context.update);
503 WINPR_ASSERT(ps->context.update->window);
504 WINPR_ASSERT(ps->context.update->window->WindowUpdate);
505
506 WLog_DBG(TAG, "called");
507 rdp_update_lock(ps->context.update);
508 const BOOL rc = ps->context.update->window->WindowUpdate(&ps->context, orderInfo, windowState);
509 rdp_update_unlock(ps->context.update);
510 return rc;
511}
512
513WINPR_ATTR_NODISCARD
514static BOOL pf_client_window_icon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
515 const WINDOW_ICON_ORDER* windowIcon)
516{
517 pClientContext* pc = (pClientContext*)context;
518 WINPR_ASSERT(pc);
519
520 proxyData* pdata = pc->pdata;
521 WINPR_ASSERT(pdata);
522
523 pServerContext* ps = proxy_data_get_server_context(pdata);
524 WINPR_ASSERT(ps);
525 WINPR_ASSERT(ps->context.update);
526 WINPR_ASSERT(ps->context.update->window);
527 WINPR_ASSERT(ps->context.update->window->WindowIcon);
528
529 WLog_DBG(TAG, "called");
530 rdp_update_lock(ps->context.update);
531 const BOOL rc = ps->context.update->window->WindowIcon(&ps->context, orderInfo, windowIcon);
532 rdp_update_unlock(ps->context.update);
533 return rc;
534}
535
536WINPR_ATTR_NODISCARD
537static BOOL pf_client_window_cached_icon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
538 const WINDOW_CACHED_ICON_ORDER* windowCachedIcon)
539{
540 pClientContext* pc = (pClientContext*)context;
541 WINPR_ASSERT(pc);
542
543 proxyData* pdata = pc->pdata;
544 WINPR_ASSERT(pdata);
545
546 pServerContext* ps = proxy_data_get_server_context(pdata);
547 WINPR_ASSERT(ps);
548 WINPR_ASSERT(ps->context.update);
549 WINPR_ASSERT(ps->context.update->window);
550 WINPR_ASSERT(ps->context.update->window->WindowCachedIcon);
551
552 WLog_DBG(TAG, "called");
553 rdp_update_lock(ps->context.update);
554 const BOOL rc =
555 ps->context.update->window->WindowCachedIcon(&ps->context, orderInfo, windowCachedIcon);
556 rdp_update_unlock(ps->context.update);
557 return rc;
558}
559
560WINPR_ATTR_NODISCARD
561static BOOL pf_client_window_delete(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo)
562{
563 pClientContext* pc = (pClientContext*)context;
564 WINPR_ASSERT(pc);
565
566 proxyData* pdata = pc->pdata;
567 WINPR_ASSERT(pdata);
568
569 pServerContext* ps = proxy_data_get_server_context(pdata);
570 WINPR_ASSERT(ps);
571 WINPR_ASSERT(ps->context.update);
572 WINPR_ASSERT(ps->context.update->window);
573 WINPR_ASSERT(ps->context.update->window->WindowDelete);
574
575 WLog_DBG(TAG, "called");
576 rdp_update_lock(ps->context.update);
577 const BOOL rc = ps->context.update->window->WindowDelete(&ps->context, orderInfo);
578 rdp_update_unlock(ps->context.update);
579 return rc;
580}
581
582WINPR_ATTR_NODISCARD
583static BOOL pf_client_notify_icon_create(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
584 const NOTIFY_ICON_STATE_ORDER* notifyIconState)
585{
586 pClientContext* pc = (pClientContext*)context;
587 WINPR_ASSERT(pc);
588
589 proxyData* pdata = pc->pdata;
590 WINPR_ASSERT(pdata);
591
592 pServerContext* ps = proxy_data_get_server_context(pdata);
593 WINPR_ASSERT(ps);
594 WINPR_ASSERT(ps->context.update);
595 WINPR_ASSERT(ps->context.update->window);
596 WINPR_ASSERT(ps->context.update->window->NotifyIconCreate);
597
598 WLog_DBG(TAG, "called");
599 rdp_update_lock(ps->context.update);
600 const BOOL rc =
601 ps->context.update->window->NotifyIconCreate(&ps->context, orderInfo, notifyIconState);
602 rdp_update_unlock(ps->context.update);
603 return rc;
604}
605
606WINPR_ATTR_NODISCARD
607static BOOL pf_client_notify_icon_update(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
608 const NOTIFY_ICON_STATE_ORDER* notifyIconState)
609{
610 pClientContext* pc = (pClientContext*)context;
611 WINPR_ASSERT(pc);
612
613 proxyData* pdata = pc->pdata;
614 WINPR_ASSERT(pdata);
615
616 pServerContext* ps = proxy_data_get_server_context(pdata);
617 WINPR_ASSERT(ps);
618 WINPR_ASSERT(ps->context.update);
619 WINPR_ASSERT(ps->context.update->window);
620 WINPR_ASSERT(ps->context.update->window->NotifyIconUpdate);
621
622 WLog_DBG(TAG, "called");
623 rdp_update_lock(ps->context.update);
624 const BOOL rc =
625 ps->context.update->window->NotifyIconUpdate(&ps->context, orderInfo, notifyIconState);
626 rdp_update_unlock(ps->context.update);
627 return rc;
628}
629
630WINPR_ATTR_NODISCARD
631static BOOL pf_client_notify_icon_delete(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo)
632{
633 pClientContext* pc = (pClientContext*)context;
634 WINPR_ASSERT(pc);
635
636 proxyData* pdata = pc->pdata;
637 WINPR_ASSERT(pdata);
638
639 pServerContext* ps = proxy_data_get_server_context(pdata);
640 WINPR_ASSERT(ps);
641 WINPR_ASSERT(ps->context.update);
642 WINPR_ASSERT(ps->context.update->window);
643 WINPR_ASSERT(ps->context.update->window->NotifyIconDelete);
644
645 WLog_DBG(TAG, "called");
646 rdp_update_lock(ps->context.update);
647 const BOOL rc = ps->context.update->window->NotifyIconDelete(&ps->context, orderInfo);
648 rdp_update_unlock(ps->context.update);
649 return rc;
650}
651
652WINPR_ATTR_NODISCARD
653static BOOL pf_client_monitored_desktop(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
654 const MONITORED_DESKTOP_ORDER* monitoredDesktop)
655{
656 pClientContext* pc = (pClientContext*)context;
657 WINPR_ASSERT(pc);
658
659 proxyData* pdata = pc->pdata;
660 WINPR_ASSERT(pdata);
661
662 pServerContext* ps = proxy_data_get_server_context(pdata);
663 WINPR_ASSERT(ps);
664 WINPR_ASSERT(ps->context.update);
665 WINPR_ASSERT(ps->context.update->window);
666 WINPR_ASSERT(ps->context.update->window->MonitoredDesktop);
667
668 WLog_DBG(TAG, "called");
669 rdp_update_lock(ps->context.update);
670 const BOOL rc =
671 ps->context.update->window->MonitoredDesktop(&ps->context, orderInfo, monitoredDesktop);
672 rdp_update_unlock(ps->context.update);
673 return rc;
674}
675
676WINPR_ATTR_NODISCARD
677static BOOL pf_client_non_monitored_desktop(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo)
678{
679 pClientContext* pc = (pClientContext*)context;
680 WINPR_ASSERT(pc);
681
682 proxyData* pdata = pc->pdata;
683 WINPR_ASSERT(pdata);
684
685 pServerContext* ps = proxy_data_get_server_context(pdata);
686 WINPR_ASSERT(ps);
687 WINPR_ASSERT(ps->context.update);
688 WINPR_ASSERT(ps->context.update->window);
689 WINPR_ASSERT(ps->context.update->window->NonMonitoredDesktop);
690
691 WLog_DBG(TAG, "called");
692 rdp_update_lock(ps->context.update);
693 const BOOL rc = ps->context.update->window->NonMonitoredDesktop(&ps->context, orderInfo);
694 rdp_update_unlock(ps->context.update);
695 return rc;
696}
697
698void pf_server_register_update_callbacks(rdpUpdate* update)
699{
700 WINPR_ASSERT(update);
701 update->RefreshRect = pf_server_refresh_rect;
702 update->SuppressOutput = pf_server_suppress_output;
703}
704
705void pf_client_register_update_callbacks(rdpUpdate* update)
706{
707 WINPR_ASSERT(update);
708 update->BeginPaint = pf_client_begin_paint;
709 update->EndPaint = pf_client_end_paint;
710 update->BitmapUpdate = pf_client_bitmap_update;
711 update->DesktopResize = pf_client_desktop_resize;
712 update->RemoteMonitors = pf_client_remote_monitors;
713 update->SaveSessionInfo = pf_client_save_session_info;
714 update->ServerStatusInfo = pf_client_server_status_info;
715 update->SetKeyboardIndicators = pf_client_set_keyboard_indicators;
716 update->SetKeyboardImeStatus = pf_client_set_keyboard_ime_status;
717
718 /* see gdi_register_update_callbacks */
719 update->SurfaceBits = pf_client_SurfaceBits;
720 update->SurfaceFrameMarker = pf_client_SurfaceFrameMarker;
721
722 /* Rail window updates */
723 update->window->WindowCreate = pf_client_window_create;
724 update->window->WindowUpdate = pf_client_window_update;
725 update->window->WindowIcon = pf_client_window_icon;
726 update->window->WindowCachedIcon = pf_client_window_cached_icon;
727 update->window->WindowDelete = pf_client_window_delete;
728 update->window->NotifyIconCreate = pf_client_notify_icon_create;
729 update->window->NotifyIconUpdate = pf_client_notify_icon_update;
730 update->window->NotifyIconDelete = pf_client_notify_icon_delete;
731 update->window->MonitoredDesktop = pf_client_monitored_desktop;
732 update->window->NonMonitoredDesktop = pf_client_non_monitored_desktop;
733
734 /* Pointer updates */
735 update->pointer->PointerSystem = pf_client_send_pointer_system;
736 update->pointer->PointerPosition = pf_client_send_pointer_position;
737 update->pointer->PointerColor = pf_client_send_pointer_color;
738 update->pointer->PointerLarge = pf_client_send_pointer_large;
739 update->pointer->PointerNew = pf_client_send_pointer_new;
740 update->pointer->PointerCached = pf_client_send_pointer_cached;
741}
freerdp_settings_copy_item
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_copy_item(rdpSettings *dst, const rdpSettings *src, SSIZE_T id)
copies one setting identified by id from src to dst
Definition settings_str.c:443
MONITOR_DEF
Definition settings_types.h:434
BITMAP_UPDATE
Definition include/freerdp/update.h:72
MONITORED_DESKTOP_ORDER
Definition include/freerdp/window.h:251
NOTIFY_ICON_STATE_ORDER
Definition include/freerdp/window.h:241
POINTER_CACHED_UPDATE
Definition include/freerdp/pointer.h:85
POINTER_COLOR_UPDATE
Definition include/freerdp/pointer.h:52
POINTER_LARGE_UPDATE
Definition include/freerdp/pointer.h:65
POINTER_NEW_UPDATE
Definition include/freerdp/pointer.h:79
POINTER_POSITION_UPDATE
Definition include/freerdp/pointer.h:41
POINTER_SYSTEM_UPDATE
Definition include/freerdp/pointer.h:47
RECTANGLE_16
Definition types.h:109
SURFACE_BITS_COMMAND
Definition include/freerdp/update.h:123
SURFACE_FRAME_MARKER
Definition include/freerdp/update.h:134
WINDOW_CACHED_ICON_ORDER
Definition include/freerdp/window.h:236
WINDOW_ICON_ORDER
Definition include/freerdp/window.h:231
WINDOW_ORDER_INFO
Definition include/freerdp/window.h:159
WINDOW_STATE_ORDER
Definition include/freerdp/window.h:195