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 CAM_DEVICE_ADDED_NOTIFICATION pdu;
152 UINT error = CHANNEL_RC_OK;
153 size_t remaining_length = 0;
154 WCHAR* channel_name_start = nullptr;
155
156 WINPR_ASSERT(context);
157 WINPR_ASSERT(header);
158
159 pdu.Header = *header;
160
161 /*
162 * RequiredLength 4:
163 *
164 * Nullterminator DeviceName (2),
165 * VirtualChannelName (>= 1),
166 * Nullterminator VirtualChannelName (1)
167 */
168 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
169 return ERROR_NO_DATA;
170
171 pdu.DeviceName = Stream_Pointer(s);
172
173 remaining_length = Stream_GetRemainingLength(s);
174 channel_name_start = Stream_Pointer(s);
175
176 /* Search for null terminator of DeviceName */
177 size_t i = 0;
178 for (; i < remaining_length; i += sizeof(WCHAR), ++channel_name_start)
179 {
180 if (*channel_name_start == L'\0')
181 break;
182 }
183
184 if (*channel_name_start != L'\0')
185 {
186 WLog_ERR(TAG, "enumerator_server_recv_device_added_notification: Invalid DeviceName!");
187 return ERROR_INVALID_DATA;
188 }
189
190 pdu.VirtualChannelName = (char*)++channel_name_start;
191 ++i;
192
193 if (i >= remaining_length || *pdu.VirtualChannelName == '\0')
194 {
195 WLog_ERR(TAG,
196 "enumerator_server_recv_device_added_notification: Invalid VirtualChannelName!");
197 return ERROR_INVALID_DATA;
198 }
199
200 char* tmp = pdu.VirtualChannelName;
201 for (; i < remaining_length; ++i, ++tmp)
202 {
203 if (*tmp == '\0')
204 break;
205 }
206
207 if (*tmp != '\0')
208 {
209 WLog_ERR(TAG,
210 "enumerator_server_recv_device_added_notification: Invalid VirtualChannelName!");
211 return ERROR_INVALID_DATA;
212 }
213
214 IFCALLRET(context->DeviceAddedNotification, error, context, &pdu);
215 if (error)
216 WLog_ERR(TAG, "context->DeviceAddedNotification failed with error %" PRIu32 "", error);
217
218 return error;
219}
220
221static UINT enumerator_server_recv_device_removed_notification(CamDevEnumServerContext* context,
222 wStream* s,
223 const CAM_SHARED_MSG_HEADER* header)
224{
225 CAM_DEVICE_REMOVED_NOTIFICATION pdu;
226 UINT error = CHANNEL_RC_OK;
227 size_t remaining_length = 0;
228
229 WINPR_ASSERT(context);
230 WINPR_ASSERT(header);
231
232 pdu.Header = *header;
233
234 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
235 return ERROR_NO_DATA;
236
237 pdu.VirtualChannelName = Stream_Pointer(s);
238
239 remaining_length = Stream_GetRemainingLength(s);
240 char* tmp = pdu.VirtualChannelName + 1;
241
242 for (size_t i = 1; i < remaining_length; ++i, ++tmp)
243 {
244 if (*tmp == '\0')
245 break;
246 }
247
248 if (*tmp != '\0')
249 {
250 WLog_ERR(TAG,
251 "enumerator_server_recv_device_removed_notification: Invalid VirtualChannelName!");
252 return ERROR_INVALID_DATA;
253 }
254
255 IFCALLRET(context->DeviceRemovedNotification, error, context, &pdu);
256 if (error)
257 WLog_ERR(TAG, "context->DeviceRemovedNotification failed with error %" PRIu32 "", error);
258
259 return error;
260}
261
262static UINT enumerator_process_message(enumerator_server* enumerator)
263{
264 BOOL rc = 0;
265 UINT error = ERROR_INTERNAL_ERROR;
266 ULONG BytesReturned = 0;
267 CAM_SHARED_MSG_HEADER header = WINPR_C_ARRAY_INIT;
268 wStream* s = nullptr;
269
270 WINPR_ASSERT(enumerator);
271 WINPR_ASSERT(enumerator->enumerator_channel);
272
273 s = enumerator->buffer;
274 WINPR_ASSERT(s);
275
276 Stream_ResetPosition(s);
277 rc = WTSVirtualChannelRead(enumerator->enumerator_channel, 0, nullptr, 0, &BytesReturned);
278 if (!rc)
279 goto out;
280
281 if (BytesReturned < 1)
282 {
283 error = CHANNEL_RC_OK;
284 goto out;
285 }
286
287 if (!Stream_EnsureRemainingCapacity(s, BytesReturned))
288 {
289 WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");
290 error = CHANNEL_RC_NO_MEMORY;
291 goto out;
292 }
293
294 if (WTSVirtualChannelRead(enumerator->enumerator_channel, 0, Stream_BufferAs(s, char),
295 (ULONG)Stream_Capacity(s), &BytesReturned) == FALSE)
296 {
297 WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
298 goto out;
299 }
300
301 if (!Stream_SetLength(s, BytesReturned))
302 return ERROR_INTERNAL_ERROR;
303
304 if (!Stream_CheckAndLogRequiredLength(TAG, s, CAM_HEADER_SIZE))
305 return ERROR_NO_DATA;
306
307 Stream_Read_UINT8(s, header.Version);
308 {
309 const UINT8 id = Stream_Get_UINT8(s);
310 if (!rdpecam_valid_messageId(id))
311 return ERROR_INVALID_DATA;
312 header.MessageId = (CAM_MSG_ID)id;
313 }
314
315 switch (header.MessageId)
316 {
317 case CAM_MSG_ID_SelectVersionRequest:
318 error =
319 enumerator_server_handle_select_version_request(&enumerator->context, s, &header);
320 break;
321 case CAM_MSG_ID_DeviceAddedNotification:
322 error =
323 enumerator_server_recv_device_added_notification(&enumerator->context, s, &header);
324 break;
325 case CAM_MSG_ID_DeviceRemovedNotification:
326 error = enumerator_server_recv_device_removed_notification(&enumerator->context, s,
327 &header);
328 break;
329 default:
330 WLog_ERR(TAG, "enumerator_process_message: unknown or invalid MessageId %" PRIu8 "",
331 header.MessageId);
332 break;
333 }
334
335out:
336 if (error)
337 WLog_ERR(TAG, "Response failed with error %" PRIu32 "!", error);
338
339 return error;
340}
341
342static UINT enumerator_server_context_poll_int(CamDevEnumServerContext* context)
343{
344 enumerator_server* enumerator = (enumerator_server*)context;
345 UINT error = ERROR_INTERNAL_ERROR;
346
347 WINPR_ASSERT(enumerator);
348
349 switch (enumerator->state)
350 {
351 case ENUMERATOR_INITIAL:
352 error = enumerator_server_open_channel(enumerator);
353 if (error)
354 WLog_ERR(TAG, "enumerator_server_open_channel failed with error %" PRIu32 "!",
355 error);
356 else
357 enumerator->state = ENUMERATOR_OPENED;
358 break;
359 case ENUMERATOR_OPENED:
360 error = enumerator_process_message(enumerator);
361 break;
362 default:
363 break;
364 }
365
366 return error;
367}
368
369static HANDLE enumerator_server_get_channel_handle(enumerator_server* enumerator)
370{
371 void* buffer = nullptr;
372 DWORD BytesReturned = 0;
373 HANDLE ChannelEvent = nullptr;
374
375 WINPR_ASSERT(enumerator);
376
377 if (WTSVirtualChannelQuery(enumerator->enumerator_channel, WTSVirtualEventHandle, &buffer,
378 &BytesReturned) == TRUE)
379 {
380 if (BytesReturned == sizeof(HANDLE))
381 ChannelEvent = *(HANDLE*)buffer;
382
383 WTSFreeMemory(buffer);
384 }
385
386 return ChannelEvent;
387}
388
389static DWORD WINAPI enumerator_server_thread_func(LPVOID arg)
390{
391 DWORD nCount = 0;
392 HANDLE events[2] = WINPR_C_ARRAY_INIT;
393 enumerator_server* enumerator = (enumerator_server*)arg;
394 UINT error = CHANNEL_RC_OK;
395 DWORD status = 0;
396
397 WINPR_ASSERT(enumerator);
398
399 nCount = 0;
400 events[nCount++] = enumerator->stopEvent;
401
402 while ((error == CHANNEL_RC_OK) && (WaitForSingleObject(events[0], 0) != WAIT_OBJECT_0))
403 {
404 switch (enumerator->state)
405 {
406 case ENUMERATOR_INITIAL:
407 error = enumerator_server_context_poll_int(&enumerator->context);
408 if (error == CHANNEL_RC_OK)
409 {
410 events[1] = enumerator_server_get_channel_handle(enumerator);
411 nCount = 2;
412 }
413 break;
414 case ENUMERATOR_OPENED:
415 status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
416 switch (status)
417 {
418 case WAIT_OBJECT_0:
419 break;
420 case WAIT_OBJECT_0 + 1:
421 case WAIT_TIMEOUT:
422 error = enumerator_server_context_poll_int(&enumerator->context);
423 break;
424
425 case WAIT_FAILED:
426 default:
427 error = ERROR_INTERNAL_ERROR;
428 break;
429 }
430 break;
431 default:
432 break;
433 }
434 }
435
436 (void)WTSVirtualChannelClose(enumerator->enumerator_channel);
437 enumerator->enumerator_channel = nullptr;
438
439 if (error && enumerator->context.rdpcontext)
440 setChannelError(enumerator->context.rdpcontext, error,
441 "enumerator_server_thread_func reported an error");
442
443 ExitThread(error);
444 return error;
445}
446
447static UINT enumerator_server_open(CamDevEnumServerContext* context)
448{
449 enumerator_server* enumerator = (enumerator_server*)context;
450
451 WINPR_ASSERT(enumerator);
452
453 if (!enumerator->externalThread && (enumerator->thread == nullptr))
454 {
455 enumerator->stopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
456 if (!enumerator->stopEvent)
457 {
458 WLog_ERR(TAG, "CreateEvent failed!");
459 return ERROR_INTERNAL_ERROR;
460 }
461
462 enumerator->thread =
463 CreateThread(nullptr, 0, enumerator_server_thread_func, enumerator, 0, nullptr);
464 if (!enumerator->thread)
465 {
466 WLog_ERR(TAG, "CreateThread failed!");
467 (void)CloseHandle(enumerator->stopEvent);
468 enumerator->stopEvent = nullptr;
469 return ERROR_INTERNAL_ERROR;
470 }
471 }
472 enumerator->isOpened = TRUE;
473
474 return CHANNEL_RC_OK;
475}
476
477static UINT enumerator_server_close(CamDevEnumServerContext* context)
478{
479 UINT error = CHANNEL_RC_OK;
480 enumerator_server* enumerator = (enumerator_server*)context;
481
482 WINPR_ASSERT(enumerator);
483
484 if (!enumerator->externalThread && enumerator->thread)
485 {
486 (void)SetEvent(enumerator->stopEvent);
487
488 if (WaitForSingleObject(enumerator->thread, INFINITE) == WAIT_FAILED)
489 {
490 error = GetLastError();
491 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
492 return error;
493 }
494
495 (void)CloseHandle(enumerator->thread);
496 (void)CloseHandle(enumerator->stopEvent);
497 enumerator->thread = nullptr;
498 enumerator->stopEvent = nullptr;
499 }
500 if (enumerator->externalThread)
501 {
502 if (enumerator->state != ENUMERATOR_INITIAL)
503 {
504 (void)WTSVirtualChannelClose(enumerator->enumerator_channel);
505 enumerator->enumerator_channel = nullptr;
506 enumerator->state = ENUMERATOR_INITIAL;
507 }
508 }
509 enumerator->isOpened = FALSE;
510
511 return error;
512}
513
514static UINT enumerator_server_context_poll(CamDevEnumServerContext* context)
515{
516 enumerator_server* enumerator = (enumerator_server*)context;
517
518 WINPR_ASSERT(enumerator);
519
520 if (!enumerator->externalThread)
521 return ERROR_INTERNAL_ERROR;
522
523 return enumerator_server_context_poll_int(context);
524}
525
526static BOOL enumerator_server_context_handle(CamDevEnumServerContext* context, HANDLE* handle)
527{
528 enumerator_server* enumerator = (enumerator_server*)context;
529
530 WINPR_ASSERT(enumerator);
531 WINPR_ASSERT(handle);
532
533 if (!enumerator->externalThread)
534 return FALSE;
535 if (enumerator->state == ENUMERATOR_INITIAL)
536 return FALSE;
537
538 *handle = enumerator_server_get_channel_handle(enumerator);
539
540 return TRUE;
541}
542
543static UINT enumerator_server_packet_send(CamDevEnumServerContext* context, wStream* s)
544{
545 enumerator_server* enumerator = (enumerator_server*)context;
546 UINT error = CHANNEL_RC_OK;
547 ULONG written = 0;
548
549 const size_t len = Stream_GetPosition(s);
550 WINPR_ASSERT(len <= UINT32_MAX);
551 if (!WTSVirtualChannelWrite(enumerator->enumerator_channel, Stream_BufferAs(s, char),
552 (UINT32)len, &written))
553 {
554 WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");
555 error = ERROR_INTERNAL_ERROR;
556 goto out;
557 }
558
559 if (written < Stream_GetPosition(s))
560 {
561 WLog_WARN(TAG, "Unexpected bytes written: %" PRIu32 "/%" PRIuz "", written,
562 Stream_GetPosition(s));
563 }
564
565out:
566 Stream_Free(s, TRUE);
567 return error;
568}
569
570static UINT enumerator_send_select_version_response_pdu(
571 CamDevEnumServerContext* context, const CAM_SELECT_VERSION_RESPONSE* selectVersionResponse)
572{
573 wStream* s = nullptr;
574
575 s = Stream_New(nullptr, CAM_HEADER_SIZE);
576 if (!s)
577 {
578 WLog_ERR(TAG, "Stream_New failed!");
579 return ERROR_NOT_ENOUGH_MEMORY;
580 }
581
582 Stream_Write_UINT8(s, selectVersionResponse->Header.Version);
583 Stream_Write_UINT8(s,
584 WINPR_ASSERTING_INT_CAST(uint8_t, selectVersionResponse->Header.MessageId));
585
586 return enumerator_server_packet_send(context, s);
587}
588
589CamDevEnumServerContext* cam_dev_enum_server_context_new(HANDLE vcm)
590{
591 enumerator_server* enumerator = (enumerator_server*)calloc(1, sizeof(enumerator_server));
592
593 if (!enumerator)
594 return nullptr;
595
596 enumerator->context.vcm = vcm;
597 enumerator->context.Initialize = enumerator_server_initialize;
598 enumerator->context.Open = enumerator_server_open;
599 enumerator->context.Close = enumerator_server_close;
600 enumerator->context.Poll = enumerator_server_context_poll;
601 enumerator->context.ChannelHandle = enumerator_server_context_handle;
602
603 enumerator->context.SelectVersionResponse = enumerator_send_select_version_response_pdu;
604
605 enumerator->buffer = Stream_New(nullptr, 4096);
606 if (!enumerator->buffer)
607 goto fail;
608
609 return &enumerator->context;
610fail:
611 WINPR_PRAGMA_DIAG_PUSH
612 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
613 cam_dev_enum_server_context_free(&enumerator->context);
614 WINPR_PRAGMA_DIAG_POP
615 return nullptr;
616}
617
618void cam_dev_enum_server_context_free(CamDevEnumServerContext* context)
619{
620 enumerator_server* enumerator = (enumerator_server*)context;
621
622 if (enumerator)
623 {
624 enumerator_server_close(context);
625 Stream_Free(enumerator->buffer, TRUE);
626 }
627
628 free(enumerator);
629}
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