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