FreeRDP
Loading...
Searching...
No Matches
camera_device_enumerator_main.c
1
20#include <winpr/cast.h>
21
22#include <freerdp/config.h>
23
24#include <freerdp/freerdp.h>
25#include <freerdp/channels/log.h>
26#include <freerdp/server/rdpecam-enumerator.h>
27
28#include "rdpecam-utils.h"
29
30#define TAG CHANNELS_TAG("rdpecam-enumerator.server")
31
32typedef enum
33{
34 ENUMERATOR_INITIAL,
35 ENUMERATOR_OPENED,
36} eEnumeratorChannelState;
37
38typedef struct
39{
40 CamDevEnumServerContext context;
41
42 HANDLE stopEvent;
43
44 HANDLE thread;
45 void* enumerator_channel;
46
47 DWORD SessionId;
48
49 BOOL isOpened;
50 BOOL externalThread;
51
52 /* Channel state */
53 eEnumeratorChannelState state;
54
55 wStream* buffer;
56} enumerator_server;
57
58static UINT enumerator_server_initialize(CamDevEnumServerContext* context, BOOL externalThread)
59{
60 UINT error = CHANNEL_RC_OK;
61 enumerator_server* enumerator = (enumerator_server*)context;
62
63 WINPR_ASSERT(enumerator);
64
65 if (enumerator->isOpened)
66 {
67 WLog_WARN(TAG, "Application error: Camera Device Enumerator channel already initialized, "
68 "calling in this state is not possible!");
69 return ERROR_INVALID_STATE;
70 }
71
72 enumerator->externalThread = externalThread;
73
74 return error;
75}
76
77static UINT enumerator_server_open_channel(enumerator_server* enumerator)
78{
79 CamDevEnumServerContext* context = &enumerator->context;
80 DWORD Error = ERROR_SUCCESS;
81 HANDLE hEvent = nullptr;
82 DWORD BytesReturned = 0;
83 PULONG pSessionId = nullptr;
84 UINT32 channelId = 0;
85 BOOL status = TRUE;
86
87 WINPR_ASSERT(enumerator);
88
89 if (WTSQuerySessionInformationA(enumerator->context.vcm, WTS_CURRENT_SESSION, WTSSessionId,
90 (LPSTR*)&pSessionId, &BytesReturned) == FALSE)
91 {
92 WLog_ERR(TAG, "WTSQuerySessionInformationA failed!");
93 return ERROR_INTERNAL_ERROR;
94 }
95
96 enumerator->SessionId = (DWORD)*pSessionId;
97 WTSFreeMemory(pSessionId);
98 hEvent = WTSVirtualChannelManagerGetEventHandle(enumerator->context.vcm);
99
100 if (WaitForSingleObject(hEvent, 1000) == WAIT_FAILED)
101 {
102 Error = GetLastError();
103 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "!", Error);
104 return Error;
105 }
106
107 enumerator->enumerator_channel = WTSVirtualChannelOpenEx(
108 enumerator->SessionId, RDPECAM_CONTROL_DVC_CHANNEL_NAME, WTS_CHANNEL_OPTION_DYNAMIC);
109 if (!enumerator->enumerator_channel)
110 {
111 Error = GetLastError();
112 WLog_ERR(TAG, "WTSVirtualChannelOpenEx failed with error %" PRIu32 "!", Error);
113 return Error;
114 }
115
116 channelId = WTSChannelGetIdByHandle(enumerator->enumerator_channel);
117
118 IFCALLRET(context->ChannelIdAssigned, status, context, channelId);
119 if (!status)
120 {
121 WLog_ERR(TAG, "context->ChannelIdAssigned failed!");
122 return ERROR_INTERNAL_ERROR;
123 }
124
125 return Error;
126}
127
128static UINT enumerator_server_handle_select_version_request(CamDevEnumServerContext* context,
129 WINPR_ATTR_UNUSED wStream* s,
130 const CAM_SHARED_MSG_HEADER* header)
131{
132 CAM_SELECT_VERSION_REQUEST pdu = WINPR_C_ARRAY_INIT;
133 UINT error = CHANNEL_RC_OK;
134
135 WINPR_ASSERT(context);
136 WINPR_ASSERT(header);
137
138 pdu.Header = *header;
139
140 IFCALLRET(context->SelectVersionRequest, error, context, &pdu);
141 if (error)
142 WLog_ERR(TAG, "context->SelectVersionRequest failed with error %" PRIu32 "", error);
143
144 return error;
145}
146
147static UINT enumerator_server_recv_device_added_notification(CamDevEnumServerContext* context,
148 wStream* s,
149 const CAM_SHARED_MSG_HEADER* header)
150{
151 UINT error = CHANNEL_RC_OK;
152
153 WINPR_ASSERT(context);
154 WINPR_ASSERT(header);
155
156 /*
157 * RequiredLength 4:
158 *
159 * Nullterminator DeviceName (2),
160 * VirtualChannelName (>= 1),
161 * Nullterminator VirtualChannelName (1)
162 */
163 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
164 return ERROR_NO_DATA;
165
166 CAM_DEVICE_ADDED_NOTIFICATION pdu = { .Header = *header,
167 .DeviceName = Stream_Pointer(s),
168 .VirtualChannelName = nullptr };
169
170 /* DeviceName: Read until either no bytes left or a unicode '\0' was found */
171 bool unicodeNull = false;
172 while (Stream_GetRemainingLength(s) >= sizeof(WCHAR))
173 {
174 const WCHAR wc = Stream_Get_UINT16(s);
175 if (wc == '\0')
176 {
177 unicodeNull = true;
178 break;
179 }
180 }
181 if (!unicodeNull)
182 {
183 WLog_ERR(TAG, "enumerator_server_recv_device_added_notification: Invalid DeviceName!");
184 return ERROR_INVALID_DATA;
185 }
186
187 /* VirtualChannelName: Read until either no bytes left or a ANSI '\0' was found */
188 pdu.VirtualChannelName = Stream_PointerAs(s, char);
189 bool ansiNull = false;
190 while (Stream_GetRemainingLength(s) >= sizeof(CHAR))
191 {
192 const CHAR wc = Stream_Get_INT8(s);
193 if (wc == '\0')
194 {
195 ansiNull = true;
196 break;
197 }
198 }
199 if (!ansiNull)
200 {
201 WLog_ERR(TAG,
202 "enumerator_server_recv_device_added_notification: Invalid VirtualChannelName!");
203 return ERROR_INVALID_DATA;
204 }
205
206 const size_t rem = Stream_GetRemainingLength(s);
207 if (rem > 0)
208 WLog_WARN(TAG, "Unparsed data: %" PRIuz " bytes remain", rem);
209
210 IFCALLRET(context->DeviceAddedNotification, error, context, &pdu);
211 if (error)
212 WLog_ERR(TAG, "context->DeviceAddedNotification failed with error %" PRIu32 "", error);
213
214 return error;
215}
216
217static UINT enumerator_server_recv_device_removed_notification(CamDevEnumServerContext* context,
218 wStream* s,
219 const CAM_SHARED_MSG_HEADER* header)
220{
221 CAM_DEVICE_REMOVED_NOTIFICATION pdu;
222 UINT error = CHANNEL_RC_OK;
223 size_t remaining_length = 0;
224
225 WINPR_ASSERT(context);
226 WINPR_ASSERT(header);
227
228 pdu.Header = *header;
229
230 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
231 return ERROR_NO_DATA;
232
233 pdu.VirtualChannelName = Stream_Pointer(s);
234
235 remaining_length = Stream_GetRemainingLength(s);
236 char* tmp = pdu.VirtualChannelName + 1;
237
238 for (size_t i = 1; i < remaining_length; ++i, ++tmp)
239 {
240 if (*tmp == '\0')
241 break;
242 }
243
244 if (*tmp != '\0')
245 {
246 WLog_ERR(TAG,
247 "enumerator_server_recv_device_removed_notification: Invalid VirtualChannelName!");
248 return ERROR_INVALID_DATA;
249 }
250
251 IFCALLRET(context->DeviceRemovedNotification, error, context, &pdu);
252 if (error)
253 WLog_ERR(TAG, "context->DeviceRemovedNotification failed with error %" PRIu32 "", error);
254
255 return error;
256}
257
258static UINT enumerator_process_message(enumerator_server* enumerator)
259{
260 BOOL rc = 0;
261 UINT error = ERROR_INTERNAL_ERROR;
262 ULONG BytesReturned = 0;
263 CAM_SHARED_MSG_HEADER header = WINPR_C_ARRAY_INIT;
264 wStream* s = nullptr;
265
266 WINPR_ASSERT(enumerator);
267 WINPR_ASSERT(enumerator->enumerator_channel);
268
269 s = enumerator->buffer;
270 WINPR_ASSERT(s);
271
272 Stream_ResetPosition(s);
273 rc = WTSVirtualChannelRead(enumerator->enumerator_channel, 0, nullptr, 0, &BytesReturned);
274 if (!rc)
275 goto out;
276
277 if (BytesReturned < 1)
278 {
279 error = CHANNEL_RC_OK;
280 goto out;
281 }
282
283 if (!Stream_EnsureRemainingCapacity(s, BytesReturned))
284 {
285 WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");
286 error = CHANNEL_RC_NO_MEMORY;
287 goto out;
288 }
289
290 if (WTSVirtualChannelRead(enumerator->enumerator_channel, 0, Stream_BufferAs(s, char),
291 (ULONG)Stream_Capacity(s), &BytesReturned) == FALSE)
292 {
293 WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
294 goto out;
295 }
296
297 if (!Stream_SetLength(s, BytesReturned))
298 return ERROR_INTERNAL_ERROR;
299
300 if (!Stream_CheckAndLogRequiredLength(TAG, s, CAM_HEADER_SIZE))
301 return ERROR_NO_DATA;
302
303 Stream_Read_UINT8(s, header.Version);
304 {
305 const UINT8 id = Stream_Get_UINT8(s);
306 if (!rdpecam_valid_messageId(id))
307 return ERROR_INVALID_DATA;
308 header.MessageId = (CAM_MSG_ID)id;
309 }
310
311 switch (header.MessageId)
312 {
313 case CAM_MSG_ID_SelectVersionRequest:
314 error =
315 enumerator_server_handle_select_version_request(&enumerator->context, s, &header);
316 break;
317 case CAM_MSG_ID_DeviceAddedNotification:
318 error =
319 enumerator_server_recv_device_added_notification(&enumerator->context, s, &header);
320 break;
321 case CAM_MSG_ID_DeviceRemovedNotification:
322 error = enumerator_server_recv_device_removed_notification(&enumerator->context, s,
323 &header);
324 break;
325 default:
326 WLog_ERR(TAG, "enumerator_process_message: unknown or invalid MessageId %" PRIu8 "",
327 header.MessageId);
328 break;
329 }
330
331out:
332 if (error)
333 WLog_ERR(TAG, "Response failed with error %" PRIu32 "!", error);
334
335 return error;
336}
337
338static UINT enumerator_server_context_poll_int(CamDevEnumServerContext* context)
339{
340 enumerator_server* enumerator = (enumerator_server*)context;
341 UINT error = ERROR_INTERNAL_ERROR;
342
343 WINPR_ASSERT(enumerator);
344
345 switch (enumerator->state)
346 {
347 case ENUMERATOR_INITIAL:
348 error = enumerator_server_open_channel(enumerator);
349 if (error)
350 WLog_ERR(TAG, "enumerator_server_open_channel failed with error %" PRIu32 "!",
351 error);
352 else
353 enumerator->state = ENUMERATOR_OPENED;
354 break;
355 case ENUMERATOR_OPENED:
356 error = enumerator_process_message(enumerator);
357 break;
358 default:
359 break;
360 }
361
362 return error;
363}
364
365static HANDLE enumerator_server_get_channel_handle(enumerator_server* enumerator)
366{
367 void* buffer = nullptr;
368 DWORD BytesReturned = 0;
369 HANDLE ChannelEvent = nullptr;
370
371 WINPR_ASSERT(enumerator);
372
373 if (WTSVirtualChannelQuery(enumerator->enumerator_channel, WTSVirtualEventHandle, &buffer,
374 &BytesReturned) == TRUE)
375 {
376 if (BytesReturned == sizeof(HANDLE))
377 ChannelEvent = *(HANDLE*)buffer;
378
379 WTSFreeMemory(buffer);
380 }
381
382 return ChannelEvent;
383}
384
385static DWORD WINAPI enumerator_server_thread_func(LPVOID arg)
386{
387 DWORD nCount = 0;
388 HANDLE events[2] = WINPR_C_ARRAY_INIT;
389 enumerator_server* enumerator = (enumerator_server*)arg;
390 UINT error = CHANNEL_RC_OK;
391 DWORD status = 0;
392
393 WINPR_ASSERT(enumerator);
394
395 nCount = 0;
396 events[nCount++] = enumerator->stopEvent;
397
398 while ((error == CHANNEL_RC_OK) && (WaitForSingleObject(events[0], 0) != WAIT_OBJECT_0))
399 {
400 switch (enumerator->state)
401 {
402 case ENUMERATOR_INITIAL:
403 error = enumerator_server_context_poll_int(&enumerator->context);
404 if (error == CHANNEL_RC_OK)
405 {
406 events[1] = enumerator_server_get_channel_handle(enumerator);
407 nCount = 2;
408 }
409 break;
410 case ENUMERATOR_OPENED:
411 status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
412 switch (status)
413 {
414 case WAIT_OBJECT_0:
415 break;
416 case WAIT_OBJECT_0 + 1:
417 case WAIT_TIMEOUT:
418 error = enumerator_server_context_poll_int(&enumerator->context);
419 break;
420
421 case WAIT_FAILED:
422 default:
423 error = ERROR_INTERNAL_ERROR;
424 break;
425 }
426 break;
427 default:
428 break;
429 }
430 }
431
432 (void)WTSVirtualChannelClose(enumerator->enumerator_channel);
433 enumerator->enumerator_channel = nullptr;
434
435 if (error && enumerator->context.rdpcontext)
436 setChannelError(enumerator->context.rdpcontext, error,
437 "enumerator_server_thread_func reported an error");
438
439 ExitThread(error);
440 return error;
441}
442
443static UINT enumerator_server_open(CamDevEnumServerContext* context)
444{
445 enumerator_server* enumerator = (enumerator_server*)context;
446
447 WINPR_ASSERT(enumerator);
448
449 if (!enumerator->externalThread && (enumerator->thread == nullptr))
450 {
451 enumerator->stopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
452 if (!enumerator->stopEvent)
453 {
454 WLog_ERR(TAG, "CreateEvent failed!");
455 return ERROR_INTERNAL_ERROR;
456 }
457
458 enumerator->thread =
459 CreateThread(nullptr, 0, enumerator_server_thread_func, enumerator, 0, nullptr);
460 if (!enumerator->thread)
461 {
462 WLog_ERR(TAG, "CreateThread failed!");
463 (void)CloseHandle(enumerator->stopEvent);
464 enumerator->stopEvent = nullptr;
465 return ERROR_INTERNAL_ERROR;
466 }
467 }
468 enumerator->isOpened = TRUE;
469
470 return CHANNEL_RC_OK;
471}
472
473static UINT enumerator_server_close(CamDevEnumServerContext* context)
474{
475 UINT error = CHANNEL_RC_OK;
476 enumerator_server* enumerator = (enumerator_server*)context;
477
478 WINPR_ASSERT(enumerator);
479
480 if (!enumerator->externalThread && enumerator->thread)
481 {
482 (void)SetEvent(enumerator->stopEvent);
483
484 if (WaitForSingleObject(enumerator->thread, INFINITE) == WAIT_FAILED)
485 {
486 error = GetLastError();
487 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
488 return error;
489 }
490
491 (void)CloseHandle(enumerator->thread);
492 (void)CloseHandle(enumerator->stopEvent);
493 enumerator->thread = nullptr;
494 enumerator->stopEvent = nullptr;
495 }
496 if (enumerator->externalThread)
497 {
498 if (enumerator->state != ENUMERATOR_INITIAL)
499 {
500 (void)WTSVirtualChannelClose(enumerator->enumerator_channel);
501 enumerator->enumerator_channel = nullptr;
502 enumerator->state = ENUMERATOR_INITIAL;
503 }
504 }
505 enumerator->isOpened = FALSE;
506
507 return error;
508}
509
510static UINT enumerator_server_context_poll(CamDevEnumServerContext* context)
511{
512 enumerator_server* enumerator = (enumerator_server*)context;
513
514 WINPR_ASSERT(enumerator);
515
516 if (!enumerator->externalThread)
517 return ERROR_INTERNAL_ERROR;
518
519 return enumerator_server_context_poll_int(context);
520}
521
522static BOOL enumerator_server_context_handle(CamDevEnumServerContext* context, HANDLE* handle)
523{
524 enumerator_server* enumerator = (enumerator_server*)context;
525
526 WINPR_ASSERT(enumerator);
527 WINPR_ASSERT(handle);
528
529 if (!enumerator->externalThread)
530 return FALSE;
531 if (enumerator->state == ENUMERATOR_INITIAL)
532 return FALSE;
533
534 *handle = enumerator_server_get_channel_handle(enumerator);
535
536 return TRUE;
537}
538
539static UINT enumerator_server_packet_send(CamDevEnumServerContext* context, wStream* s)
540{
541 enumerator_server* enumerator = (enumerator_server*)context;
542 UINT error = CHANNEL_RC_OK;
543 ULONG written = 0;
544
545 const size_t len = Stream_GetPosition(s);
546 WINPR_ASSERT(len <= UINT32_MAX);
547 if (!WTSVirtualChannelWrite(enumerator->enumerator_channel, Stream_BufferAs(s, char),
548 (UINT32)len, &written))
549 {
550 WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");
551 error = ERROR_INTERNAL_ERROR;
552 goto out;
553 }
554
555 if (written < Stream_GetPosition(s))
556 {
557 WLog_WARN(TAG, "Unexpected bytes written: %" PRIu32 "/%" PRIuz "", written,
558 Stream_GetPosition(s));
559 }
560
561out:
562 Stream_Free(s, TRUE);
563 return error;
564}
565
566static UINT enumerator_send_select_version_response_pdu(
567 CamDevEnumServerContext* context, const CAM_SELECT_VERSION_RESPONSE* selectVersionResponse)
568{
569 wStream* s = nullptr;
570
571 s = Stream_New(nullptr, CAM_HEADER_SIZE);
572 if (!s)
573 {
574 WLog_ERR(TAG, "Stream_New failed!");
575 return ERROR_NOT_ENOUGH_MEMORY;
576 }
577
578 Stream_Write_UINT8(s, selectVersionResponse->Header.Version);
579 Stream_Write_UINT8(s,
580 WINPR_ASSERTING_INT_CAST(uint8_t, selectVersionResponse->Header.MessageId));
581
582 return enumerator_server_packet_send(context, s);
583}
584
585CamDevEnumServerContext* cam_dev_enum_server_context_new(HANDLE vcm)
586{
587 enumerator_server* enumerator = (enumerator_server*)calloc(1, sizeof(enumerator_server));
588
589 if (!enumerator)
590 return nullptr;
591
592 enumerator->context.vcm = vcm;
593 enumerator->context.Initialize = enumerator_server_initialize;
594 enumerator->context.Open = enumerator_server_open;
595 enumerator->context.Close = enumerator_server_close;
596 enumerator->context.Poll = enumerator_server_context_poll;
597 enumerator->context.ChannelHandle = enumerator_server_context_handle;
598
599 enumerator->context.SelectVersionResponse = enumerator_send_select_version_response_pdu;
600
601 enumerator->buffer = Stream_New(nullptr, 4096);
602 if (!enumerator->buffer)
603 goto fail;
604
605 return &enumerator->context;
606fail:
607 WINPR_PRAGMA_DIAG_PUSH
608 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
609 cam_dev_enum_server_context_free(&enumerator->context);
610 WINPR_PRAGMA_DIAG_POP
611 return nullptr;
612}
613
614void cam_dev_enum_server_context_free(CamDevEnumServerContext* context)
615{
616 enumerator_server* enumerator = (enumerator_server*)context;
617
618 if (enumerator)
619 {
620 enumerator_server_close(context);
621 Stream_Free(enumerator->buffer, TRUE);
622 }
623
624 free(enumerator);
625}
CAM_DEVICE_ADDED_NOTIFICATION
Definition channels/rdpecam.h:90
CAM_DEVICE_REMOVED_NOTIFICATION
Definition channels/rdpecam.h:97
CAM_SELECT_VERSION_REQUEST
Definition channels/rdpecam.h:80
CAM_SELECT_VERSION_RESPONSE
Definition channels/rdpecam.h:85
CAM_SHARED_MSG_HEADER
Definition channels/rdpecam.h:72