30#include <winpr/wlog.h>
31#include <winpr/image.h>
34#include "sdl_clip.hpp"
35#include "sdl_context.hpp"
37#if defined(__EMSCRIPTEN__)
42static std::mutex s_web_lock;
43static sdlClip* s_web_clip =
nullptr;
44#include <emscripten.h>
45#include <emscripten/proxying.h>
46#include <emscripten/threading.h>
47#include <winpr/string.h>
51#define TAG CLIENT_TAG("sdl.cliprdr")
53#define mime_text_plain "text/plain"
54const char mime_text_utf8[] =
"text/plain;charset=utf-8";
56static const char* first_announcement[] = {
57 "sdl-clipboard-monitor-ready-4b8c7d9b-6d5c-4dcc-add1-21573ca564b0"
60[[nodiscard]]
static const std::vector<const char*>& s_mime_text()
62 static std::vector<const char*> values;
65 values = std::vector<const char*>(
66 { mime_text_utf8,
"UTF8_STRING", mime_text_plain,
"COMPOUND_TEXT",
"TEXT",
"STRING" });
71static const char s_mime_jxl[] =
"image/jxl";
72static const char s_mime_avif[] =
"image/avif";
73static const char s_mime_png[] =
"image/png";
74static const char s_mime_webp[] =
"image/webp";
75static const char s_mime_jpg[] =
"image/jpeg";
77static const char s_mime_tiff[] =
"image/tiff";
78static const char s_mime_uri_list[] =
"text/uri-list";
80static const char s_type_file_url[] =
"public.file-url";
81static const char s_mime_html[] =
"text/html";
83#define BMP_MIME_LIST "image/bmp", "image/x-bmp", "image/x-MS-bmp", "image/x-win-bitmap"
85[[nodiscard]]
static const std::vector<const char*>& s_mime_bitmap()
87 static std::vector<const char*> values;
90 values = std::vector<const char*>({ BMP_MIME_LIST });
95[[nodiscard]]
static const std::vector<const char*>& s_mime_image()
97 static std::vector<const char*> values;
100 if (winpr_image_format_is_supported(WINPR_IMAGE_WEBP))
101 values.push_back(s_mime_webp);
103 if (winpr_image_format_is_supported(WINPR_IMAGE_PNG))
104 values.push_back(s_mime_png);
106 if (winpr_image_format_is_supported(WINPR_IMAGE_JPEG))
107 values.push_back(s_mime_jpg);
109 auto bmp = std::vector<const char*>({ BMP_MIME_LIST });
110 values.insert(values.end(), bmp.begin(), bmp.end());
117[[nodiscard]]
static const std::vector<const char*>& s_mime_dib_sources()
119 static const std::vector<const char*> values = []()
121 std::vector<const char*> v({ BMP_MIME_LIST });
122 if (winpr_image_format_is_supported(WINPR_IMAGE_PNG))
123 v.push_back(s_mime_png);
124 if (winpr_image_format_is_supported(WINPR_IMAGE_WEBP))
125 v.push_back(s_mime_webp);
126 if (winpr_image_format_is_supported(WINPR_IMAGE_JPEG))
127 v.push_back(s_mime_jpg);
134[[nodiscard]]
static const std::vector<const char*>& s_mime_html_image_sources()
136 static const std::vector<const char*> values({ s_mime_jpg, s_mime_png, s_mime_webp, s_mime_avif,
137 s_mime_jxl, s_mime_tiff, BMP_MIME_LIST });
144[[nodiscard]]
static std::vector<std::string> localMimeTypes()
146 std::vector<std::string> list;
148 auto mimes = SDL_GetClipboardMimeTypes(&count);
149 for (
size_t x = 0; mimes && (x < count); x++)
152 list.emplace_back(mimes[x]);
154 SDL_free(
static_cast<void*
>(mimes));
158[[nodiscard]]
static bool hasMime(
const std::vector<std::string>& list,
const char* mime)
160 return std::find(list.begin(), list.end(), mime) != list.end();
163[[nodiscard]]
static const char* firstOffered(
const std::vector<std::string>& offered,
164 const std::vector<const char*>& candidates)
166 for (
const auto& m : candidates)
168 if (hasMime(offered, m))
177[[nodiscard]]
static uint32_t textLength(
const void* data, uint32_t size)
179 const auto end = memchr(data,
'\0', size);
182 return WINPR_ASSERTING_INT_CAST(uint32_t,
183 static_cast<const char*
>(end) -
static_cast<const char*
>(data));
186static const char s_mime_gnome_copied_files[] =
"x-special/gnome-copied-files";
187static const char s_mime_mate_copied_files[] =
"x-special/mate-copied-files";
189static const char s_mime_freerdp_update[] =
"x-special/freerdp-clipboard-update";
191static const char* s_type_HtmlFormat =
"HTML Format";
192static const char* s_type_FileGroupDescriptorW =
"FileGroupDescriptorW";
194class ClipboardLockGuard
197 explicit ClipboardLockGuard(wClipboard* clipboard) : _clipboard(clipboard)
199 ClipboardLock(_clipboard);
201 ClipboardLockGuard(
const ClipboardLockGuard& other) =
delete;
202 ClipboardLockGuard(ClipboardLockGuard&& other) =
delete;
204 ClipboardLockGuard& operator=(
const ClipboardLockGuard& rhs) =
delete;
205 ClipboardLockGuard& operator=(ClipboardLockGuard&& rhs) =
delete;
207 ~ClipboardLockGuard()
209 ClipboardUnlock(_clipboard);
213 wClipboard* _clipboard;
218 return (lhs.formatId < rhs.formatId);
223 return (lhs.formatId == rhs.formatId);
227 : _sdl(
sdl), _file(cliprdr_file_context_new(this)), _log(WLog_Get(TAG)),
228 _system(ClipboardCreate()), _event(CreateEventA(nullptr, TRUE, FALSE, nullptr)),
229 _uuid(
sdl::utils::generate_uuid_v4())
233 std::stringstream ss;
234 ss << s_mime_freerdp_update <<
"-" << _uuid;
235 _mime_uuid = ss.str();
237 std::ignore = cliprdr_file_context_set_locally_available(_file, TRUE);
242#if defined(__EMSCRIPTEN__)
244 std::scoped_lock web(s_web_lock);
245 if (s_web_clip ==
this)
246 s_web_clip =
nullptr;
249 cliprdr_file_context_free(_file);
250 ClipboardDestroy(_system);
251 std::ignore = CloseHandle(_event);
254bool sdlClip::init(CliprdrClientContext* clip)
257 ClipboardLockGuard systemlock(_system);
258 std::scoped_lock lock(_lock);
261 _ctx->MonitorReady = sdlClip::MonitorReady;
262 _ctx->ServerCapabilities = sdlClip::ReceiveServerCapabilities;
263 _ctx->ServerFormatList = sdlClip::ReceiveServerFormatList;
264 _ctx->ServerFormatListResponse = sdlClip::ReceiveFormatListResponse;
265 _ctx->ServerFormatDataRequest = sdlClip::ReceiveFormatDataRequest;
266 _ctx->ServerFormatDataResponse = sdlClip::ReceiveFormatDataResponse;
267#if defined(__EMSCRIPTEN__)
269 std::scoped_lock web(s_web_lock);
274 return cliprdr_file_context_init(_file, _ctx);
277bool sdlClip::uninit(CliprdrClientContext* clip)
280#if defined(__EMSCRIPTEN__)
282 std::scoped_lock web(s_web_lock);
283 if (s_web_clip ==
this)
284 s_web_clip =
nullptr;
287 ClipboardLockGuard systemlock(_system);
288 std::scoped_lock lock(_lock);
289 if (!cliprdr_file_context_uninit(_file, _ctx))
292 clip->custom =
nullptr;
293 _server_requests.clear();
297bool sdlClip::contains(
const char** mime_types, Sint32 count)
299 for (Sint32 x = 0; x < count; x++)
301 const auto mime = mime_types[x];
302 if (mime && (strcmp(_mime_uuid.c_str(), mime) == 0))
308bool sdlClip::ownsClipboard()
const
310 return hasMime(localMimeTypes(), _mime_uuid.c_str());
313bool sdlClip::handleEvent(
const SDL_ClipboardEvent& ev)
315 std::unique_ptr<
char*,
decltype(&SDL_free)> current(
nullptr, SDL_free);
316 const char** mime_types = ev.mime_types;
317 size_t nformats = WINPR_ASSERTING_INT_CAST(
size_t, ev.num_mime_types);
318 bool connected =
false;
320 std::scoped_lock lock(_lock);
321 connected = (_ctx !=
nullptr);
323 if (connected && _ctx && _sync && ev.owner && (ev.num_mime_types == 1))
325 if (strcmp(first_announcement[0], ev.mime_types[0]) == 0)
327 current.reset(SDL_GetClipboardMimeTypes(&nformats));
328 mime_types =
const_cast<const char**
>(current.get());
333 else if (!connected || !_ctx || !_sync || ev.owner)
335 _last_timestamp = ev.timestamp;
339 std::vector<std::string> mimes;
341 ClipboardLockGuard systemlock(_system);
342 std::scoped_lock lock(_lock);
343 mimes.swap(_current_mimetypes);
350 std::vector<const char*> cmimes;
351 cmimes.reserve(mimes.size());
352 for (
const auto& m : mimes)
353 cmimes.push_back(m.c_str());
357 if (cliprdr_file_context_set_local_clipboard_data(_file, sdlClip::ClipDataCb,
this,
358 cmimes.data(), cmimes.size()))
362 return SDL_SetClipboardData(sdlClip::ClipDataCb, sdlClip::ClipCleanCb,
this, cmimes.data(),
366 if (ev.timestamp == _last_timestamp)
369 if (contains(mime_types, WINPR_ASSERTING_INT_CAST(Sint32, nformats)))
379 WLog_Print(_log, WLOG_DEBUG,
"ignoring stale local clipboard update");
384 ClipboardLockGuard systemlock(_system);
385 std::scoped_lock lock(_lock);
386 clearServerFormats();
389 const std::string mime_html = s_mime_html;
391 const std::vector<std::string> mime_bitmap = { BMP_MIME_LIST };
392 const std::string mime_webp = s_mime_webp;
393 const std::string mime_png = s_mime_png;
394 const std::string mime_jpeg = s_mime_jpg;
395 const std::string mime_tiff = s_mime_tiff;
396 const std::vector<std::string> mime_images = { mime_webp, mime_png, mime_jpeg,
397 mime_tiff, s_mime_avif, s_mime_jxl };
399 std::vector<std::string> clientFormatNames;
400 std::vector<CLIPRDR_FORMAT> clientFormats;
402 const char** clipboard_mime_formats = mime_types;
404 WLog_Print(_log, WLOG_TRACE,
"SDL has %" PRIuz
" formats", nformats);
406 bool textPushed =
false;
407 bool imgPushed =
false;
408 bool filePushed =
false;
410 for (
size_t i = 0; i < nformats; i++)
412 std::string local_mime = clipboard_mime_formats[i];
413 WLog_Print(_log, WLOG_TRACE,
" - %s", local_mime.c_str());
415 if (std::find(s_mime_text().begin(), s_mime_text().end(), local_mime) !=
421 clientFormats.push_back({ CF_TEXT,
nullptr });
422 clientFormats.push_back({ CF_OEMTEXT,
nullptr });
423 clientFormats.push_back({ CF_UNICODETEXT,
nullptr });
427 else if (local_mime == mime_html)
429 clientFormatNames.emplace_back(s_type_HtmlFormat);
430 else if ((std::find(mime_bitmap.begin(), mime_bitmap.end(), local_mime) !=
431 mime_bitmap.end()) ||
432 (std::find(mime_images.begin(), mime_images.end(), local_mime) !=
438 clientFormats.push_back({ CF_DIB,
nullptr });
439#if defined(WINPR_UTILS_IMAGE_DIBv5)
440 clientFormats.push_back({ CF_DIBV5,
nullptr });
443 if (winpr_image_format_is_supported(WINPR_IMAGE_BITMAP))
445 for (
auto& bmp : mime_bitmap)
446 clientFormatNames.emplace_back(bmp);
449 if (winpr_image_format_is_supported(WINPR_IMAGE_JPEG))
450 clientFormatNames.emplace_back(mime_jpeg);
451 if (winpr_image_format_is_supported(WINPR_IMAGE_WEBP))
452 clientFormatNames.emplace_back(mime_webp);
453 if (winpr_image_format_is_supported(WINPR_IMAGE_PNG))
454 clientFormatNames.emplace_back(mime_png);
456 clientFormatNames.emplace_back(s_type_HtmlFormat);
459 clientFormatNames.emplace_back(local_mime);
461 else if (mime_is_file(local_mime) || (local_mime == s_type_file_url))
465 clientFormatNames.emplace_back(s_type_FileGroupDescriptorW);
471 std::sort(clientFormatNames.begin(), clientFormatNames.end());
472 clientFormatNames.erase(std::unique(clientFormatNames.begin(), clientFormatNames.end()),
473 clientFormatNames.end());
475 for (
auto& name : clientFormatNames)
477 clientFormats.push_back({ ClipboardRegisterFormat(_system, name.c_str()), name.data() });
480 std::sort(clientFormats.begin(), clientFormats.end(),
481 [](
const auto& a,
const auto& b) { return a < b; });
482 auto u = std::unique(clientFormats.begin(), clientFormats.end());
483 clientFormats.erase(u, clientFormats.end());
485 const CLIPRDR_FORMAT_LIST formatList = {
486 { CB_FORMAT_LIST, 0, 0 },
487 static_cast<UINT32
>(clientFormats.size()),
488 clientFormats.data(),
491 WLog_Print(_log, WLOG_TRACE,
492 "-------------- client format list [%" PRIu32
"] ------------------",
493 formatList.numFormats);
494 for (UINT32 x = 0; x < formatList.numFormats; x++)
496 auto format = &formatList.formats[x];
497 WLog_Print(_log, WLOG_TRACE,
"client announces %" PRIu32
" [%s][%s]", format->formatId,
498 ClipboardGetFormatIdString(format->formatId), format->formatName);
502 ClipboardLockGuard systemlock(_system);
503 std::scoped_lock lock(_lock);
507 if (cliprdr_file_context_notify_new_client_format_list(_file) != CHANNEL_RC_OK)
511 WINPR_ASSERT(_ctx->ClientFormatList);
512 return _ctx->ClientFormatList(_ctx, &formatList) == CHANNEL_RC_OK;
517 WINPR_UNUSED(monitorReady);
518 WINPR_ASSERT(context);
519 WINPR_ASSERT(monitorReady);
521 auto clipboard =
static_cast<sdlClip*
>(
522 cliprdr_file_context_get_context(
static_cast<CliprdrFileContext*
>(context->custom)));
523 WINPR_ASSERT(clipboard);
525 auto ret = clipboard->SendClientCapabilities();
526 if (ret != CHANNEL_RC_OK)
529 clipboard->_sync =
true;
531 ev.clipboard.type = SDL_EVENT_CLIPBOARD_UPDATE;
532 ev.clipboard.owner =
true;
533 ev.clipboard.timestamp = SDL_GetTicksNS();
534 ev.clipboard.num_mime_types = ARRAYSIZE(first_announcement);
535 ev.clipboard.mime_types = first_announcement;
537 auto rc = SDL_PushEvent(&ev);
539 return ERROR_INTERNAL_ERROR;
541 return CHANNEL_RC_OK;
544UINT sdlClip::SendClientCapabilities()
546 CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet = {
547 CB_CAPSTYPE_GENERAL, 12, CB_CAPS_VERSION_2,
548 CB_USE_LONG_FORMAT_NAMES | cliprdr_file_context_current_flags(_file)
550 const CLIPRDR_CAPABILITIES capabilities = {
551 { CB_TYPE_NONE, 0, 0 }, 1,
reinterpret_cast<CLIPRDR_CAPABILITY_SET*
>(&generalCapabilitySet)
555 WINPR_ASSERT(_ctx->ClientCapabilities);
556 return _ctx->ClientCapabilities(_ctx, &capabilities);
559void sdlClip::clearServerFormats()
562 ClipboardLockGuard systemlock(_system);
563 std::scoped_lock lock(_lock);
564 _serverFormats.clear();
568 ClipboardEmpty(_system);
570 cliprdr_file_context_clear(_file);
573UINT sdlClip::SendFormatListResponse(BOOL status)
575 const CLIPRDR_FORMAT_LIST_RESPONSE formatListResponse = {
576 { CB_FORMAT_LIST_RESPONSE,
static_cast<UINT16
>(status ? CB_RESPONSE_OK : CB_RESPONSE_FAIL),
580 WINPR_ASSERT(_ctx->ClientFormatListResponse);
581 return _ctx->ClientFormatListResponse(_ctx, &formatListResponse);
584UINT sdlClip::SendDataResponse(
const BYTE* data,
size_t size)
586 CLIPRDR_FORMAT_DATA_RESPONSE response = {};
588 if (size > UINT32_MAX)
589 return ERROR_INVALID_PARAMETER;
591 response.common.msgFlags = (data) ? CB_RESPONSE_OK : CB_RESPONSE_FAIL;
592 response.common.dataLen =
static_cast<UINT32
>(size);
593 response.requestedFormatData = data;
596 WINPR_ASSERT(_ctx->ClientFormatDataResponse);
597 return _ctx->ClientFormatDataResponse(_ctx, &response);
600UINT sdlClip::SendDataRequest(uint32_t formatID,
const std::string& mime)
602 const CLIPRDR_FORMAT_DATA_REQUEST request = { { CB_TYPE_NONE, 0, 0 }, formatID };
604 _request_queue.emplace(formatID, mime);
607 WINPR_ASSERT(_ctx->ClientFormatDataRequest);
608 UINT ret = _ctx->ClientFormatDataRequest(_ctx, &request);
609 if (ret != CHANNEL_RC_OK)
611 WLog_Print(_log, WLOG_ERROR,
"error sending ClientFormatDataRequest, cancelling request");
612 _request_queue.pop();
618std::string sdlClip::getServerFormat(uint32_t
id)
620 for (
auto& fmt : _serverFormats)
622 if (fmt.formatId() ==
id)
624 if (fmt.formatName())
625 return fmt.formatName();
633uint32_t sdlClip::serverIdForMime(
const std::string& mime)
635 std::string cmp = mime;
636 if (mime_is_html(mime))
637 cmp = s_type_HtmlFormat;
638 if (mime_is_file(mime))
639 cmp = s_type_FileGroupDescriptorW;
641 for (
auto& format : _serverFormats)
643 if (!format.formatName())
645 if (cmp == format.formatName())
646 return format.formatId();
649 if (mime_is_image(mime) || mime_is_bmp(mime))
654 for (
auto& format : _serverFormats)
656 if ((format.formatId() == CF_DIB) || (format.formatId() == CF_DIBV5))
657 return format.formatId();
658 if (!named && format.formatName() &&
659 (mime_is_image(format.formatName()) || mime_is_bmp(format.formatName())))
660 named = format.formatId();
662 return named ? named : CF_DIB;
664 if (mime_is_text(mime))
665 return CF_UNICODETEXT;
670UINT sdlClip::ReceiveServerCapabilities(CliprdrClientContext* context,
673 WINPR_ASSERT(context);
674 WINPR_ASSERT(capabilities);
676 auto capsPtr =
reinterpret_cast<const BYTE*
>(capabilities->capabilitySets);
677 WINPR_ASSERT(capsPtr);
679 auto clipboard =
static_cast<sdlClip*
>(
680 cliprdr_file_context_get_context(
static_cast<CliprdrFileContext*
>(context->custom)));
681 WINPR_ASSERT(clipboard);
683 if (!cliprdr_file_context_remote_set_flags(clipboard->_file, 0))
684 return ERROR_INTERNAL_ERROR;
686 for (UINT32 i = 0; i < capabilities->cCapabilitiesSets; i++)
688 auto caps =
reinterpret_cast<const CLIPRDR_CAPABILITY_SET*
>(capsPtr);
690 if (caps->capabilitySetType == CB_CAPSTYPE_GENERAL)
692 auto generalCaps =
reinterpret_cast<const CLIPRDR_GENERAL_CAPABILITY_SET*
>(caps);
694 if (!cliprdr_file_context_remote_set_flags(clipboard->_file, generalCaps->generalFlags))
695 return ERROR_INTERNAL_ERROR;
698 capsPtr += caps->capabilitySetLength;
701 return CHANNEL_RC_OK;
704UINT sdlClip::ReceiveServerFormatList(CliprdrClientContext* context,
712 if (!context || !context->custom)
713 return ERROR_INVALID_PARAMETER;
715 auto filecontext =
static_cast<CliprdrFileContext*
>(context->custom);
716 auto clipboard =
static_cast<sdlClip*
>(cliprdr_file_context_get_context(filecontext));
717 WINPR_ASSERT(clipboard);
719 ClipboardLockGuard systemlock(clipboard->_system);
720 std::scoped_lock lock(clipboard->_lock);
722 clipboard->clearServerFormats();
726 ClipboardEmpty(clipboard->_system);
728 for (UINT32 i = 0; i < formatList->numFormats; i++)
730 const CLIPRDR_FORMAT* format = &formatList->formats[i];
732 clipboard->_serverFormats.emplace_back(format->formatId, format->formatName);
734 if (format->formatName)
736 if (strcmp(format->formatName, s_type_HtmlFormat) == 0)
741 else if (strcmp(format->formatName, s_type_FileGroupDescriptorW) == 0)
746 else if (mime_is_image(format->formatName) || mime_is_bmp(format->formatName))
754 switch (format->formatId)
772 clipboard->_current_mimetypes.clear();
775 auto res = cliprdr_file_context_notify_new_server_format_list(filecontext);
776 if (res != CHANNEL_RC_OK)
782 clipboard->_current_mimetypes.insert(clipboard->_current_mimetypes.end(),
783 s_mime_text().begin(), s_mime_text().end());
787 clipboard->_current_mimetypes.insert(clipboard->_current_mimetypes.end(),
788 s_mime_bitmap().begin(), s_mime_bitmap().end());
789 clipboard->_current_mimetypes.insert(clipboard->_current_mimetypes.end(),
790 s_mime_image().begin(), s_mime_image().end());
794 clipboard->_current_mimetypes.emplace_back(s_mime_html);
798 clipboard->_current_mimetypes.emplace_back(s_mime_uri_list);
799 clipboard->_current_mimetypes.emplace_back(s_mime_gnome_copied_files);
800 clipboard->_current_mimetypes.emplace_back(s_mime_mate_copied_files);
802 clipboard->_current_mimetypes.emplace_back(clipboard->_mime_uuid.c_str());
804 auto& mime = clipboard->_current_mimetypes;
805 std::sort(mime.begin(), mime.end());
806 mime.erase(std::unique(mime.begin(), mime.end()), mime.end());
808 WLog_Print(clipboard->_log, WLOG_TRACE,
809 "-------------- server mime types [%" PRIuz
"] ------------------", mime.size());
810 for (
const auto& m : mime)
812 WLog_Print(clipboard->_log, WLOG_TRACE,
"server announces %s]", m.c_str());
818 ev.clipboard.type = SDL_EVENT_CLIPBOARD_UPDATE;
819 ev.clipboard.owner =
true;
820 ev.clipboard.timestamp = SDL_GetTicksNS();
821 ev.clipboard.num_mime_types = 0;
822 ev.clipboard.mime_types =
nullptr;
824 auto rc = (SDL_PushEvent(&ev) == 1);
825 const UINT ret = clipboard->SendFormatListResponse(rc);
826#if defined(__EMSCRIPTEN__)
827 clipboard->_web_offers.serverAnnounced();
828 if (ret == CHANNEL_RC_OK)
829 std::ignore = clipboard->webRequestServerText();
834UINT sdlClip::ReceiveFormatListResponse(WINPR_ATTR_UNUSED CliprdrClientContext* context,
837 WINPR_ASSERT(context);
838 WINPR_ASSERT(formatListResponse);
840 if (formatListResponse->common.msgFlags & CB_RESPONSE_FAIL)
841 WLog_WARN(
TAG,
"format list update failed");
842 return CHANNEL_RC_OK;
845std::shared_ptr<BYTE> sdlClip::getLocalData(uint32_t formatId, uint32_t& len)
849 const auto offered = localMimeTypes();
854 if (hasMime(offered, _mime_uuid.c_str()))
856 WLog_Print(_log, WLOG_DEBUG,
"local clipboard holds server data, not answering request");
860 UINT32 fileFormatId = 0;
861 UINT32 htmlFormatId = 0;
863 ClipboardLockGuard systemlock(_system);
864 std::scoped_lock lock(_lock);
865 WLog_Print(_log, WLOG_DEBUG,
"Requesting format %s [0x%08" PRIx32
"] [%s]",
866 ClipboardGetFormatIdString(formatId), formatId,
867 ClipboardGetFormatName(_system, formatId));
868 fileFormatId = ClipboardGetFormatId(_system, s_type_FileGroupDescriptorW);
869 htmlFormatId = ClipboardGetFormatId(_system, s_type_HtmlFormat);
885 std::vector<Candidate> candidates;
893 const char* mime = firstOffered(offered, s_mime_text());
895 candidates.push_back({ mime, Store::Lookup });
903 for (
const auto& mime : s_mime_dib_sources())
905 if (hasMime(offered, mime))
906 candidates.push_back({ mime, Store::Register });
911 candidates.push_back({ s_mime_tiff, Store::Requested });
915 if (formatId == fileFormatId)
916 candidates.push_back({ s_mime_uri_list, Store::Lookup });
917 else if (formatId == htmlFormatId)
920 const char* mime = hasMime(offered, s_mime_html)
922 : firstOffered(offered, s_mime_html_image_sources());
924 candidates.push_back({ mime, Store::Lookup });
928 ClipboardLockGuard systemlock(_system);
929 std::scoped_lock lock(_lock);
930 const char* formatName = ClipboardGetFormatName(_system, formatId);
931 if (formatName && hasMime(offered, formatName))
934 candidates.push_back({ formatName, Store::Lookup });
936 else if (formatName && (mime_is_image(formatName) || mime_is_bmp(formatName)))
941 for (
const auto& mime : s_mime_dib_sources())
943 if (hasMime(offered, mime))
944 candidates.push_back({ mime, Store::Register });
951 std::shared_ptr<BYTE> data;
952 for (
const auto& candidate : candidates)
957 std::shared_ptr<void> sdldata;
958 if (formatId == fileFormatId)
960 std::shared_ptr<void>(cliprdr_file_context_get_local_uri_list(_file, &size), free);
962 sdldata = std::shared_ptr<void>(SDL_GetClipboardData(candidate.mime, &size), SDL_free);
963 if (!sdldata || (size > UINT32_MAX))
966 ClipboardLockGuard systemlock(_system);
967 std::scoped_lock lock(_lock);
969 if (formatId == fileFormatId)
971 auto bdata =
static_cast<const char*
>(sdldata.get());
972 if (!cliprdr_file_context_update_client_data(_file, bdata, size))
976 UINT32 storeId = formatId;
977 if (candidate.store == Store::Lookup)
978 storeId = ClipboardGetFormatId(_system, candidate.mime);
979 else if (candidate.store == Store::Register)
980 storeId = ClipboardRegisterFormat(_system, candidate.mime);
984 if (ClipboardSetData(_system, storeId, sdldata.get(),
static_cast<uint32_t
>(size)))
985 ptr =
static_cast<BYTE*
>(ClipboardGetData(_system, formatId, &ptrlen));
989 ClipboardEmpty(_system);
993 WLog_Print(_log, WLOG_DEBUG,
"could not convert local %s", candidate.mime);
997 data = std::shared_ptr<BYTE>(ptr, free);
1000 if (formatId == fileFormatId)
1002 BYTE* ddata =
nullptr;
1004 const UINT32 flags = cliprdr_file_context_remote_get_flags(_file);
1005 const UINT32 error = cliprdr_serialize_file_list_ex(
1006 flags,
reinterpret_cast<const FILEDESCRIPTORW*
>(data.get()),
1007 ptrlen /
sizeof(FILEDESCRIPTORW), &ddata, &dsize);
1008 data = std::shared_ptr<BYTE>(ddata, free);
1021UINT sdlClip::ReceiveFormatDataRequest(CliprdrClientContext* context,
1024 WINPR_ASSERT(context);
1025 WINPR_ASSERT(formatDataRequest);
1027 auto clipboard =
static_cast<sdlClip*
>(
1028 cliprdr_file_context_get_context(
static_cast<CliprdrFileContext*
>(context->custom)));
1029 WINPR_ASSERT(clipboard);
1031#if defined(__EMSCRIPTEN__)
1036 if (!clipboard->webAnswerDataRequest(formatDataRequest))
1037 return clipboard->SendDataResponse(
nullptr, 0);
1038 return CHANNEL_RC_OK;
1041 std::scoped_lock lock(clipboard->_lock);
1043 FreeRDP_ClipboardFeatureMask);
1045 const UINT32 fileId =
1046 ClipboardRegisterFormat(clipboard->_system, s_type_FileGroupDescriptorW);
1047 if (fileId == formatDataRequest->requestedFormatId)
1049 if ((mask & CLIPRDR_FLAG_LOCAL_TO_REMOTE_FILES) == 0)
1050 return clipboard->SendDataResponse(
nullptr, 0);
1054 if ((mask & CLIPRDR_FLAG_LOCAL_TO_REMOTE) == 0)
1055 return clipboard->SendDataResponse(
nullptr, 0);
1063 if (clipboard->_reading_server)
1065 WLog_Print(clipboard->_log, WLOG_DEBUG,
1066 "local read of server data in progress, failing server request");
1067 return clipboard->SendDataResponse(
nullptr, 0);
1069 clipboard->_server_requests.push_back(formatDataRequest->requestedFormatId);
1074 if (!SDL_RunOnMainThread([](
void* userdata)
1075 {
static_cast<sdlClip*
>(userdata)->handleDataRequests(); }, clipboard,
1078 std::scoped_lock lock(clipboard->_lock);
1079 if (!clipboard->_server_requests.empty())
1080 clipboard->_server_requests.pop_back();
1081 return clipboard->SendDataResponse(
nullptr, 0);
1083 return CHANNEL_RC_OK;
1086void sdlClip::handleDataRequests()
1090 uint32_t formatId = 0;
1092 std::scoped_lock lock(_lock);
1093 if (_server_requests.empty())
1095 formatId = _server_requests.front();
1096 _server_requests.pop_front();
1102 auto data = getLocalData(formatId, len);
1103 std::scoped_lock lock(_lock);
1106 if (SendDataResponse(data.get(), len) != CHANNEL_RC_OK)
1107 WLog_Print(_log, WLOG_WARN,
"failed to send clipboard data response");
1111UINT sdlClip::ReceiveFormatDataResponse(CliprdrClientContext* context,
1114 WINPR_ASSERT(context);
1115 WINPR_ASSERT(formatDataResponse);
1117 const UINT32 size = formatDataResponse->common.dataLen;
1118 const BYTE* data = formatDataResponse->requestedFormatData;
1120 auto clipboard =
static_cast<sdlClip*
>(
1121 cliprdr_file_context_get_context(
static_cast<CliprdrFileContext*
>(context->custom)));
1122 WINPR_ASSERT(clipboard);
1124#if defined(__EMSCRIPTEN__)
1125 if (clipboard->webTakeDataResponse(formatDataResponse))
1126 return CHANNEL_RC_OK;
1128 ClipboardLockGuard systemlock(clipboard->_system);
1129 std::scoped_lock lock(clipboard->_lock);
1130 if (clipboard->_request_queue.empty())
1136 WLog_Print(clipboard->_log, WLOG_WARN,
1137 "format data response with no pending request (late reply?), ignoring");
1138 return CHANNEL_RC_OK;
1143 UINT32 srcFormatId = 0;
1144 auto& request = clipboard->_request_queue.front();
1145 bool success = (formatDataResponse->common.msgFlags & CB_RESPONSE_OK) &&
1146 !(formatDataResponse->common.msgFlags & CB_RESPONSE_FAIL);
1147 request.setSuccess(success);
1151 WLog_Print(clipboard->_log, WLOG_WARN,
1152 "clipboard data request for format %" PRIu32
" [%s], mime %s failed",
1153 request.format(), request.formatstr().c_str(), request.mime().c_str());
1157 switch (request.format())
1161 case CF_UNICODETEXT:
1162 srcFormatId = request.format();
1167 srcFormatId = request.format();
1172 auto name = clipboard->getServerFormat(request.format());
1175 if (name == s_type_FileGroupDescriptorW)
1178 ClipboardGetFormatId(clipboard->_system, s_type_FileGroupDescriptorW);
1180 if (cliprdr_file_context_has_local_support(clipboard->_file))
1182 if (!cliprdr_file_context_update_server_data(
1183 clipboard->_file, clipboard->_system, data, size))
1185 WLog_Print(clipboard->_log, WLOG_WARN,
1186 "File clipboard failed to update");
1190 else if (name == s_type_HtmlFormat)
1192 srcFormatId = ClipboardGetFormatId(clipboard->_system, s_type_HtmlFormat);
1194 else if (mime_is_image(name) || mime_is_bmp(name))
1196 srcFormatId = ClipboardGetFormatId(clipboard->_system, name.c_str());
1203 if (!ClipboardSetData(clipboard->_system, srcFormatId, data, size))
1207 WLog_Print(clipboard->_log, WLOG_ERROR,
"error when setting clipboard data");
1208 request.setSuccess(
false);
1211 WLog_Print(clipboard->_log, WLOG_DEBUG,
"updated clipboard data %s [0x%08" PRIx32
"]",
1212 ClipboardGetFormatName(clipboard->_system, srcFormatId), srcFormatId);
1215 if (!SetEvent(clipboard->_event))
1217 WLog_Print(clipboard->_log, WLOG_ERROR,
"error when setting clipboard event");
1218 return ERROR_INTERNAL_ERROR;
1221 return CHANNEL_RC_OK;
1224const void* sdlClip::ClipDataCb(
void* userdata,
const char* mime_type,
size_t* size)
1226 auto clip =
static_cast<sdlClip*
>(userdata);
1229 WINPR_ASSERT(mime_type);
1234 if (mime_is_text(mime_type))
1236 if (mime_is_utf8(mime_type))
1237 mime_type = mime_text_utf8;
1239 mime_type = mime_text_plain;
1243 ClipboardLockGuard systemlock(clip->_system);
1244 std::scoped_lock lock(clip->_lock);
1250 auto cache = clip->_cache_data.find(mime_type);
1251 if (cache != clip->_cache_data.end())
1253 *size = cache->second.size;
1254 return cache->second.ptr.get();
1257 auto formatID = clip->serverIdForMime(mime_type);
1261 auto mimeFormatID = ClipboardRegisterFormat(clip->_system, mime_type);
1262 auto fptr = ClipboardGetData(clip->_system, mimeFormatID, &fsize);
1265 auto ptr = std::shared_ptr<void>(fptr, free);
1266 if (mime_is_text(mime_type))
1267 fsize = textLength(fptr, fsize);
1268 clip->_cache_data.emplace(mime_type, cache_entry{ fsize, ptr });
1270 auto fcache = clip->_cache_data.find(mime_type);
1271 if (fcache != clip->_cache_data.end())
1273 *size = fcache->second.size;
1274 return fcache->second.ptr.get();
1278 WLog_Print(clip->_log, WLOG_DEBUG,
"requesting format %s [%s 0x%08" PRIx32
"]", mime_type,
1279 ClipboardGetFormatName(clip->_system, formatID), formatID);
1284 clip->_reading_server =
true;
1285 while (!clip->_server_requests.empty())
1287 clip->_server_requests.pop_front();
1288 WLog_Print(clip->_log, WLOG_DEBUG,
1289 "local read of server data in progress, failing queued server request");
1290 std::ignore = clip->SendDataResponse(
nullptr, 0);
1293 if (clip->SendDataRequest(formatID, mime_type))
1295 clip->_reading_server =
false;
1300 HANDLE hdl[2] = { freerdp_abort_event(clip->_sdl->context()), clip->_event };
1302 const UINT32 timeout =
1304 DWORD status = WaitForMultipleObjects(ARRAYSIZE(hdl), hdl, FALSE, timeout);
1306 if (status != WAIT_OBJECT_0 + 1)
1308 std::scoped_lock lock(clip->_lock);
1309 clip->_reading_server =
false;
1310 if (!clip->_request_queue.empty())
1311 clip->_request_queue.pop();
1313 if (status == WAIT_TIMEOUT)
1314 WLog_Print(clip->_log, WLOG_ERROR,
1315 "no reply in 10 seconds, returning empty content");
1322 ClipboardLockGuard systemlock(clip->_system);
1323 std::scoped_lock lock(clip->_lock);
1324 clip->_reading_server =
false;
1325 if (clip->_request_queue.empty())
1328 auto request = std::move(clip->_request_queue.front());
1329 clip->_request_queue.pop();
1331 if (clip->_request_queue.empty())
1332 std::ignore = ResetEvent(clip->_event);
1334 if (request.success())
1336 auto formatID = ClipboardRegisterFormat(clip->_system, mime_type);
1337 auto data = ClipboardGetData(clip->_system, formatID, &len);
1340 WLog_Print(clip->_log, WLOG_ERROR,
"error retrieving clipboard data");
1344 auto ptr = std::shared_ptr<void>(data, free);
1345 if (mime_is_text(mime_type))
1346 len = textLength(data, len);
1347 clip->_cache_data.emplace(mime_type, cache_entry{ len, ptr });
1356void sdlClip::ClipCleanCb(
void* userdata)
1358 auto clip =
static_cast<sdlClip*
>(userdata);
1360 ClipboardLockGuard give_me_a_name(clip->_system);
1361 std::scoped_lock lock(clip->_lock);
1362 ClipboardEmpty(clip->_system);
1365bool sdlClip::mime_is_file(
const std::string& mime)
1367 if (strncmp(s_mime_uri_list, mime.c_str(),
sizeof(s_mime_uri_list)) == 0)
1369 if (strncmp(s_mime_gnome_copied_files, mime.c_str(),
sizeof(s_mime_gnome_copied_files)) == 0)
1371 if (strncmp(s_mime_mate_copied_files, mime.c_str(),
sizeof(s_mime_mate_copied_files)) == 0)
1376bool sdlClip::mime_is_text(
const std::string& mime)
1378 for (
const auto& tmime : s_mime_text())
1380 assert(tmime !=
nullptr);
1388bool sdlClip::mime_is_utf8(
const std::string& mime)
1390 if (mime == std::string(mime_text_utf8))
1393 return mime == std::string(
"UTF8_STRING");
1396bool sdlClip::mime_is_image(
const std::string& mime)
1398 for (
const auto& imime : s_mime_image())
1400 assert(imime !=
nullptr);
1408bool sdlClip::mime_is_bmp(
const std::string& mime)
1410 for (
const auto& imime : s_mime_bitmap())
1412 assert(imime !=
nullptr);
1420bool sdlClip::mime_is_html(
const std::string& mime)
1422 return mime.compare(s_mime_html) == 0;
1425ClipRequest::ClipRequest(UINT32 format,
const std::string& mime)
1426 : _format(format), _mime(mime), _success(false)
1430uint32_t ClipRequest::format()
const
1435std::string ClipRequest::formatstr()
const
1437 return ClipboardGetFormatIdString(_format);
1440std::string ClipRequest::mime()
const
1445bool ClipRequest::success()
const
1450void ClipRequest::setSuccess(
bool status)
1455CliprdrFormat::CliprdrFormat(uint32_t formatID,
const char* formatName) : _formatID(formatID)
1458 _formatName = formatName;
1461uint32_t CliprdrFormat::formatId()
const
1466const char* CliprdrFormat::formatName()
const
1468 if (_formatName.empty())
1470 return _formatName.c_str();
1473#if defined(__EMSCRIPTEN__)
1479static const char s_web_mime_text[] =
"x-freerdp-web-text";
1480static const char s_web_mime_dib[] =
"x-freerdp-web-dib";
1481static const char s_web_mime_png[] =
"x-freerdp-web-png";
1484extern "C" void freerdp_web_clipboard_write_js(
const char* utf8);
1485extern "C" void freerdp_web_clipboard_write_image_js(
const BYTE* data,
size_t size,
int png);
1495static void web_write_on_main(
void* arg)
1497 auto job =
static_cast<web_write_job*
>(arg);
1499 freerdp_web_clipboard_write_js(job->text);
1501 freerdp_web_clipboard_write_image_js(job->dib, job->size, job->png ? 1 : 0);
1507static void web_write(
char* text, BYTE* dib,
size_t size,
bool png =
false)
1509 auto job =
static_cast<web_write_job*
>(calloc(1,
sizeof(web_write_job)));
1520 if (emscripten_is_main_browser_thread())
1521 web_write_on_main(job);
1522 else if (!emscripten_proxy_async(emscripten_proxy_get_system_queue(),
1523 emscripten_main_runtime_thread_id(), web_write_on_main, job))
1531bool sdlClip::webOffer(
const char* utf8,
const BYTE* dib,
size_t dibSize)
1533 std::scoped_lock web(s_web_lock);
1534 auto clip = s_web_clip;
1535 if (!clip || !clip->_ctx || !clip->_ctx->ClientFormatList)
1537 std::vector<CLIPRDR_FORMAT> formats;
1539 std::scoped_lock lock(clip->_lock);
1540 const std::string text = utf8 ? utf8 :
"";
1541 if (!clip->_web_offers.offer(text, dib, dibSize))
1543 clip->_web_local = text;
1544 clip->_web_local_dib.assign(dib, dib ? dib + dibSize : dib);
1546 if (!clip->_web_local.empty())
1547 clip->_web_recent.push_back(std::hash<std::string>{}(clip->_web_local));
1549 clip->_web_recent.push_back(std::hash<std::string_view>{}(
1550 std::string_view(
reinterpret_cast<const char*
>(dib), dibSize)));
1551 while (clip->_web_recent.size() > 16)
1552 clip->_web_recent.pop_front();
1553 if (!clip->_web_local.empty())
1555 formats.push_back({ CF_UNICODETEXT,
nullptr });
1556 formats.push_back({ CF_TEXT,
nullptr });
1558 if (!clip->_web_local_dib.empty())
1559 formats.push_back({ CF_DIB,
nullptr });
1561 if (formats.empty())
1563 CLIPRDR_FORMAT_LIST list = {};
1564 list.common.msgType = CB_FORMAT_LIST;
1565 list.numFormats =
static_cast<UINT32
>(formats.size());
1566 list.formats = formats.data();
1567 return clip->_ctx->ClientFormatList(clip->_ctx, &list) == CHANNEL_RC_OK;
1570bool sdlClip::webRequestServerText()
1572 bool has_text =
false;
1573 bool has_dib =
false;
1575 std::scoped_lock lock(_lock);
1576 for (
const auto& f : _serverFormats)
1578 has_text |= (f.formatId() == CF_UNICODETEXT);
1579 has_dib |= (f.formatId() == CF_DIB);
1581 if (f.formatName() && (strcmp(f.formatName(), s_mime_png) == 0))
1582 png_id = f.formatId();
1584 if (!has_text && !has_dib && !png_id)
1591 ok &= (SendDataRequest(CF_UNICODETEXT, s_web_mime_text) == CHANNEL_RC_OK);
1593 ok &= (SendDataRequest(CF_DIB, s_web_mime_dib) == CHANNEL_RC_OK);
1595 ok &= (SendDataRequest(png_id, s_web_mime_png) == CHANNEL_RC_OK);
1603 std::scoped_lock lock(_lock);
1604 if (_request_queue.empty())
1606 kind = _request_queue.front().mime();
1607 if ((kind != s_web_mime_text) && (kind != s_web_mime_dib) && (kind != s_web_mime_png))
1609 _request_queue.pop();
1612 if (!(response->common.msgFlags & CB_RESPONSE_OK) || !response->requestedFormatData)
1614 const BYTE* data = response->requestedFormatData;
1615 const size_t size = response->common.dataLen;
1616 if (kind == s_web_mime_text)
1618 char* utf8 = ConvertWCharNToUtf8Alloc(
reinterpret_cast<const WCHAR*
>(data),
1619 size /
sizeof(WCHAR),
nullptr);
1623 std::scoped_lock lock(_lock);
1624 const auto hv = std::hash<std::string>{}(std::string(utf8));
1625 if (std::find(_web_recent.begin(), _web_recent.end(), hv) != _web_recent.end())
1631 _web_local_dib.clear();
1632 _web_offers.serverSentText(utf8);
1634 web_write(utf8,
nullptr, 0);
1636 else if ((kind == s_web_mime_png) ? (size > 8)
1640 std::scoped_lock lock(_lock);
1641 const auto hv = std::hash<std::string_view>{}(
1642 std::string_view(
reinterpret_cast<const char*
>(data), size));
1643 if (std::find(_web_recent.begin(), _web_recent.end(), hv) != _web_recent.end())
1646 _web_local_dib.clear();
1647 _web_offers.serverSentImage();
1649 auto copy =
static_cast<BYTE*
>(malloc(size));
1652 memcpy(copy, data, size);
1653 web_write(
nullptr, copy, size, kind == s_web_mime_png);
1662 std::vector<BYTE> dib;
1664 std::scoped_lock lock(_lock);
1665 if (_web_local.empty() && _web_local_dib.empty())
1668 dib = _web_local_dib;
1670 switch (request->requestedFormatId)
1672 case CF_UNICODETEXT:
1676 WCHAR* wstr = ConvertUtf8NToWCharAlloc(text.c_str(), text.size() + 1,
nullptr);
1680 std::ignore = SendDataResponse(
reinterpret_cast<const BYTE*
>(wstr),
1681 (_wcslen(wstr) + 1) *
sizeof(WCHAR));
1689 SendDataResponse(
reinterpret_cast<const BYTE*
>(text.c_str()), text.size() + 1);
1694 std::ignore = SendDataResponse(dib.data(), dib.size());
1714static void* web_offer_thread(
void* arg)
1716 auto job =
static_cast<web_offer_job*
>(arg);
1717 std::ignore = sdlClip::webOffer(job->text, job->dib, job->size);
1724extern "C" EMSCRIPTEN_KEEPALIVE
int freerdp_web_clipboard_offer(
const char* utf8,
const BYTE* dib,
1728 std::scoped_lock web(s_web_lock);
1732 auto job =
static_cast<web_offer_job*
>(calloc(1,
sizeof(web_offer_job)));
1735 job->text = utf8 ? _strdup(utf8) : nullptr;
1738 job->dib =
static_cast<BYTE*
>(malloc(dibSize));
1741 memcpy(job->dib, dib, dibSize);
1742 job->size = dibSize;
1746 if (pthread_create(&tid,
nullptr, web_offer_thread, job) != 0)
1753 pthread_detach(tid);
object that handles clipboard context for the SDL3 client
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.