FreeRDP
Loading...
Searching...
No Matches
sfreerdp.c
1
22#include <freerdp/config.h>
23
24#include <errno.h>
25#include <signal.h>
26
27#include <winpr/winpr.h>
28#include <winpr/crt.h>
29#include <winpr/cast.h>
30#include <winpr/assert.h>
31#include <winpr/ssl.h>
32#include <winpr/synch.h>
33#include <winpr/file.h>
34#include <winpr/string.h>
35#include <winpr/path.h>
36#include <winpr/image.h>
37#include <winpr/winsock.h>
38
39#include <freerdp/streamdump.h>
40#include <freerdp/transport_io.h>
41
42#include <freerdp/channels/wtsvc.h>
43#include <freerdp/channels/channels.h>
44#include <freerdp/channels/drdynvc.h>
45
46#include <freerdp/freerdp.h>
47#include <freerdp/constants.h>
48#include <freerdp/server/rdpsnd.h>
49#include <freerdp/settings.h>
50
51#include "sf_ainput.h"
52#include "sf_audin.h"
53#include "sf_rdpsnd.h"
54#include "sf_encomsp.h"
55
56#include "sfreerdp.h"
57
58#include <freerdp/log.h>
59#define TAG SERVER_TAG("sample")
60
61#define SAMPLE_SERVER_USE_CLIENT_RESOLUTION 1
62#define SAMPLE_SERVER_DEFAULT_WIDTH 1024
63#define SAMPLE_SERVER_DEFAULT_HEIGHT 768
64
65struct server_info
66{
67 BOOL test_dump_rfx_realtime;
68 const char* test_pcap_file;
69 const char* replay_dump;
70 const char* cert;
71 const char* key;
72};
73
74static void test_peer_context_free(freerdp_peer* client, rdpContext* ctx)
75{
76 testPeerContext* context = (testPeerContext*)ctx;
77
78 WINPR_UNUSED(client);
79
80 if (context)
81 {
82 winpr_image_free(context->image, TRUE);
83 if (context->debug_channel_thread)
84 {
85 WINPR_ASSERT(context->stopEvent);
86 (void)SetEvent(context->stopEvent);
87 (void)WaitForSingleObject(context->debug_channel_thread, INFINITE);
88 (void)CloseHandle(context->debug_channel_thread);
89 }
90
91 Stream_Free(context->s, TRUE);
92 free(context->bg_data);
93 rfx_context_free(context->rfx_context);
94 nsc_context_free(context->nsc_context);
95
96 if (context->debug_channel)
97 (void)WTSVirtualChannelClose(context->debug_channel);
98
99 sf_peer_audin_uninit(context);
100
101#if defined(CHANNEL_AINPUT_SERVER)
102 sf_peer_ainput_uninit(context);
103#endif
104
105 rdpsnd_server_context_free(context->rdpsnd);
106 encomsp_server_context_free(context->encomsp);
107
108 WTSCloseServer(context->vcm);
109 }
110}
111
112WINPR_ATTR_NODISCARD
113static BOOL test_peer_context_new(freerdp_peer* client, rdpContext* ctx)
114{
115 testPeerContext* context = (testPeerContext*)ctx;
116
117 WINPR_ASSERT(client);
118 WINPR_ASSERT(context);
119 WINPR_ASSERT(ctx->settings);
120
121 context->image = winpr_image_new();
122 if (!context->image)
123 goto fail;
124 if (!(context->rfx_context = rfx_context_new_ex(
125 TRUE, freerdp_settings_get_uint32(ctx->settings, FreeRDP_ThreadingFlags))))
126 goto fail;
127
128 if (!rfx_context_reset(context->rfx_context, SAMPLE_SERVER_DEFAULT_WIDTH,
129 SAMPLE_SERVER_DEFAULT_HEIGHT))
130 goto fail;
131
132 {
133 const UINT32 rlgr = freerdp_settings_get_uint32(ctx->settings, FreeRDP_RemoteFxRlgrMode);
134 if (!rfx_context_set_mode(context->rfx_context, WINPR_ASSERTING_INT_CAST(RLGR_MODE, rlgr)))
135 goto fail;
136 }
137
138 if (!(context->nsc_context = nsc_context_new()))
139 goto fail;
140
141 if (!(context->s = Stream_New(nullptr, 65536)))
142 goto fail;
143
144 context->icon_x = UINT32_MAX;
145 context->icon_y = UINT32_MAX;
146 context->vcm = WTSOpenServerA((LPSTR)client->context);
147
148 if (!context->vcm || context->vcm == INVALID_HANDLE_VALUE)
149 goto fail;
150
151 return TRUE;
152fail:
153 test_peer_context_free(client, ctx);
154 return FALSE;
155}
156
157WINPR_ATTR_NODISCARD
158static BOOL test_peer_init(freerdp_peer* client)
159{
160 WINPR_ASSERT(client);
161
162 client->ContextSize = sizeof(testPeerContext);
163 client->ContextNew = test_peer_context_new;
164 client->ContextFree = test_peer_context_free;
165 return freerdp_peer_context_new(client);
166}
167
168WINPR_ATTR_NODISCARD
169static wStream* test_peer_stream_init(testPeerContext* context)
170{
171 WINPR_ASSERT(context);
172 WINPR_ASSERT(context->s);
173
174 Stream_Clear(context->s);
175 Stream_SetPosition(context->s, 0);
176 return context->s;
177}
178
179static void test_peer_begin_frame(freerdp_peer* client)
180{
181 rdpUpdate* update = nullptr;
182 SURFACE_FRAME_MARKER fm = WINPR_C_ARRAY_INIT;
183 testPeerContext* context = nullptr;
184
185 WINPR_ASSERT(client);
186 WINPR_ASSERT(client->context);
187
188 update = client->context->update;
189 WINPR_ASSERT(update);
190
191 context = (testPeerContext*)client->context;
192 WINPR_ASSERT(context);
193
194 fm.frameAction = SURFACECMD_FRAMEACTION_BEGIN;
195 fm.frameId = context->frame_id;
196 WINPR_ASSERT(update->SurfaceFrameMarker);
197 if (!update->SurfaceFrameMarker(update->context, &fm))
198 WLog_WARN(TAG, "SurfaceFrameMarker failed");
199}
200
201static void test_peer_end_frame(freerdp_peer* client)
202{
203 rdpUpdate* update = nullptr;
204 SURFACE_FRAME_MARKER fm = WINPR_C_ARRAY_INIT;
205 testPeerContext* context = nullptr;
206
207 WINPR_ASSERT(client);
208
209 context = (testPeerContext*)client->context;
210 WINPR_ASSERT(context);
211
212 update = client->context->update;
213 WINPR_ASSERT(update);
214
215 fm.frameAction = SURFACECMD_FRAMEACTION_END;
216 fm.frameId = context->frame_id;
217 WINPR_ASSERT(update->SurfaceFrameMarker);
218 if (!update->SurfaceFrameMarker(update->context, &fm))
219 WLog_WARN(TAG, "SurfaceFrameMarker failed");
220 context->frame_id++;
221}
222
223WINPR_ATTR_NODISCARD
224static BOOL stream_surface_bits_supported(const rdpSettings* settings)
225{
226 const UINT32 supported =
227 freerdp_settings_get_uint32(settings, FreeRDP_SurfaceCommandsSupported);
228 return ((supported & SURFCMDS_STREAM_SURFACE_BITS) != 0);
229}
230
231static BOOL test_peer_draw_background(freerdp_peer* client, const RFX_RECT* rect)
232{
233 SURFACE_BITS_COMMAND cmd = WINPR_C_ARRAY_INIT;
234 BOOL ret = FALSE;
235 const UINT32 colorFormat = PIXEL_FORMAT_RGB24;
236 const size_t bpp = FreeRDPGetBytesPerPixel(colorFormat);
237
238 WINPR_ASSERT(client);
239
240 testPeerContext* context = (testPeerContext*)client->context;
241 WINPR_ASSERT(context);
242
243 rdpSettings* settings = client->context->settings;
244 WINPR_ASSERT(settings);
245
246 rdpUpdate* update = client->context->update;
247 WINPR_ASSERT(update);
248
249 const BOOL RemoteFxCodec = freerdp_settings_get_bool(settings, FreeRDP_RemoteFxCodec);
250 if (!RemoteFxCodec && !freerdp_settings_get_bool(settings, FreeRDP_NSCodec))
251 return FALSE;
252
253 WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) <= UINT16_MAX);
254 WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) <= UINT16_MAX);
255
256 wStream* s = test_peer_stream_init(context);
257 const size_t size = bpp * rect->width * rect->height;
258 if (size == 0)
259 return FALSE;
260
261 BYTE* rgb_data = malloc(size);
262 if (!rgb_data)
263 {
264 WLog_ERR(TAG, "Problem allocating memory");
265 return FALSE;
266 }
267
268 memset(rgb_data, 0xA0, size);
269
270 if (RemoteFxCodec && stream_surface_bits_supported(settings))
271 {
272 WLog_DBG(TAG, "Using RemoteFX codec");
273 rfx_context_set_pixel_format(context->rfx_context, colorFormat);
274
275 WINPR_ASSERT(bpp <= UINT16_MAX);
276 RFX_RECT rrect = { .x = 0, .y = 0, .width = rect->width, .height = rect->height };
277
278 if (!rfx_compose_message(context->rfx_context, s, &rrect, 1, rgb_data, rect->width,
279 rect->height, (UINT32)(bpp * rect->width)))
280 {
281 goto out;
282 }
283
284 const UINT32 RemoteFxCodecId =
285 freerdp_settings_get_uint32(settings, FreeRDP_RemoteFxCodecId);
286 WINPR_ASSERT(RemoteFxCodecId <= UINT16_MAX);
287 cmd.bmp.codecID = (UINT16)RemoteFxCodecId;
288 cmd.cmdType = CMDTYPE_STREAM_SURFACE_BITS;
289 }
290 else
291 {
292 WLog_DBG(TAG, "Using NSCodec");
293 if (!nsc_context_set_parameters(context->nsc_context, NSC_COLOR_FORMAT, colorFormat))
294 goto out;
295
296 WINPR_ASSERT(bpp <= UINT16_MAX);
297 if (!nsc_compose_message(context->nsc_context, s, rgb_data, rect->width, rect->height,
298 (UINT32)(bpp * rect->width)))
299 goto out;
300 const UINT32 NSCodecId = freerdp_settings_get_uint32(settings, FreeRDP_NSCodecId);
301 WINPR_ASSERT(NSCodecId <= UINT16_MAX);
302 cmd.bmp.codecID = (UINT16)NSCodecId;
303 cmd.cmdType = CMDTYPE_SET_SURFACE_BITS;
304 }
305
306 cmd.destLeft = rect->x;
307 cmd.destTop = rect->y;
308 cmd.destRight = rect->x + rect->width;
309 cmd.destBottom = rect->y + rect->height;
310 cmd.bmp.bpp = 32;
311 cmd.bmp.flags = 0;
312 cmd.bmp.width = rect->width;
313 cmd.bmp.height = rect->height;
314 WINPR_ASSERT(Stream_GetPosition(s) <= UINT32_MAX);
315 cmd.bmp.bitmapDataLength = (UINT32)Stream_GetPosition(s);
316 cmd.bmp.bitmapData = Stream_Buffer(s);
317
318 ret = update->SurfaceBits(update->context, &cmd);
319out:
320 free(rgb_data);
321 return ret;
322}
323
324WINPR_ATTR_NODISCARD
325static int open_icon(wImage* img)
326{
327 char* paths[] = { SAMPLE_RESOURCE_ROOT, "." };
328 const char* names[] = { "test_icon.webp", "test_icon.png", "test_icon.jpg", "test_icon.bmp" };
329
330 for (size_t x = 0; x < ARRAYSIZE(paths); x++)
331 {
332 const char* path = paths[x];
333 if (!winpr_PathFileExists(path))
334 continue;
335
336 for (size_t y = 0; y < ARRAYSIZE(names); y++)
337 {
338 const char* name = names[y];
339 char* file = GetCombinedPath(path, name);
340 int rc = winpr_image_read(img, file);
341 free(file);
342 if (rc > 0)
343 return rc;
344 }
345 }
346 WLog_ERR(TAG, "Unable to open test icon");
347 return -1;
348}
349
350WINPR_ATTR_NODISCARD
351static BOOL test_peer_load_icon(freerdp_peer* client)
352{
353 testPeerContext* context = nullptr;
354 rdpSettings* settings = nullptr;
355
356 WINPR_ASSERT(client);
357
358 context = (testPeerContext*)client->context;
359 WINPR_ASSERT(context);
360
361 settings = client->context->settings;
362 WINPR_ASSERT(settings);
363
364 if (!freerdp_settings_get_bool(settings, FreeRDP_RemoteFxCodec) &&
365 !freerdp_settings_get_bool(settings, FreeRDP_NSCodec))
366 {
367 WLog_ERR(TAG, "Client doesn't support RemoteFX or NSCodec");
368 return FALSE;
369 }
370
371 int rc = open_icon(context->image);
372 if (rc <= 0)
373 goto out_fail;
374
375 /* background with same size, which will be used to erase the icon from old position */
376 if (!(context->bg_data = calloc(context->image->height, 3ULL * context->image->width)))
377 goto out_fail;
378
379 memset(context->bg_data, 0xA0, 3ULL * context->image->height * context->image->width);
380 return TRUE;
381out_fail:
382 context->bg_data = nullptr;
383 return FALSE;
384}
385
386static void test_send_cursor_update(freerdp_peer* client, UINT32 x, UINT32 y)
387{
388 WINPR_ASSERT(client);
389
390 testPeerContext* context = (testPeerContext*)client->context;
391 WINPR_ASSERT(context);
392
393 rdpSettings* settings = client->context->settings;
394
395 const BOOL RemoteFxCodec = freerdp_settings_get_bool(settings, FreeRDP_RemoteFxCodec);
396
397 if (context->image->width < 1 || !context->activated)
398 return;
399
400 RFX_RECT rect = { .x = 0,
401 .y = 0,
402 .width = WINPR_ASSERTING_INT_CAST(UINT16, context->image->width),
403 .height = WINPR_ASSERTING_INT_CAST(UINT16, context->image->height) };
404
405 const UINT32 w = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
406 const UINT32 h = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
407 if (context->icon_x + context->image->width > w)
408 return;
409 if (context->icon_y + context->image->height > h)
410 return;
411 if (x + context->image->width > w)
412 return;
413 if (y + context->image->height > h)
414 return;
415
416 SURFACE_BITS_COMMAND cmd = WINPR_C_ARRAY_INIT;
417 if (RemoteFxCodec && stream_surface_bits_supported(settings))
418 {
419 const UINT32 RemoteFxCodecId =
420 freerdp_settings_get_uint32(settings, FreeRDP_RemoteFxCodecId);
421 WINPR_ASSERT(RemoteFxCodecId <= UINT16_MAX);
422 cmd.bmp.codecID = (UINT16)RemoteFxCodecId;
423 cmd.cmdType = CMDTYPE_STREAM_SURFACE_BITS;
424 }
425 else
426 {
427 const UINT32 NSCodecId = freerdp_settings_get_uint32(settings, FreeRDP_NSCodecId);
428 WINPR_ASSERT(NSCodecId <= UINT16_MAX);
429 cmd.bmp.codecID = (UINT16)NSCodecId;
430 cmd.cmdType = CMDTYPE_SET_SURFACE_BITS;
431 }
432
433 wStream* s = test_peer_stream_init(context);
434
435 {
436 const UINT32 colorFormat =
437 context->image->bitsPerPixel > 24 ? PIXEL_FORMAT_BGRA32 : PIXEL_FORMAT_BGR24;
438
439 if (RemoteFxCodec)
440 {
441 rfx_context_set_pixel_format(context->rfx_context, colorFormat);
442 if (!rfx_compose_message(context->rfx_context, s, &rect, 1, context->image->data,
443 rect.width, rect.height, context->image->scanline))
444 WLog_WARN(TAG, "rfx_compose_message failed");
445 }
446 else
447 {
448 if (!nsc_context_set_parameters(context->nsc_context, NSC_COLOR_FORMAT, colorFormat))
449 WLog_WARN(TAG, "nsc_context_set_parameters failed");
450 else if (!nsc_compose_message(context->nsc_context, s, context->image->data, rect.width,
451 rect.height, context->image->scanline))
452 WLog_WARN(TAG, "rfx_compose_message failed");
453 }
454 }
455
456 cmd.destLeft = x;
457 cmd.destTop = y;
458 cmd.destRight = x + rect.width;
459 cmd.destBottom = y + rect.height;
460 cmd.bmp.bpp = 32;
461 cmd.bmp.width = rect.width;
462 cmd.bmp.height = rect.height;
463 cmd.bmp.bitmapDataLength = (UINT32)Stream_GetPosition(s);
464 cmd.bmp.bitmapData = Stream_Buffer(s);
465
466 rdpUpdate* update = client->context->update;
467 WINPR_ASSERT(update);
468 WINPR_ASSERT(update->SurfaceBits);
469 if (!update->SurfaceBits(update->context, &cmd))
470 {
471 WLog_WARN(TAG, "update->SurfaceBits failed");
472 }
473 context->icon_x = x;
474 context->icon_y = y;
475}
476
477static void test_peer_draw_icon(freerdp_peer* client, UINT32 x, UINT32 y)
478{
479 WINPR_ASSERT(client);
480
481 rdpSettings* settings = client->context->settings;
482 WINPR_ASSERT(settings);
483
484 if (freerdp_settings_get_bool(settings, FreeRDP_DumpRemoteFx))
485 return;
486
487 test_peer_begin_frame(client);
488
489 testPeerContext* context = (testPeerContext*)client->context;
490 if ((context->icon_x != UINT32_MAX) && (context->icon_y != UINT32_MAX))
491 {
492 RFX_RECT rect = { .x = WINPR_ASSERTING_INT_CAST(uint16_t, context->icon_x),
493 .y = WINPR_ASSERTING_INT_CAST(uint16_t, context->icon_y),
494 .width = WINPR_ASSERTING_INT_CAST(uint16_t, context->image->width),
495 .height = WINPR_ASSERTING_INT_CAST(uint16_t, context->image->height) };
496
497 test_peer_draw_background(client, &rect);
498 }
499 test_send_cursor_update(client, x, y);
500 test_peer_end_frame(client);
501}
502
503WINPR_ATTR_NODISCARD
504static BOOL test_sleep_tsdiff(UINT32* old_sec, UINT32* old_usec, UINT32 new_sec, UINT32 new_usec)
505{
506 INT64 sec = 0;
507 INT64 usec = 0;
508
509 WINPR_ASSERT(old_sec);
510 WINPR_ASSERT(old_usec);
511
512 if ((*old_sec == 0) && (*old_usec == 0))
513 {
514 *old_sec = new_sec;
515 *old_usec = new_usec;
516 return TRUE;
517 }
518
519 sec = new_sec - *old_sec;
520 usec = new_usec - *old_usec;
521
522 if ((sec < 0) || ((sec == 0) && (usec < 0)))
523 {
524 WLog_ERR(TAG, "Invalid time stamp detected.");
525 return FALSE;
526 }
527
528 *old_sec = new_sec;
529 *old_usec = new_usec;
530
531 while (usec < 0)
532 {
533 usec += 1000000;
534 sec--;
535 }
536
537 if (sec > 0)
538 Sleep((DWORD)sec * 1000);
539
540 if (usec > 0)
541 USleep((DWORD)usec);
542
543 return TRUE;
544}
545
546static BOOL tf_peer_dump_rfx(freerdp_peer* client)
547{
548 BOOL rc = FALSE;
549 wStream* s = nullptr;
550 UINT32 prev_seconds = 0;
551 UINT32 prev_useconds = 0;
552 rdpUpdate* update = nullptr;
553 rdpPcap* pcap_rfx = nullptr;
554 pcap_record record = WINPR_C_ARRAY_INIT;
555
556 WINPR_ASSERT(client);
557 WINPR_ASSERT(client->context);
558
559 struct server_info* info = client->ContextExtra;
560 WINPR_ASSERT(info);
561
562 s = Stream_New(nullptr, 512);
563
564 if (!s)
565 return FALSE;
566
567 update = client->context->update;
568 WINPR_ASSERT(update);
569
570 pcap_rfx = pcap_open(info->test_pcap_file, FALSE);
571 if (!pcap_rfx)
572 goto fail;
573
574 prev_seconds = prev_useconds = 0;
575
576 while (pcap_has_next_record(pcap_rfx))
577 {
578 if (!pcap_get_next_record_header(pcap_rfx, &record))
579 break;
580
581 if (!Stream_EnsureCapacity(s, record.length))
582 break;
583
584 record.data = Stream_Buffer(s);
585 if (!pcap_get_next_record_content(pcap_rfx, &record))
586 break;
587 Stream_SetPosition(s, Stream_Capacity(s));
588
589 if (info->test_dump_rfx_realtime &&
590 test_sleep_tsdiff(&prev_seconds, &prev_useconds, record.header.ts_sec,
591 record.header.ts_usec) == FALSE)
592 break;
593
594 WINPR_ASSERT(update->SurfaceCommand);
595 if (!update->SurfaceCommand(update->context, s))
596 break;
597
598 WINPR_ASSERT(client->CheckFileDescriptor);
599 if (client->CheckFileDescriptor(client) != TRUE)
600 break;
601 }
602
603 rc = TRUE;
604fail:
605 Stream_Free(s, TRUE);
606 pcap_close(pcap_rfx);
607 return rc;
608}
609
610WINPR_ATTR_NODISCARD
611static DWORD WINAPI tf_debug_channel_thread_func(LPVOID arg)
612{
613 void* fd = nullptr;
614 void* buffer = nullptr;
615 DWORD BytesReturned = 0;
616 ULONG written = 0;
617 testPeerContext* context = (testPeerContext*)arg;
618
619 WINPR_ASSERT(context);
620 if (WTSVirtualChannelQuery(context->debug_channel, WTSVirtualFileHandle, &buffer,
621 &BytesReturned) == TRUE)
622 {
623 fd = *((void**)buffer);
624 WTSFreeMemory(buffer);
625
626 if (!(context->event = CreateWaitObjectEvent(nullptr, TRUE, FALSE, fd)))
627 return 0;
628 }
629
630 wStream* s = Stream_New(nullptr, 4096);
631 if (!s)
632 goto fail;
633
634 if (!WTSVirtualChannelWrite(context->debug_channel, (PCHAR) "test1", 5, &written))
635 goto fail;
636
637 while (1)
638 {
639 DWORD status = 0;
640 DWORD nCount = 0;
641 HANDLE handles[MAXIMUM_WAIT_OBJECTS] = WINPR_C_ARRAY_INIT;
642
643 handles[nCount++] = context->event;
644 handles[nCount++] = freerdp_abort_event(&context->_p);
645 handles[nCount++] = context->stopEvent;
646 status = WaitForMultipleObjects(nCount, handles, FALSE, INFINITE);
647 switch (status)
648 {
649 case WAIT_OBJECT_0:
650 break;
651 default:
652 goto fail;
653 }
654
655 Stream_SetPosition(s, 0);
656
657 if (WTSVirtualChannelRead(context->debug_channel, 0, Stream_BufferAs(s, char),
658 (ULONG)Stream_Capacity(s), &BytesReturned) == FALSE)
659 {
660 if (BytesReturned == 0)
661 break;
662
663 if (!Stream_EnsureRemainingCapacity(s, BytesReturned))
664 break;
665
666 if (WTSVirtualChannelRead(context->debug_channel, 0, Stream_BufferAs(s, char),
667 (ULONG)Stream_Capacity(s), &BytesReturned) == FALSE)
668 {
669 /* should not happen */
670 break;
671 }
672 }
673
674 Stream_SetPosition(s, BytesReturned);
675 WLog_DBG(TAG, "got %" PRIu32 " bytes", BytesReturned);
676 }
677fail:
678 Stream_Free(s, TRUE);
679 return 0;
680}
681
682WINPR_ATTR_NODISCARD
683static BOOL tf_peer_post_connect(freerdp_peer* client)
684{
685 testPeerContext* context = nullptr;
686 rdpSettings* settings = nullptr;
687
688 WINPR_ASSERT(client);
689
690 context = (testPeerContext*)client->context;
691 WINPR_ASSERT(context);
692
693 settings = client->context->settings;
694 WINPR_ASSERT(settings);
695
702 WLog_DBG(TAG, "Client %s is activated (osMajorType %" PRIu32 " osMinorType %" PRIu32 ")",
703 client->local ? "(local)" : client->hostname,
704 freerdp_settings_get_uint32(settings, FreeRDP_OsMajorType),
705 freerdp_settings_get_uint32(settings, FreeRDP_OsMinorType));
706
707 if (freerdp_settings_get_bool(settings, FreeRDP_AutoLogonEnabled))
708 {
709 const char* Username = freerdp_settings_get_string(settings, FreeRDP_Username);
710 const char* Domain = freerdp_settings_get_string(settings, FreeRDP_Domain);
711 WLog_DBG(TAG, " and wants to login automatically as %s\\%s", Domain ? Domain : "",
712 Username);
713 /* A real server may perform OS login here if NLA is not executed previously. */
714 }
715
716 WLog_DBG(TAG, "Client requested desktop: %" PRIu32 "x%" PRIu32 "x%" PRIu32 "",
717 freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
718 freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight),
719 freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth));
720#if (SAMPLE_SERVER_USE_CLIENT_RESOLUTION == 1)
721
722 if (!rfx_context_reset(context->rfx_context,
723 freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
724 freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)))
725 return FALSE;
726
727 WLog_DBG(TAG, "Using resolution requested by client.");
728#else
729 client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) =
730 context->rfx_context->width;
731 client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) =
732 context->rfx_context->height;
733 WLog_DBG(TAG, "Resizing client to %" PRIu32 "x%" PRIu32 "",
734 client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
735 client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight));
736 client->update->DesktopResize(client->update->context);
737#endif
738
739 /* A real server should tag the peer as activated here and start sending updates in main loop.
740 */
741 if (!test_peer_load_icon(client))
742 {
743 WLog_DBG(TAG, "Unable to load icon");
744 return FALSE;
745 }
746
747 if (WTSVirtualChannelManagerIsChannelJoined(context->vcm, "rdpdbg"))
748 {
749 context->debug_channel = WTSVirtualChannelOpen(context->vcm, WTS_CURRENT_SESSION, "rdpdbg");
750
751 if (context->debug_channel != nullptr)
752 {
753 WLog_DBG(TAG, "Open channel rdpdbg.");
754
755 if (!(context->stopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr)))
756 {
757 WLog_ERR(TAG, "Failed to create stop event");
758 return FALSE;
759 }
760
761 if (!(context->debug_channel_thread = CreateThread(
762 nullptr, 0, tf_debug_channel_thread_func, (void*)context, 0, nullptr)))
763 {
764 WLog_ERR(TAG, "Failed to create debug channel thread");
765 (void)CloseHandle(context->stopEvent);
766 context->stopEvent = nullptr;
767 return FALSE;
768 }
769 }
770 }
771
772 if (WTSVirtualChannelManagerIsChannelJoined(context->vcm, RDPSND_CHANNEL_NAME))
773 {
774 if (!sf_peer_rdpsnd_init(context)) /* Audio Output */
775 return FALSE;
776 }
777
778 if (WTSVirtualChannelManagerIsChannelJoined(context->vcm, ENCOMSP_SVC_CHANNEL_NAME))
779 {
780 if (!sf_peer_encomsp_init(context)) /* Lync Multiparty */
781 return FALSE;
782 }
783
784 /* Dynamic Virtual Channels */
785 if (!sf_peer_audin_init(context)) /* Audio Input */
786 return FALSE;
787
788#if defined(CHANNEL_AINPUT_SERVER)
789 sf_peer_ainput_init(context);
790#endif
791
792 /* Return FALSE here would stop the execution of the peer main loop. */
793 return TRUE;
794}
795
796WINPR_ATTR_NODISCARD
797static BOOL tf_peer_activate(freerdp_peer* client)
798{
799 BOOL rc = TRUE;
800 WINPR_ASSERT(client);
801
802 testPeerContext* context = (testPeerContext*)client->context;
803 WINPR_ASSERT(context);
804
805 rdpSettings* settings = client->context->settings;
806 WINPR_ASSERT(settings);
807
808 struct server_info* info = client->ContextExtra;
809 WINPR_ASSERT(info);
810
811 context->activated = TRUE;
812 // PACKET_COMPR_TYPE_8K;
813 // PACKET_COMPR_TYPE_64K;
814 // PACKET_COMPR_TYPE_RDP6;
815 if (!freerdp_settings_set_uint32(settings, FreeRDP_CompressionLevel, PACKET_COMPR_TYPE_RDP8))
816 return FALSE;
817
818 if (info->test_pcap_file != nullptr)
819 {
820 if (!freerdp_settings_set_bool(settings, FreeRDP_DumpRemoteFx, TRUE))
821 return FALSE;
822
823 if (!tf_peer_dump_rfx(client))
824 return FALSE;
825 }
826 else
827 {
828 const RFX_RECT rect = {
829 .x = 0,
830 .y = 0,
831 .width = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
832 .height = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)
833 };
834 test_peer_begin_frame(client);
835 rc = test_peer_draw_background(client, &rect);
836 test_peer_end_frame(client);
837 }
838
839 return rc;
840}
841
842WINPR_ATTR_NODISCARD
843static BOOL tf_peer_synchronize_event(rdpInput* input, UINT32 flags)
844{
845 WINPR_UNUSED(input);
846 WINPR_ASSERT(input);
847 WLog_DBG(TAG, "Client sent a synchronize event (flags:0x%" PRIX32 ")", flags);
848 return TRUE;
849}
850
851WINPR_ATTR_NODISCARD
852static BOOL tf_peer_keyboard_event(rdpInput* input, UINT16 flags, UINT8 code)
853{
854 freerdp_peer* client = nullptr;
855 rdpUpdate* update = nullptr;
856 rdpContext* context = nullptr;
857 testPeerContext* tcontext = nullptr;
858 rdpSettings* settings = nullptr;
859
860 WINPR_ASSERT(input);
861
862 context = input->context;
863 WINPR_ASSERT(context);
864
865 client = context->peer;
866 WINPR_ASSERT(client);
867
868 settings = context->settings;
869 WINPR_ASSERT(settings);
870
871 update = context->update;
872 WINPR_ASSERT(update);
873
874 tcontext = (testPeerContext*)context;
875 WINPR_ASSERT(tcontext);
876
877 WLog_DBG(TAG, "Client sent a keyboard event (flags:0x%04" PRIX16 " code:0x%04" PRIX8 ")", flags,
878 code);
879
880 if (((flags & KBD_FLAGS_RELEASE) == 0) && (code == RDP_SCANCODE_KEY_G)) /* 'g' key */
881 {
882 if (freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) != 800)
883 {
884 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, 800))
885 return FALSE;
886 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, 600))
887 return FALSE;
888 }
889 else
890 {
891 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth,
892 SAMPLE_SERVER_DEFAULT_WIDTH))
893 return FALSE;
894 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight,
895 SAMPLE_SERVER_DEFAULT_HEIGHT))
896 return FALSE;
897 }
898
899 if (!rfx_context_reset(tcontext->rfx_context,
900 freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
901 freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)))
902 return FALSE;
903
904 WINPR_ASSERT(update->DesktopResize);
905 if (!update->DesktopResize(update->context))
906 return FALSE;
907 tcontext->activated = FALSE;
908 }
909 else if (((flags & KBD_FLAGS_RELEASE) == 0) && code == RDP_SCANCODE_KEY_C) /* 'c' key */
910 {
911 if (tcontext->debug_channel)
912 {
913 ULONG written = 0;
914 if (!WTSVirtualChannelWrite(tcontext->debug_channel, (PCHAR) "test2", 5, &written))
915 return FALSE;
916 }
917 }
918 else if (((flags & KBD_FLAGS_RELEASE) == 0) && code == RDP_SCANCODE_KEY_X) /* 'x' key */
919 {
920 WINPR_ASSERT(client->Close);
921 if (!client->Close(client))
922 return FALSE;
923 }
924 else if (((flags & KBD_FLAGS_RELEASE) == 0) && code == RDP_SCANCODE_KEY_R) /* 'r' key */
925 {
926 tcontext->audin_open = !tcontext->audin_open;
927 }
928#if defined(CHANNEL_AINPUT_SERVER)
929 else if (((flags & KBD_FLAGS_RELEASE) == 0) && code == RDP_SCANCODE_KEY_I) /* 'i' key */
930 {
931 tcontext->ainput_open = !tcontext->ainput_open;
932 }
933#endif
934 else if (((flags & KBD_FLAGS_RELEASE) == 0) && code == RDP_SCANCODE_KEY_S) /* 's' key */
935 {
936 }
937
938 return TRUE;
939}
940
941WINPR_ATTR_NODISCARD
942static BOOL tf_peer_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
943{
944 WINPR_UNUSED(input);
945 WINPR_ASSERT(input);
946
947 WLog_DBG(TAG,
948 "Client sent a unicode keyboard event (flags:0x%04" PRIX16 " code:0x%04" PRIX16 ")",
949 flags, code);
950 return TRUE;
951}
952
953WINPR_ATTR_NODISCARD
954static BOOL tf_peer_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
955{
956 WINPR_UNUSED(flags);
957 WINPR_ASSERT(input);
958 WINPR_ASSERT(input->context);
959
960 WLog_DBG(TAG, "Client sent a mouse event (flags:0x%04" PRIX16 " pos:%" PRIu16 ",%" PRIu16 ")",
961 flags, x, y);
962 test_peer_draw_icon(input->context->peer, x + 10, y);
963 return TRUE;
964}
965
966WINPR_ATTR_NODISCARD
967static UINT32 add(UINT32 old, UINT32 max, INT16 diff)
968{
969 INT64 val = old;
970 val += diff;
971 if (val > max)
972 val = val % max;
973 else if (val < 0)
974 val = max - val;
975 return WINPR_ASSERTING_INT_CAST(uint32_t, val);
976}
977
978WINPR_ATTR_NODISCARD
979static BOOL tf_peer_rel_mouse_event(rdpInput* input, UINT16 flags, INT16 xDelta, INT16 yDelta)
980{
981 WINPR_UNUSED(flags);
982 WINPR_ASSERT(input);
983 WINPR_ASSERT(input->context);
984
985 const UINT32 w = freerdp_settings_get_uint32(input->context->settings, FreeRDP_DesktopWidth);
986 const UINT32 h = freerdp_settings_get_uint32(input->context->settings, FreeRDP_DesktopHeight);
987
988 static UINT32 xpos = 0;
989 static UINT32 ypos = 0;
990
991 xpos = add(xpos, w, xDelta);
992 ypos = add(ypos, h, yDelta);
993
994 WLog_DBG(TAG,
995 "Client sent a relative mouse event (flags:0x%04" PRIX16 " pos:%" PRId16 ",%" PRId16
996 ")",
997 flags, xDelta, yDelta);
998 test_peer_draw_icon(input->context->peer, xpos + 10, ypos);
999 return TRUE;
1000}
1001
1002WINPR_ATTR_NODISCARD
1003static BOOL tf_peer_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
1004{
1005 WINPR_UNUSED(flags);
1006 WINPR_ASSERT(input);
1007 WINPR_ASSERT(input->context);
1008
1009 WLog_DBG(TAG,
1010 "Client sent an extended mouse event (flags:0x%04" PRIX16 " pos:%" PRIu16 ",%" PRIu16
1011 ")",
1012 flags, x, y);
1013 test_peer_draw_icon(input->context->peer, x + 10, y);
1014 return TRUE;
1015}
1016
1017WINPR_ATTR_NODISCARD
1018static BOOL tf_peer_refresh_rect(rdpContext* context, BYTE count, const RECTANGLE_16* areas)
1019{
1020 WINPR_UNUSED(context);
1021 WINPR_ASSERT(context);
1022 WINPR_ASSERT(areas || (count == 0));
1023
1024 WLog_DBG(TAG, "Client requested to refresh:");
1025
1026 for (BYTE i = 0; i < count; i++)
1027 {
1028 WLog_DBG(TAG, " (%" PRIu16 ", %" PRIu16 ") (%" PRIu16 ", %" PRIu16 ")", areas[i].left,
1029 areas[i].top, areas[i].right, areas[i].bottom);
1030 }
1031
1032 return TRUE;
1033}
1034
1035WINPR_ATTR_NODISCARD
1036static BOOL tf_peer_suppress_output(rdpContext* context, BYTE allow, const RECTANGLE_16* area)
1037{
1038 WINPR_UNUSED(context);
1039
1040 if (allow > 0)
1041 {
1042 WINPR_ASSERT(area);
1043 WLog_DBG(TAG,
1044 "Client restore output (%" PRIu16 ", %" PRIu16 ") (%" PRIu16 ", %" PRIu16 ").",
1045 area->left, area->top, area->right, area->bottom);
1046 }
1047 else
1048 {
1049 WLog_DBG(TAG, "Client minimized and suppress output.");
1050 }
1051
1052 return TRUE;
1053}
1054
1055WINPR_ATTR_NODISCARD
1056static int hook_peer_write_pdu(rdpTransport* transport, wStream* s)
1057{
1058 UINT64 ts = 0;
1059 wStream* ls = nullptr;
1060 UINT64 last_ts = 0;
1061 size_t offset = 0;
1062 UINT32 flags = 0;
1063 rdpContext* context = transport_get_context(transport);
1064
1065 WINPR_ASSERT(context);
1066 WINPR_ASSERT(s);
1067
1068 freerdp_peer* client = context->peer;
1069 WINPR_ASSERT(client);
1070
1071 testPeerContext* peerCtx = (testPeerContext*)client->context;
1072 WINPR_ASSERT(peerCtx);
1073 WINPR_ASSERT(peerCtx->io.WritePdu);
1074
1075 /* Let the client authenticate.
1076 * After that is done, we stop the normal operation and send
1077 * a previously recorded session PDU by PDU to the client.
1078 *
1079 * This is fragile and the connecting client needs to use the same
1080 * configuration as the one that recorded the session!
1081 */
1082 CONNECTION_STATE state = freerdp_get_state(context);
1083 if (state < CONNECTION_STATE_NEGO)
1084 return peerCtx->io.WritePdu(transport, s);
1085
1086 ls = Stream_New(nullptr, 4096);
1087 if (!ls)
1088 goto fail;
1089
1090 while (stream_dump_get(context, &flags, ls, &offset, &ts) > 0)
1091 {
1092 int rc = 0;
1093 /* Skip messages from client. */
1094 if (flags & STREAM_MSG_SRV_TX)
1095 {
1096 if ((last_ts > 0) && (ts > last_ts))
1097 {
1098 UINT64 diff = ts - last_ts;
1099 while (diff > 0)
1100 {
1101 UINT32 d = diff > UINT32_MAX ? UINT32_MAX : (UINT32)diff;
1102 diff -= d;
1103 Sleep(d);
1104 }
1105 }
1106 last_ts = ts;
1107 rc = peerCtx->io.WritePdu(transport, ls);
1108 if (rc < 0)
1109 goto fail;
1110 }
1111 Stream_SetPosition(ls, 0);
1112 }
1113
1114fail:
1115 Stream_Free(ls, TRUE);
1116 return -1;
1117}
1118
1119WINPR_ATTR_NODISCARD
1120static DWORD WINAPI test_peer_mainloop(LPVOID arg)
1121{
1122 BOOL rc = 0;
1123 DWORD error = CHANNEL_RC_OK;
1124 HANDLE handles[MAXIMUM_WAIT_OBJECTS] = WINPR_C_ARRAY_INIT;
1125 DWORD count = 0;
1126 DWORD status = 0;
1127 testPeerContext* context = nullptr;
1128 rdpSettings* settings = nullptr;
1129 rdpInput* input = nullptr;
1130 rdpUpdate* update = nullptr;
1131 freerdp_peer* client = (freerdp_peer*)arg;
1132
1133 WINPR_ASSERT(client);
1134
1135 struct server_info* info = client->ContextExtra;
1136 WINPR_ASSERT(info);
1137
1138 if (!test_peer_init(client))
1139 {
1140 freerdp_peer_free(client);
1141 return 0;
1142 }
1143
1144 /* Initialize the real server settings here */
1145 WINPR_ASSERT(client->context);
1146 settings = client->context->settings;
1147 WINPR_ASSERT(settings);
1148 if (info->replay_dump)
1149 {
1150 if (!freerdp_settings_set_bool(settings, FreeRDP_TransportDumpReplay, TRUE) ||
1151 !freerdp_settings_set_string(settings, FreeRDP_TransportDumpFile, info->replay_dump))
1152 goto fail;
1153 }
1154
1155 {
1156 rdpPrivateKey* key = freerdp_key_new_from_file_enc(info->key, nullptr);
1157 if (!key)
1158 goto fail;
1159 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerRsaKey, key, 1))
1160 goto fail;
1161 }
1162 {
1163 rdpCertificate* cert = freerdp_certificate_new_from_file(info->cert);
1164 if (!cert)
1165 goto fail;
1166 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerCertificate, cert, 1))
1167 goto fail;
1168 }
1169
1170 if (!freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, TRUE))
1171 goto fail;
1172 if (!freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, TRUE))
1173 goto fail;
1174 if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, FALSE))
1175 goto fail;
1176 if (!freerdp_settings_set_uint32(settings, FreeRDP_EncryptionLevel,
1177 ENCRYPTION_LEVEL_CLIENT_COMPATIBLE))
1178 goto fail;
1179 /* ENCRYPTION_LEVEL_HIGH; */
1180 /* ENCRYPTION_LEVEL_LOW; */
1181 /* ENCRYPTION_LEVEL_FIPS; */
1182 if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteFxCodec, TRUE))
1183 goto fail;
1184 if (!freerdp_settings_set_bool(settings, FreeRDP_NSCodec, TRUE) ||
1185 !freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32))
1186 goto fail;
1187
1188 if (!freerdp_settings_set_bool(settings, FreeRDP_SuppressOutput, TRUE))
1189 goto fail;
1190 if (!freerdp_settings_set_bool(settings, FreeRDP_RefreshRect, TRUE))
1191 goto fail;
1192 if (!freerdp_settings_set_bool(settings, FreeRDP_HasRelativeMouseEvent, TRUE))
1193 goto fail;
1194
1195 client->PostConnect = tf_peer_post_connect;
1196 client->Activate = tf_peer_activate;
1197
1198 WINPR_ASSERT(client->context);
1199 input = client->context->input;
1200 WINPR_ASSERT(input);
1201
1202 input->SynchronizeEvent = tf_peer_synchronize_event;
1203 input->KeyboardEvent = tf_peer_keyboard_event;
1204 input->UnicodeKeyboardEvent = tf_peer_unicode_keyboard_event;
1205 input->MouseEvent = tf_peer_mouse_event;
1206 input->RelMouseEvent = tf_peer_rel_mouse_event;
1207 input->ExtendedMouseEvent = tf_peer_extended_mouse_event;
1208
1209 update = client->context->update;
1210 WINPR_ASSERT(update);
1211
1212 update->RefreshRect = tf_peer_refresh_rect;
1213 update->SuppressOutput = tf_peer_suppress_output;
1214 if (!freerdp_settings_set_uint32(settings, FreeRDP_MultifragMaxRequestSize,
1215 0xFFFFFF /* FIXME */))
1216 goto fail;
1217
1218 WINPR_ASSERT(client->Initialize);
1219 rc = client->Initialize(client);
1220 if (!rc)
1221 goto fail;
1222
1223 context = (testPeerContext*)client->context;
1224 WINPR_ASSERT(context);
1225
1226 if (info->replay_dump)
1227 {
1228 const rdpTransportIo* cb = freerdp_get_io_callbacks(client->context);
1229 rdpTransportIo replay;
1230
1231 WINPR_ASSERT(cb);
1232 replay = *cb;
1233 context->io = *cb;
1234 replay.WritePdu = hook_peer_write_pdu;
1235 if (!freerdp_set_io_callbacks(client->context, &replay))
1236 goto fail;
1237 }
1238
1239 WLog_INFO(TAG, "We've got a client %s", client->local ? "(local)" : client->hostname);
1240
1241 while (error == CHANNEL_RC_OK)
1242 {
1243 count = 0;
1244 {
1245 WINPR_ASSERT(client->GetEventHandles);
1246 DWORD tmp = client->GetEventHandles(client, &handles[count], 32 - count);
1247
1248 if (tmp == 0)
1249 {
1250 WLog_ERR(TAG, "Failed to get FreeRDP transport event handles");
1251 break;
1252 }
1253
1254 count += tmp;
1255 }
1256
1257 HANDLE channelHandle = WTSVirtualChannelManagerGetEventHandle(context->vcm);
1258 handles[count++] = channelHandle;
1259 status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
1260
1261 if (status == WAIT_FAILED)
1262 {
1263 WLog_ERR(TAG, "WaitForMultipleObjects failed (errno: %d)", errno);
1264 break;
1265 }
1266
1267 WINPR_ASSERT(client->CheckFileDescriptor);
1268 if (client->CheckFileDescriptor(client) != TRUE)
1269 break;
1270
1271 if (WTSVirtualChannelManagerCheckFileDescriptor(context->vcm) != TRUE)
1272 break;
1273
1274 /* Handle dynamic virtual channel initializations */
1275 if (WTSVirtualChannelManagerIsChannelJoined(context->vcm, DRDYNVC_SVC_CHANNEL_NAME))
1276 {
1277 switch (WTSVirtualChannelManagerGetDrdynvcState(context->vcm))
1278 {
1279 case DRDYNVC_STATE_NONE:
1280 break;
1281
1282 case DRDYNVC_STATE_INITIALIZED:
1283 break;
1284
1285 case DRDYNVC_STATE_READY:
1286
1287 /* Here is the correct state to start dynamic virtual channels */
1288 if (sf_peer_audin_running(context) != context->audin_open)
1289 {
1290 if (!sf_peer_audin_running(context))
1291 sf_peer_audin_start(context);
1292 else
1293 sf_peer_audin_stop(context);
1294 }
1295
1296#if defined(CHANNEL_AINPUT_SERVER)
1297 if (sf_peer_ainput_running(context) != context->ainput_open)
1298 {
1299 if (!sf_peer_ainput_running(context))
1300 sf_peer_ainput_start(context);
1301 else
1302 sf_peer_ainput_stop(context);
1303 }
1304#endif
1305
1306 break;
1307
1308 case DRDYNVC_STATE_FAILED:
1309 default:
1310 break;
1311 }
1312 }
1313 }
1314
1315 WLog_INFO(TAG, "Client %s disconnected.", client->local ? "(local)" : client->hostname);
1316
1317 WINPR_ASSERT(client->Disconnect);
1318 client->Disconnect(client);
1319fail:
1320 freerdp_peer_context_free(client);
1321 freerdp_peer_free(client);
1322 return error;
1323}
1324
1325WINPR_ATTR_NODISCARD
1326static BOOL test_peer_accepted(freerdp_listener* instance, freerdp_peer* client)
1327{
1328 HANDLE hThread = nullptr;
1329
1330 WINPR_UNUSED(instance);
1331
1332 WINPR_ASSERT(instance);
1333 WINPR_ASSERT(client);
1334
1335 struct server_info* info = instance->info;
1336 client->ContextExtra = info;
1337
1338 if (!(hThread = CreateThread(nullptr, 0, test_peer_mainloop, (void*)client, 0, nullptr)))
1339 return FALSE;
1340
1341 (void)CloseHandle(hThread);
1342 return TRUE;
1343}
1344
1345static void test_server_mainloop(freerdp_listener* instance)
1346{
1347 HANDLE handles[32] = WINPR_C_ARRAY_INIT;
1348 DWORD count = 0;
1349 DWORD status = 0;
1350
1351 WINPR_ASSERT(instance);
1352 while (1)
1353 {
1354 WINPR_ASSERT(instance->GetEventHandles);
1355 count = instance->GetEventHandles(instance, handles, 32);
1356
1357 if (0 == count)
1358 {
1359 WLog_ERR(TAG, "Failed to get FreeRDP event handles");
1360 break;
1361 }
1362
1363 status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
1364
1365 if (WAIT_FAILED == status)
1366 {
1367 WLog_ERR(TAG, "select failed");
1368 break;
1369 }
1370
1371 WINPR_ASSERT(instance->CheckFileDescriptor);
1372 if (instance->CheckFileDescriptor(instance) != TRUE)
1373 {
1374 WLog_ERR(TAG, "Failed to check FreeRDP file descriptor");
1375 break;
1376 }
1377 }
1378
1379 WINPR_ASSERT(instance->Close);
1380 instance->Close(instance);
1381}
1382
1383static const struct
1384{
1385 const char spcap[7];
1386 const char sfast[7];
1387 const char sport[7];
1388 const char slocal_only[13];
1389 const char scert[7];
1390 const char skey[6];
1391} options = { { '-', '-', 'p', 'c', 'a', 'p', '=' },
1392 { '-', '-', 'f', 'a', 's', 't' },
1393 { '-', '-', 'p', 'o', 'r', 't', '=' },
1394 { '-', '-', 'l', 'o', 'c', 'a', 'l', '-', 'o', 'n', 'l', 'y' },
1395 { '-', '-', 'c', 'e', 'r', 't', '=' },
1396 { '-', '-', 'k', 'e', 'y', '=' } };
1397
1398WINPR_PRAGMA_DIAG_PUSH
1399WINPR_PRAGMA_DIAG_IGNORED_FORMAT_NONLITERAL
1400WINPR_ATTR_FORMAT_ARG(2, 0)
1401static void print_entry(FILE* fp, WINPR_FORMAT_ARG const char* fmt, const char* what, size_t size)
1402{
1403 char buffer[32] = WINPR_C_ARRAY_INIT;
1404 strncpy(buffer, what, MIN(size, sizeof(buffer) - 1));
1405 (void)fprintf(fp, fmt, buffer);
1406}
1407WINPR_PRAGMA_DIAG_POP
1408
1409WINPR_ATTR_NODISCARD
1410static int usage(const char* app, const char* invalid)
1411{
1412 FILE* fp = stdout;
1413
1414 (void)fprintf(fp, "Invalid argument '%s'\n", invalid);
1415 (void)fprintf(fp, "Usage: %s <arg>[ <arg> ...]\n", app);
1416 (void)fprintf(fp, "Arguments:\n");
1417 print_entry(fp, "\t%s<pcap file>\n", options.spcap, sizeof(options.spcap));
1418 print_entry(fp, "\t%s<cert file>\n", options.scert, sizeof(options.scert));
1419 print_entry(fp, "\t%s<key file>\n", options.skey, sizeof(options.skey));
1420 print_entry(fp, "\t%s\n", options.sfast, sizeof(options.sfast));
1421 print_entry(fp, "\t%s<port>\n", options.sport, sizeof(options.sport));
1422 print_entry(fp, "\t%s\n", options.slocal_only, sizeof(options.slocal_only));
1423 return -1;
1424}
1425
1426int main(int argc, char* argv[])
1427{
1428 int rc = -1;
1429 BOOL started = FALSE;
1430 WSADATA wsaData = WINPR_C_ARRAY_INIT;
1431 freerdp_listener* instance = nullptr;
1432 char* file = nullptr;
1433 char name[MAX_PATH] = WINPR_C_ARRAY_INIT;
1434 long port = 3389;
1435 BOOL localOnly = FALSE;
1436 struct server_info info = WINPR_C_ARRAY_INIT;
1437 const char* app = argv[0];
1438
1439 info.test_dump_rfx_realtime = TRUE;
1440
1441 errno = 0;
1442
1443 for (int i = 1; i < argc; i++)
1444 {
1445 char* arg = argv[i];
1446
1447 if (strncmp(arg, options.sfast, sizeof(options.sfast)) == 0)
1448 info.test_dump_rfx_realtime = FALSE;
1449 else if (strncmp(arg, options.sport, sizeof(options.sport)) == 0)
1450 {
1451 const char* sport = &arg[sizeof(options.sport)];
1452 port = strtol(sport, nullptr, 10);
1453
1454 if ((port < 1) || (port > UINT16_MAX) || (errno != 0))
1455 return usage(app, arg);
1456 }
1457 else if (strncmp(arg, options.slocal_only, sizeof(options.slocal_only)) == 0)
1458 localOnly = TRUE;
1459 else if (strncmp(arg, options.spcap, sizeof(options.spcap)) == 0)
1460 {
1461 info.test_pcap_file = &arg[sizeof(options.spcap)];
1462 if (!winpr_PathFileExists(info.test_pcap_file))
1463 return usage(app, arg);
1464 }
1465 else if (strncmp(arg, options.scert, sizeof(options.scert)) == 0)
1466 {
1467 info.cert = &arg[sizeof(options.scert)];
1468 if (!winpr_PathFileExists(info.cert))
1469 return usage(app, arg);
1470 }
1471 else if (strncmp(arg, options.skey, sizeof(options.skey)) == 0)
1472 {
1473 info.key = &arg[sizeof(options.skey)];
1474 if (!winpr_PathFileExists(info.key))
1475 return usage(app, arg);
1476 }
1477 else
1478 return usage(app, arg);
1479 }
1480
1481 WTSRegisterWtsApiFunctionTable(FreeRDP_InitWtsApi());
1482 winpr_InitializeSSL(WINPR_SSL_INIT_DEFAULT);
1483 instance = freerdp_listener_new();
1484
1485 if (!instance)
1486 return -1;
1487
1488 if (!info.cert)
1489 info.cert = "server.crt";
1490 if (!info.key)
1491 info.key = "server.key";
1492
1493 instance->info = (void*)&info;
1494 instance->PeerAccepted = test_peer_accepted;
1495
1496 if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
1497 goto fail;
1498
1499 /* Open the server socket and start listening. */
1500 (void)sprintf_s(name, sizeof(name), "tfreerdp-server.%ld", port);
1501 file = GetKnownSubPath(KNOWN_PATH_TEMP, name);
1502
1503 if (!file)
1504 goto fail;
1505
1506 if (localOnly)
1507 {
1508 WINPR_ASSERT(instance->OpenLocal);
1509 started = instance->OpenLocal(instance, file);
1510 }
1511 else
1512 {
1513 WINPR_ASSERT(instance->Open);
1514 started = instance->Open(instance, nullptr, (UINT16)port);
1515 }
1516
1517 if (started)
1518 {
1519 /* Entering the server main loop. In a real server the listener can be run in its own
1520 * thread. */
1521 test_server_mainloop(instance);
1522 }
1523
1524 rc = 0;
1525fail:
1526 free(file);
1527 freerdp_listener_free(instance);
1528 WSACleanup();
1529 return rc;
1530}
freerdp_settings_set_uint32
FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 val)
Sets a UINT32 settings value.
freerdp_settings_set_bool
FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL val)
Sets a BOOL settings value.
freerdp_settings_get_string
WINPR_ATTR_NODISCARD FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
freerdp_settings_set_pointer_len
FREERDP_API BOOL freerdp_settings_set_pointer_len(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id, const void *data, size_t len)
Set a pointer to value data.
Definition common/settings.c:1426
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
freerdp_settings_set_string
FREERDP_API BOOL freerdp_settings_set_string(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const char *val)
Sets a string settings value. The param is copied.
Definition settings_getters.c:3729
RECTANGLE_16
Definition types.h:109
RFX_RECT
Definition rfx.h:44
SURFACE_BITS_COMMAND
Definition include/freerdp/update.h:123
SURFACE_FRAME_MARKER
Definition include/freerdp/update.h:134