FreeRDP
rdpei_common.c
1 
21 #include <freerdp/config.h>
22 
23 #include <winpr/crt.h>
24 #include <winpr/cast.h>
25 #include <winpr/stream.h>
26 
27 #include "rdpei_common.h"
28 
29 #include <freerdp/log.h>
30 
31 #define TAG FREERDP_TAG("channels.rdpei.common")
32 
33 BOOL rdpei_read_2byte_unsigned(wStream* s, UINT16* value)
34 {
35  BYTE byte = 0;
36 
37  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
38  return FALSE;
39 
40  Stream_Read_UINT8(s, byte);
41 
42  if (byte & 0x80)
43  {
44  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
45  return FALSE;
46 
47  const INT32 ibyte = ((byte & 0x7F) << 8);
48  *value = WINPR_ASSERTING_INT_CAST(UINT16, ibyte);
49  Stream_Read_UINT8(s, byte);
50  *value |= byte;
51  }
52  else
53  {
54  *value = (byte & 0x7F);
55  }
56 
57  return TRUE;
58 }
59 
60 BOOL rdpei_write_2byte_unsigned(wStream* s, UINT16 value)
61 {
62  BYTE byte = 0;
63 
64  if (!Stream_EnsureRemainingCapacity(s, 2))
65  return FALSE;
66 
67  if (value > 0x7FFF)
68  return FALSE;
69 
70  if (value >= 0x7F)
71  {
72  byte = ((value & 0x7F00) >> 8);
73  Stream_Write_UINT8(s, byte | 0x80);
74  byte = (value & 0xFF);
75  Stream_Write_UINT8(s, byte);
76  }
77  else
78  {
79  byte = (value & 0x7F);
80  Stream_Write_UINT8(s, byte);
81  }
82 
83  return TRUE;
84 }
85 
86 BOOL rdpei_read_2byte_signed(wStream* s, INT16* value)
87 {
88  BYTE byte = 0;
89  BOOL negative = 0;
90 
91  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
92  return FALSE;
93 
94  Stream_Read_UINT8(s, byte);
95 
96  negative = (byte & 0x40) ? TRUE : FALSE;
97 
98  const BYTE val = (byte & 0x3F);
99 
100  if (byte & 0x80)
101  {
102  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
103  return FALSE;
104 
105  Stream_Read_UINT8(s, byte);
106  *value = (INT16)((val << 8) | byte);
107  }
108  else
109  *value = val;
110 
111  if (negative)
112  *value *= -1;
113 
114  return TRUE;
115 }
116 
117 BOOL rdpei_write_2byte_signed(wStream* s, INT16 value)
118 {
119  BYTE byte = 0;
120  BOOL negative = FALSE;
121 
122  if (!Stream_EnsureRemainingCapacity(s, 2))
123  return FALSE;
124 
125  if (value < 0)
126  {
127  negative = TRUE;
128  value *= -1;
129  }
130 
131  if (value > 0x3FFF)
132  return FALSE;
133 
134  if (value >= 0x3F)
135  {
136  byte = ((value & 0x3F00) >> 8);
137 
138  if (negative)
139  byte |= 0x40;
140 
141  Stream_Write_UINT8(s, byte | 0x80);
142  byte = (value & 0xFF);
143  Stream_Write_UINT8(s, byte);
144  }
145  else
146  {
147  byte = (value & 0x3F);
148 
149  if (negative)
150  byte |= 0x40;
151 
152  Stream_Write_UINT8(s, byte);
153  }
154 
155  return TRUE;
156 }
157 
158 BOOL rdpei_read_4byte_unsigned(wStream* s, UINT32* value)
159 {
160  BYTE byte = 0;
161  BYTE count = 0;
162 
163  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
164  return FALSE;
165 
166  Stream_Read_UINT8(s, byte);
167 
168  count = (byte & 0xC0) >> 6;
169 
170  if (!Stream_CheckAndLogRequiredLength(TAG, s, count))
171  return FALSE;
172 
173  switch (count)
174  {
175  case 0:
176  *value = (byte & 0x3F);
177  break;
178 
179  case 1:
180  *value = ((byte & 0x3F) << 8) & 0xFF00;
181  Stream_Read_UINT8(s, byte);
182  *value |= byte;
183  break;
184 
185  case 2:
186  *value = ((byte & 0x3F) << 16) & 0xFF0000;
187  Stream_Read_UINT8(s, byte);
188  *value |= ((byte << 8) & 0xFF00);
189  Stream_Read_UINT8(s, byte);
190  *value |= byte;
191  break;
192 
193  case 3:
194  *value = ((byte & 0x3F) << 24) & 0xFF000000;
195  Stream_Read_UINT8(s, byte);
196  *value |= ((byte << 16) & 0xFF0000);
197  Stream_Read_UINT8(s, byte);
198  *value |= ((byte << 8) & 0xFF00);
199  Stream_Read_UINT8(s, byte);
200  *value |= byte;
201  break;
202 
203  default:
204  break;
205  }
206 
207  return TRUE;
208 }
209 
210 BOOL rdpei_write_4byte_unsigned(wStream* s, UINT32 value)
211 {
212  BYTE byte = 0;
213 
214  if (!Stream_EnsureRemainingCapacity(s, 4))
215  return FALSE;
216 
217  if (value <= 0x3FUL)
218  {
219  Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, value));
220  }
221  else if (value <= 0x3FFFUL)
222  {
223  byte = (value >> 8) & 0x3F;
224  Stream_Write_UINT8(s, byte | 0x40);
225  byte = (value & 0xFF);
226  Stream_Write_UINT8(s, byte);
227  }
228  else if (value <= 0x3FFFFFUL)
229  {
230  byte = (value >> 16) & 0x3F;
231  Stream_Write_UINT8(s, byte | 0x80);
232  byte = (value >> 8) & 0xFF;
233  Stream_Write_UINT8(s, byte);
234  byte = (value & 0xFF);
235  Stream_Write_UINT8(s, byte);
236  }
237  else if (value <= 0x3FFFFFFFUL)
238  {
239  byte = (value >> 24) & 0x3F;
240  Stream_Write_UINT8(s, byte | 0xC0);
241  byte = (value >> 16) & 0xFF;
242  Stream_Write_UINT8(s, byte);
243  byte = (value >> 8) & 0xFF;
244  Stream_Write_UINT8(s, byte);
245  byte = (value & 0xFF);
246  Stream_Write_UINT8(s, byte);
247  }
248  else
249  {
250  return FALSE;
251  }
252 
253  return TRUE;
254 }
255 
256 BOOL rdpei_read_4byte_signed(wStream* s, INT32* value)
257 {
258  BYTE byte = 0;
259  BYTE count = 0;
260  BOOL negative = 0;
261 
262  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
263  return FALSE;
264 
265  Stream_Read_UINT8(s, byte);
266 
267  count = (byte & 0xC0) >> 6;
268  negative = (byte & 0x20) ? TRUE : FALSE;
269 
270  if (!Stream_CheckAndLogRequiredLength(TAG, s, count))
271  return FALSE;
272 
273  switch (count)
274  {
275  case 0:
276  *value = (byte & 0x1F);
277  break;
278 
279  case 1:
280  *value = (byte & 0x1F) << 8;
281  Stream_Read_UINT8(s, byte);
282  *value |= byte;
283  break;
284 
285  case 2:
286  *value = (byte & 0x1F) << 16;
287  Stream_Read_UINT8(s, byte);
288  *value |= (byte << 8);
289  Stream_Read_UINT8(s, byte);
290  *value |= byte;
291  break;
292 
293  case 3:
294  *value = (byte & 0x1F) << 24;
295  Stream_Read_UINT8(s, byte);
296  *value |= (byte << 16);
297  Stream_Read_UINT8(s, byte);
298  *value |= (byte << 8);
299  Stream_Read_UINT8(s, byte);
300  *value |= byte;
301  break;
302 
303  default:
304  break;
305  }
306 
307  if (negative)
308  *value *= -1;
309 
310  return TRUE;
311 }
312 
313 BOOL rdpei_write_4byte_signed(wStream* s, INT32 value)
314 {
315  BYTE byte = 0;
316  BOOL negative = FALSE;
317 
318  if (!Stream_EnsureRemainingCapacity(s, 4))
319  return FALSE;
320 
321  if (value < 0)
322  {
323  negative = TRUE;
324  value *= -1;
325  }
326 
327  if (value <= 0x1FL)
328  {
329  byte = value & 0x1F;
330 
331  if (negative)
332  byte |= 0x20;
333 
334  Stream_Write_UINT8(s, byte);
335  }
336  else if (value <= 0x1FFFL)
337  {
338  byte = (value >> 8) & 0x1F;
339 
340  if (negative)
341  byte |= 0x20;
342 
343  Stream_Write_UINT8(s, byte | 0x40);
344  byte = (value & 0xFF);
345  Stream_Write_UINT8(s, byte);
346  }
347  else if (value <= 0x1FFFFFL)
348  {
349  byte = (value >> 16) & 0x1F;
350 
351  if (negative)
352  byte |= 0x20;
353 
354  Stream_Write_UINT8(s, byte | 0x80);
355  byte = (value >> 8) & 0xFF;
356  Stream_Write_UINT8(s, byte);
357  byte = (value & 0xFF);
358  Stream_Write_UINT8(s, byte);
359  }
360  else if (value <= 0x1FFFFFFFL)
361  {
362  byte = (value >> 24) & 0x1F;
363 
364  if (negative)
365  byte |= 0x20;
366 
367  Stream_Write_UINT8(s, byte | 0xC0);
368  byte = (value >> 16) & 0xFF;
369  Stream_Write_UINT8(s, byte);
370  byte = (value >> 8) & 0xFF;
371  Stream_Write_UINT8(s, byte);
372  byte = (value & 0xFF);
373  Stream_Write_UINT8(s, byte);
374  }
375  else
376  {
377  return FALSE;
378  }
379 
380  return TRUE;
381 }
382 
383 BOOL rdpei_read_8byte_unsigned(wStream* s, UINT64* value)
384 {
385  UINT64 byte = 0;
386  BYTE count = 0;
387 
388  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
389  return FALSE;
390 
391  Stream_Read_UINT8(s, byte);
392 
393  count = (byte & 0xE0) >> 5;
394 
395  if (!Stream_CheckAndLogRequiredLength(TAG, s, count))
396  return FALSE;
397 
398  switch (count)
399  {
400  case 0:
401  *value = (byte & 0x1F);
402  break;
403 
404  case 1:
405  *value = (byte & 0x1FU) << 8U;
406  Stream_Read_UINT8(s, byte);
407  *value |= byte;
408  break;
409 
410  case 2:
411  *value = (byte & 0x1FU) << 16U;
412  Stream_Read_UINT8(s, byte);
413  *value |= (byte << 8U);
414  Stream_Read_UINT8(s, byte);
415  *value |= byte;
416  break;
417 
418  case 3:
419  *value = (byte & 0x1FU) << 24U;
420  Stream_Read_UINT8(s, byte);
421  *value |= (byte << 16U);
422  Stream_Read_UINT8(s, byte);
423  *value |= (byte << 8U);
424  Stream_Read_UINT8(s, byte);
425  *value |= byte;
426  break;
427 
428  case 4:
429  *value = ((byte & 0x1FU)) << 32U;
430  Stream_Read_UINT8(s, byte);
431  *value |= (byte << 24U);
432  Stream_Read_UINT8(s, byte);
433  *value |= (byte << 16U);
434  Stream_Read_UINT8(s, byte);
435  *value |= (byte << 8U);
436  Stream_Read_UINT8(s, byte);
437  *value |= byte;
438  break;
439 
440  case 5:
441  *value = ((byte & 0x1FU)) << 40U;
442  Stream_Read_UINT8(s, byte);
443  *value |= ((byte) << 32U);
444  Stream_Read_UINT8(s, byte);
445  *value |= (byte << 24U);
446  Stream_Read_UINT8(s, byte);
447  *value |= (byte << 16U);
448  Stream_Read_UINT8(s, byte);
449  *value |= (byte << 8U);
450  Stream_Read_UINT8(s, byte);
451  *value |= byte;
452  break;
453 
454  case 6:
455  *value = ((byte & 0x1FU)) << 48U;
456  Stream_Read_UINT8(s, byte);
457  *value |= ((byte) << 40U);
458  Stream_Read_UINT8(s, byte);
459  *value |= ((byte) << 32U);
460  Stream_Read_UINT8(s, byte);
461  *value |= (byte << 24U);
462  Stream_Read_UINT8(s, byte);
463  *value |= (byte << 16U);
464  Stream_Read_UINT8(s, byte);
465  *value |= (byte << 8U);
466  Stream_Read_UINT8(s, byte);
467  *value |= byte;
468  break;
469 
470  case 7:
471  *value = ((byte & 0x1FU)) << 56U;
472  Stream_Read_UINT8(s, byte);
473  *value |= ((byte) << 48U);
474  Stream_Read_UINT8(s, byte);
475  *value |= ((byte) << 40U);
476  Stream_Read_UINT8(s, byte);
477  *value |= ((byte) << 32U);
478  Stream_Read_UINT8(s, byte);
479  *value |= (byte << 24U);
480  Stream_Read_UINT8(s, byte);
481  *value |= (byte << 16U);
482  Stream_Read_UINT8(s, byte);
483  *value |= (byte << 8U);
484  Stream_Read_UINT8(s, byte);
485  *value |= byte;
486  break;
487 
488  default:
489  break;
490  }
491 
492  return TRUE;
493 }
494 
495 BOOL rdpei_write_8byte_unsigned(wStream* s, UINT64 value)
496 {
497  BYTE byte = 0;
498 
499  if (!Stream_EnsureRemainingCapacity(s, 8))
500  return FALSE;
501 
502  if (value <= 0x1FULL)
503  {
504  byte = value & 0x1F;
505  Stream_Write_UINT8(s, byte);
506  }
507  else if (value <= 0x1FFFULL)
508  {
509  byte = (value >> 8) & 0x1F;
510  byte |= (1 << 5);
511  Stream_Write_UINT8(s, byte);
512  byte = (value & 0xFF);
513  Stream_Write_UINT8(s, byte);
514  }
515  else if (value <= 0x1FFFFFULL)
516  {
517  byte = (value >> 16) & 0x1F;
518  byte |= (2 << 5);
519  Stream_Write_UINT8(s, byte);
520  byte = (value >> 8) & 0xFF;
521  Stream_Write_UINT8(s, byte);
522  byte = (value & 0xFF);
523  Stream_Write_UINT8(s, byte);
524  }
525  else if (value <= 0x1FFFFFFFULL)
526  {
527  byte = (value >> 24) & 0x1F;
528  byte |= (3 << 5);
529  Stream_Write_UINT8(s, byte);
530  byte = (value >> 16) & 0xFF;
531  Stream_Write_UINT8(s, byte);
532  byte = (value >> 8) & 0xFF;
533  Stream_Write_UINT8(s, byte);
534  byte = (value & 0xFF);
535  Stream_Write_UINT8(s, byte);
536  }
537  else if (value <= 0x1FFFFFFFFFULL)
538  {
539  byte = (value >> 32) & 0x1F;
540  byte |= (4 << 5);
541  Stream_Write_UINT8(s, byte);
542  byte = (value >> 24) & 0x1F;
543  Stream_Write_UINT8(s, byte);
544  byte = (value >> 16) & 0xFF;
545  Stream_Write_UINT8(s, byte);
546  byte = (value >> 8) & 0xFF;
547  Stream_Write_UINT8(s, byte);
548  byte = (value & 0xFF);
549  Stream_Write_UINT8(s, byte);
550  }
551  else if (value <= 0x1FFFFFFFFFFFULL)
552  {
553  byte = (value >> 40) & 0x1F;
554  byte |= (5 << 5);
555  Stream_Write_UINT8(s, byte);
556  byte = (value >> 32) & 0x1F;
557  Stream_Write_UINT8(s, byte);
558  byte = (value >> 24) & 0x1F;
559  Stream_Write_UINT8(s, byte);
560  byte = (value >> 16) & 0xFF;
561  Stream_Write_UINT8(s, byte);
562  byte = (value >> 8) & 0xFF;
563  Stream_Write_UINT8(s, byte);
564  byte = (value & 0xFF);
565  Stream_Write_UINT8(s, byte);
566  }
567  else if (value <= 0x1FFFFFFFFFFFFFULL)
568  {
569  byte = (value >> 48) & 0x1F;
570  byte |= (6 << 5);
571  Stream_Write_UINT8(s, byte);
572  byte = (value >> 40) & 0x1F;
573  Stream_Write_UINT8(s, byte);
574  byte = (value >> 32) & 0x1F;
575  Stream_Write_UINT8(s, byte);
576  byte = (value >> 24) & 0x1F;
577  Stream_Write_UINT8(s, byte);
578  byte = (value >> 16) & 0xFF;
579  Stream_Write_UINT8(s, byte);
580  byte = (value >> 8) & 0xFF;
581  Stream_Write_UINT8(s, byte);
582  byte = (value & 0xFF);
583  Stream_Write_UINT8(s, byte);
584  }
585  else if (value <= 0x1FFFFFFFFFFFFFFFULL)
586  {
587  byte = (value >> 56) & 0x1F;
588  byte |= (7 << 5);
589  Stream_Write_UINT8(s, byte);
590  byte = (value >> 48) & 0x1F;
591  Stream_Write_UINT8(s, byte);
592  byte = (value >> 40) & 0x1F;
593  Stream_Write_UINT8(s, byte);
594  byte = (value >> 32) & 0x1F;
595  Stream_Write_UINT8(s, byte);
596  byte = (value >> 24) & 0x1F;
597  Stream_Write_UINT8(s, byte);
598  byte = (value >> 16) & 0xFF;
599  Stream_Write_UINT8(s, byte);
600  byte = (value >> 8) & 0xFF;
601  Stream_Write_UINT8(s, byte);
602  byte = (value & 0xFF);
603  Stream_Write_UINT8(s, byte);
604  }
605  else
606  {
607  return FALSE;
608  }
609 
610  return TRUE;
611 }
612 
613 void touch_event_reset(RDPINPUT_TOUCH_EVENT* event)
614 {
615  for (UINT16 i = 0; i < event->frameCount; i++)
616  touch_frame_reset(&event->frames[i]);
617 
618  free(event->frames);
619  event->frames = NULL;
620  event->frameCount = 0;
621 }
622 
623 void touch_frame_reset(RDPINPUT_TOUCH_FRAME* frame)
624 {
625  free(frame->contacts);
626  frame->contacts = NULL;
627  frame->contactCount = 0;
628 }
629 
630 void pen_event_reset(RDPINPUT_PEN_EVENT* event)
631 {
632  for (UINT16 i = 0; i < event->frameCount; i++)
633  pen_frame_reset(&event->frames[i]);
634 
635  free(event->frames);
636  event->frames = NULL;
637  event->frameCount = 0;
638 }
639 
640 void pen_frame_reset(RDPINPUT_PEN_FRAME* frame)
641 {
642  free(frame->contacts);
643  frame->contacts = NULL;
644  frame->contactCount = 0;
645 }
RDPINPUT_PEN_EVENT
a touch event with some frames
Definition: channels/rdpei.h:160
RDPINPUT_PEN_FRAME
Definition: channels/rdpei.h:152
RDPINPUT_TOUCH_EVENT
a touch event with some frames
Definition: channels/rdpei.h:129
RDPINPUT_TOUCH_FRAME
a frame containing contact points
Definition: channels/rdpei.h:121