FreeRDP
Loading...
Searching...
No Matches
client/rdpei_main.c
1
22#include <freerdp/config.h>
23
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <stdint.h>
28
29#include <winpr/crt.h>
30#include <winpr/cast.h>
31#include <winpr/synch.h>
32#include <winpr/thread.h>
33#include <winpr/stream.h>
34#include <winpr/sysinfo.h>
35#include <winpr/cmdline.h>
36#include <winpr/collections.h>
37
38#include <freerdp/addin.h>
39#include <freerdp/freerdp.h>
40#include <freerdp/client/channels.h>
41
42#include "rdpei_common.h"
43
44#include "rdpei_main.h"
45
46#define RDPEI_TAG CHANNELS_TAG("rdpei.client")
47
68#define MAX_CONTACTS 64
69#define MAX_PEN_CONTACTS 4
70
71typedef struct
72{
73 GENERIC_DYNVC_PLUGIN base;
74
75 RdpeiClientContext* context;
76
77 UINT32 version;
78 UINT32 features; /* SC_READY_MULTIPEN_INJECTION_SUPPORTED */
79 UINT16 maxTouchContacts;
80 UINT64 currentFrameTime;
81 UINT64 previousFrameTime;
82 RDPINPUT_CONTACT_POINT contactPoints[MAX_CONTACTS];
83
84 UINT64 currentPenFrameTime;
85 UINT64 previousPenFrameTime;
86 UINT16 maxPenContacts;
87 RDPINPUT_PEN_CONTACT_POINT penContactPoints[MAX_PEN_CONTACTS];
88
89 CRITICAL_SECTION lock;
90 rdpContext* rdpcontext;
91
92 HANDLE thread;
93
94 HANDLE event;
95 UINT64 lastPollEventTime;
96 BOOL running;
97 BOOL async;
98} RDPEI_PLUGIN;
99
105static UINT rdpei_send_frame(RdpeiClientContext* context, RDPINPUT_TOUCH_FRAME* frame);
106
107#ifdef WITH_DEBUG_RDPEI
108static const char* rdpei_eventid_string(UINT16 event)
109{
110 switch (event)
111 {
112 case EVENTID_SC_READY:
113 return "EVENTID_SC_READY";
114 case EVENTID_CS_READY:
115 return "EVENTID_CS_READY";
116 case EVENTID_TOUCH:
117 return "EVENTID_TOUCH";
118 case EVENTID_SUSPEND_TOUCH:
119 return "EVENTID_SUSPEND_TOUCH";
120 case EVENTID_RESUME_TOUCH:
121 return "EVENTID_RESUME_TOUCH";
122 case EVENTID_DISMISS_HOVERING_CONTACT:
123 return "EVENTID_DISMISS_HOVERING_CONTACT";
124 case EVENTID_PEN:
125 return "EVENTID_PEN";
126 default:
127 return "EVENTID_UNKNOWN";
128 }
129}
130#endif
131
132static RDPINPUT_CONTACT_POINT* rdpei_contact(RDPEI_PLUGIN* rdpei, INT32 externalId, BOOL active)
133{
134 for (UINT16 i = 0; i < rdpei->maxTouchContacts; i++)
135 {
136 RDPINPUT_CONTACT_POINT* contactPoint = &rdpei->contactPoints[i];
137
138 if (!contactPoint->active && active)
139 continue;
140 else if (!contactPoint->active && !active)
141 {
142 contactPoint->contactId = i;
143 contactPoint->externalId = externalId;
144 contactPoint->active = TRUE;
145 return contactPoint;
146 }
147 else if (contactPoint->externalId == externalId)
148 {
149 return contactPoint;
150 }
151 }
152 return NULL;
153}
154
160static UINT rdpei_add_frame(RdpeiClientContext* context)
161{
162 RDPEI_PLUGIN* rdpei = NULL;
163 RDPINPUT_TOUCH_FRAME frame = { 0 };
164 RDPINPUT_CONTACT_DATA contacts[MAX_CONTACTS] = { 0 };
165
166 if (!context || !context->handle)
167 return ERROR_INTERNAL_ERROR;
168
169 rdpei = (RDPEI_PLUGIN*)context->handle;
170 frame.contacts = contacts;
171
172 for (UINT16 i = 0; i < rdpei->maxTouchContacts; i++)
173 {
174 RDPINPUT_CONTACT_POINT* contactPoint = &rdpei->contactPoints[i];
175 RDPINPUT_CONTACT_DATA* contact = &contactPoint->data;
176
177 if (contactPoint->dirty)
178 {
179 contacts[frame.contactCount] = *contact;
180 rdpei->contactPoints[i].dirty = FALSE;
181 frame.contactCount++;
182 }
183 else if (contactPoint->active)
184 {
185 if (contact->contactFlags & RDPINPUT_CONTACT_FLAG_DOWN)
186 {
187 contact->contactFlags = RDPINPUT_CONTACT_FLAG_UPDATE;
188 contact->contactFlags |= RDPINPUT_CONTACT_FLAG_INRANGE;
189 contact->contactFlags |= RDPINPUT_CONTACT_FLAG_INCONTACT;
190 }
191
192 contacts[frame.contactCount] = *contact;
193 frame.contactCount++;
194 }
195 if (contact->contactFlags & RDPINPUT_CONTACT_FLAG_UP)
196 {
197 contactPoint->active = FALSE;
198 contactPoint->externalId = 0;
199 contactPoint->contactId = 0;
200 }
201 }
202
203 if (frame.contactCount > 0)
204 {
205 UINT error = rdpei_send_frame(context, &frame);
206 if (error != CHANNEL_RC_OK)
207 {
208 WLog_Print(rdpei->base.log, WLOG_ERROR,
209 "rdpei_send_frame failed with error %" PRIu32 "!", error);
210 return error;
211 }
212 }
213 return CHANNEL_RC_OK;
214}
215
221static UINT rdpei_send_pdu(GENERIC_CHANNEL_CALLBACK* callback, wStream* s, UINT16 eventId,
222 size_t pduLength)
223{
224 UINT status = 0;
225
226 if (!callback || !s || !callback->channel || !callback->channel->Write)
227 return ERROR_INTERNAL_ERROR;
228
229 if (pduLength > UINT32_MAX)
230 return ERROR_INVALID_PARAMETER;
231
232 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)callback->plugin;
233 if (!rdpei)
234 return ERROR_INTERNAL_ERROR;
235
236 Stream_SetPosition(s, 0);
237 Stream_Write_UINT16(s, eventId); /* eventId (2 bytes) */
238 Stream_Write_UINT32(s, (UINT32)pduLength); /* pduLength (4 bytes) */
239 Stream_SetPosition(s, Stream_Length(s));
240 status = callback->channel->Write(callback->channel, (UINT32)Stream_Length(s), Stream_Buffer(s),
241 NULL);
242#ifdef WITH_DEBUG_RDPEI
243 WLog_Print(rdpei->base.log, WLOG_DEBUG,
244 "rdpei_send_pdu: eventId: %" PRIu16 " (%s) length: %" PRIu32 " status: %" PRIu32 "",
245 eventId, rdpei_eventid_string(eventId), pduLength, status);
246#endif
247 return status;
248}
249
250static UINT rdpei_write_pen_frame(wStream* s, const RDPINPUT_PEN_FRAME* frame)
251{
252 if (!s || !frame)
253 return ERROR_INTERNAL_ERROR;
254
255 if (!rdpei_write_2byte_unsigned(s, frame->contactCount))
256 return ERROR_OUTOFMEMORY;
257 if (!rdpei_write_8byte_unsigned(s, frame->frameOffset))
258 return ERROR_OUTOFMEMORY;
259 for (UINT16 x = 0; x < frame->contactCount; x++)
260 {
261 const RDPINPUT_PEN_CONTACT* contact = &frame->contacts[x];
262
263 if (!Stream_EnsureRemainingCapacity(s, 1))
264 return ERROR_OUTOFMEMORY;
265 Stream_Write_UINT8(s, contact->deviceId);
266 if (!rdpei_write_2byte_unsigned(s, contact->fieldsPresent))
267 return ERROR_OUTOFMEMORY;
268 if (!rdpei_write_4byte_signed(s, contact->x))
269 return ERROR_OUTOFMEMORY;
270 if (!rdpei_write_4byte_signed(s, contact->y))
271 return ERROR_OUTOFMEMORY;
272 if (!rdpei_write_4byte_unsigned(s, contact->contactFlags))
273 return ERROR_OUTOFMEMORY;
274 if (contact->fieldsPresent & RDPINPUT_PEN_CONTACT_PENFLAGS_PRESENT)
275 {
276 if (!rdpei_write_4byte_unsigned(s, contact->penFlags))
277 return ERROR_OUTOFMEMORY;
278 }
279 if (contact->fieldsPresent & RDPINPUT_PEN_CONTACT_PRESSURE_PRESENT)
280 {
281 if (!rdpei_write_4byte_unsigned(s, contact->pressure))
282 return ERROR_OUTOFMEMORY;
283 }
284 if (contact->fieldsPresent & RDPINPUT_PEN_CONTACT_ROTATION_PRESENT)
285 {
286 if (!rdpei_write_2byte_unsigned(s, contact->rotation))
287 return ERROR_OUTOFMEMORY;
288 }
289 if (contact->fieldsPresent & RDPINPUT_PEN_CONTACT_TILTX_PRESENT)
290 {
291 if (!rdpei_write_2byte_signed(s, contact->tiltX))
292 return ERROR_OUTOFMEMORY;
293 }
294 if (contact->fieldsPresent & RDPINPUT_PEN_CONTACT_TILTY_PRESENT)
295 {
296 if (!rdpei_write_2byte_signed(s, contact->tiltY))
297 return ERROR_OUTOFMEMORY;
298 }
299 }
300 return CHANNEL_RC_OK;
301}
302
303static UINT rdpei_send_pen_event_pdu(GENERIC_CHANNEL_CALLBACK* callback, size_t frameOffset,
304 const RDPINPUT_PEN_FRAME* frames, size_t count)
305{
306 UINT status = 0;
307 wStream* s = NULL;
308
309 WINPR_ASSERT(callback);
310
311 if (frameOffset > UINT32_MAX)
312 return ERROR_INVALID_PARAMETER;
313 if (count > UINT16_MAX)
314 return ERROR_INVALID_PARAMETER;
315
316 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)callback->plugin;
317 if (!rdpei)
318 return ERROR_INTERNAL_ERROR;
319
320 if (!frames || (count == 0))
321 return ERROR_INTERNAL_ERROR;
322
323 s = Stream_New(NULL, 64);
324
325 if (!s)
326 {
327 WLog_Print(rdpei->base.log, WLOG_ERROR, "Stream_New failed!");
328 return CHANNEL_RC_NO_MEMORY;
329 }
330
331 Stream_Seek(s, RDPINPUT_HEADER_LENGTH);
336 rdpei_write_4byte_unsigned(s,
337 (UINT32)frameOffset); /* encodeTime (FOUR_BYTE_UNSIGNED_INTEGER) */
338 rdpei_write_2byte_unsigned(s, (UINT16)count); /* (frameCount) TWO_BYTE_UNSIGNED_INTEGER */
339
340 for (size_t x = 0; x < count; x++)
341 {
342 if ((status = rdpei_write_pen_frame(s, &frames[x])))
343 {
344 WLog_Print(rdpei->base.log, WLOG_ERROR,
345 "rdpei_write_pen_frame failed with error %" PRIu32 "!", status);
346 Stream_Free(s, TRUE);
347 return status;
348 }
349 }
350 Stream_SealLength(s);
351
352 status = rdpei_send_pdu(callback, s, EVENTID_PEN, Stream_Length(s));
353 Stream_Free(s, TRUE);
354 return status;
355}
356
357static UINT rdpei_send_pen_frame(RdpeiClientContext* context, RDPINPUT_PEN_FRAME* frame)
358{
359 const UINT64 currentTime = GetTickCount64();
360 RDPEI_PLUGIN* rdpei = NULL;
361 GENERIC_CHANNEL_CALLBACK* callback = NULL;
362 UINT error = 0;
363
364 if (!context)
365 return ERROR_INTERNAL_ERROR;
366 rdpei = (RDPEI_PLUGIN*)context->handle;
367 if (!rdpei || !rdpei->base.listener_callback)
368 return ERROR_INTERNAL_ERROR;
369 if (!rdpei || !rdpei->rdpcontext)
370 return ERROR_INTERNAL_ERROR;
371 if (freerdp_settings_get_bool(rdpei->rdpcontext->settings, FreeRDP_SuspendInput))
372 return CHANNEL_RC_OK;
373
374 callback = rdpei->base.listener_callback->channel_callback;
375 /* Just ignore the event if the channel is not connected */
376 if (!callback)
377 return CHANNEL_RC_OK;
378
379 if (!rdpei->previousPenFrameTime && !rdpei->currentPenFrameTime)
380 {
381 rdpei->currentPenFrameTime = currentTime;
382 frame->frameOffset = 0;
383 }
384 else
385 {
386 rdpei->currentPenFrameTime = currentTime;
387 frame->frameOffset = rdpei->currentPenFrameTime - rdpei->previousPenFrameTime;
388 }
389
390 const size_t off = WINPR_ASSERTING_INT_CAST(size_t, frame->frameOffset);
391 error = rdpei_send_pen_event_pdu(callback, off, frame, 1);
392 if (error)
393 return error;
394
395 rdpei->previousPenFrameTime = rdpei->currentPenFrameTime;
396 return error;
397}
398
399static UINT rdpei_add_pen_frame(RdpeiClientContext* context)
400{
401 RDPEI_PLUGIN* rdpei = NULL;
402 RDPINPUT_PEN_FRAME penFrame = { 0 };
403 RDPINPUT_PEN_CONTACT penContacts[MAX_PEN_CONTACTS] = { 0 };
404
405 if (!context || !context->handle)
406 return ERROR_INTERNAL_ERROR;
407
408 rdpei = (RDPEI_PLUGIN*)context->handle;
409
410 penFrame.contacts = penContacts;
411
412 for (UINT16 i = 0; i < rdpei->maxPenContacts; i++)
413 {
414 RDPINPUT_PEN_CONTACT_POINT* contact = &(rdpei->penContactPoints[i]);
415
416 if (contact->dirty)
417 {
418 penContacts[penFrame.contactCount++] = contact->data;
419 contact->dirty = FALSE;
420 }
421 else if (contact->active)
422 {
423 if (contact->data.contactFlags & RDPINPUT_CONTACT_FLAG_DOWN)
424 {
425 contact->data.contactFlags = RDPINPUT_CONTACT_FLAG_UPDATE;
426 contact->data.contactFlags |= RDPINPUT_CONTACT_FLAG_INRANGE;
427 contact->data.contactFlags |= RDPINPUT_CONTACT_FLAG_INCONTACT;
428 }
429
430 penContacts[penFrame.contactCount++] = contact->data;
431 }
432 if (contact->data.contactFlags & RDPINPUT_CONTACT_FLAG_CANCELED)
433 {
434 contact->externalId = 0;
435 contact->active = FALSE;
436 }
437 }
438
439 if (penFrame.contactCount > 0)
440 return rdpei_send_pen_frame(context, &penFrame);
441 return CHANNEL_RC_OK;
442}
443
444static UINT rdpei_update(wLog* log, RdpeiClientContext* context)
445{
446 UINT error = rdpei_add_frame(context);
447 if (error != CHANNEL_RC_OK)
448 {
449 WLog_Print(log, WLOG_ERROR, "rdpei_add_frame failed with error %" PRIu32 "!", error);
450 return error;
451 }
452
453 return rdpei_add_pen_frame(context);
454}
455
456static BOOL rdpei_poll_run_unlocked(rdpContext* context, void* userdata)
457{
458 RDPEI_PLUGIN* rdpei = userdata;
459 WINPR_ASSERT(rdpei);
460 WINPR_ASSERT(context);
461
462 const UINT64 now = GetTickCount64();
463
464 /* Send an event every ~20ms */
465 if ((now < rdpei->lastPollEventTime) || (now - rdpei->lastPollEventTime < 20ULL))
466 return TRUE;
467
468 rdpei->lastPollEventTime = now;
469
470 const UINT error = rdpei_update(rdpei->base.log, rdpei->context);
471
472 (void)ResetEvent(rdpei->event);
473
474 if (error != CHANNEL_RC_OK)
475 {
476 WLog_Print(rdpei->base.log, WLOG_ERROR, "rdpei_add_frame failed with error %" PRIu32 "!",
477 error);
478 setChannelError(context, error, "rdpei_add_frame reported an error");
479 return FALSE;
480 }
481
482 return TRUE;
483}
484
485static BOOL rdpei_poll_run(rdpContext* context, void* userdata)
486{
487 RDPEI_PLUGIN* rdpei = userdata;
488 WINPR_ASSERT(rdpei);
489
490 EnterCriticalSection(&rdpei->lock);
491 BOOL rc = rdpei_poll_run_unlocked(context, userdata);
492 LeaveCriticalSection(&rdpei->lock);
493 return rc;
494}
495
496static DWORD WINAPI rdpei_periodic_update(LPVOID arg)
497{
498 DWORD status = 0;
499 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)arg;
500 UINT error = CHANNEL_RC_OK;
501 RdpeiClientContext* context = NULL;
502
503 if (!rdpei)
504 {
505 error = ERROR_INVALID_PARAMETER;
506 goto out;
507 }
508
509 context = rdpei->context;
510
511 if (!context)
512 {
513 error = ERROR_INVALID_PARAMETER;
514 goto out;
515 }
516
517 while (rdpei->running)
518 {
519 status = WaitForSingleObject(rdpei->event, 20);
520
521 if (status == WAIT_FAILED)
522 {
523 error = GetLastError();
524 WLog_Print(rdpei->base.log, WLOG_ERROR,
525 "WaitForMultipleObjects failed with error %" PRIu32 "!", error);
526 break;
527 }
528
529 if (!rdpei_poll_run(rdpei->rdpcontext, rdpei))
530 error = ERROR_INTERNAL_ERROR;
531 }
532
533out:
534
535 if (error && rdpei && rdpei->rdpcontext)
536 setChannelError(rdpei->rdpcontext, error, "rdpei_schedule_thread reported an error");
537
538 if (rdpei)
539 rdpei->running = FALSE;
540
541 ExitThread(error);
542 return error;
543}
544
550static UINT rdpei_send_cs_ready_pdu(GENERIC_CHANNEL_CALLBACK* callback)
551{
552 UINT status = 0;
553 wStream* s = NULL;
554 UINT32 flags = 0;
555 UINT32 pduLength = 0;
556 RDPEI_PLUGIN* rdpei = NULL;
557
558 if (!callback || !callback->plugin)
559 return ERROR_INTERNAL_ERROR;
560 rdpei = (RDPEI_PLUGIN*)callback->plugin;
561
562 flags |= CS_READY_FLAGS_SHOW_TOUCH_VISUALS & rdpei->context->clientFeaturesMask;
563 if (rdpei->version > RDPINPUT_PROTOCOL_V10)
564 flags |= CS_READY_FLAGS_DISABLE_TIMESTAMP_INJECTION & rdpei->context->clientFeaturesMask;
565 if (rdpei->features & SC_READY_MULTIPEN_INJECTION_SUPPORTED)
566 flags |= CS_READY_FLAGS_ENABLE_MULTIPEN_INJECTION & rdpei->context->clientFeaturesMask;
567
568 pduLength = RDPINPUT_HEADER_LENGTH + 10;
569 s = Stream_New(NULL, pduLength);
570
571 if (!s)
572 {
573 WLog_Print(rdpei->base.log, WLOG_ERROR, "Stream_New failed!");
574 return CHANNEL_RC_NO_MEMORY;
575 }
576
577 Stream_Seek(s, RDPINPUT_HEADER_LENGTH);
578 Stream_Write_UINT32(s, flags); /* flags (4 bytes) */
579 Stream_Write_UINT32(s, rdpei->version); /* protocolVersion (4 bytes) */
580 Stream_Write_UINT16(s, rdpei->maxTouchContacts); /* maxTouchContacts (2 bytes) */
581 Stream_SealLength(s);
582 status = rdpei_send_pdu(callback, s, EVENTID_CS_READY, pduLength);
583 Stream_Free(s, TRUE);
584 return status;
585}
586
587#if defined(WITH_DEBUG_RDPEI)
588static void rdpei_print_contact_flags(wLog* log, UINT32 contactFlags)
589{
590 if (contactFlags & RDPINPUT_CONTACT_FLAG_DOWN)
591 WLog_Print(log, WLOG_DEBUG, " RDPINPUT_CONTACT_FLAG_DOWN");
592
593 if (contactFlags & RDPINPUT_CONTACT_FLAG_UPDATE)
594 WLog_Print(log, WLOG_DEBUG, " RDPINPUT_CONTACT_FLAG_UPDATE");
595
596 if (contactFlags & RDPINPUT_CONTACT_FLAG_UP)
597 WLog_Print(log, WLOG_DEBUG, " RDPINPUT_CONTACT_FLAG_UP");
598
599 if (contactFlags & RDPINPUT_CONTACT_FLAG_INRANGE)
600 WLog_Print(log, WLOG_DEBUG, " RDPINPUT_CONTACT_FLAG_INRANGE");
601
602 if (contactFlags & RDPINPUT_CONTACT_FLAG_INCONTACT)
603 WLog_Print(log, WLOG_DEBUG, " RDPINPUT_CONTACT_FLAG_INCONTACT");
604
605 if (contactFlags & RDPINPUT_CONTACT_FLAG_CANCELED)
606 WLog_Print(log, WLOG_DEBUG, " RDPINPUT_CONTACT_FLAG_CANCELED");
607}
608#endif
609
610static INT16 bounded(INT32 val)
611{
612 if (val < INT16_MIN)
613 return INT16_MIN;
614 if (val > INT16_MAX)
615 return INT16_MAX;
616 return (INT16)val;
617}
618
624static UINT rdpei_write_touch_frame(wLog* log, wStream* s, RDPINPUT_TOUCH_FRAME* frame)
625{
626 int rectSize = 2;
627 RDPINPUT_CONTACT_DATA* contact = NULL;
628 if (!s || !frame)
629 return ERROR_INTERNAL_ERROR;
630#ifdef WITH_DEBUG_RDPEI
631 WLog_Print(log, WLOG_DEBUG, "contactCount: %" PRIu32 "", frame->contactCount);
632 WLog_Print(log, WLOG_DEBUG, "frameOffset: 0x%016" PRIX64 "", frame->frameOffset);
633#endif
634 rdpei_write_2byte_unsigned(s,
635 frame->contactCount); /* contactCount (TWO_BYTE_UNSIGNED_INTEGER) */
640 rdpei_write_8byte_unsigned(s, frame->frameOffset *
641 1000); /* frameOffset (EIGHT_BYTE_UNSIGNED_INTEGER) */
642
643 if (!Stream_EnsureRemainingCapacity(s, (size_t)frame->contactCount * 64))
644 {
645 WLog_Print(log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
646 return CHANNEL_RC_NO_MEMORY;
647 }
648
649 for (UINT32 index = 0; index < frame->contactCount; index++)
650 {
651 contact = &frame->contacts[index];
652 contact->fieldsPresent |= CONTACT_DATA_CONTACTRECT_PRESENT;
653 contact->contactRectLeft = bounded(contact->x - rectSize);
654 contact->contactRectTop = bounded(contact->y - rectSize);
655 contact->contactRectRight = bounded(contact->x + rectSize);
656 contact->contactRectBottom = bounded(contact->y + rectSize);
657#ifdef WITH_DEBUG_RDPEI
658 WLog_Print(log, WLOG_DEBUG, "contact[%" PRIu32 "].contactId: %" PRIu32 "", index,
659 contact->contactId);
660 WLog_Print(log, WLOG_DEBUG, "contact[%" PRIu32 "].fieldsPresent: %" PRIu32 "", index,
661 contact->fieldsPresent);
662 WLog_Print(log, WLOG_DEBUG, "contact[%" PRIu32 "].x: %" PRId32 "", index, contact->x);
663 WLog_Print(log, WLOG_DEBUG, "contact[%" PRIu32 "].y: %" PRId32 "", index, contact->y);
664 WLog_Print(log, WLOG_DEBUG, "contact[%" PRIu32 "].contactFlags: 0x%08" PRIX32 "", index,
665 contact->contactFlags);
666 rdpei_print_contact_flags(log, contact->contactFlags);
667#endif
668 Stream_Write_UINT8(
669 s, WINPR_ASSERTING_INT_CAST(uint8_t, contact->contactId)); /* contactId (1 byte) */
670 /* fieldsPresent (TWO_BYTE_UNSIGNED_INTEGER) */
671 rdpei_write_2byte_unsigned(s, contact->fieldsPresent);
672 rdpei_write_4byte_signed(s, contact->x); /* x (FOUR_BYTE_SIGNED_INTEGER) */
673 rdpei_write_4byte_signed(s, contact->y); /* y (FOUR_BYTE_SIGNED_INTEGER) */
674 /* contactFlags (FOUR_BYTE_UNSIGNED_INTEGER) */
675 rdpei_write_4byte_unsigned(s, contact->contactFlags);
676
677 if (contact->fieldsPresent & CONTACT_DATA_CONTACTRECT_PRESENT)
678 {
679 /* contactRectLeft (TWO_BYTE_SIGNED_INTEGER) */
680 rdpei_write_2byte_signed(s, contact->contactRectLeft);
681 /* contactRectTop (TWO_BYTE_SIGNED_INTEGER) */
682 rdpei_write_2byte_signed(s, contact->contactRectTop);
683 /* contactRectRight (TWO_BYTE_SIGNED_INTEGER) */
684 rdpei_write_2byte_signed(s, contact->contactRectRight);
685 /* contactRectBottom (TWO_BYTE_SIGNED_INTEGER) */
686 rdpei_write_2byte_signed(s, contact->contactRectBottom);
687 }
688
689 if (contact->fieldsPresent & CONTACT_DATA_ORIENTATION_PRESENT)
690 {
691 /* orientation (FOUR_BYTE_UNSIGNED_INTEGER) */
692 rdpei_write_4byte_unsigned(s, contact->orientation);
693 }
694
695 if (contact->fieldsPresent & CONTACT_DATA_PRESSURE_PRESENT)
696 {
697 /* pressure (FOUR_BYTE_UNSIGNED_INTEGER) */
698 rdpei_write_4byte_unsigned(s, contact->pressure);
699 }
700 }
701
702 return CHANNEL_RC_OK;
703}
704
710static UINT rdpei_send_touch_event_pdu(GENERIC_CHANNEL_CALLBACK* callback,
711 RDPINPUT_TOUCH_FRAME* frame)
712{
713 UINT status = 0;
714
715 WINPR_ASSERT(callback);
716
717 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)callback->plugin;
718 if (!rdpei || !rdpei->rdpcontext)
719 return ERROR_INTERNAL_ERROR;
720 if (freerdp_settings_get_bool(rdpei->rdpcontext->settings, FreeRDP_SuspendInput))
721 return CHANNEL_RC_OK;
722
723 if (!frame)
724 return ERROR_INTERNAL_ERROR;
725
726 size_t pduLength = 64ULL + (64ULL * frame->contactCount);
727 wStream* s = Stream_New(NULL, pduLength);
728
729 if (!s)
730 {
731 WLog_Print(rdpei->base.log, WLOG_ERROR, "Stream_New failed!");
732 return CHANNEL_RC_NO_MEMORY;
733 }
734
735 Stream_Seek(s, RDPINPUT_HEADER_LENGTH);
740 rdpei_write_4byte_unsigned(
741 s, (UINT32)frame->frameOffset); /* encodeTime (FOUR_BYTE_UNSIGNED_INTEGER) */
742 rdpei_write_2byte_unsigned(s, 1); /* (frameCount) TWO_BYTE_UNSIGNED_INTEGER */
743
744 status = rdpei_write_touch_frame(rdpei->base.log, s, frame);
745 if (status)
746 {
747 WLog_Print(rdpei->base.log, WLOG_ERROR,
748 "rdpei_write_touch_frame failed with error %" PRIu32 "!", status);
749 Stream_Free(s, TRUE);
750 return status;
751 }
752
753 Stream_SealLength(s);
754 status = rdpei_send_pdu(callback, s, EVENTID_TOUCH, Stream_Length(s));
755 Stream_Free(s, TRUE);
756 return status;
757}
758
764static UINT rdpei_recv_sc_ready_pdu(GENERIC_CHANNEL_CALLBACK* callback, wStream* s)
765{
766 UINT32 features = 0;
767 UINT32 protocolVersion = 0;
768
769 if (!callback || !callback->plugin)
770 return ERROR_INTERNAL_ERROR;
771
772 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)callback->plugin;
773
774 if (!Stream_CheckAndLogRequiredLengthWLog(rdpei->base.log, s, 4))
775 return ERROR_INVALID_DATA;
776 Stream_Read_UINT32(s, protocolVersion); /* protocolVersion (4 bytes) */
777
778 if (protocolVersion >= RDPINPUT_PROTOCOL_V300)
779 {
780 if (!Stream_CheckAndLogRequiredLengthWLog(rdpei->base.log, s, 4))
781 return ERROR_INVALID_DATA;
782 }
783
784 if (Stream_GetRemainingLength(s) >= 4)
785 Stream_Read_UINT32(s, features);
786
787 if (rdpei->version > protocolVersion)
788 rdpei->version = protocolVersion;
789 rdpei->features = features;
790
791 if (protocolVersion > RDPINPUT_PROTOCOL_V300)
792 {
793 WLog_Print(rdpei->base.log, WLOG_WARN,
794 "Unknown [MS-RDPEI] protocolVersion: 0x%08" PRIX32 "", protocolVersion);
795 }
796
797 return CHANNEL_RC_OK;
798}
799
805static UINT rdpei_recv_suspend_touch_pdu(GENERIC_CHANNEL_CALLBACK* callback, wStream* s)
806{
807 UINT error = CHANNEL_RC_OK;
808
809 WINPR_UNUSED(s);
810
811 if (!callback || !callback->plugin)
812 return ERROR_INTERNAL_ERROR;
813
814 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)callback->plugin;
815 RdpeiClientContext* context = rdpei->context;
816 if (!rdpei)
817 return ERROR_INTERNAL_ERROR;
818
819 IFCALLRET(context->SuspendTouch, error, context);
820
821 if (error)
822 WLog_Print(rdpei->base.log, WLOG_ERROR,
823 "rdpei->SuspendTouch failed with error %" PRIu32 "!", error);
824
825 return error;
826}
827
833static UINT rdpei_recv_resume_touch_pdu(GENERIC_CHANNEL_CALLBACK* callback, wStream* s)
834{
835 UINT error = CHANNEL_RC_OK;
836 if (!s || !callback)
837 return ERROR_INTERNAL_ERROR;
838
839 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)callback->plugin;
840 if (!rdpei)
841 return ERROR_INTERNAL_ERROR;
842
843 RdpeiClientContext* context = (RdpeiClientContext*)callback->plugin->pInterface;
844 if (!context)
845 return ERROR_INTERNAL_ERROR;
846
847 IFCALLRET(context->ResumeTouch, error, context);
848
849 if (error)
850 WLog_Print(rdpei->base.log, WLOG_ERROR, "rdpei->ResumeTouch failed with error %" PRIu32 "!",
851 error);
852
853 return error;
854}
855
861static UINT rdpei_recv_pdu(GENERIC_CHANNEL_CALLBACK* callback, wStream* s)
862{
863 UINT16 eventId = 0;
864 UINT32 pduLength = 0;
865 UINT error = 0;
866
867 if (!callback || !s)
868 return ERROR_INTERNAL_ERROR;
869
870 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)callback->plugin;
871 if (!rdpei)
872 return ERROR_INTERNAL_ERROR;
873
874 if (!Stream_CheckAndLogRequiredLengthWLog(rdpei->base.log, s, 6))
875 return ERROR_INVALID_DATA;
876
877 Stream_Read_UINT16(s, eventId); /* eventId (2 bytes) */
878 Stream_Read_UINT32(s, pduLength); /* pduLength (4 bytes) */
879#ifdef WITH_DEBUG_RDPEI
880 WLog_Print(rdpei->base.log, WLOG_DEBUG,
881 "rdpei_recv_pdu: eventId: %" PRIu16 " (%s) length: %" PRIu32 "", eventId,
882 rdpei_eventid_string(eventId), pduLength);
883#endif
884
885 if ((pduLength < 6) || !Stream_CheckAndLogRequiredLengthWLog(rdpei->base.log, s, pduLength - 6))
886 return ERROR_INVALID_DATA;
887
888 switch (eventId)
889 {
890 case EVENTID_SC_READY:
891 if ((error = rdpei_recv_sc_ready_pdu(callback, s)))
892 {
893 WLog_Print(rdpei->base.log, WLOG_ERROR,
894 "rdpei_recv_sc_ready_pdu failed with error %" PRIu32 "!", error);
895 return error;
896 }
897
898 if ((error = rdpei_send_cs_ready_pdu(callback)))
899 {
900 WLog_Print(rdpei->base.log, WLOG_ERROR,
901 "rdpei_send_cs_ready_pdu failed with error %" PRIu32 "!", error);
902 return error;
903 }
904
905 break;
906
907 case EVENTID_SUSPEND_TOUCH:
908 if ((error = rdpei_recv_suspend_touch_pdu(callback, s)))
909 {
910 WLog_Print(rdpei->base.log, WLOG_ERROR,
911 "rdpei_recv_suspend_touch_pdu failed with error %" PRIu32 "!", error);
912 return error;
913 }
914
915 break;
916
917 case EVENTID_RESUME_TOUCH:
918 if ((error = rdpei_recv_resume_touch_pdu(callback, s)))
919 {
920 WLog_Print(rdpei->base.log, WLOG_ERROR,
921 "rdpei_recv_resume_touch_pdu failed with error %" PRIu32 "!", error);
922 return error;
923 }
924
925 break;
926
927 default:
928 break;
929 }
930
931 return CHANNEL_RC_OK;
932}
933
939static UINT rdpei_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data)
940{
941 GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
942 return rdpei_recv_pdu(callback, data);
943}
944
950static UINT rdpei_on_close(IWTSVirtualChannelCallback* pChannelCallback)
951{
952 GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
953 if (callback)
954 {
955 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)callback->plugin;
956 if (rdpei && rdpei->base.listener_callback)
957 {
958 if (rdpei->base.listener_callback->channel_callback == callback)
959 rdpei->base.listener_callback->channel_callback = NULL;
960 }
961 }
962 free(callback);
963 return CHANNEL_RC_OK;
964}
965
970static UINT32 rdpei_get_version(RdpeiClientContext* context)
971{
972 RDPEI_PLUGIN* rdpei = NULL;
973 if (!context || !context->handle)
974 return 0;
975 rdpei = (RDPEI_PLUGIN*)context->handle;
976 return rdpei->version;
977}
978
979static UINT32 rdpei_get_features(RdpeiClientContext* context)
980{
981 RDPEI_PLUGIN* rdpei = NULL;
982 if (!context || !context->handle)
983 return 0;
984 rdpei = (RDPEI_PLUGIN*)context->handle;
985 return rdpei->features;
986}
987
993UINT rdpei_send_frame(RdpeiClientContext* context, RDPINPUT_TOUCH_FRAME* frame)
994{
995 UINT64 currentTime = GetTickCount64();
996 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)context->handle;
997 GENERIC_CHANNEL_CALLBACK* callback = NULL;
998 UINT error = 0;
999
1000 callback = rdpei->base.listener_callback->channel_callback;
1001
1002 /* Just ignore the event if the channel is not connected */
1003 if (!callback)
1004 return CHANNEL_RC_OK;
1005
1006 if (!rdpei->previousFrameTime && !rdpei->currentFrameTime)
1007 {
1008 rdpei->currentFrameTime = currentTime;
1009 frame->frameOffset = 0;
1010 }
1011 else
1012 {
1013 rdpei->currentFrameTime = currentTime;
1014 frame->frameOffset = rdpei->currentFrameTime - rdpei->previousFrameTime;
1015 }
1016
1017 if ((error = rdpei_send_touch_event_pdu(callback, frame)))
1018 {
1019 WLog_Print(rdpei->base.log, WLOG_ERROR,
1020 "rdpei_send_touch_event_pdu failed with error %" PRIu32 "!", error);
1021 return error;
1022 }
1023
1024 rdpei->previousFrameTime = rdpei->currentFrameTime;
1025 return error;
1026}
1027
1033static UINT rdpei_add_contact(RdpeiClientContext* context, const RDPINPUT_CONTACT_DATA* contact)
1034{
1035 RDPINPUT_CONTACT_POINT* contactPoint = NULL;
1036 RDPEI_PLUGIN* rdpei = NULL;
1037 if (!context || !contact || !context->handle)
1038 return ERROR_INTERNAL_ERROR;
1039
1040 rdpei = (RDPEI_PLUGIN*)context->handle;
1041
1042 EnterCriticalSection(&rdpei->lock);
1043 contactPoint = &rdpei->contactPoints[contact->contactId];
1044
1045 if (contactPoint->dirty && contactPoint->data.contactFlags != contact->contactFlags)
1046 rdpei_add_frame(context);
1047
1048 contactPoint->data = *contact;
1049 contactPoint->dirty = TRUE;
1050 (void)SetEvent(rdpei->event);
1051 LeaveCriticalSection(&rdpei->lock);
1052
1053 return CHANNEL_RC_OK;
1054}
1055
1056static UINT rdpei_touch_process(RdpeiClientContext* context, INT32 externalId, UINT32 contactFlags,
1057 INT32 x, INT32 y, INT32* contactId, UINT32 fieldFlags, va_list ap)
1058{
1059 INT64 contactIdlocal = -1;
1060 RDPINPUT_CONTACT_POINT* contactPoint = NULL;
1061 UINT error = CHANNEL_RC_OK;
1062
1063 if (!context || !contactId || !context->handle)
1064 return ERROR_INTERNAL_ERROR;
1065
1066 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)context->handle;
1067 /* Create a new contact point in an empty slot */
1068 EnterCriticalSection(&rdpei->lock);
1069 const BOOL begin = (contactFlags & RDPINPUT_CONTACT_FLAG_DOWN) != 0;
1070 contactPoint = rdpei_contact(rdpei, externalId, !begin);
1071 if (contactPoint)
1072 contactIdlocal = contactPoint->contactId;
1073 LeaveCriticalSection(&rdpei->lock);
1074
1075 if (contactIdlocal > UINT32_MAX)
1076 return ERROR_INVALID_PARAMETER;
1077
1078 if (contactIdlocal >= 0)
1079 {
1080 RDPINPUT_CONTACT_DATA contact = { 0 };
1081 contact.x = x;
1082 contact.y = y;
1083 contact.contactId = (UINT32)contactIdlocal;
1084 contact.contactFlags = contactFlags;
1085 contact.fieldsPresent = WINPR_ASSERTING_INT_CAST(UINT16, fieldFlags);
1086
1087 if (fieldFlags & CONTACT_DATA_CONTACTRECT_PRESENT)
1088 {
1089 INT32 val = va_arg(ap, INT32);
1090 contact.contactRectLeft = WINPR_ASSERTING_INT_CAST(INT16, val);
1091
1092 val = va_arg(ap, INT32);
1093 contact.contactRectTop = WINPR_ASSERTING_INT_CAST(INT16, val);
1094
1095 val = va_arg(ap, INT32);
1096 contact.contactRectRight = WINPR_ASSERTING_INT_CAST(INT16, val);
1097
1098 val = va_arg(ap, INT32);
1099 contact.contactRectBottom = WINPR_ASSERTING_INT_CAST(INT16, val);
1100 }
1101 if (fieldFlags & CONTACT_DATA_ORIENTATION_PRESENT)
1102 {
1103 UINT32 p = va_arg(ap, UINT32);
1104 if (p >= 360)
1105 {
1106 WLog_Print(rdpei->base.log, WLOG_WARN,
1107 "TouchContact %" PRId64 ": Invalid orientation value %" PRIu32
1108 "degree, clamping to 359 degree",
1109 contactIdlocal, p);
1110 p = 359;
1111 }
1112 contact.orientation = p;
1113 }
1114 if (fieldFlags & CONTACT_DATA_PRESSURE_PRESENT)
1115 {
1116 UINT32 p = va_arg(ap, UINT32);
1117 if (p > 1024)
1118 {
1119 WLog_Print(rdpei->base.log, WLOG_WARN,
1120 "TouchContact %" PRId64 ": Invalid pressure value %" PRIu32
1121 ", clamping to 1024",
1122 contactIdlocal, p);
1123 p = 1024;
1124 }
1125 contact.pressure = p;
1126 }
1127
1128 error = context->AddContact(context, &contact);
1129 }
1130
1131 if (contactId)
1132 *contactId = (INT32)contactIdlocal;
1133 return error;
1134}
1135
1141static UINT rdpei_touch_begin(RdpeiClientContext* context, INT32 externalId, INT32 x, INT32 y,
1142 INT32* contactId)
1143{
1144 UINT rc = 0;
1145 va_list ap = { 0 };
1146 rc = rdpei_touch_process(context, externalId,
1147 RDPINPUT_CONTACT_FLAG_DOWN | RDPINPUT_CONTACT_FLAG_INRANGE |
1148 RDPINPUT_CONTACT_FLAG_INCONTACT,
1149 x, y, contactId, 0, ap);
1150 return rc;
1151}
1152
1158static UINT rdpei_touch_update(RdpeiClientContext* context, INT32 externalId, INT32 x, INT32 y,
1159 INT32* contactId)
1160{
1161 UINT rc = 0;
1162 va_list ap = { 0 };
1163 rc = rdpei_touch_process(context, externalId,
1164 RDPINPUT_CONTACT_FLAG_UPDATE | RDPINPUT_CONTACT_FLAG_INRANGE |
1165 RDPINPUT_CONTACT_FLAG_INCONTACT,
1166 x, y, contactId, 0, ap);
1167 return rc;
1168}
1169
1175static UINT rdpei_touch_end(RdpeiClientContext* context, INT32 externalId, INT32 x, INT32 y,
1176 INT32* contactId)
1177{
1178 UINT error = 0;
1179 va_list ap = { 0 };
1180 error = rdpei_touch_process(context, externalId,
1181 RDPINPUT_CONTACT_FLAG_UPDATE | RDPINPUT_CONTACT_FLAG_INRANGE |
1182 RDPINPUT_CONTACT_FLAG_INCONTACT,
1183 x, y, contactId, 0, ap);
1184 if (error != CHANNEL_RC_OK)
1185 return error;
1186 error =
1187 rdpei_touch_process(context, externalId, RDPINPUT_CONTACT_FLAG_UP, x, y, contactId, 0, ap);
1188 return error;
1189}
1190
1196static UINT rdpei_touch_cancel(RdpeiClientContext* context, INT32 externalId, INT32 x, INT32 y,
1197 INT32* contactId)
1198{
1199 UINT rc = 0;
1200 va_list ap = { 0 };
1201 rc = rdpei_touch_process(context, externalId,
1202 RDPINPUT_CONTACT_FLAG_UP | RDPINPUT_CONTACT_FLAG_CANCELED, x, y,
1203 contactId, 0, ap);
1204 return rc;
1205}
1206
1207static UINT rdpei_touch_raw_event(RdpeiClientContext* context, INT32 externalId, INT32 x, INT32 y,
1208 INT32* contactId, UINT32 flags, UINT32 fieldFlags, ...)
1209{
1210 UINT rc = 0;
1211 va_list ap;
1212 va_start(ap, fieldFlags);
1213 rc = rdpei_touch_process(context, externalId, flags, x, y, contactId, fieldFlags, ap);
1214 va_end(ap);
1215 return rc;
1216}
1217
1218static UINT rdpei_touch_raw_event_va(RdpeiClientContext* context, INT32 externalId, INT32 x,
1219 INT32 y, INT32* contactId, UINT32 flags, UINT32 fieldFlags,
1220 va_list args)
1221{
1222 return rdpei_touch_process(context, externalId, flags, x, y, contactId, fieldFlags, args);
1223}
1224
1225static RDPINPUT_PEN_CONTACT_POINT* rdpei_pen_contact(RDPEI_PLUGIN* rdpei, INT32 externalId,
1226 BOOL active)
1227{
1228 if (!rdpei)
1229 return NULL;
1230
1231 for (UINT32 x = 0; x < rdpei->maxPenContacts; x++)
1232 {
1233 RDPINPUT_PEN_CONTACT_POINT* contact = &rdpei->penContactPoints[x];
1234 if (active)
1235 {
1236 if (contact->active)
1237 {
1238 if (contact->externalId == externalId)
1239 return contact;
1240 }
1241 }
1242 else
1243 {
1244 if (!contact->active)
1245 {
1246 contact->externalId = externalId;
1247 contact->active = TRUE;
1248 return contact;
1249 }
1250 }
1251 }
1252 return NULL;
1253}
1254
1255static UINT rdpei_add_pen(RdpeiClientContext* context, INT32 externalId,
1256 const RDPINPUT_PEN_CONTACT* contact)
1257{
1258 RDPEI_PLUGIN* rdpei = NULL;
1259 RDPINPUT_PEN_CONTACT_POINT* contactPoint = NULL;
1260
1261 if (!context || !contact || !context->handle)
1262 return ERROR_INTERNAL_ERROR;
1263
1264 rdpei = (RDPEI_PLUGIN*)context->handle;
1265
1266 EnterCriticalSection(&rdpei->lock);
1267 contactPoint = rdpei_pen_contact(rdpei, externalId, TRUE);
1268 if (contactPoint)
1269 {
1270 contactPoint->data = *contact;
1271 contactPoint->dirty = TRUE;
1272 (void)SetEvent(rdpei->event);
1273 }
1274 LeaveCriticalSection(&rdpei->lock);
1275
1276 return CHANNEL_RC_OK;
1277}
1278
1279static UINT rdpei_pen_process(RdpeiClientContext* context, INT32 externalId, UINT32 contactFlags,
1280 UINT32 fieldFlags, INT32 x, INT32 y, va_list ap)
1281{
1282 RDPINPUT_PEN_CONTACT_POINT* contactPoint = NULL;
1283 RDPEI_PLUGIN* rdpei = NULL;
1284 UINT error = CHANNEL_RC_OK;
1285
1286 if (!context || !context->handle)
1287 return ERROR_INTERNAL_ERROR;
1288
1289 rdpei = (RDPEI_PLUGIN*)context->handle;
1290
1291 EnterCriticalSection(&rdpei->lock);
1292 // Start a new contact only when it is not active.
1293 contactPoint = rdpei_pen_contact(rdpei, externalId, TRUE);
1294 if (!contactPoint)
1295 {
1296 const UINT32 mask = RDPINPUT_CONTACT_FLAG_INRANGE;
1297 if ((contactFlags & mask) == mask)
1298 {
1299 contactPoint = rdpei_pen_contact(rdpei, externalId, FALSE);
1300 }
1301 }
1302 LeaveCriticalSection(&rdpei->lock);
1303 if (contactPoint != NULL)
1304 {
1305 RDPINPUT_PEN_CONTACT contact = { 0 };
1306
1307 contact.x = x;
1308 contact.y = y;
1309 contact.fieldsPresent = WINPR_ASSERTING_INT_CAST(UINT16, fieldFlags);
1310
1311 contact.contactFlags = contactFlags;
1312 if (fieldFlags & RDPINPUT_PEN_CONTACT_PENFLAGS_PRESENT)
1313 {
1314 const UINT32 val = va_arg(ap, UINT32);
1315 contact.penFlags = WINPR_ASSERTING_INT_CAST(UINT16, val);
1316 }
1317 if (fieldFlags & RDPINPUT_PEN_CONTACT_PRESSURE_PRESENT)
1318 {
1319 const UINT32 val = va_arg(ap, UINT32);
1320 contact.pressure = WINPR_ASSERTING_INT_CAST(UINT16, val);
1321 }
1322 if (fieldFlags & RDPINPUT_PEN_CONTACT_ROTATION_PRESENT)
1323 {
1324 const UINT32 val = va_arg(ap, UINT32);
1325 contact.rotation = WINPR_ASSERTING_INT_CAST(UINT16, val);
1326 }
1327 if (fieldFlags & RDPINPUT_PEN_CONTACT_TILTX_PRESENT)
1328 {
1329 const INT32 val = va_arg(ap, INT32);
1330 contact.tiltX = WINPR_ASSERTING_INT_CAST(INT16, val);
1331 }
1332 if (fieldFlags & RDPINPUT_PEN_CONTACT_TILTY_PRESENT)
1333 {
1334 const INT32 val = va_arg(ap, INT32);
1335 WINPR_ASSERT((val >= INT16_MIN) && (val <= INT16_MAX));
1336 contact.tiltY = WINPR_ASSERTING_INT_CAST(INT16, val);
1337 }
1338
1339 error = context->AddPen(context, externalId, &contact);
1340 }
1341
1342 return error;
1343}
1344
1350static UINT rdpei_pen_begin(RdpeiClientContext* context, INT32 externalId, UINT32 fieldFlags,
1351 INT32 x, INT32 y, ...)
1352{
1353 UINT error = 0;
1354 va_list ap;
1355
1356 va_start(ap, y);
1357 error = rdpei_pen_process(context, externalId,
1358 RDPINPUT_CONTACT_FLAG_DOWN | RDPINPUT_CONTACT_FLAG_INRANGE |
1359 RDPINPUT_CONTACT_FLAG_INCONTACT,
1360 fieldFlags, x, y, ap);
1361 va_end(ap);
1362
1363 return error;
1364}
1365
1371static UINT rdpei_pen_update(RdpeiClientContext* context, INT32 externalId, UINT32 fieldFlags,
1372 INT32 x, INT32 y, ...)
1373{
1374 UINT error = 0;
1375 va_list ap;
1376
1377 va_start(ap, y);
1378 error = rdpei_pen_process(context, externalId,
1379 RDPINPUT_CONTACT_FLAG_UPDATE | RDPINPUT_CONTACT_FLAG_INRANGE |
1380 RDPINPUT_CONTACT_FLAG_INCONTACT,
1381 fieldFlags, x, y, ap);
1382 va_end(ap);
1383 return error;
1384}
1385
1391static UINT rdpei_pen_end(RdpeiClientContext* context, INT32 externalId, UINT32 fieldFlags, INT32 x,
1392 INT32 y, ...)
1393{
1394 UINT error = 0;
1395 va_list ap;
1396 va_start(ap, y);
1397 error = rdpei_pen_process(context, externalId,
1398 RDPINPUT_CONTACT_FLAG_UP | RDPINPUT_CONTACT_FLAG_INRANGE, fieldFlags,
1399 x, y, ap);
1400 va_end(ap);
1401 return error;
1402}
1403
1409static UINT rdpei_pen_hover_begin(RdpeiClientContext* context, INT32 externalId, UINT32 fieldFlags,
1410 INT32 x, INT32 y, ...)
1411{
1412 UINT error = 0;
1413 va_list ap;
1414
1415 va_start(ap, y);
1416 error = rdpei_pen_process(context, externalId,
1417 RDPINPUT_CONTACT_FLAG_UPDATE | RDPINPUT_CONTACT_FLAG_INRANGE,
1418 fieldFlags, x, y, ap);
1419 va_end(ap);
1420
1421 return error;
1422}
1423
1429static UINT rdpei_pen_hover_update(RdpeiClientContext* context, INT32 externalId, UINT32 fieldFlags,
1430 INT32 x, INT32 y, ...)
1431{
1432 UINT error = 0;
1433 va_list ap;
1434
1435 va_start(ap, y);
1436 error = rdpei_pen_process(context, externalId,
1437 RDPINPUT_CONTACT_FLAG_UPDATE | RDPINPUT_CONTACT_FLAG_INRANGE,
1438 fieldFlags, x, y, ap);
1439 va_end(ap);
1440
1441 return error;
1442}
1443
1449static UINT rdpei_pen_hover_cancel(RdpeiClientContext* context, INT32 externalId, UINT32 fieldFlags,
1450 INT32 x, INT32 y, ...)
1451{
1452 UINT error = 0;
1453 va_list ap;
1454
1455 va_start(ap, y);
1456 error = rdpei_pen_process(context, externalId,
1457 RDPINPUT_CONTACT_FLAG_UPDATE | RDPINPUT_CONTACT_FLAG_CANCELED,
1458 fieldFlags, x, y, ap);
1459 va_end(ap);
1460
1461 return error;
1462}
1463
1464static UINT rdpei_pen_raw_event(RdpeiClientContext* context, INT32 externalId, UINT32 contactFlags,
1465 UINT32 fieldFlags, INT32 x, INT32 y, ...)
1466{
1467 UINT error = 0;
1468 va_list ap;
1469
1470 va_start(ap, y);
1471 error = rdpei_pen_process(context, externalId, contactFlags, fieldFlags, x, y, ap);
1472 va_end(ap);
1473 return error;
1474}
1475
1476static UINT rdpei_pen_raw_event_va(RdpeiClientContext* context, INT32 externalId,
1477 UINT32 contactFlags, UINT32 fieldFlags, INT32 x, INT32 y,
1478 va_list args)
1479{
1480 return rdpei_pen_process(context, externalId, contactFlags, fieldFlags, x, y, args);
1481}
1482
1483static UINT init_plugin_cb(GENERIC_DYNVC_PLUGIN* base, rdpContext* rcontext, rdpSettings* settings)
1484{
1485 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)base;
1486
1487 WINPR_ASSERT(base);
1488 WINPR_UNUSED(settings);
1489
1490 rdpei->version = RDPINPUT_PROTOCOL_V300;
1491 rdpei->currentFrameTime = 0;
1492 rdpei->previousFrameTime = 0;
1493 rdpei->maxTouchContacts = MAX_CONTACTS;
1494 rdpei->maxPenContacts = MAX_PEN_CONTACTS;
1495 rdpei->rdpcontext = rcontext;
1496
1497 WINPR_ASSERT(rdpei->base.log);
1498
1499 InitializeCriticalSection(&rdpei->lock);
1500 rdpei->event = CreateEventA(NULL, TRUE, FALSE, NULL);
1501 if (!rdpei->event)
1502 {
1503 WLog_Print(rdpei->base.log, WLOG_ERROR, "calloc failed!");
1504 return CHANNEL_RC_NO_MEMORY;
1505 }
1506
1507 RdpeiClientContext* context = (RdpeiClientContext*)calloc(1, sizeof(RdpeiClientContext));
1508 if (!context)
1509 {
1510 WLog_Print(rdpei->base.log, WLOG_ERROR, "calloc failed!");
1511 return CHANNEL_RC_NO_MEMORY;
1512 }
1513
1514 context->clientFeaturesMask = UINT32_MAX;
1515 context->handle = (void*)rdpei;
1516 context->GetVersion = rdpei_get_version;
1517 context->GetFeatures = rdpei_get_features;
1518 context->AddContact = rdpei_add_contact;
1519 context->TouchBegin = rdpei_touch_begin;
1520 context->TouchUpdate = rdpei_touch_update;
1521 context->TouchEnd = rdpei_touch_end;
1522 context->TouchCancel = rdpei_touch_cancel;
1523 context->TouchRawEvent = rdpei_touch_raw_event;
1524 context->TouchRawEventVA = rdpei_touch_raw_event_va;
1525 context->AddPen = rdpei_add_pen;
1526 context->PenBegin = rdpei_pen_begin;
1527 context->PenUpdate = rdpei_pen_update;
1528 context->PenEnd = rdpei_pen_end;
1529 context->PenHoverBegin = rdpei_pen_hover_begin;
1530 context->PenHoverUpdate = rdpei_pen_hover_update;
1531 context->PenHoverCancel = rdpei_pen_hover_cancel;
1532 context->PenRawEvent = rdpei_pen_raw_event;
1533 context->PenRawEventVA = rdpei_pen_raw_event_va;
1534
1535 rdpei->context = context;
1536 rdpei->base.iface.pInterface = (void*)context;
1537
1538 rdpei->async =
1539 !freerdp_settings_get_bool(rdpei->rdpcontext->settings, FreeRDP_SynchronousDynamicChannels);
1540 if (rdpei->async)
1541 {
1542 rdpei->running = TRUE;
1543
1544 rdpei->thread = CreateThread(NULL, 0, rdpei_periodic_update, rdpei, 0, NULL);
1545 if (!rdpei->thread)
1546 {
1547 WLog_Print(rdpei->base.log, WLOG_ERROR, "calloc failed!");
1548 return CHANNEL_RC_NO_MEMORY;
1549 }
1550 }
1551 else
1552 {
1553 if (!freerdp_client_channel_register(rdpei->rdpcontext->channels, rdpei->event,
1554 rdpei_poll_run, rdpei))
1555 return ERROR_INTERNAL_ERROR;
1556 }
1557
1558 return CHANNEL_RC_OK;
1559}
1560
1561static void terminate_plugin_cb(GENERIC_DYNVC_PLUGIN* base)
1562{
1563 RDPEI_PLUGIN* rdpei = (RDPEI_PLUGIN*)base;
1564 WINPR_ASSERT(rdpei);
1565
1566 rdpei->running = FALSE;
1567 if (rdpei->event)
1568 (void)SetEvent(rdpei->event);
1569
1570 if (rdpei->thread)
1571 {
1572 (void)WaitForSingleObject(rdpei->thread, INFINITE);
1573 (void)CloseHandle(rdpei->thread);
1574 }
1575
1576 if (rdpei->event && !rdpei->async)
1577 (void)freerdp_client_channel_unregister(rdpei->rdpcontext->channels, rdpei->event);
1578
1579 if (rdpei->event)
1580 (void)CloseHandle(rdpei->event);
1581
1582 DeleteCriticalSection(&rdpei->lock);
1583 free(rdpei->context);
1584}
1585
1586static const IWTSVirtualChannelCallback geometry_callbacks = { rdpei_on_data_received,
1587 NULL, /* Open */
1588 rdpei_on_close, NULL };
1589
1595FREERDP_ENTRY_POINT(UINT VCAPITYPE rdpei_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints))
1596{
1597 return freerdp_generic_DVCPluginEntry(pEntryPoints, RDPEI_TAG, RDPEI_DVC_CHANNEL_NAME,
1598 sizeof(RDPEI_PLUGIN), sizeof(GENERIC_CHANNEL_CALLBACK),
1599 &geometry_callbacks, init_plugin_cb, terminate_plugin_cb);
1600}
freerdp_settings_get_bool
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
GENERIC_CHANNEL_CALLBACK
Definition include/freerdp/client/channels.h:35
GENERIC_DYNVC_PLUGIN
Definition include/freerdp/client/channels.h:57
RDPINPUT_CONTACT_DATA
a contact point
Definition channels/rdpei.h:105
RDPINPUT_CONTACT_POINT
Definition client/rdpei_main.h:62
RDPINPUT_PEN_CONTACT_POINT
Definition client/rdpei_main.h:71
RDPINPUT_PEN_CONTACT
Definition channels/rdpei.h:136
RDPINPUT_PEN_FRAME
Definition channels/rdpei.h:152
RDPINPUT_TOUCH_FRAME
a frame containing contact points
Definition channels/rdpei.h:121
RTL_CRITICAL_SECTION
Definition include/winpr/synch.h:158