VirtualBox

source: vbox/trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp@ 104775

Last change on this file since 104775 was 104775, checked in by vboxsync, 6 months ago

Shared Clipboard: Make ShClUtf16LFLenUtf8 to provide proper length in characters for LF -> CRLF conversion (fixed typo), bugref:10694.

  • Property eol-style set to native
  • Property svn:eol-style set to native
  • Property svn:keywords set to Date Revision Author Id
File size: 45.9 KB
Line 
1/* $Id: clipboard-common.cpp 104775 2024-05-24 13:04:35Z vboxsync $ */
2/** @file
3 * Shared Clipboard: Some helper function for converting between the various eol.
4 */
5
6/*
7 * Includes contributions from François Revol
8 *
9 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
10 *
11 * This file is part of VirtualBox base platform packages, as
12 * available from https://www.virtualbox.org.
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation, in version 3 of the
17 * License.
18 *
19 * This program is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, see <https://www.gnu.org/licenses>.
26 *
27 * SPDX-License-Identifier: GPL-3.0-only
28 */
29
30#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
31
32#include <iprt/alloc.h>
33#include <iprt/assert.h>
34#include <iprt/semaphore.h>
35#include <iprt/path.h>
36#include <iprt/rand.h>
37#include <iprt/utf16.h>
38
39#include <iprt/formats/bmp.h>
40
41#include <iprt/errcore.h>
42#include <VBox/log.h>
43#include <VBox/GuestHost/clipboard-helper.h>
44#include <VBox/HostServices/VBoxClipboardSvc.h>
45
46
47/*********************************************************************************************************************************
48* Prototypes *
49*********************************************************************************************************************************/
50static void shClEventSourceResetInternal(PSHCLEVENTSOURCE pSource);
51static int shClEventSourceUnregisterEvent(PSHCLEVENTSOURCE pSource, PSHCLEVENT pEvent);
52
53static void shClEventDestroy(PSHCLEVENT pEvent);
54DECLINLINE(PSHCLEVENT) shclEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent);
55
56
57/*********************************************************************************************************************************
58* Implementation *
59*********************************************************************************************************************************/
60
61/**
62 * Allocates a new event payload.
63 *
64 * @returns VBox status code.
65 * @param uID Payload ID to set for this payload. Useful for consequtive payloads.
66 * @param pvData Data to associate to this payload.
67 * The payload owns the data then.
68 * @param cbData Size (in bytes) of data to associate.
69 * @param ppPayload Where to store the allocated event payload on success.
70 */
71int ShClPayloadInit(uint32_t uID, void *pvData, uint32_t cbData,
72 PSHCLEVENTPAYLOAD *ppPayload)
73{
74 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
75 AssertReturn(cbData > 0, VERR_INVALID_PARAMETER);
76
77 PSHCLEVENTPAYLOAD pPayload = (PSHCLEVENTPAYLOAD)RTMemAlloc(sizeof(SHCLEVENTPAYLOAD));
78 if (pPayload)
79 {
80 pPayload->pvData = pvData;
81 pPayload->cbData = cbData;
82 pPayload->uID = uID;
83
84 *ppPayload = pPayload;
85 return VINF_SUCCESS;
86 }
87
88 return VERR_NO_MEMORY;
89}
90
91/**
92 * Allocates a new event payload.
93 *
94 * @returns VBox status code.
95 * @param uID Payload ID to set for this payload. Useful for consequtive payloads.
96 * @param pvData Data block to allocate (duplicate) to this payload.
97 * @param cbData Size (in bytes) of data block to allocate.
98 * @param ppPayload Where to store the allocated event payload on success.
99 */
100int ShClPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
101 PSHCLEVENTPAYLOAD *ppPayload)
102{
103 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
104 AssertReturn(cbData > 0, VERR_INVALID_PARAMETER);
105
106 void *pvDataDup = RTMemDup(pvData, cbData);
107 if (pvDataDup)
108 return ShClPayloadInit(uID, pvDataDup, cbData, ppPayload);
109
110 return VERR_NO_MEMORY;
111}
112
113/**
114 * Frees an event payload.
115 *
116 * @returns VBox status code.
117 * @param pPayload Event payload to free.
118 */
119void ShClPayloadFree(PSHCLEVENTPAYLOAD pPayload)
120{
121 if (!pPayload)
122 return;
123
124 if (pPayload->pvData)
125 {
126 Assert(pPayload->cbData);
127 RTMemFree(pPayload->pvData);
128 pPayload->pvData = NULL;
129 }
130
131 pPayload->cbData = 0;
132 pPayload->uID = UINT32_MAX;
133
134 RTMemFree(pPayload);
135}
136
137/**
138 * Creates a new event source.
139 *
140 * @returns VBox status code.
141 * @param pSource Event source to create.
142 * @param uID ID to use for event source.
143 */
144int ShClEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID)
145{
146 LogFlowFunc(("pSource=%p, uID=%RU16\n", pSource, uID));
147 AssertPtrReturn(pSource, VERR_INVALID_POINTER);
148
149 int rc = RTCritSectInit(&pSource->CritSect);
150 AssertRCReturn(rc, rc);
151
152 RTListInit(&pSource->lstEvents);
153
154 pSource->uID = uID;
155 /* Choose a random event ID starting point. */
156 pSource->idNextEvent = RTRandU32Ex(1, VBOX_SHCL_MAX_EVENTS - 1);
157
158 return VINF_SUCCESS;
159}
160
161/**
162 * Destroys an event source.
163 *
164 * @returns VBox status code.
165 * @param pSource Event source to destroy.
166 */
167int ShClEventSourceDestroy(PSHCLEVENTSOURCE pSource)
168{
169 if (!pSource)
170 return VINF_SUCCESS;
171
172 if (!RTCritSectIsInitialized(&pSource->CritSect)) /* Already destroyed? Bail out. */
173 return VINF_SUCCESS;
174
175 LogFlowFunc(("ID=%RU32\n", pSource->uID));
176
177 int rc = RTCritSectEnter(&pSource->CritSect);
178 if (RT_SUCCESS(rc))
179 {
180 shClEventSourceResetInternal(pSource);
181
182 rc = RTCritSectLeave(&pSource->CritSect);
183 AssertRC(rc);
184
185 RTCritSectDelete(&pSource->CritSect);
186
187 pSource->uID = UINT16_MAX;
188 pSource->idNextEvent = UINT32_MAX;
189 }
190
191 return rc;
192}
193
194/**
195 * Resets an event source, internal version.
196 *
197 * @param pSource Event source to reset.
198 */
199static void shClEventSourceResetInternal(PSHCLEVENTSOURCE pSource)
200{
201 LogFlowFunc(("ID=%RU32\n", pSource->uID));
202
203 PSHCLEVENT pEvIt;
204 PSHCLEVENT pEvItNext;
205 RTListForEachSafe(&pSource->lstEvents, pEvIt, pEvItNext, SHCLEVENT, Node)
206 {
207 bool const fDealloc = ASMAtomicReadU32(&pEvIt->cRefs) == 0; /* Still any references left? Skip de-allocation. */
208 if (!fDealloc)
209 Log3Func(("Event %RU32 has %RU32 references left, skipping de-allocation\n", pEvIt->idEvent, pEvIt->cRefs));
210
211 shClEventDestroy(pEvIt);
212
213 int rc2 = shClEventSourceUnregisterEvent(pSource, pEvIt);
214 AssertRC(rc2);
215
216 if (fDealloc)
217 {
218 RTMemFree(pEvIt);
219 pEvIt = NULL;
220 }
221 }
222}
223
224/**
225 * Resets an event source.
226 *
227 * @param pSource Event source to reset.
228 */
229void ShClEventSourceReset(PSHCLEVENTSOURCE pSource)
230{
231 int rc2 = RTCritSectEnter(&pSource->CritSect);
232 if (RT_SUCCESS(rc2))
233 {
234 shClEventSourceResetInternal(pSource);
235
236 rc2 = RTCritSectLeave(&pSource->CritSect);
237 AssertRC(rc2);
238 }
239}
240
241/**
242 * Generates a new event ID for a specific event source and registers it.
243 *
244 * @returns VBox status code.
245 * @param pSource Event source to generate event for.
246 * @param ppEvent Where to return the new event generated on success.
247 */
248int ShClEventSourceGenerateAndRegisterEvent(PSHCLEVENTSOURCE pSource, PSHCLEVENT *ppEvent)
249{
250 AssertPtrReturn(pSource, VERR_INVALID_POINTER);
251 AssertPtrReturn(ppEvent, VERR_INVALID_POINTER);
252
253 PSHCLEVENT pEvent = (PSHCLEVENT)RTMemAllocZ(sizeof(SHCLEVENT));
254 AssertReturn(pEvent, VERR_NO_MEMORY);
255 int rc = RTSemEventMultiCreate(&pEvent->hEvtMulSem);
256 if (RT_SUCCESS(rc))
257 {
258 rc = RTCritSectEnter(&pSource->CritSect);
259 if (RT_SUCCESS(rc))
260 {
261 /*
262 * Allocate an unique event ID.
263 */
264 for (uint32_t cTries = 0;; cTries++)
265 {
266 SHCLEVENTID idEvent = ++pSource->idNextEvent;
267 if (idEvent < VBOX_SHCL_MAX_EVENTS)
268 { /* likely */ }
269 else
270 pSource->idNextEvent = idEvent = 1; /* zero == error, remember! */
271
272 if (shclEventGet(pSource, idEvent) == NULL)
273 {
274 pEvent->pParent = pSource;
275 pEvent->idEvent = idEvent;
276 RTListAppend(&pSource->lstEvents, &pEvent->Node);
277
278 rc = RTCritSectLeave(&pSource->CritSect);
279 AssertRC(rc);
280
281 LogFlowFunc(("uSource=%RU16: New event: %#x\n", pSource->uID, idEvent));
282
283 ShClEventRetain(pEvent);
284 *ppEvent = pEvent;
285
286 return VINF_SUCCESS;
287 }
288
289 AssertBreak(cTries < 4096);
290 }
291
292 rc = RTCritSectLeave(&pSource->CritSect);
293 AssertRC(rc);
294 }
295 }
296
297 AssertMsgFailed(("Unable to register a new event ID for event source %RU16\n", pSource->uID));
298
299 RTSemEventMultiDestroy(pEvent->hEvtMulSem);
300 pEvent->hEvtMulSem = NIL_RTSEMEVENTMULTI;
301 RTMemFree(pEvent);
302 return rc;
303}
304
305/**
306 * Destroys an event.
307 *
308 * @param pEvent Event to destroy.
309 */
310static void shClEventDestroy(PSHCLEVENT pEvent)
311{
312 if (!pEvent)
313 return;
314
315 LogFlowFunc(("Event %RU32\n", pEvent->idEvent));
316
317 if (pEvent->hEvtMulSem != NIL_RTSEMEVENT)
318 {
319 RTSemEventMultiDestroy(pEvent->hEvtMulSem);
320 pEvent->hEvtMulSem = NIL_RTSEMEVENT;
321 }
322
323 ShClPayloadFree(pEvent->pPayload);
324 pEvent->pPayload = NULL;
325
326 pEvent->idEvent = NIL_SHCLEVENTID;
327}
328
329/**
330 * Unregisters an event.
331 *
332 * @returns VBox status code.
333 * @param pSource Event source to unregister event for.
334 * @param pEvent Event to unregister.
335 */
336static int shClEventSourceUnregisterEvent(PSHCLEVENTSOURCE pSource, PSHCLEVENT pEvent)
337{
338 RT_NOREF(pSource);
339
340 LogFlowFunc(("idEvent=%RU32, cRefs=%RU32\n", pEvent->idEvent, pEvent->cRefs));
341
342 RTListNodeRemove(&pEvent->Node);
343 pEvent->pParent = NULL;
344
345 return VINF_SUCCESS;
346}
347
348/**
349 * Returns a specific event of a event source. Inlined version.
350 *
351 * @returns Pointer to event if found, or NULL if not found.
352 * @param pSource Event source to get event from.
353 * @param uID Event ID to get.
354 */
355DECLINLINE(PSHCLEVENT) shclEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent)
356{
357 PSHCLEVENT pEvent;
358 RTListForEach(&pSource->lstEvents, pEvent, SHCLEVENT, Node)
359 {
360 if (pEvent->idEvent == idEvent)
361 return pEvent;
362 }
363
364 return NULL;
365}
366
367/**
368 * Returns a specific event of a event source.
369 *
370 * @returns Pointer to event if found, or NULL if not found.
371 * @param pSource Event source to get event from.
372 * @param idEvent ID of event to return.
373 */
374PSHCLEVENT ShClEventSourceGetFromId(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent)
375{
376 AssertPtrReturn(pSource, NULL);
377
378 int rc = RTCritSectEnter(&pSource->CritSect);
379 if (RT_SUCCESS(rc))
380 {
381 PSHCLEVENT pEvent = shclEventGet(pSource, idEvent);
382
383 rc = RTCritSectLeave(&pSource->CritSect);
384 AssertRC(rc);
385
386 return pEvent;
387 }
388
389 return NULL;
390}
391
392/**
393 * Returns the last (newest) event ID which has been registered for an event source.
394 *
395 * @returns Pointer to last registered event, or NULL if not found.
396 * @param pSource Event source to get last registered event from.
397 */
398PSHCLEVENT ShClEventSourceGetLast(PSHCLEVENTSOURCE pSource)
399{
400 AssertPtrReturn(pSource, NULL);
401
402 int rc = RTCritSectEnter(&pSource->CritSect);
403 if (RT_SUCCESS(rc))
404 {
405 PSHCLEVENT pEvent = RTListGetLast(&pSource->lstEvents, SHCLEVENT, Node);
406
407 rc = RTCritSectLeave(&pSource->CritSect);
408 AssertRC(rc);
409
410 return pEvent;
411 }
412
413 return NULL;
414}
415
416/**
417 * Returns the current reference count for a specific event.
418 *
419 * @returns Reference count.
420 * @param pSource Event source the specific event is part of.
421 * @param idEvent Event ID to return reference count for.
422 */
423uint32_t ShClEventGetRefs(PSHCLEVENT pEvent)
424{
425 AssertPtrReturn(pEvent, 0);
426
427 return ASMAtomicReadU32(&pEvent->cRefs);
428}
429
430/**
431 * Detaches a payload from an event, internal version.
432 *
433 * @returns Pointer to the detached payload. Can be NULL if the event has no payload.
434 * @param pEvent Event to detach payload for.
435 */
436static PSHCLEVENTPAYLOAD shclEventPayloadDetachInternal(PSHCLEVENT pEvent)
437{
438#ifdef VBOX_STRICT
439 AssertPtrReturn(pEvent, NULL);
440#endif
441
442 PSHCLEVENTPAYLOAD pPayload = pEvent->pPayload;
443
444 pEvent->pPayload = NULL;
445
446 return pPayload;
447}
448
449/**
450 * Waits for an event to get signalled.
451 *
452 * @returns VBox status code.
453 * @retval VERR_SHCLPB_EVENT_FAILED if the event has a set error code.
454 * @param pEvent Event to wait for.
455 * @param uTimeoutMs Timeout (in ms) to wait.
456 * @param pRc Where to return the event rc. Optional and can be NULL.
457 * @param ppPayload Where to store the (allocated) event payload on success. Needs to be free'd with
458 * SharedClipboardPayloadFree(). Optional.
459 */
460int ShClEventWaitEx(PSHCLEVENT pEvent, RTMSINTERVAL uTimeoutMs, int *pRc, PSHCLEVENTPAYLOAD *ppPayload)
461{
462 AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
463 AssertPtrNullReturn(ppPayload, VERR_INVALID_POINTER);
464 LogFlowFuncEnter();
465
466 int rc = RTSemEventMultiWait(pEvent->hEvtMulSem, uTimeoutMs);
467 if (RT_SUCCESS(rc))
468 {
469 if (RT_FAILURE(pEvent->rc))
470 rc = VERR_SHCLPB_EVENT_FAILED;
471
472 if (pRc)
473 *pRc = pEvent->rc;
474
475 if (ppPayload)
476 {
477 /* Make sure to detach payload here, as the caller now owns the data. */
478 *ppPayload = shclEventPayloadDetachInternal(pEvent);
479 }
480 }
481
482 if (RT_FAILURE(rc))
483 LogRel2(("Shared Clipboard: Waiting for event %RU32 failed, rc=%Rrc\n", pEvent->idEvent, rc));
484
485 LogFlowFuncLeaveRC(rc);
486 return rc;
487}
488
489/**
490 * Waits for an event to get signalled.
491 *
492 * @returns VBox status code.
493 * @retval VERR_SHCLPB_EVENT_FAILED if the event has a set error code.
494 * @param pEvent Event to wait for.
495 * @param uTimeoutMs Timeout (in ms) to wait.
496 * @param ppPayload Where to store the (allocated) event payload on success. Needs to be free'd with
497 * SharedClipboardPayloadFree(). Optional.
498 */
499int ShClEventWait(PSHCLEVENT pEvent, RTMSINTERVAL uTimeoutMs, PSHCLEVENTPAYLOAD *ppPayload)
500{
501 return ShClEventWaitEx(pEvent, uTimeoutMs, NULL /* pRc */, ppPayload);
502}
503
504/**
505 * Retains an event by increasing its reference count.
506 *
507 * @returns New reference count, or UINT32_MAX if failed.
508 * @param pEvent Event to retain.
509 */
510uint32_t ShClEventRetain(PSHCLEVENT pEvent)
511{
512 AssertPtrReturn(pEvent, UINT32_MAX);
513 AssertReturn(ASMAtomicReadU32(&pEvent->cRefs) < 64, UINT32_MAX);
514 return ASMAtomicIncU32(&pEvent->cRefs);
515}
516
517/**
518 * Releases event by decreasing its reference count. Will be destroyed once the reference count reaches 0.
519 *
520 * @returns New reference count, or UINT32_MAX if failed.
521 * @param pEvent Event to release.
522 * If the reference count reaches 0, the event will
523 * be destroyed and \a pEvent will be invalid.
524 */
525uint32_t ShClEventRelease(PSHCLEVENT pEvent)
526{
527 if (!pEvent)
528 return 0;
529
530 AssertReturn(ASMAtomicReadU32(&pEvent->cRefs) > 0, UINT32_MAX);
531
532 uint32_t const cRefs = ASMAtomicDecU32(&pEvent->cRefs);
533 if (cRefs == 0)
534 {
535 int rc;
536 PSHCLEVENTSOURCE pParent = pEvent->pParent;
537 if ( pParent
538 && RTCritSectIsInitialized(&pParent->CritSect))
539 {
540 rc = RTCritSectEnter(&pParent->CritSect);
541 if (RT_SUCCESS(rc))
542 {
543 rc = shClEventSourceUnregisterEvent(pParent, pEvent);
544
545 int rc2 = RTCritSectLeave(&pParent->CritSect);
546 if (RT_SUCCESS(rc))
547 rc = rc2;
548 }
549 }
550 else
551 rc = VINF_SUCCESS;
552
553 if (RT_SUCCESS(rc))
554 {
555 shClEventDestroy(pEvent);
556
557 RTMemFree(pEvent);
558 pEvent = NULL;
559 }
560
561 return RT_SUCCESS(rc) ? 0 : UINT32_MAX;
562 }
563
564 return cRefs;
565}
566
567/**
568 * Signals an event, extended version.
569 *
570 * @returns VBox status code.
571 * @param pEvent Event to signal.
572 * @param rc Result code to set.
573 * @param pPayload Event payload to associate. Takes ownership on
574 * success. Optional.
575 */
576int ShClEventSignalEx(PSHCLEVENT pEvent, int rc, PSHCLEVENTPAYLOAD pPayload)
577{
578 AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
579
580 Assert(pEvent->pPayload == NULL);
581
582 pEvent->rc = rc;
583 pEvent->pPayload = pPayload;
584
585 int rc2 = RTSemEventMultiSignal(pEvent->hEvtMulSem);
586 if (RT_FAILURE(rc2))
587 pEvent->pPayload = NULL; /* (no race condition if consumer also enters the critical section) */
588
589 LogFlowFuncLeaveRC(rc2);
590 return rc2;
591}
592
593/**
594 * Signals an event.
595 *
596 * @returns VBox status code.
597 * @param pEvent Event to signal.
598 * @param pPayload Event payload to associate. Takes ownership on
599 * success. Optional.
600 */
601int ShClEventSignal(PSHCLEVENT pEvent, PSHCLEVENTPAYLOAD pPayload)
602{
603 return ShClEventSignalEx(pEvent, VINF_SUCCESS, pPayload);
604}
605
606int ShClUtf16LenUtf8(PCRTUTF16 pcwszSrc, size_t cwcSrc, size_t *pchLen)
607{
608 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
609 AssertPtrReturn(pchLen, VERR_INVALID_POINTER);
610
611 size_t chLen = 0;
612 int rc = RTUtf16CalcUtf8LenEx(pcwszSrc, cwcSrc, &chLen);
613 if (RT_SUCCESS(rc))
614 *pchLen = chLen;
615 return rc;
616}
617
618int ShClConvUtf16CRLFToUtf8LF(PCRTUTF16 pcwszSrc, size_t cwcSrc,
619 char *pszBuf, size_t cbBuf, size_t *pcbLen)
620{
621 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
622 AssertReturn (cwcSrc, VERR_INVALID_PARAMETER);
623 AssertPtrReturn(pszBuf, VERR_INVALID_POINTER);
624 AssertPtrReturn(pcbLen, VERR_INVALID_POINTER);
625
626 int rc;
627
628 PRTUTF16 pwszTmp = NULL;
629 size_t cchTmp = 0;
630
631 size_t cbLen = 0;
632
633 /* How long will the converted text be? */
634 rc = ShClUtf16CRLFLenUtf8(pcwszSrc, cwcSrc, &cchTmp);
635 if (RT_SUCCESS(rc))
636 {
637 cchTmp++; /* Add space for terminator. */
638
639 pwszTmp = (PRTUTF16)RTMemAlloc(cchTmp * sizeof(RTUTF16));
640 if (pwszTmp)
641 {
642 rc = ShClConvUtf16CRLFToLF(pcwszSrc, cwcSrc, pwszTmp, cchTmp);
643 if (RT_SUCCESS(rc))
644 rc = RTUtf16ToUtf8Ex(pwszTmp + 1, cchTmp - 1, &pszBuf, cbBuf, &cbLen);
645
646 RTMemFree(reinterpret_cast<void *>(pwszTmp));
647 }
648 else
649 rc = VERR_NO_MEMORY;
650 }
651
652 if (RT_SUCCESS(rc))
653 {
654 *pcbLen = cbLen;
655 }
656
657 return rc;
658}
659
660int ShClConvUtf16LFToCRLFA(PCRTUTF16 pcwszSrc, size_t cwcSrc,
661 PRTUTF16 *ppwszDst, size_t *pcwDst)
662{
663 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
664 AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER);
665 AssertPtrReturn(pcwDst, VERR_INVALID_POINTER);
666
667 PRTUTF16 pwszDst = NULL;
668 size_t cchDst;
669
670 int rc = ShClUtf16CalcNormalizedEolToCRLFLength(pcwszSrc, cwcSrc, &cchDst);
671 if (RT_SUCCESS(rc))
672 {
673 pwszDst = (PRTUTF16)RTMemAlloc((cchDst + 1 /* Leave space for terminator */) * sizeof(RTUTF16));
674 if (pwszDst)
675 {
676 rc = ShClConvUtf16LFToCRLF(pcwszSrc, cwcSrc, pwszDst, cchDst + 1 /* Include terminator */);
677 }
678 else
679 rc = VERR_NO_MEMORY;
680 }
681
682 if (RT_SUCCESS(rc))
683 {
684 *ppwszDst = pwszDst;
685 *pcwDst = cchDst;
686 }
687 else
688 RTMemFree(pwszDst);
689
690 LogFlowFuncLeaveRC(rc);
691 return rc;
692}
693
694int ShClConvUtf8LFToUtf16CRLF(const char *pcszSrc, size_t cbSrc,
695 PRTUTF16 *ppwszDst, size_t *pcwDst)
696{
697 AssertPtrReturn(pcszSrc, VERR_INVALID_POINTER);
698 AssertReturn(cbSrc, VERR_INVALID_PARAMETER);
699 AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER);
700 AssertPtrReturn(pcwDst, VERR_INVALID_POINTER);
701
702 /* Intermediate conversion to UTF-16. */
703 size_t cwcTmp;
704 PRTUTF16 pwcTmp = NULL;
705 int rc = RTStrToUtf16Ex(pcszSrc, cbSrc, &pwcTmp, 0, &cwcTmp);
706 if (RT_SUCCESS(rc))
707 {
708 rc = ShClConvUtf16LFToCRLFA(pwcTmp, cwcTmp, ppwszDst, pcwDst);
709 RTUtf16Free(pwcTmp);
710 }
711
712 return rc;
713}
714
715/**
716 * Converts a Latin-1 string with LF line endings into an UTF-16 string with CRLF endings.
717 *
718 * @returns VBox status code.
719 * @param pcszSrc Latin-1 string to convert.
720 * @param cbSrc Size (in bytes) of Latin-1 string to convert.
721 * @param ppwszDst Where to return the converted UTF-16 string on success.
722 * @param pcwDst Where to return the length (in UTF-16 characters) on success.
723 *
724 * @note Only converts the source until the string terminator is found (or length limit is hit).
725 */
726int ShClConvLatin1LFToUtf16CRLF(const char *pcszSrc, size_t cbSrc,
727 PRTUTF16 *ppwszDst, size_t *pcwDst)
728{
729 AssertPtrReturn(pcszSrc, VERR_INVALID_POINTER);
730 AssertReturn(cbSrc, VERR_INVALID_PARAMETER);
731 AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER);
732 AssertPtrReturn(pcwDst, VERR_INVALID_POINTER);
733
734 size_t chSrc = 0;
735
736 PRTUTF16 pwszDst = NULL;
737
738 /* Calculate the space needed. */
739 size_t cwDst = 0;
740 for (size_t i = 0; i < cbSrc && pcszSrc[i] != '\0'; ++i)
741 {
742 if (pcszSrc[i] == VBOX_SHCL_LINEFEED)
743 cwDst += 2; /* Space for VBOX_SHCL_CARRIAGERETURN + VBOX_SHCL_LINEFEED. */
744 else
745 ++cwDst;
746 chSrc++;
747 }
748
749 pwszDst = (PRTUTF16)RTMemAlloc((cwDst + 1 /* Leave space for the terminator */) * sizeof(RTUTF16));
750 AssertPtrReturn(pwszDst, VERR_NO_MEMORY);
751
752 /* Do the conversion, bearing in mind that Latin-1 expands "naturally" to UTF-16. */
753 for (size_t i = 0, j = 0; i < chSrc; ++i, ++j)
754 {
755 AssertMsg(j <= cwDst, ("cbSrc=%zu, j=%u vs. cwDst=%u\n", cbSrc, j, cwDst));
756 if (pcszSrc[i] != VBOX_SHCL_LINEFEED)
757 pwszDst[j] = pcszSrc[i];
758 else
759 {
760 pwszDst[j] = VBOX_SHCL_CARRIAGERETURN;
761 pwszDst[j + 1] = VBOX_SHCL_LINEFEED;
762 ++j;
763 }
764 }
765
766 pwszDst[cwDst] = '\0'; /* Make sure we are zero-terminated. */
767
768 *ppwszDst = pwszDst;
769 *pcwDst = cwDst;
770
771 return VINF_SUCCESS;
772}
773
774int ShClConvUtf16ToUtf8HTML(PCRTUTF16 pcwszSrc, size_t cwcSrc, char **ppszDst, size_t *pcbDst)
775{
776 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
777 AssertReturn (cwcSrc, VERR_INVALID_PARAMETER);
778 AssertPtrReturn(ppszDst, VERR_INVALID_POINTER);
779 AssertPtrReturn(pcbDst, VERR_INVALID_POINTER);
780
781 int rc = VINF_SUCCESS;
782
783 size_t cwTmp = cwcSrc;
784 PCRTUTF16 pwTmp = pcwszSrc;
785
786 char *pchDst = NULL;
787 size_t cbDst = 0;
788
789 size_t i = 0;
790 while (i < cwTmp)
791 {
792 /* Find zero symbol (end of string). */
793 for (; i < cwTmp && pcwszSrc[i] != 0; i++)
794 ;
795
796 /* Convert found string. */
797 char *psz = NULL;
798 size_t cch = 0;
799 rc = RTUtf16ToUtf8Ex(pwTmp, cwTmp, &psz, pwTmp - pcwszSrc, &cch);
800 if (RT_FAILURE(rc))
801 break;
802
803 /* Append new substring. */
804 char *pchNew = (char *)RTMemRealloc(pchDst, cbDst + cch + 1);
805 if (!pchNew)
806 {
807 RTStrFree(psz);
808 rc = VERR_NO_MEMORY;
809 break;
810 }
811
812 pchDst = pchNew;
813 memcpy(pchDst + cbDst, psz, cch + 1);
814
815 RTStrFree(psz);
816
817 cbDst += cch + 1;
818
819 /* Skip zero symbols. */
820 for (; i < cwTmp && pcwszSrc[i] == 0; i++)
821 ;
822
823 /* Remember start of string. */
824 pwTmp += i;
825 }
826
827 if (RT_SUCCESS(rc))
828 {
829 *ppszDst = pchDst;
830 *pcbDst = cbDst;
831
832 return VINF_SUCCESS;
833 }
834
835 RTMemFree(pchDst);
836
837 return rc;
838}
839
840int ShClUtf16CalcNormalizedEolToCRLFLength(PCRTUTF16 pcwszSrc, size_t cwSrc, size_t *pchLen)
841{
842 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
843 AssertPtrReturn(pchLen, VERR_INVALID_POINTER);
844
845 AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
846 ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
847
848 size_t cLen = 0;
849
850 /* Don't copy the endian marker. */
851 size_t i = pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER ? 1 : 0;
852
853 /* Calculate the size of the destination text string. */
854 /* Is this Utf16 or Utf16-LE? */
855 for (; i < cwSrc; ++i, ++cLen)
856 {
857 /* Check for a single line feed */
858 if ( pcwszSrc[i] == VBOX_SHCL_LINEFEED
859 && (i == 0 || pcwszSrc[i - 1] != VBOX_SHCL_CARRIAGERETURN))
860 {
861 ++cLen;
862 }
863#ifdef RT_OS_DARWIN
864 /* Check for a single carriage return (MacOS) */
865 if ( pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN
866 && (i + 1 >= cwSrc || pcwszSrc[i + 1] != VBOX_SHCL_LINEFEED))
867 {
868 ++cLen;
869 }
870#endif
871 if (pcwszSrc[i] == 0)
872 {
873 /* Don't count this, as we do so below. */
874 break;
875 }
876 }
877
878 *pchLen = cLen;
879
880 return VINF_SUCCESS;
881}
882
883int ShClUtf16CRLFLenUtf8(PCRTUTF16 pcwszSrc, size_t cwSrc, size_t *pchLen)
884{
885 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
886 AssertReturn(cwSrc, VERR_INVALID_PARAMETER);
887 AssertPtrReturn(pchLen, VERR_INVALID_POINTER);
888
889 AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
890 ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
891
892 size_t cLen = 0;
893
894 /* Calculate the size of the destination text string. */
895 /* Is this Utf16 or Utf16-LE? */
896 if (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER)
897 cLen = 0;
898 else
899 cLen = 1;
900
901 for (size_t i = 0; i < cwSrc; ++i, ++cLen)
902 {
903 if ( (i + 1 < cwSrc)
904 && (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN)
905 && (pcwszSrc[i + 1] == VBOX_SHCL_LINEFEED))
906 {
907 ++i;
908 }
909 if (pcwszSrc[i] == 0)
910 break;
911 }
912
913 *pchLen = cLen;
914
915 return VINF_SUCCESS;
916}
917
918int ShClConvUtf16LFToCRLF(PCRTUTF16 pcwszSrc, size_t cwcSrc, PRTUTF16 pu16Dst, size_t cwcDst)
919{
920 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
921 AssertPtrReturn(pu16Dst, VERR_INVALID_POINTER);
922 AssertReturn(cwcDst, VERR_INVALID_PARAMETER);
923
924 AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
925 ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
926
927 /* Don't copy the endian marker. */
928 size_t offDst = 0;
929 for (size_t offSrc = pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER ? 1 : 0; offSrc < cwcSrc; ++offSrc, ++offDst)
930 {
931 /* Ensure more output space: */
932 if (offDst < cwcDst) { /* likely */ }
933 else return VERR_BUFFER_OVERFLOW;
934
935 /* Don't copy the null byte, as we add it below. */
936 if (pcwszSrc[offSrc] == 0)
937 break;
938
939 /* Check for newlines not preceeded by carriage return: "\n" -> "\r\n"; but not "\r\n" to "\r\r\n"! */
940 if ( pcwszSrc[offSrc] == VBOX_SHCL_LINEFEED
941 && (offSrc == 0 || pcwszSrc[offSrc - 1] != VBOX_SHCL_CARRIAGERETURN))
942 {
943 pu16Dst[offDst++] = VBOX_SHCL_CARRIAGERETURN;
944
945 /* Ensure sufficient output space: */
946 if (offDst < cwcDst) { /* likely */ }
947 else return VERR_BUFFER_OVERFLOW;
948 }
949#ifdef RT_OS_DARWIN
950 /* Check for a carriage return not followed by newline (MacOS): "\r" -> "\n\r"; but not "\r\n" to "\r\n\n"! */
951 else if ( pcwszSrc[offSrc] == VBOX_SHCL_CARRIAGERETURN
952 && (offSrc + 1 >= cwcSrc || pcwszSrc[offSrc + 1] != VBOX_SHCL_LINEFEED))
953 {
954 pu16Dst[offDst++] = VBOX_SHCL_CARRIAGERETURN;
955
956 /* Ensure more output space: */
957 if (offDst < cwcDst) { /* likely */ }
958 else return VERR_BUFFER_OVERFLOW;
959
960 /* Add line feed. */
961 pu16Dst[offDst] = VBOX_SHCL_LINEFEED;
962 continue;
963 }
964#endif
965 pu16Dst[offDst] = pcwszSrc[offSrc];
966 }
967
968 /* Add terminator. */
969 if (offDst < cwcDst)
970 {
971 pu16Dst[offDst] = 0;
972 return VINF_SUCCESS;
973 }
974 return VERR_BUFFER_OVERFLOW;
975}
976
977int ShClConvUtf16CRLFToLF(PCRTUTF16 pcwszSrc, size_t cwcSrc, PRTUTF16 pu16Dst, size_t cwDst)
978{
979 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
980 AssertReturn(cwcSrc, VERR_INVALID_PARAMETER);
981 AssertPtrReturn(pu16Dst, VERR_INVALID_POINTER);
982 AssertReturn(cwDst, VERR_INVALID_PARAMETER);
983
984 AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
985 ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
986
987 /* Prepend the Utf16 byte order marker if it is missing. */
988 size_t cwDstPos;
989 if (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER)
990 {
991 cwDstPos = 0;
992 }
993 else
994 {
995 pu16Dst[0] = VBOX_SHCL_UTF16LEMARKER;
996 cwDstPos = 1;
997 }
998
999 for (size_t i = 0; i < cwcSrc; ++i, ++cwDstPos)
1000 {
1001 if (pcwszSrc[i] == 0)
1002 break;
1003
1004 if (cwDstPos == cwDst)
1005 return VERR_BUFFER_OVERFLOW;
1006
1007 if ( (i + 1 < cwcSrc)
1008 && (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN)
1009 && (pcwszSrc[i + 1] == VBOX_SHCL_LINEFEED))
1010 {
1011 ++i;
1012 }
1013
1014 pu16Dst[cwDstPos] = pcwszSrc[i];
1015 }
1016
1017 if (cwDstPos == cwDst)
1018 return VERR_BUFFER_OVERFLOW;
1019
1020 /* Add terminating zero. */
1021 pu16Dst[cwDstPos] = 0;
1022
1023 return VINF_SUCCESS;
1024}
1025
1026int ShClDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDest, size_t *pcbDest)
1027{
1028 AssertPtrReturn(pvSrc, VERR_INVALID_POINTER);
1029 AssertReturn(cbSrc, VERR_INVALID_PARAMETER);
1030 AssertPtrReturn(ppvDest, VERR_INVALID_POINTER);
1031 AssertPtrReturn(pcbDest, VERR_INVALID_POINTER);
1032
1033 PBMPWIN3XINFOHDR coreHdr = (PBMPWIN3XINFOHDR)pvSrc;
1034 /** @todo Support all the many versions of the DIB headers. */
1035 if ( cbSrc < sizeof(BMPWIN3XINFOHDR)
1036 || RT_LE2H_U32(coreHdr->cbSize) < sizeof(BMPWIN3XINFOHDR)
1037 || RT_LE2H_U32(coreHdr->cbSize) != sizeof(BMPWIN3XINFOHDR))
1038 {
1039 return VERR_INVALID_PARAMETER;
1040 }
1041
1042 size_t offPixel = sizeof(BMPFILEHDR)
1043 + RT_LE2H_U32(coreHdr->cbSize)
1044 + RT_LE2H_U32(coreHdr->cClrUsed) * sizeof(uint32_t);
1045 if (cbSrc < offPixel)
1046 return VERR_INVALID_PARAMETER;
1047
1048 size_t cbDst = sizeof(BMPFILEHDR) + cbSrc;
1049
1050 void *pvDest = RTMemAlloc(cbDst);
1051 if (!pvDest)
1052 return VERR_NO_MEMORY;
1053
1054 PBMPFILEHDR fileHdr = (PBMPFILEHDR)pvDest;
1055
1056 fileHdr->uType = BMP_HDR_MAGIC;
1057 fileHdr->cbFileSize = (uint32_t)RT_H2LE_U32(cbDst);
1058 fileHdr->Reserved1 = 0;
1059 fileHdr->Reserved2 = 0;
1060 fileHdr->offBits = (uint32_t)RT_H2LE_U32(offPixel);
1061
1062 memcpy((uint8_t *)pvDest + sizeof(BMPFILEHDR), pvSrc, cbSrc);
1063
1064 *ppvDest = pvDest;
1065 *pcbDest = cbDst;
1066
1067 return VINF_SUCCESS;
1068}
1069
1070int ShClBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDest, size_t *pcbDest)
1071{
1072 AssertPtrReturn(pvSrc, VERR_INVALID_POINTER);
1073 AssertReturn(cbSrc, VERR_INVALID_PARAMETER);
1074 AssertPtrReturn(ppvDest, VERR_INVALID_POINTER);
1075 AssertPtrReturn(pcbDest, VERR_INVALID_POINTER);
1076
1077 PBMPFILEHDR pBmpHdr = (PBMPFILEHDR)pvSrc;
1078 if ( cbSrc < sizeof(BMPFILEHDR)
1079 || pBmpHdr->uType != BMP_HDR_MAGIC
1080 || RT_LE2H_U32(pBmpHdr->cbFileSize) != cbSrc)
1081 {
1082 return VERR_INVALID_PARAMETER;
1083 }
1084
1085 *ppvDest = ((uint8_t *)pvSrc) + sizeof(BMPFILEHDR);
1086 *pcbDest = cbSrc - sizeof(BMPFILEHDR);
1087
1088 return VINF_SUCCESS;
1089}
1090
1091#ifdef LOG_ENABLED
1092
1093int ShClDbgDumpHtml(const char *pcszSrc, size_t cbSrc)
1094{
1095 int rc = VINF_SUCCESS;
1096 char *pszBuf = (char *)RTMemTmpAllocZ(cbSrc + 1);
1097 if (pszBuf)
1098 {
1099 memcpy(pszBuf, pcszSrc, cbSrc);
1100 pszBuf[cbSrc] = '\0';
1101 for (size_t off = 0; off < cbSrc; ++off)
1102 if (pszBuf[off] == '\n' || pszBuf[off] == '\r')
1103 pszBuf[off] = ' ';
1104 LogFunc(("Removed \\r\\n: %s\n", pszBuf));
1105 RTMemTmpFree(pszBuf);
1106 }
1107 else
1108 rc = VERR_NO_MEMORY;
1109 return rc;
1110}
1111
1112void ShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT uFormat)
1113{
1114 if (LogIsEnabled())
1115 {
1116 if (uFormat & VBOX_SHCL_FMT_UNICODETEXT)
1117 {
1118 LogFunc(("VBOX_SHCL_FMT_UNICODETEXT:\n"));
1119 if (pv && cb)
1120 LogFunc(("%ls\n", pv));
1121 else
1122 LogFunc(("%p %zu\n", pv, cb));
1123 }
1124 else if (uFormat & VBOX_SHCL_FMT_BITMAP)
1125 LogFunc(("VBOX_SHCL_FMT_BITMAP\n"));
1126 else if (uFormat & VBOX_SHCL_FMT_HTML)
1127 {
1128 LogFunc(("VBOX_SHCL_FMT_HTML:\n"));
1129 if (pv && cb)
1130 {
1131 LogFunc(("%s\n", pv));
1132 ShClDbgDumpHtml((const char *)pv, cb);
1133 }
1134 else
1135 LogFunc(("%p %zu\n", pv, cb));
1136 }
1137 else
1138 LogFunc(("Invalid format %02X\n", uFormat));
1139 }
1140}
1141
1142#endif /* LOG_ENABLED */
1143
1144/**
1145 * Translates a Shared Clipboard host function number to a string.
1146 *
1147 * @returns Function ID string name.
1148 * @param uFn The function to translate.
1149 */
1150const char *ShClHostFunctionToStr(uint32_t uFn)
1151{
1152 switch (uFn)
1153 {
1154 RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_SET_MODE);
1155 RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_SET_TRANSFER_MODE);
1156 RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_SET_HEADLESS);
1157 RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_CANCEL);
1158 RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_ERROR);
1159 }
1160 return "Unknown";
1161}
1162
1163/**
1164 * Translates a Shared Clipboard host message enum to a string.
1165 *
1166 * @returns Message ID string name.
1167 * @param uMsg The message to translate.
1168 */
1169const char *ShClHostMsgToStr(uint32_t uMsg)
1170{
1171 switch (uMsg)
1172 {
1173 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_QUIT);
1174 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_READ_DATA);
1175 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_FORMATS_REPORT);
1176 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_CANCELED);
1177 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_READ_DATA_CID);
1178 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_STATUS);
1179 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ);
1180 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_WRITE);
1181 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ);
1182 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_WRITE);
1183 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_OPEN);
1184 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_CLOSE);
1185 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_READ);
1186 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_WRITE);
1187 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ);
1188 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_WRITE);
1189 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN);
1190 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_CLOSE);
1191 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_READ);
1192 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_WRITE);
1193 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_CANCEL);
1194 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ERROR);
1195 }
1196 return "Unknown";
1197}
1198
1199/**
1200 * Translates a Shared Clipboard guest message enum to a string.
1201 *
1202 * @returns Message ID string name.
1203 * @param uMsg The message to translate.
1204 */
1205const char *ShClGuestMsgToStr(uint32_t uMsg)
1206{
1207 switch (uMsg)
1208 {
1209 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_OLD_GET_WAIT);
1210 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_REPORT_FORMATS);
1211 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_DATA_READ);
1212 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_DATA_WRITE);
1213 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_CONNECT);
1214 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_REPORT_FEATURES);
1215 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_QUERY_FEATURES);
1216 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT);
1217 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT);
1218 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_GET);
1219 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_CANCEL);
1220 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_REPLY);
1221 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ);
1222 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE);
1223 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ);
1224 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE);
1225 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_OPEN);
1226 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_CLOSE);
1227 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_HDR_READ);
1228 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE);
1229 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ);
1230 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE);
1231 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_OPEN);
1232 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_CLOSE);
1233 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_READ);
1234 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_WRITE);
1235 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ERROR);
1236 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_NEGOTIATE_CHUNK_SIZE);
1237 }
1238 return "Unknown";
1239}
1240
1241/**
1242 * Converts Shared Clipboard formats to a string.
1243 *
1244 * @returns Stringified Shared Clipboard formats, or NULL on failure. Must be free'd with RTStrFree().
1245 * @param fFormats Shared Clipboard formats to convert.
1246 *
1247 */
1248char *ShClFormatsToStrA(SHCLFORMATS fFormats)
1249{
1250#define APPEND_FMT_TO_STR(_aFmt) \
1251 if (fFormats & VBOX_SHCL_FMT_##_aFmt) \
1252 { \
1253 if (pszFmts) \
1254 { \
1255 rc2 = RTStrAAppend(&pszFmts, ", "); \
1256 if (RT_FAILURE(rc2)) \
1257 break; \
1258 } \
1259 \
1260 rc2 = RTStrAAppend(&pszFmts, #_aFmt); \
1261 if (RT_FAILURE(rc2)) \
1262 break; \
1263 }
1264
1265 char *pszFmts = NULL;
1266 int rc2 = VINF_SUCCESS;
1267
1268 do
1269 {
1270 APPEND_FMT_TO_STR(UNICODETEXT);
1271 APPEND_FMT_TO_STR(BITMAP);
1272 APPEND_FMT_TO_STR(HTML);
1273# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
1274 APPEND_FMT_TO_STR(URI_LIST);
1275# endif
1276
1277 } while (0);
1278
1279 if (!pszFmts)
1280 rc2 = RTStrAAppend(&pszFmts, "NONE");
1281
1282 if ( RT_FAILURE(rc2)
1283 && pszFmts)
1284 {
1285 RTStrFree(pszFmts);
1286 pszFmts = NULL;
1287 }
1288
1289#undef APPEND_FMT_TO_STR
1290
1291 return pszFmts;
1292}
1293
1294
1295/*********************************************************************************************************************************
1296* Shared Clipboard Cache *
1297*********************************************************************************************************************************/
1298
1299/**
1300 * Returns (mutable) data of a cache entry.
1301 *
1302 * @param pCacheEntry Cache entry to return data for.
1303 * @param pvData Where to return the (mutable) data pointer.
1304 * @param pcbData Where to return the data size.
1305 */
1306void ShClCacheEntryGet(PSHCLCACHEENTRY pCacheEntry, void **pvData, size_t *pcbData)
1307{
1308 AssertPtrReturnVoid(pCacheEntry);
1309 AssertPtrReturnVoid(pvData);
1310 AssertReturnVoid(pcbData);
1311
1312 *pvData = pCacheEntry->pvData;
1313 *pcbData = pCacheEntry->cbData;
1314}
1315
1316/**
1317 * Initializes a cache entry.
1318 *
1319 * @returns VBox status code.
1320 * @param pCacheEntry Cache entry to init.
1321 * @param pvData Data to copy to entry. Can be NULL to initialize an emptry entry.
1322 * @param cbData Size (in bytes) of \a pvData to copy to entry. Must be 0 if \a pvData is NULL.
1323 */
1324static int shClCacheEntryInit(PSHCLCACHEENTRY pCacheEntry, const void *pvData, size_t cbData)
1325{
1326 AssertReturn(RT_VALID_PTR(pvData) || cbData == 0, VERR_INVALID_PARAMETER);
1327
1328 RT_BZERO(pCacheEntry, sizeof(SHCLCACHEENTRY));
1329
1330 if (pvData)
1331 {
1332 pCacheEntry->pvData = RTMemDup(pvData, cbData);
1333 AssertPtrReturn(pCacheEntry->pvData, VERR_NO_MEMORY);
1334 pCacheEntry->cbData = cbData;
1335 }
1336
1337 return VINF_SUCCESS;
1338}
1339
1340/**
1341 * Returns whether a cache entry is valid (cache hit) or not.
1342 *
1343 * @returns \c true if valid, or \c false if not.
1344 * @param pCacheEntry Cache entry to check for.
1345 */
1346DECLINLINE(bool) shClCacheEntryIsValid(PSHCLCACHEENTRY pCacheEntry)
1347{
1348 return pCacheEntry->pvData != NULL;
1349}
1350
1351/**
1352 * Destroys a cache entry.
1353 *
1354 * @param pCacheEntry Cache entry to destroy.
1355 */
1356DECLINLINE(void) shClCacheEntryDestroy(PSHCLCACHEENTRY pCacheEntry)
1357{
1358 if (pCacheEntry->pvData)
1359 {
1360 Assert(pCacheEntry->cbData);
1361 RTMemFree(pCacheEntry->pvData);
1362 pCacheEntry->pvData = NULL;
1363 pCacheEntry->cbData = 0;
1364 }
1365}
1366
1367/**
1368 * Initializes a cache.
1369 *
1370 * @param pCache Cache to init.
1371 */
1372void ShClCacheInit(PSHCLCACHE pCache)
1373{
1374 AssertPtrReturnVoid(pCache);
1375
1376 RT_BZERO(pCache, sizeof(SHCLCACHE));
1377
1378 for (size_t i = 0; i < RT_ELEMENTS(pCache->aEntries); i++)
1379 shClCacheEntryInit(&pCache->aEntries[i], NULL, 0);
1380}
1381
1382/**
1383 * Destroys all entries of a cache.
1384 *
1385 * @param pCache Cache to destroy entries for.
1386 */
1387DECLINLINE(void) shClCacheDestroyEntries(PSHCLCACHE pCache)
1388{
1389 for (size_t i = 0; i < RT_ELEMENTS(pCache->aEntries); i++)
1390 shClCacheEntryDestroy(&pCache->aEntries[i]);
1391}
1392
1393/**
1394 * Destroys a cache.
1395 *
1396 * @param pCache Cache to destroy.
1397 */
1398void ShClCacheDestroy(PSHCLCACHE pCache)
1399{
1400 AssertPtrReturnVoid(pCache);
1401
1402 shClCacheDestroyEntries(pCache);
1403
1404 RT_BZERO(pCache, sizeof(SHCLCACHE));
1405}
1406
1407/**
1408 * Invalidates a cache.
1409 *
1410 * @param pCache Cache to invalidate.
1411 */
1412void ShClCacheInvalidate(PSHCLCACHE pCache)
1413{
1414 AssertPtrReturnVoid(pCache);
1415
1416 shClCacheDestroyEntries(pCache);
1417}
1418
1419/**
1420 * Invalidates a specific cache entry.
1421 *
1422 * @param pCache Cache to invalidate.
1423 * @param uFmt Format to invalidate entry for.
1424 */
1425void ShClCacheInvalidateEntry(PSHCLCACHE pCache, SHCLFORMAT uFmt)
1426{
1427 AssertPtrReturnVoid(pCache);
1428 AssertReturnVoid(uFmt < VBOX_SHCL_FMT_MAX);
1429 shClCacheEntryDestroy(&pCache->aEntries[uFmt]);
1430}
1431
1432/**
1433 * Gets an entry for a Shared Clipboard format.
1434 *
1435 * @returns Pointer to entry if cached, or NULL if not in cache (cache miss).
1436 * @param pCache Cache to get entry for.
1437 * @param uFmt Format to get entry for.
1438 */
1439PSHCLCACHEENTRY ShClCacheGet(PSHCLCACHE pCache, SHCLFORMAT uFmt)
1440{
1441 AssertReturn(uFmt < VBOX_SHCL_FMT_MAX, NULL);
1442 return shClCacheEntryIsValid(&pCache->aEntries[uFmt]) ? &pCache->aEntries[uFmt] : NULL;
1443}
1444
1445/**
1446 * Sets data to cache for a specific clipboard format, internal version.
1447 *
1448 * @returns VBox status code.
1449 * @param pCache Cache to set data for.
1450 * @param uFmt Clipboard format to set data for.
1451 * @param pvData Data to set.
1452 * @param cbData Size (in bytes) of data to set.
1453 */
1454DECLINLINE(int) shClCacheSet(PSHCLCACHE pCache, SHCLFORMAT uFmt, const void *pvData, size_t cbData)
1455{
1456 AssertReturn(uFmt < VBOX_SHCL_FMT_MAX, VERR_INVALID_PARAMETER);
1457 AssertReturn(shClCacheEntryIsValid(&pCache->aEntries[uFmt]) == false, VERR_ALREADY_EXISTS);
1458
1459 return shClCacheEntryInit(&pCache->aEntries[uFmt], pvData, cbData);
1460}
1461
1462/**
1463 * Sets data to cache for a specific clipboard format.
1464 *
1465 * @returns VBox status code.
1466 * @param pCache Cache to set data for.
1467 * @param uFmt Clipboard format to set data for.
1468 * @param pvData Data to set.
1469 * @param cbData Size (in bytes) of data to set.
1470 */
1471int ShClCacheSet(PSHCLCACHE pCache, SHCLFORMAT uFmt, const void *pvData, size_t cbData)
1472{
1473 AssertPtrReturn(pCache, VERR_INVALID_POINTER);
1474
1475 if (!pvData) /* Nothing to cache? */
1476 return VINF_SUCCESS;
1477
1478 AssertReturn(cbData, VERR_INVALID_PARAMETER);
1479
1480 return shClCacheSet(pCache, uFmt, pvData, cbData);
1481}
1482
1483/**
1484 * Sets data to cache for multiple clipboard formats.
1485 *
1486 * Will bail out if a given format cannot be handled with the data given.
1487 *
1488 * @returns VBox status code.
1489 * @param pCache Cache to set data for.
1490 * @param uFmt Clipboard format to set data for.
1491 * @param pvData Data to set.
1492 * @param cbData Size (in bytes) of data to set.
1493 */
1494int ShClCacheSetMultiple(PSHCLCACHE pCache, SHCLFORMATS uFmts, const void *pvData, size_t cbData)
1495{
1496 AssertPtrReturn(pCache, VERR_INVALID_POINTER);
1497
1498 if (!pvData) /* Nothing to cache? */
1499 return VINF_SUCCESS;
1500
1501 AssertReturn(cbData, VERR_INVALID_PARAMETER);
1502
1503 int rc = VINF_SUCCESS;
1504
1505 SHCLFORMATS uFmtsLeft = uFmts;
1506 while (uFmtsLeft)
1507 {
1508 SHCLFORMAT uFmt = VBOX_SHCL_FMT_NONE;
1509 void *pvConv = NULL;
1510 size_t cbConv = 0;
1511 if (uFmtsLeft & VBOX_SHCL_FMT_UNICODETEXT)
1512 {
1513 uFmt = VBOX_SHCL_FMT_UNICODETEXT;
1514
1515 rc = RTStrValidateEncoding((const char *)pvData);
1516 if (RT_SUCCESS(rc))
1517 {
1518 rc = RTStrToUtf16((const char *)pvData, (PRTUTF16 *)&pvConv);
1519 if (RT_SUCCESS(rc))
1520 cbConv = (RTUtf16Len((const PRTUTF16)pvConv) + 1) * sizeof(RTUTF16);
1521 }
1522 else if (!RTUtf16ValidateEncoding((const PRTUTF16)pvData))
1523 {
1524 AssertFailedBreakStmt(rc = VERR_INVALID_PARAMETER);
1525 }
1526 }
1527 else if (uFmtsLeft & VBOX_SHCL_FMT_BITMAP)
1528 uFmt = VBOX_SHCL_FMT_BITMAP;
1529 else if (uFmtsLeft & VBOX_SHCL_FMT_HTML)
1530 uFmt = VBOX_SHCL_FMT_HTML;
1531 else if (uFmtsLeft & VBOX_SHCL_FMT_URI_LIST)
1532 uFmt = VBOX_SHCL_FMT_URI_LIST;
1533 else
1534 AssertFailedBreakStmt(rc = VERR_NOT_SUPPORTED);
1535
1536 uFmtsLeft &= ~uFmt; /* Remove from list. */
1537 Assert(RT_VALID_PTR(pvConv) || cbConv == 0); /* Sanity. */
1538
1539 if (RT_SUCCESS(rc))
1540 rc = shClCacheSet(pCache, uFmt,
1541 pvConv ? pvConv : pvData,
1542 cbConv ? cbConv : cbData);
1543 RTMemFree(pvConv);
1544 AssertRCBreak(rc);
1545 }
1546
1547 return rc;
1548}
1549
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette