FreeRDP
Loading...
Searching...
No Matches
synthetic.c
1
20#include <winpr/config.h>
21
22#include <errno.h>
23#include <winpr/crt.h>
24#include <winpr/user.h>
25#include <winpr/image.h>
26
27#include "../utils/image.h"
28#include "clipboard.h"
29
30#include "../log.h"
31#define TAG WINPR_TAG("clipboard.synthetic")
32
33static const char mime_html[] = "text/html";
34static const char mime_ms_html[] = "HTML Format";
35static const char* mime_bitmap[] = { "image/bmp", "image/x-bmp", "image/x-MS-bmp",
36 "image/x-win-bitmap" };
37
38static const char mime_webp[] = "image/webp";
39static const char mime_png[] = "image/png";
40static const char mime_jpeg[] = "image/jpeg";
41static const char mime_tiff[] = "image/tiff";
42
43static const BYTE enc_base64url[] =
44 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
45
46static inline char* b64_encode(const BYTE* WINPR_RESTRICT data, size_t length, size_t* plen)
47{
48 WINPR_ASSERT(plen);
49 const BYTE* WINPR_RESTRICT alphabet = enc_base64url;
50 int c = 0;
51 size_t blocks = 0;
52 size_t outLen = (length + 3) * 4 / 3;
53 size_t extra = 0;
54
55 const BYTE* q = data;
56 const size_t alen = outLen + extra + 1ull;
57 BYTE* p = malloc(alen);
58 if (!p)
59 return NULL;
60
61 BYTE* ret = p;
62
63 /* b1, b2, b3 are input bytes
64 *
65 * 0 1 2
66 * 012345678901234567890123
67 * | b1 | b2 | b3 |
68 *
69 * [ c1 ] [ c3 ]
70 * [ c2 ] [ c4 ]
71 *
72 * c1, c2, c3, c4 are output chars in base64
73 */
74
75 /* first treat complete blocks */
76 blocks = length - (length % 3);
77 for (size_t i = 0; i < blocks; i += 3, q += 3)
78 {
79 c = (q[0] << 16) + (q[1] << 8) + q[2];
80
81 *p++ = alphabet[(c & 0x00FC0000) >> 18];
82 *p++ = alphabet[(c & 0x0003F000) >> 12];
83 *p++ = alphabet[(c & 0x00000FC0) >> 6];
84 *p++ = alphabet[c & 0x0000003F];
85 }
86
87 /* then remainder */
88 switch (length % 3)
89 {
90 case 0:
91 break;
92 case 1:
93 c = (q[0] << 16);
94 *p++ = alphabet[(c & 0x00FC0000) >> 18];
95 *p++ = alphabet[(c & 0x0003F000) >> 12];
96 break;
97 case 2:
98 c = (q[0] << 16) + (q[1] << 8);
99 *p++ = alphabet[(c & 0x00FC0000) >> 18];
100 *p++ = alphabet[(c & 0x0003F000) >> 12];
101 *p++ = alphabet[(c & 0x00000FC0) >> 6];
102 break;
103 default:
104 break;
105 }
106
107 *p = 0;
108 *plen = WINPR_ASSERTING_INT_CAST(size_t, p - ret);
109
110 return (char*)ret;
111}
112
124static void* clipboard_synthesize_cf_text(wClipboard* clipboard, UINT32 formatId, const void* data,
125 UINT32* pSize)
126{
127 size_t size = 0;
128 char* pDstData = NULL;
129
130 if (formatId == CF_UNICODETEXT)
131 {
132 char* str = ConvertWCharNToUtf8Alloc(data, *pSize / sizeof(WCHAR), &size);
133
134 if (!str || (size > UINT32_MAX))
135 {
136 free(str);
137 return NULL;
138 }
139
140 pDstData = ConvertLineEndingToCRLF(str, &size);
141 free(str);
142 *pSize = (UINT32)size;
143 return pDstData;
144 }
145 else if ((formatId == CF_TEXT) || (formatId == CF_OEMTEXT) ||
146 (formatId == ClipboardGetFormatId(clipboard, mime_text_plain)))
147 {
148 size = *pSize;
149 pDstData = ConvertLineEndingToCRLF(data, &size);
150
151 if (!pDstData || (size > *pSize))
152 {
153 free(pDstData);
154 return NULL;
155 }
156
157 *pSize = (UINT32)size;
158 return pDstData;
159 }
160
161 return NULL;
162}
163
170static void* clipboard_synthesize_cf_oemtext(wClipboard* clipboard, UINT32 formatId,
171 const void* data, UINT32* pSize)
172{
173 return clipboard_synthesize_cf_text(clipboard, formatId, data, pSize);
174}
175
182static void* clipboard_synthesize_cf_locale(WINPR_ATTR_UNUSED wClipboard* clipboard,
183 WINPR_ATTR_UNUSED UINT32 formatId,
184 WINPR_ATTR_UNUSED const void* data,
185 WINPR_ATTR_UNUSED UINT32* pSize)
186{
187 UINT32* pDstData = NULL;
188 pDstData = (UINT32*)malloc(sizeof(UINT32));
189
190 if (!pDstData)
191 return NULL;
192
193 *pDstData = 0x0409; /* English - United States */
194 return (void*)pDstData;
195}
196
203static void* clipboard_synthesize_cf_unicodetext(wClipboard* clipboard, UINT32 formatId,
204 const void* data, UINT32* pSize)
205{
206 size_t size = 0;
207 char* crlfStr = NULL;
208 WCHAR* pDstData = NULL;
209
210 if ((formatId == CF_TEXT) || (formatId == CF_OEMTEXT) ||
211 (formatId == ClipboardGetFormatId(clipboard, mime_text_plain)))
212 {
213 size_t len = 0;
214 if (!pSize || (*pSize > INT32_MAX))
215 return NULL;
216
217 size = *pSize;
218 crlfStr = ConvertLineEndingToCRLF((const char*)data, &size);
219
220 if (!crlfStr)
221 return NULL;
222
223 pDstData = ConvertUtf8NToWCharAlloc(crlfStr, size, &len);
224 free(crlfStr);
225
226 if ((len < 1) || ((len + 1) > UINT32_MAX / sizeof(WCHAR)))
227 {
228 free(pDstData);
229 return NULL;
230 }
231
232 const size_t slen = (len + 1) * sizeof(WCHAR);
233 *pSize = (UINT32)slen;
234 }
235
236 return (void*)pDstData;
237}
238
245static void* clipboard_synthesize_utf8_string(wClipboard* clipboard, UINT32 formatId,
246 const void* data, UINT32* pSize)
247{
248 if (formatId == CF_UNICODETEXT)
249 {
250 size_t size = 0;
251 char* pDstData = ConvertWCharNToUtf8Alloc(data, *pSize / sizeof(WCHAR), &size);
252
253 if (!pDstData)
254 return NULL;
255
256 const size_t rc = ConvertLineEndingToLF(pDstData, size);
257 WINPR_ASSERT(rc <= UINT32_MAX);
258 *pSize = (UINT32)rc;
259 return pDstData;
260 }
261 else if ((formatId == CF_TEXT) || (formatId == CF_OEMTEXT) ||
262 (formatId == ClipboardGetFormatId(clipboard, mime_text_plain)))
263 {
264 const size_t size = *pSize;
265 char* pDstData = calloc(size + 1, sizeof(char));
266
267 if (!pDstData)
268 return NULL;
269
270 CopyMemory(pDstData, data, size);
271 const size_t rc = ConvertLineEndingToLF(pDstData, size);
272 WINPR_ASSERT(rc <= UINT32_MAX);
273 *pSize = (UINT32)rc;
274 return pDstData;
275 }
276
277 return NULL;
278}
279
280static BOOL is_format_bitmap(wClipboard* clipboard, UINT32 formatId)
281{
282 for (size_t x = 0; x < ARRAYSIZE(mime_bitmap); x++)
283 {
284 const char* mime = mime_bitmap[x];
285 const UINT32 altFormatId = ClipboardGetFormatId(clipboard, mime);
286 if (altFormatId == formatId)
287 return TRUE;
288 }
289
290 return FALSE;
291}
292
299static void* clipboard_synthesize_cf_dib(wClipboard* clipboard, UINT32 formatId, const void* data,
300 UINT32* pSize)
301{
302 UINT32 SrcSize = 0;
303 UINT32 DstSize = 0;
304 BYTE* pDstData = NULL;
305 SrcSize = *pSize;
306
307#if defined(WINPR_UTILS_IMAGE_DIBv5)
308 if (formatId == CF_DIBV5)
309 {
310 WLog_WARN(TAG, "[DIB] Unsupported destination format %s",
311 ClipboardGetFormatName(clipboard, formatId));
312 }
313 else
314#endif
315 if (is_format_bitmap(clipboard, formatId))
316 {
317 WINPR_BITMAP_FILE_HEADER pFileHeader = { 0 };
318 wStream sbuffer = { 0 };
319 wStream* s = Stream_StaticConstInit(&sbuffer, data, SrcSize);
320 if (!readBitmapFileHeader(s, &pFileHeader))
321 return NULL;
322
323 DstSize = SrcSize - sizeof(BITMAPFILEHEADER);
324 pDstData = (BYTE*)malloc(DstSize);
325
326 if (!pDstData)
327 return NULL;
328
329 data = (const void*)&((const BYTE*)data)[sizeof(BITMAPFILEHEADER)];
330 CopyMemory(pDstData, data, DstSize);
331 *pSize = DstSize;
332 return pDstData;
333 }
334 else
335 {
336 WLog_WARN(TAG, "[DIB] Unsupported destination format %s",
337 ClipboardGetFormatName(clipboard, formatId));
338 }
339
340 return NULL;
341}
342
348#if defined(WINPR_UTILS_IMAGE_DIBv5)
349static void* clipboard_synthesize_cf_dibv5(wClipboard* clipboard, UINT32 formatId,
350 WINPR_ATTR_UNUSED const void* data,
351 WINPR_ATTR_UNUSED UINT32* pSize)
352{
353 if (formatId == CF_DIB)
354 {
355 WLog_WARN(TAG, "[DIBv5] Unsupported destination format %s",
356 ClipboardGetFormatName(clipboard, formatId));
357 }
358 else if (is_format_bitmap(clipboard, formatId))
359 {
360 WLog_WARN(TAG, "[DIBv5] Unsupported destination format %s",
361 ClipboardGetFormatName(clipboard, formatId));
362 }
363 else
364 {
365 BOOL handled = FALSE;
366#if defined(WINPR_UTILS_IMAGE_PNG)
367 {
368 const UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime_png);
369 if (formatId == altFormatId)
370 {
371 }
372 }
373#endif
374#if defined(WINPR_UTILS_IMAGE_JPEG)
375 {
376 const UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime_jpeg);
377 if (formatId == altFormatId)
378 {
379 }
380 }
381#endif
382 if (!handled)
383 {
384 WLog_WARN(TAG, "[DIBv5] Unsupported destination format %s",
385 ClipboardGetFormatName(clipboard, formatId));
386 }
387 }
388
389 return NULL;
390}
391#endif
392
393static void* clipboard_prepend_bmp_header(const WINPR_BITMAP_INFO_HEADER* pInfoHeader,
394 const void* data, size_t size, UINT32* pSize)
395{
396 WINPR_ASSERT(pInfoHeader);
397 WINPR_ASSERT(pSize);
398
399 *pSize = 0;
400 if ((pInfoHeader->biBitCount < 1) || (pInfoHeader->biBitCount > 32))
401 return NULL;
402
403 const size_t DstSize = sizeof(WINPR_BITMAP_FILE_HEADER) + size;
404 if (DstSize > UINT32_MAX)
405 return NULL;
406
407 wStream* s = Stream_New(NULL, DstSize);
408 if (!s)
409 return NULL;
410
411 WINPR_BITMAP_FILE_HEADER fileHeader = { 0 };
412 fileHeader.bfType[0] = 'B';
413 fileHeader.bfType[1] = 'M';
414 fileHeader.bfSize = (UINT32)DstSize;
415 fileHeader.bfOffBits = sizeof(WINPR_BITMAP_FILE_HEADER) + sizeof(WINPR_BITMAP_INFO_HEADER);
416 if (!writeBitmapFileHeader(s, &fileHeader))
417 goto fail;
418
419 if (!Stream_EnsureRemainingCapacity(s, size))
420 goto fail;
421 Stream_Write(s, data, size);
422
423 {
424 const size_t len = Stream_GetPosition(s);
425 if (len != DstSize)
426 goto fail;
427 }
428
429 *pSize = (UINT32)DstSize;
430
431 {
432 BYTE* dst = Stream_Buffer(s);
433 Stream_Free(s, FALSE);
434 return dst;
435 }
436
437fail:
438 Stream_Free(s, TRUE);
439 return NULL;
440}
441
448static void* clipboard_synthesize_image_bmp(WINPR_ATTR_UNUSED wClipboard* clipboard,
449 UINT32 formatId, const void* data, UINT32* pSize)
450{
451 UINT32 SrcSize = *pSize;
452
453 if (formatId == CF_DIB)
454 {
455 if (SrcSize < sizeof(BITMAPINFOHEADER))
456 return NULL;
457
458 wStream sbuffer = { 0 };
459 size_t offset = 0;
460 WINPR_BITMAP_INFO_HEADER header = { 0 };
461 wStream* s = Stream_StaticConstInit(&sbuffer, data, SrcSize);
462 if (!readBitmapInfoHeader(s, &header, &offset))
463 return NULL;
464
465 return clipboard_prepend_bmp_header(&header, data, SrcSize, pSize);
466 }
467#if defined(WINPR_UTILS_IMAGE_DIBv5)
468 else if (formatId == CF_DIBV5)
469 {
470 WLog_WARN(TAG, "[BMP] Unsupported destination format %s",
471 ClipboardGetFormatName(clipboard, formatId));
472 }
473#endif
474 else
475 {
476 WLog_WARN(TAG, "[BMP] Unsupported destination format %s",
477 ClipboardGetFormatName(clipboard, formatId));
478 }
479
480 return NULL;
481}
482
483#if defined(WINPR_UTILS_IMAGE_PNG) || defined(WINPR_UTILS_IMAGE_WEBP) || \
484 defined(WINPR_UTILS_IMAGE_JPEG)
485static void* clipboard_synthesize_image_bmp_to_format(wClipboard* clipboard, UINT32 formatId,
486 UINT32 bmpFormat, const void* data,
487 UINT32* pSize)
488{
489 WINPR_ASSERT(clipboard);
490 WINPR_ASSERT(data);
491 WINPR_ASSERT(pSize);
492
493 size_t dsize = 0;
494 void* result = NULL;
495
496 wImage* img = winpr_image_new();
497 void* bmp = clipboard_synthesize_image_bmp(clipboard, formatId, data, pSize);
498 const UINT32 SrcSize = *pSize;
499 *pSize = 0;
500
501 if (!bmp || !img)
502 goto fail;
503
504 if (winpr_image_read_buffer(img, bmp, SrcSize) <= 0)
505 goto fail;
506
507 result = winpr_image_write_buffer(img, bmpFormat, &dsize);
508 if (result)
509 {
510 if (dsize <= UINT32_MAX)
511 *pSize = (UINT32)dsize;
512 else
513 {
514 free(result);
515 result = NULL;
516 }
517 }
518
519fail:
520 free(bmp);
521 winpr_image_free(img, TRUE);
522 return result;
523}
524#endif
525
526#if defined(WINPR_UTILS_IMAGE_PNG)
527static void* clipboard_synthesize_image_bmp_to_png(wClipboard* clipboard, UINT32 formatId,
528 const void* data, UINT32* pSize)
529{
530 return clipboard_synthesize_image_bmp_to_format(clipboard, formatId, WINPR_IMAGE_PNG, data,
531 pSize);
532}
533#endif
534
535#if defined(WINPR_UTILS_IMAGE_PNG) || defined(WINPR_UTILS_IMAGE_WEBP) || \
536 defined(WINPR_UTILS_IMAGE_JPEG)
537static void* clipboard_synthesize_image_format_to_bmp(wClipboard* clipboard,
538 WINPR_ATTR_UNUSED UINT32 srcFormatId,
539 const void* data, UINT32* pSize)
540{
541 WINPR_ASSERT(clipboard);
542 WINPR_ASSERT(data);
543 WINPR_ASSERT(pSize);
544
545 BYTE* dst = NULL;
546 const UINT32 SrcSize = *pSize;
547 size_t size = 0;
548 wImage* image = winpr_image_new();
549 if (!image)
550 goto fail;
551
552 const int res = winpr_image_read_buffer(image, data, SrcSize);
553 if (res <= 0)
554 goto fail;
555
556 dst = winpr_image_write_buffer(image, WINPR_IMAGE_BITMAP, &size);
557 if ((size < sizeof(WINPR_BITMAP_FILE_HEADER)) || (size > UINT32_MAX))
558 {
559 free(dst);
560 dst = NULL;
561 goto fail;
562 }
563 *pSize = (UINT32)size;
564
565fail:
566 winpr_image_free(image, TRUE);
567
568 if (dst)
569 memmove(dst, &dst[sizeof(WINPR_BITMAP_FILE_HEADER)],
570 size - sizeof(WINPR_BITMAP_FILE_HEADER));
571 return dst;
572}
573#endif
574
575#if defined(WINPR_UTILS_IMAGE_PNG)
576static void* clipboard_synthesize_image_png_to_bmp(wClipboard* clipboard, UINT32 formatId,
577 const void* data, UINT32* pSize)
578{
579 return clipboard_synthesize_image_format_to_bmp(clipboard, formatId, data, pSize);
580}
581#endif
582
583#if defined(WINPR_UTILS_IMAGE_WEBP)
584static void* clipboard_synthesize_image_bmp_to_webp(wClipboard* clipboard, UINT32 formatId,
585 const void* data, UINT32* pSize)
586{
587 return clipboard_synthesize_image_bmp_to_format(clipboard, formatId, WINPR_IMAGE_WEBP, data,
588 pSize);
589}
590
591static void* clipboard_synthesize_image_webp_to_bmp(wClipboard* clipboard, UINT32 formatId,
592 const void* data, UINT32* pSize)
593{
594 return clipboard_synthesize_image_format_to_bmp(clipboard, formatId, data, pSize);
595}
596#endif
597
598#if defined(WINPR_UTILS_IMAGE_JPEG)
599static void* clipboard_synthesize_image_bmp_to_jpeg(wClipboard* clipboard, UINT32 formatId,
600 const void* data, UINT32* pSize)
601{
602 return clipboard_synthesize_image_bmp_to_format(clipboard, formatId, WINPR_IMAGE_JPEG, data,
603 pSize);
604}
605
606static void* clipboard_synthesize_image_jpeg_to_bmp(wClipboard* clipboard, UINT32 formatId,
607 const void* data, UINT32* pSize)
608{
609 return clipboard_synthesize_image_format_to_bmp(clipboard, formatId, data, pSize);
610}
611#endif
612
619static void* clipboard_synthesize_html_format(wClipboard* clipboard, UINT32 formatId,
620 const void* pData, UINT32* pSize)
621{
622 union
623 {
624 const void* cpv;
625 const char* cpc;
626 const BYTE* cpb;
627 WCHAR* pv;
628 } pSrcData;
629 char* pDstData = NULL;
630
631 pSrcData.cpv = NULL;
632
633 WINPR_ASSERT(clipboard);
634 WINPR_ASSERT(pSize);
635
636 if (formatId == ClipboardGetFormatId(clipboard, mime_html))
637 {
638 const size_t SrcSize = (size_t)*pSize;
639 const size_t DstSize = SrcSize + 200;
640 char* body = NULL;
641 char num[20] = { 0 };
642
643 /* Create a copy, we modify the input data */
644 pSrcData.pv = calloc(1, SrcSize + 1);
645 if (!pSrcData.pv)
646 goto fail;
647 memcpy(pSrcData.pv, pData, SrcSize);
648
649 if (SrcSize > 2)
650 {
651 if (SrcSize > INT_MAX)
652 goto fail;
653
654 /* Check the BOM (Byte Order Mark) */
655 if ((pSrcData.cpb[0] == 0xFE) && (pSrcData.cpb[1] == 0xFF))
656 ByteSwapUnicode(pSrcData.pv, (SrcSize / 2));
657
658 /* Check if we have WCHAR, convert to UTF-8 */
659 if ((pSrcData.cpb[0] == 0xFF) && (pSrcData.cpb[1] == 0xFE))
660 {
661 char* utfString =
662 ConvertWCharNToUtf8Alloc(&pSrcData.pv[1], SrcSize / sizeof(WCHAR), NULL);
663 free(pSrcData.pv);
664 pSrcData.cpc = utfString;
665 if (!utfString)
666 goto fail;
667 }
668 }
669
670 pDstData = (char*)calloc(1, DstSize);
671
672 if (!pDstData)
673 goto fail;
674
675 (void)sprintf_s(pDstData, DstSize,
676 "Version:0.9\r\n"
677 "StartHTML:0000000000\r\n"
678 "EndHTML:0000000000\r\n"
679 "StartFragment:0000000000\r\n"
680 "EndFragment:0000000000\r\n");
681 body = strstr(pSrcData.cpc, "<body");
682
683 if (!body)
684 body = strstr(pSrcData.cpc, "<BODY");
685
686 /* StartHTML */
687 (void)sprintf_s(num, sizeof(num), "%010" PRIuz "", strnlen(pDstData, DstSize));
688 CopyMemory(&pDstData[23], num, 10);
689
690 if (!body)
691 {
692 if (!winpr_str_append("<HTML><BODY>", pDstData, DstSize, NULL))
693 goto fail;
694 }
695
696 if (!winpr_str_append("<!--StartFragment-->", pDstData, DstSize, NULL))
697 goto fail;
698
699 /* StartFragment */
700 (void)sprintf_s(num, sizeof(num), "%010" PRIuz "", strnlen(pDstData, SrcSize + 200));
701 CopyMemory(&pDstData[69], num, 10);
702
703 if (!winpr_str_append(pSrcData.cpc, pDstData, DstSize, NULL))
704 goto fail;
705
706 /* EndFragment */
707 (void)sprintf_s(num, sizeof(num), "%010" PRIuz "", strnlen(pDstData, SrcSize + 200));
708 CopyMemory(&pDstData[93], num, 10);
709
710 if (!winpr_str_append("<!--EndFragment-->", pDstData, DstSize, NULL))
711 goto fail;
712
713 if (!body)
714 {
715 if (!winpr_str_append("</BODY></HTML>", pDstData, DstSize, NULL))
716 goto fail;
717 }
718
719 /* EndHTML */
720 (void)sprintf_s(num, sizeof(num), "%010" PRIuz "", strnlen(pDstData, DstSize));
721 CopyMemory(&pDstData[43], num, 10);
722 *pSize = (UINT32)strnlen(pDstData, DstSize) + 1;
723 }
724fail:
725 free(pSrcData.pv);
726 return pDstData;
727}
728
729static char* html_pre_write(wStream* s, const char* what)
730{
731 const size_t len = strlen(what);
732 Stream_Write(s, what, len);
733 char* startHTML = Stream_PointerAs(s, char);
734 for (size_t x = 0; x < 10; x++)
735 Stream_Write_INT8(s, '0');
736 Stream_Write(s, "\r\n", 2);
737 return startHTML;
738}
739
740static void html_fill_number(char* pos, size_t val)
741{
742 char str[11] = { 0 };
743 (void)_snprintf(str, sizeof(str), "%010" PRIuz, val);
744 memcpy(pos, str, 10);
745}
746
747static void* clipboard_wrap_html(const char* mime, const char* idata, size_t ilength,
748 uint32_t* plen)
749{
750 WINPR_ASSERT(mime);
751 WINPR_ASSERT(plen);
752
753 *plen = 0;
754
755 size_t b64len = 0;
756 char* b64 = b64_encode((const BYTE*)idata, ilength, &b64len);
757 if (!b64)
758 return NULL;
759
760 const size_t mimelen = strlen(mime);
761 wStream* s = Stream_New(NULL, b64len + 225 + mimelen);
762 if (!s)
763 {
764 free(b64);
765 return NULL;
766 }
767
768 char* startHTML = html_pre_write(s, "Version:0.9\r\nStartHTML:");
769 char* endHTML = html_pre_write(s, "EndHTML:");
770 char* startFragment = html_pre_write(s, "StartFragment:");
771 char* endFragment = html_pre_write(s, "EndFragment:");
772
773 html_fill_number(startHTML, Stream_GetPosition(s));
774 const char html[] = "<html><!--StartFragment-->";
775 Stream_Write(s, html, strnlen(html, sizeof(html)));
776
777 html_fill_number(startFragment, Stream_GetPosition(s));
778
779 const char body[] = "<body><img alt=\"FreeRDP clipboard image\" src=\"data:";
780 Stream_Write(s, body, strnlen(body, sizeof(body)));
781
782 Stream_Write(s, mime, mimelen);
783
784 const char base64[] = ";base64,";
785 Stream_Write(s, base64, strnlen(base64, sizeof(base64)));
786 Stream_Write(s, b64, b64len);
787
788 const char end[] = "\"/></body>";
789 Stream_Write(s, end, strnlen(end, sizeof(end)));
790
791 html_fill_number(endFragment, Stream_GetPosition(s));
792
793 const char fragend[] = "<!--EndFragment--></html>";
794 Stream_Write(s, fragend, strnlen(fragend, sizeof(fragend)));
795 html_fill_number(endHTML, Stream_GetPosition(s));
796
797 void* res = Stream_Buffer(s);
798 const size_t pos = Stream_GetPosition(s);
799 *plen = WINPR_ASSERTING_INT_CAST(uint32_t, pos);
800 Stream_Free(s, FALSE);
801 free(b64);
802 return res;
803}
804
805static void* clipboard_wrap_format_to_html(uint32_t bmpFormat, const char* idata, size_t ilength,
806 uint32_t* plen)
807{
808 void* res = NULL;
809 wImage* img = winpr_image_new();
810 if (!img)
811 goto fail;
812
813 if (winpr_image_read_buffer(img, (const BYTE*)idata, ilength) <= 0)
814 goto fail;
815
816 {
817 size_t bmpsize = 0;
818 void* bmp = winpr_image_write_buffer(img, bmpFormat, &bmpsize);
819 if (!bmp)
820 goto fail;
821
822 res = clipboard_wrap_html(winpr_image_format_mime(bmpFormat), bmp, bmpsize, plen);
823 free(bmp);
824 }
825fail:
826 winpr_image_free(img, TRUE);
827 return res;
828}
829
830static void* clipboard_wrap_bmp_to_html(const char* idata, size_t ilength, uint32_t* plen)
831{
832 const uint32_t formats[] = { WINPR_IMAGE_WEBP, WINPR_IMAGE_PNG, WINPR_IMAGE_JPEG };
833
834 for (size_t x = 0; x < ARRAYSIZE(formats); x++)
835 {
836 const uint32_t format = formats[x];
837 if (winpr_image_format_is_supported(format))
838 {
839 return clipboard_wrap_format_to_html(format, idata, ilength, plen);
840 }
841 }
842 const uint32_t bmpFormat = WINPR_IMAGE_BITMAP;
843 return clipboard_wrap_html(winpr_image_format_mime(bmpFormat), idata, ilength, plen);
844}
845
846static void* clipboard_synthesize_image_html(WINPR_ATTR_UNUSED wClipboard* clipboard,
847 UINT32 formatId, const void* data, UINT32* pSize)
848{
849 WINPR_ASSERT(pSize);
850
851 const size_t datalen = *pSize;
852
853 switch (formatId)
854 {
855 case CF_TIFF:
856 return clipboard_wrap_html(mime_tiff, data, datalen, pSize);
857 case CF_DIB:
858 case CF_DIBV5:
859 {
860 uint32_t bmplen = *pSize;
861 void* bmp = clipboard_synthesize_image_bmp(clipboard, formatId, data, &bmplen);
862 if (!bmp)
863 {
864 WLog_WARN(TAG, "failed to convert formatId 0x%08" PRIx32 " [%s]", formatId,
865 ClipboardGetFormatName(clipboard, formatId));
866 *pSize = 0;
867 return NULL;
868 }
869
870 void* res = clipboard_wrap_bmp_to_html(bmp, bmplen, pSize);
871 free(bmp);
872 return res;
873 }
874 default:
875 {
876 const uint32_t idWebp = ClipboardRegisterFormat(clipboard, mime_webp);
877 const uint32_t idPng = ClipboardRegisterFormat(clipboard, mime_png);
878 const uint32_t idJpeg = ClipboardRegisterFormat(clipboard, mime_jpeg);
879 const uint32_t idTiff = ClipboardRegisterFormat(clipboard, mime_tiff);
880 if (formatId == idWebp)
881 {
882 return clipboard_wrap_html(mime_webp, data, datalen, pSize);
883 }
884 else if (formatId == idPng)
885 {
886 return clipboard_wrap_html(mime_png, data, datalen, pSize);
887 }
888 else if (formatId == idJpeg)
889 {
890 return clipboard_wrap_html(mime_jpeg, data, datalen, pSize);
891 }
892 else if (formatId == idTiff)
893 {
894 return clipboard_wrap_html(mime_tiff, data, datalen, pSize);
895 }
896 else
897 {
898 for (size_t x = 0; x < ARRAYSIZE(mime_bitmap); x++)
899 {
900 const char* mime = mime_bitmap[x];
901 const uint32_t id = ClipboardRegisterFormat(clipboard, mime);
902
903 if (formatId == id)
904 return clipboard_wrap_bmp_to_html(data, datalen, pSize);
905 }
906 }
907
908 WLog_WARN(TAG, "Unsupported image format id 0x%08" PRIx32 " [%s]", formatId,
909 ClipboardGetFormatName(clipboard, formatId));
910 *pSize = 0;
911 return NULL;
912 }
913 }
914}
915
922static void* clipboard_synthesize_text_html(wClipboard* clipboard, UINT32 formatId,
923 const void* data, UINT32* pSize)
924{
925 char* pDstData = NULL;
926
927 if (formatId == ClipboardGetFormatId(clipboard, mime_ms_html))
928 {
929 const char* str = (const char*)data;
930 const size_t SrcSize = *pSize;
931 const char* begStr = strstr(str, "StartHTML:");
932 const char* endStr = strstr(str, "EndHTML:");
933
934 if (!begStr || !endStr)
935 return NULL;
936
937 errno = 0;
938 const long beg = strtol(&begStr[10], NULL, 10);
939
940 if (errno != 0)
941 return NULL;
942
943 const long end = strtol(&endStr[8], NULL, 10);
944
945 if ((beg < 0) || (end < 0) || ((size_t)beg > SrcSize) || ((size_t)end > SrcSize) ||
946 (beg >= end) || (errno != 0))
947 return NULL;
948
949 const size_t DstSize = (size_t)(end - beg);
950 pDstData = calloc(DstSize + 1, sizeof(char));
951
952 if (!pDstData)
953 return NULL;
954
955 CopyMemory(pDstData, &str[beg], DstSize);
956 const size_t rc = ConvertLineEndingToLF(pDstData, DstSize);
957 WINPR_ASSERT(rc <= UINT32_MAX);
958 *pSize = (UINT32)rc;
959 }
960
961 return pDstData;
962}
963
964BOOL ClipboardInitSynthesizers(wClipboard* clipboard)
965{
969 {
970 ClipboardRegisterSynthesizer(clipboard, CF_TEXT, CF_OEMTEXT,
971 clipboard_synthesize_cf_oemtext);
972 ClipboardRegisterSynthesizer(clipboard, CF_TEXT, CF_UNICODETEXT,
973 clipboard_synthesize_cf_unicodetext);
974 ClipboardRegisterSynthesizer(clipboard, CF_TEXT, CF_LOCALE, clipboard_synthesize_cf_locale);
975
976 UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime_text_plain);
977 ClipboardRegisterSynthesizer(clipboard, CF_TEXT, altFormatId,
978 clipboard_synthesize_utf8_string);
979 }
983 {
984 ClipboardRegisterSynthesizer(clipboard, CF_OEMTEXT, CF_TEXT, clipboard_synthesize_cf_text);
985 ClipboardRegisterSynthesizer(clipboard, CF_OEMTEXT, CF_UNICODETEXT,
986 clipboard_synthesize_cf_unicodetext);
987 ClipboardRegisterSynthesizer(clipboard, CF_OEMTEXT, CF_LOCALE,
988 clipboard_synthesize_cf_locale);
989 UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime_text_plain);
990 ClipboardRegisterSynthesizer(clipboard, CF_OEMTEXT, altFormatId,
991 clipboard_synthesize_utf8_string);
992 }
996 {
997 ClipboardRegisterSynthesizer(clipboard, CF_UNICODETEXT, CF_TEXT,
998 clipboard_synthesize_cf_text);
999 ClipboardRegisterSynthesizer(clipboard, CF_UNICODETEXT, CF_OEMTEXT,
1000 clipboard_synthesize_cf_oemtext);
1001 ClipboardRegisterSynthesizer(clipboard, CF_UNICODETEXT, CF_LOCALE,
1002 clipboard_synthesize_cf_locale);
1003 UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime_text_plain);
1004 ClipboardRegisterSynthesizer(clipboard, CF_UNICODETEXT, altFormatId,
1005 clipboard_synthesize_utf8_string);
1006 }
1010 {
1011 UINT32 formatId = ClipboardRegisterFormat(clipboard, mime_text_plain);
1012
1013 if (formatId)
1014 {
1015 ClipboardRegisterSynthesizer(clipboard, formatId, CF_TEXT,
1016 clipboard_synthesize_cf_text);
1017 ClipboardRegisterSynthesizer(clipboard, formatId, CF_OEMTEXT,
1018 clipboard_synthesize_cf_oemtext);
1019 ClipboardRegisterSynthesizer(clipboard, formatId, CF_UNICODETEXT,
1020 clipboard_synthesize_cf_unicodetext);
1021 ClipboardRegisterSynthesizer(clipboard, formatId, CF_LOCALE,
1022 clipboard_synthesize_cf_locale);
1023 }
1024 }
1028 {
1029 UINT32 formatId = ClipboardRegisterFormat(clipboard, mime_text_plain);
1030
1031 if (formatId)
1032 {
1033 ClipboardRegisterSynthesizer(clipboard, formatId, CF_TEXT,
1034 clipboard_synthesize_cf_text);
1035 ClipboardRegisterSynthesizer(clipboard, formatId, CF_OEMTEXT,
1036 clipboard_synthesize_cf_oemtext);
1037 ClipboardRegisterSynthesizer(clipboard, formatId, CF_UNICODETEXT,
1038 clipboard_synthesize_cf_unicodetext);
1039 ClipboardRegisterSynthesizer(clipboard, formatId, CF_LOCALE,
1040 clipboard_synthesize_cf_locale);
1041 }
1042 }
1043
1044 const uint32_t htmlFormat = ClipboardRegisterFormat(clipboard, mime_ms_html);
1045 const uint32_t tiffFormat = ClipboardRegisterFormat(clipboard, mime_tiff);
1046
1050 ClipboardRegisterSynthesizer(clipboard, CF_TIFF, htmlFormat, clipboard_synthesize_image_html);
1051 ClipboardRegisterSynthesizer(clipboard, tiffFormat, htmlFormat,
1052 clipboard_synthesize_image_html);
1053
1057 {
1058#if defined(WINPR_UTILS_IMAGE_DIBv5)
1059 ClipboardRegisterSynthesizer(clipboard, CF_DIB, CF_DIBV5, clipboard_synthesize_cf_dibv5);
1060#endif
1061 for (size_t x = 0; x < ARRAYSIZE(mime_bitmap); x++)
1062 {
1063 const char* mime = mime_bitmap[x];
1064 const UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime);
1065 if (altFormatId == 0)
1066 continue;
1067 ClipboardRegisterSynthesizer(clipboard, CF_DIB, altFormatId,
1068 clipboard_synthesize_image_bmp);
1069 }
1070 ClipboardRegisterSynthesizer(clipboard, CF_DIB, htmlFormat,
1071 clipboard_synthesize_image_html);
1072 }
1073
1077#if defined(WINPR_UTILS_IMAGE_DIBv5)
1078 {
1079 ClipboardRegisterSynthesizer(clipboard, CF_DIBV5, CF_DIB, clipboard_synthesize_cf_dib);
1080
1081 for (size_t x = 0; x < ARRAYSIZE(mime_bitmap); x++)
1082 {
1083 const char* mime = mime_bitmap[x];
1084 const UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime);
1085 if (altFormatId == 0)
1086 continue;
1087 ClipboardRegisterSynthesizer(clipboard, CF_DIBV5, altFormatId,
1088 clipboard_synthesize_image_bmp);
1089 }
1090 ClipboardRegisterSynthesizer(clipboard, CF_DIBV5, htmlFormat,
1091 clipboard_synthesize_image_html);
1092 }
1093#endif
1094
1098 for (size_t x = 0; x < ARRAYSIZE(mime_bitmap); x++)
1099 {
1100 const char* mime = mime_bitmap[x];
1101 const UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime);
1102 if (altFormatId == 0)
1103 continue;
1104 ClipboardRegisterSynthesizer(clipboard, altFormatId, CF_DIB, clipboard_synthesize_cf_dib);
1105#if defined(WINPR_UTILS_IMAGE_DIBv5)
1106 ClipboardRegisterSynthesizer(clipboard, altFormatId, CF_DIBV5,
1107 clipboard_synthesize_cf_dibv5);
1108#endif
1109 ClipboardRegisterSynthesizer(clipboard, altFormatId, htmlFormat,
1110 clipboard_synthesize_image_html);
1111 }
1112
1116#if defined(WINPR_UTILS_IMAGE_PNG)
1117 {
1118 const UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime_png);
1119 ClipboardRegisterSynthesizer(clipboard, CF_DIB, altFormatId,
1120 clipboard_synthesize_image_bmp_to_png);
1121 ClipboardRegisterSynthesizer(clipboard, altFormatId, CF_DIB,
1122 clipboard_synthesize_image_png_to_bmp);
1123 ClipboardRegisterSynthesizer(clipboard, altFormatId, htmlFormat,
1124 clipboard_synthesize_image_html);
1125#if defined(WINPR_UTILS_IMAGE_DIBv5)
1126 ClipboardRegisterSynthesizer(clipboard, CF_DIBV5, altFormatId,
1127 clipboard_synthesize_image_bmp_to_png);
1128 ClipboardRegisterSynthesizer(clipboard, altFormatId, CF_DIBV5,
1129 clipboard_synthesize_image_png_to_bmp);
1130#endif
1131 }
1132#endif
1133
1137#if defined(WINPR_UTILS_IMAGE_WEBP)
1138 {
1139 const UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime_webp);
1140 ClipboardRegisterSynthesizer(clipboard, CF_DIB, altFormatId,
1141 clipboard_synthesize_image_bmp_to_webp);
1142 ClipboardRegisterSynthesizer(clipboard, altFormatId, CF_DIB,
1143 clipboard_synthesize_image_webp_to_bmp);
1144 ClipboardRegisterSynthesizer(clipboard, altFormatId, htmlFormat,
1145 clipboard_synthesize_image_html);
1146#if defined(WINPR_UTILS_IMAGE_DIBv5)
1147 ClipboardRegisterSynthesizer(clipboard, CF_DIBV5, altFormatId,
1148 clipboard_synthesize_image_bmp_to_webp);
1149 ClipboardRegisterSynthesizer(clipboard, altFormatId, CF_DIBV5,
1150 clipboard_synthesize_image_webp_to_bmp);
1151#endif
1152 }
1153#endif
1154
1158#if defined(WINPR_UTILS_IMAGE_JPEG)
1159 {
1160 const UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime_jpeg);
1161 ClipboardRegisterSynthesizer(clipboard, CF_DIB, altFormatId,
1162 clipboard_synthesize_image_bmp_to_jpeg);
1163 ClipboardRegisterSynthesizer(clipboard, altFormatId, CF_DIB,
1164 clipboard_synthesize_image_jpeg_to_bmp);
1165 ClipboardRegisterSynthesizer(clipboard, altFormatId, htmlFormat,
1166 clipboard_synthesize_image_html);
1167#if defined(WINPR_UTILS_IMAGE_DIBv5)
1168 ClipboardRegisterSynthesizer(clipboard, altFormatId, CF_DIBV5,
1169 clipboard_synthesize_image_jpeg_to_bmp);
1170 ClipboardRegisterSynthesizer(clipboard, CF_DIBV5, altFormatId,
1171 clipboard_synthesize_image_bmp_to_jpeg);
1172#endif
1173 }
1174#endif
1175
1179 {
1180 UINT32 formatId = ClipboardRegisterFormat(clipboard, mime_ms_html);
1181
1182 if (formatId)
1183 {
1184 const UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime_html);
1185 ClipboardRegisterSynthesizer(clipboard, formatId, altFormatId,
1186 clipboard_synthesize_text_html);
1187 }
1188 }
1189
1193 {
1194 UINT32 formatId = ClipboardRegisterFormat(clipboard, mime_html);
1195
1196 if (formatId)
1197 {
1198 const UINT32 altFormatId = ClipboardRegisterFormat(clipboard, mime_ms_html);
1199 ClipboardRegisterSynthesizer(clipboard, formatId, altFormatId,
1200 clipboard_synthesize_html_format);
1201 }
1202 }
1203
1204 return TRUE;
1205}
WINPR_BITMAP_FILE_HEADER
Definition include/winpr/image.h:29
WINPR_BITMAP_INFO_HEADER
Definition include/winpr/image.h:38