24#include <winpr/stream.h>
25#include <freerdp/channels/log.h>
27#define TAG CHANNELS_TAG("cliprdr.common")
29#include "cliprdr_common.h"
31static const char* CB_MSG_TYPE_STR(UINT32 type)
36 return "CB_TYPE_NONE";
37 case CB_MONITOR_READY:
38 return "CB_MONITOR_READY";
40 return "CB_FORMAT_LIST";
41 case CB_FORMAT_LIST_RESPONSE:
42 return "CB_FORMAT_LIST_RESPONSE";
43 case CB_FORMAT_DATA_REQUEST:
44 return "CB_FORMAT_DATA_REQUEST";
45 case CB_FORMAT_DATA_RESPONSE:
46 return "CB_FORMAT_DATA_RESPONSE";
47 case CB_TEMP_DIRECTORY:
48 return "CB_TEMP_DIRECTORY";
50 return "CB_CLIP_CAPS";
51 case CB_FILECONTENTS_REQUEST:
52 return "CB_FILECONTENTS_REQUEST";
53 case CB_FILECONTENTS_RESPONSE:
54 return "CB_FILECONTENTS_RESPONSE";
55 case CB_LOCK_CLIPDATA:
56 return "CB_LOCK_CLIPDATA";
57 case CB_UNLOCK_CLIPDATA:
58 return "CB_UNLOCK_CLIPDATA";
64const char* CB_MSG_TYPE_STRING(UINT16 type,
char* buffer,
size_t size)
66 (void)_snprintf(buffer, size,
"%s [0x%04" PRIx16
"]", CB_MSG_TYPE_STR(type), type);
70const char* CB_MSG_FLAGS_STRING(UINT16 msgFlags,
char* buffer,
size_t size)
72 if ((msgFlags & CB_RESPONSE_OK) != 0)
73 winpr_str_append(
"CB_RESPONSE_OK", buffer, size,
"|");
74 if ((msgFlags & CB_RESPONSE_FAIL) != 0)
75 winpr_str_append(
"CB_RESPONSE_FAIL", buffer, size,
"|");
76 if ((msgFlags & CB_ASCII_NAMES) != 0)
77 winpr_str_append(
"CB_ASCII_NAMES", buffer, size,
"|");
79 const size_t len = strnlen(buffer, size);
81 winpr_str_append(
"NONE", buffer, size,
"");
83 char val[32] = WINPR_C_ARRAY_INIT;
84 (void)_snprintf(val,
sizeof(val),
"[0x%04" PRIx16
"]", msgFlags);
85 winpr_str_append(val, buffer, size,
"|");
100 if (request->dwFlags & FILECONTENTS_SIZE)
102 if (request->cbRequested !=
sizeof(UINT64))
104 WLog_ERR(TAG,
"cbRequested must be %" PRIuz
", got %" PRIu32
"",
sizeof(UINT64),
105 request->cbRequested);
109 if (request->nPositionHigh != 0 || request->nPositionLow != 0)
111 WLog_ERR(TAG,
"nPositionHigh and nPositionLow must be set to 0");
119wStream* cliprdr_packet_new(UINT16 msgType, UINT16 msgFlags,
size_t dataLen)
121 WINPR_ASSERT(dataLen < UINT32_MAX - 8ull);
122 wStream* s = Stream_New(
nullptr, dataLen + 8ULL);
126 WLog_ERR(TAG,
"Stream_New failed!");
130 Stream_Write_UINT16(s, msgType);
131 Stream_Write_UINT16(s, msgFlags);
133 Stream_Write_UINT32(s, 0);
137static void cliprdr_write_file_contents_request(
wStream* s,
140 Stream_Write_UINT32(s, request->streamId);
141 Stream_Write_UINT32(s, request->listIndex);
142 Stream_Write_UINT32(s, request->dwFlags);
143 Stream_Write_UINT32(s, request->nPositionLow);
144 Stream_Write_UINT32(s, request->nPositionHigh);
145 Stream_Write_UINT32(s, request->cbRequested);
147 if (request->haveClipDataId)
148 Stream_Write_UINT32(s, request->clipDataId);
151static inline void cliprdr_write_lock_unlock_clipdata(
wStream* s, UINT32 clipDataId)
153 Stream_Write_UINT32(s, clipDataId);
156static void cliprdr_write_lock_clipdata(
wStream* s,
159 cliprdr_write_lock_unlock_clipdata(s, lockClipboardData->clipDataId);
162static void cliprdr_write_unlock_clipdata(
wStream* s,
165 cliprdr_write_lock_unlock_clipdata(s, unlockClipboardData->clipDataId);
168static void cliprdr_write_file_contents_response(
wStream* s,
171 Stream_Write_UINT32(s, response->streamId);
172 Stream_Write(s, response->requestedData, response->cbRequested);
179 if (!lockClipboardData)
182 s = cliprdr_packet_new(CB_LOCK_CLIPDATA, 0, 4);
187 cliprdr_write_lock_clipdata(s, lockClipboardData);
196 if (!unlockClipboardData)
199 s = cliprdr_packet_new(CB_UNLOCK_CLIPDATA, 0, 4);
204 cliprdr_write_unlock_clipdata(s, unlockClipboardData);
215 s = cliprdr_packet_new(CB_FILECONTENTS_REQUEST, 0, 28);
220 cliprdr_write_file_contents_request(s, request);
226 if (!response || (response->cbRequested > UINT32_MAX - 4))
229 wStream* s = cliprdr_packet_new(CB_FILECONTENTS_RESPONSE, response->common.msgFlags,
230 4ull + response->cbRequested);
235 cliprdr_write_file_contents_response(s, response);
240 BOOL useLongFormatNames, BOOL useAsciiNames)
242 WINPR_ASSERT(formatList);
244 if (formatList->common.msgType != CB_FORMAT_LIST)
245 WLog_WARN(TAG,
"called with invalid type %08" PRIx32, formatList->common.msgType);
247 if (useLongFormatNames && useAsciiNames)
248 WLog_WARN(TAG,
"called with invalid arguments useLongFormatNames=true && "
249 "useAsciiNames=true. useAsciiNames requires "
250 "useLongFormatNames=false, ignoring argument.");
252 if (formatList->numFormats > UINT32_MAX / 36ull)
254 WLog_ERR(TAG,
"called with numFormats=%" PRIu32
", which exceeds maximum allowed %" PRIu32,
255 formatList->numFormats, UINT32_MAX);
259 const UINT32 length = formatList->numFormats * 36ull;
260 const size_t formatNameCharSize =
261 (useLongFormatNames || !useAsciiNames) ?
sizeof(WCHAR) :
sizeof(CHAR);
263 wStream* s = cliprdr_packet_new(CB_FORMAT_LIST, 0, length);
266 WLog_ERR(TAG,
"cliprdr_packet_new failed!");
270 for (UINT32 index = 0; index < formatList->numFormats; index++)
274 const char* szFormatName = format->formatName;
275 size_t formatNameLength = 0;
276 size_t formatNameStrLength = 0;
279 formatNameStrLength = strlen(szFormatName);
280 const SSIZE_T wlen = ConvertUtf8ToWChar(szFormatName,
nullptr, 0);
283 formatNameLength = WINPR_ASSERTING_INT_CAST(
size_t, wlen);
286 size_t formatNameMaxLength = formatNameLength + 1;
287 if (!Stream_EnsureRemainingCapacity(s,
288 4 + MAX(32, formatNameMaxLength * formatNameCharSize)))
291 Stream_Write_UINT32(s, format->formatId);
293 if (!useLongFormatNames)
295 formatNameMaxLength = useAsciiNames ? 32 : 16;
296 formatNameLength = MIN(formatNameMaxLength - 1, formatNameLength);
299 if (szFormatName && (formatNameLength > 0))
303 Stream_Write(s, szFormatName, formatNameLength);
304 Stream_Zero(s, formatNameMaxLength - formatNameLength);
308 const size_t formatNameWriteLength =
309 MIN(formatNameStrLength, formatNameMaxLength - 1);
310 if (Stream_Write_UTF16_String_From_UTF8(s, formatNameMaxLength - 1, szFormatName,
311 formatNameWriteLength, TRUE) < 0)
313 Stream_Write_UINT16(s, 0);
317 Stream_Zero(s, formatNameMaxLength * formatNameCharSize);
323 Stream_Free(s, TRUE);
329 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
330 return ERROR_INVALID_DATA;
332 Stream_Read_UINT32(s, unlockClipboardData->clipDataId);
333 return CHANNEL_RC_OK;
338 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
339 return ERROR_INVALID_DATA;
341 Stream_Read_UINT32(s, request->requestedFormatId);
342 return CHANNEL_RC_OK;
347 response->requestedFormatData =
nullptr;
349 if (!Stream_CheckAndLogRequiredLength(TAG, s, response->common.dataLen))
350 return ERROR_INVALID_DATA;
352 if (response->common.dataLen > 0)
354 response->requestedFormatData = Stream_ConstPointer(s);
355 if (!Stream_SafeSeek(s, response->common.dataLen))
356 return ERROR_INVALID_DATA;
358 return CHANNEL_RC_OK;
363 if (!Stream_CheckAndLogRequiredLength(TAG, s, 24))
364 return ERROR_INVALID_DATA;
366 request->haveClipDataId = FALSE;
367 Stream_Read_UINT32(s, request->streamId);
368 Stream_Read_UINT32(s, request->listIndex);
369 Stream_Read_UINT32(s, request->dwFlags);
370 Stream_Read_UINT32(s, request->nPositionLow);
371 Stream_Read_UINT32(s, request->nPositionHigh);
372 Stream_Read_UINT32(s, request->cbRequested);
374 if (Stream_GetRemainingLength(s) >= 4)
376 Stream_Read_UINT32(s, request->clipDataId);
377 request->haveClipDataId = TRUE;
380 if (!cliprdr_validate_file_contents_request(request))
381 return ERROR_BAD_ARGUMENTS;
383 return CHANNEL_RC_OK;
388 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
389 return ERROR_INVALID_DATA;
391 Stream_Read_UINT32(s, response->streamId);
392 response->requestedData = Stream_ConstPointer(s);
394 if (response->common.dataLen < 4)
396 WLog_WARN(TAG,
"dataLen=%" PRIu32
" but expected >= 4", response->common.dataLen);
397 return ERROR_INVALID_DATA;
400 response->cbRequested = response->common.dataLen - 4;
401 if (!Stream_CheckAndLogRequiredLength(TAG, s, response->cbRequested))
402 return ERROR_INVALID_DATA;
403 Stream_Seek(s, response->cbRequested);
404 return CHANNEL_RC_OK;
408 BOOL useLongFormatNames)
411 size_t formatNameLength = 0;
412 const char* szFormatName =
nullptr;
413 const WCHAR* wszFormatName =
nullptr;
414 wStream sub1buffer = WINPR_C_ARRAY_INIT;
416 UINT error = ERROR_INTERNAL_ERROR;
418 const BOOL asciiNames = (formatList->common.msgFlags & CB_ASCII_NAMES) != 0;
422 formatList->formats =
nullptr;
423 formatList->numFormats = 0;
426 Stream_StaticConstInit(&sub1buffer, Stream_ConstPointer(s), formatList->common.dataLen);
427 if (!Stream_SafeSeek(s, formatList->common.dataLen))
428 return ERROR_INVALID_DATA;
430 if (!formatList->common.dataLen)
433 else if (!useLongFormatNames)
435 const size_t cap = Stream_Capacity(sub1) / 36ULL;
436 if (cap > UINT32_MAX)
438 WLog_Print(log, WLOG_ERROR,
"Invalid short format list length: %" PRIuz
"", cap);
439 return ERROR_INTERNAL_ERROR;
441 formatList->numFormats = (UINT32)cap;
443 if (formatList->numFormats)
448 WLog_Print(log, WLOG_ERROR,
"calloc failed!");
449 return CHANNEL_RC_NO_MEMORY;
452 formatList->formats = formats;
454 while (Stream_GetRemainingLength(sub1) >= 4)
456 if (index >= formatList->numFormats)
461 Stream_Read_UINT32(sub1, format->formatId);
471 szFormatName = Stream_ConstPointer(sub1);
472 wszFormatName = Stream_ConstPointer(sub1);
473 if (!Stream_SafeSeek(sub1, 32))
476 free(format->formatName);
477 format->formatName =
nullptr;
484 format->formatName = strndup(szFormatName, 31);
485 if (!format->formatName)
487 WLog_Print(log, WLOG_ERROR,
"malloc failed!");
488 error = CHANNEL_RC_NO_MEMORY;
495 if (wszFormatName[0])
497 format->formatName = ConvertWCharNToUtf8Alloc(wszFormatName, 16,
nullptr);
498 if (!format->formatName)
508 wStream sub2buffer = sub1buffer;
513 while (Stream_GetRemainingLength(sub1) >= 4)
516 if (!Stream_SafeSeek(sub1, 4))
519 wszFormatName = Stream_ConstPointer(sub1);
520 rest = Stream_GetRemainingLength(sub1);
521 formatNameLength = _wcsnlen(wszFormatName, rest /
sizeof(WCHAR));
523 if (!Stream_SafeSeek(sub1, (formatNameLength + 1) *
sizeof(WCHAR)))
525 formatList->numFormats++;
528 if (formatList->numFormats)
533 WLog_Print(log, WLOG_ERROR,
"calloc failed!");
534 return CHANNEL_RC_NO_MEMORY;
537 formatList->formats = formats;
539 while (Stream_GetRemainingLength(sub2) >= 4)
541 if (index >= formatList->numFormats)
547 Stream_Read_UINT32(sub2, format->formatId);
549 free(format->formatName);
550 format->formatName =
nullptr;
552 wszFormatName = Stream_ConstPointer(sub2);
553 rest = Stream_GetRemainingLength(sub2);
554 formatNameLength = _wcsnlen(wszFormatName, rest /
sizeof(WCHAR));
555 if (!Stream_SafeSeek(sub2, (formatNameLength + 1) *
sizeof(WCHAR)))
558 if (formatNameLength)
561 ConvertWCharNToUtf8Alloc(wszFormatName, formatNameLength,
nullptr);
562 if (!format->formatName)
570 return CHANNEL_RC_OK;
573 cliprdr_free_format_list(formatList);
579 if (formatList ==
nullptr)
582 if (formatList->formats)
584 for (UINT32 index = 0; index < formatList->numFormats; index++)
586 free(formatList->formats[index].formatName);
589 free(formatList->formats);
590 formatList->formats =
nullptr;
591 formatList->numFormats = 0;