VirtualBox

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

Last change on this file since 91933 was 91630, checked in by vboxsync, 3 years ago

SharedClipboard/common: ShClEventSignal must clear pEvent->pPayload if RTSemEventMultiSignal fails, otherwise it the payload could be freed twice. Don't leak semaphores in ShClEventIdGenerateAndRegister failure path. Three longish r=bird comments on the insanity of the event interface. [scm fix] bugref:9437
  • Property eol-style set to native
  • Property svn:eol-style set to native
  • Property svn:keywords set to Date Revision Author Id
File size: 35.2 KB
Line 
1/* $Id: clipboard-common.cpp 91630 2021-10-07 21:28:39Z 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-2020 Oracle Corporation
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 */
19
20#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
21
22#include <iprt/alloc.h>
23#include <iprt/assert.h>
24#include <iprt/semaphore.h>
25#include <iprt/path.h>
26#include <iprt/rand.h>
27#include <iprt/utf16.h>
28
29#include <iprt/formats/bmp.h>
30
31#include <iprt/errcore.h>
32#include <VBox/log.h>
33#include <VBox/GuestHost/clipboard-helper.h>
34#include <VBox/HostServices/VBoxClipboardSvc.h>
35
36
37/*********************************************************************************************************************************
38* Prototypes *
39*********************************************************************************************************************************/
40DECLINLINE(PSHCLEVENT) shclEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent);
41
42
43/*********************************************************************************************************************************
44* Implementation *
45*********************************************************************************************************************************/
46
47/**
48 * Allocates a new event payload.
49 *
50 * @returns VBox status code.
51 * @param uID Payload ID to set for this payload. Useful for consequtive payloads.
52 * @param pvData Data block to associate to this payload.
53 * @param cbData Size (in bytes) of data block to associate.
54 * @param ppPayload Where to store the allocated event payload on success.
55 */
56int ShClPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
57 PSHCLEVENTPAYLOAD *ppPayload)
58{
59 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
60 AssertReturn(cbData > 0, VERR_INVALID_PARAMETER);
61
62 PSHCLEVENTPAYLOAD pPayload = (PSHCLEVENTPAYLOAD)RTMemAlloc(sizeof(SHCLEVENTPAYLOAD));
63 if (pPayload)
64 {
65 pPayload->pvData = RTMemDup(pvData, cbData);
66 if (pPayload->pvData)
67 {
68 pPayload->cbData = cbData;
69 pPayload->uID = uID;
70
71 *ppPayload = pPayload;
72 return VINF_SUCCESS;
73 }
74
75 RTMemFree(pPayload);
76 }
77 return VERR_NO_MEMORY;
78}
79
80/**
81 * Frees an event payload.
82 *
83 * @returns VBox status code.
84 * @param pPayload Event payload to free.
85 */
86void ShClPayloadFree(PSHCLEVENTPAYLOAD pPayload)
87{
88 if (!pPayload)
89 return;
90
91 if (pPayload->pvData)
92 {
93 Assert(pPayload->cbData);
94 RTMemFree(pPayload->pvData);
95 pPayload->pvData = NULL;
96 }
97
98 pPayload->cbData = 0;
99 pPayload->uID = UINT32_MAX;
100
101 RTMemFree(pPayload);
102}
103
104/**
105 * Destroys an event, but doesn't free the memory.
106 *
107 * @param pEvent Event to destroy.
108 */
109static void shClEventTerm(PSHCLEVENT pEvent)
110{
111 if (!pEvent)
112 return;
113
114 AssertMsgReturnVoid(pEvent->cRefs == 0, ("Event %RU32 still has %RU32 references\n",
115 pEvent->idEvent, pEvent->cRefs));
116
117 LogFlowFunc(("Event %RU32\n", pEvent->idEvent));
118
119 if (pEvent->hEvtMulSem != NIL_RTSEMEVENT)
120 {
121 RTSemEventMultiDestroy(pEvent->hEvtMulSem);
122 pEvent->hEvtMulSem = NIL_RTSEMEVENT;
123 }
124
125 ShClPayloadFree(pEvent->pPayload);
126
127 pEvent->idEvent = 0;
128}
129
130/**
131 * Creates a new event source.
132 *
133 * @returns VBox status code.
134 * @param pSource Event source to create.
135 * @param uID ID to use for event source.
136 */
137int ShClEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID)
138{
139 LogFlowFunc(("pSource=%p, uID=%RU16\n", pSource, uID));
140 AssertPtrReturn(pSource, VERR_INVALID_POINTER);
141
142 RTListInit(&pSource->lstEvents);
143
144 pSource->uID = uID;
145 /* Choose a random event ID starting point. */
146 pSource->idNextEvent = RTRandU32Ex(1, VBOX_SHCL_MAX_EVENTS - 1);
147
148 return VINF_SUCCESS;
149}
150
151/**
152 * Destroys an event source.
153 *
154 * @param pSource Event source to destroy.
155 */
156void ShClEventSourceDestroy(PSHCLEVENTSOURCE pSource)
157{
158 if (!pSource)
159 return;
160
161 LogFlowFunc(("ID=%RU32\n", pSource->uID));
162
163 ShClEventSourceReset(pSource);
164
165 pSource->uID = UINT16_MAX;
166 pSource->idNextEvent = UINT32_MAX;
167}
168
169/**
170 * Resets an event source.
171 *
172 * @param pSource Event source to reset.
173 */
174void ShClEventSourceReset(PSHCLEVENTSOURCE pSource)
175{
176 LogFlowFunc(("ID=%RU32\n", pSource->uID));
177
178 PSHCLEVENT pEvIt;
179 PSHCLEVENT pEvItNext;
180 RTListForEachSafe(&pSource->lstEvents, pEvIt, pEvItNext, SHCLEVENT, Node)
181 {
182 RTListNodeRemove(&pEvIt->Node);
183
184 shClEventTerm(pEvIt);
185
186 RTMemFree(pEvIt);
187 pEvIt = NULL;
188 }
189}
190
191/**
192 * Generates a new event ID for a specific event source and registers it.
193 *
194 * @returns New event ID generated, or NIL_SHCLEVENTID on error.
195 * @param pSource Event source to generate event for.
196 */
197SHCLEVENTID ShClEventIdGenerateAndRegister(PSHCLEVENTSOURCE pSource)
198{
199 AssertPtrReturn(pSource, NIL_SHCLEVENTID);
200
201 /*
202 * Allocate an event.
203 */
204 PSHCLEVENT pEvent = (PSHCLEVENT)RTMemAllocZ(sizeof(SHCLEVENT));
205 AssertReturn(pEvent, NIL_SHCLEVENTID);
206 int rc = RTSemEventMultiCreate(&pEvent->hEvtMulSem);
207 AssertRCReturnStmt(rc, RTMemFree(pEvent), NIL_SHCLEVENTID);
208
209 /*
210 * Allocate an unique event ID.
211 */
212 for (uint32_t cTries = 0;; cTries++)
213 {
214 SHCLEVENTID idEvent = ++pSource->idNextEvent;
215 if (idEvent < VBOX_SHCL_MAX_EVENTS)
216 { /* likely */ }
217 else
218 pSource->idNextEvent = idEvent = 1; /* zero == error, remember! */
219
220 if (shclEventGet(pSource, idEvent) == NULL)
221 {
222 pEvent->idEvent = idEvent;
223 RTListAppend(&pSource->lstEvents, &pEvent->Node);
224
225 LogFlowFunc(("uSource=%RU16: New event: %#x\n", pSource->uID, idEvent));
226 return idEvent;
227 }
228
229 AssertBreak(cTries < 4096);
230 }
231
232 AssertMsgFailed(("Unable to register a new event ID for event source %RU16\n", pSource->uID));
233
234 RTSemEventMultiDestroy(pEvent->hEvtMulSem);
235 pEvent->hEvtMulSem = NIL_RTSEMEVENTMULTI;
236 RTMemFree(pEvent);
237 return NIL_SHCLEVENTID;
238}
239
240/**
241 * Returns a specific event of a event source. Inlined version.
242 *
243 * @returns Pointer to event if found, or NULL if not found.
244 * @param pSource Event source to get event from.
245 * @param uID Event ID to get.
246 */
247DECLINLINE(PSHCLEVENT) shclEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent)
248{
249 PSHCLEVENT pEvent;
250 RTListForEach(&pSource->lstEvents, pEvent, SHCLEVENT, Node)
251 {
252 if (pEvent->idEvent == idEvent)
253 return pEvent;
254 }
255
256 return NULL;
257}
258
259/**
260 * Returns a specific event of a event source.
261 *
262 * @returns Pointer to event if found, or NULL if not found.
263 * @param pSource Event source to get event from.
264 * @param uID Event ID to get.
265 */
266PSHCLEVENT ShClEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent)
267{
268 return shclEventGet(pSource, idEvent);
269}
270
271/**
272 * Returns the last (newest) event ID which has been registered for an event source.
273 *
274 * @returns Last registered event ID, or 0 if not found.
275 * @param pSource Event source to get last registered event from.
276 */
277SHCLEVENTID ShClEventGetLast(PSHCLEVENTSOURCE pSource)
278{
279 AssertPtrReturn(pSource, 0);
280 PSHCLEVENT pEvent = RTListGetLast(&pSource->lstEvents, SHCLEVENT, Node);
281 if (pEvent)
282 return pEvent->idEvent;
283
284 return 0;
285}
286
287/**
288 * Returns the current reference count for a specific event.
289 *
290 * @returns Reference count.
291 * @param pSource Event source the specific event is part of.
292 * @param idEvent Event ID to return reference count for.
293 */
294uint32_t ShClEventGetRefs(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent)
295{
296 PSHCLEVENT pEvent = shclEventGet(pSource, idEvent);
297 if (pEvent)
298 return pEvent->cRefs;
299
300 AssertMsgFailed(("No event with %RU32\n", idEvent));
301 return 0;
302}
303
304/**
305 * Detaches a payload from an event, internal version.
306 *
307 * @returns Pointer to the detached payload. Can be NULL if the payload has no payload.
308 * @param pEvent Event to detach payload for.
309 */
310static PSHCLEVENTPAYLOAD shclEventPayloadDetachInternal(PSHCLEVENT pEvent)
311{
312#ifdef VBOX_STRICT
313 AssertPtrReturn(pEvent, NULL);
314#endif
315
316 PSHCLEVENTPAYLOAD pPayload = pEvent->pPayload;
317
318 pEvent->pPayload = NULL;
319
320 return pPayload;
321}
322
323/**
324 * Unregisters an event.
325 *
326 * @returns VBox status code.
327 * @param pSource Event source to unregister event for.
328 * @param uID Event ID to unregister.
329 *
330 * @todo r=bird: The caller must enter crit sect protecting the event source
331 * here, must it? See explanation in ShClEventWait.
332 */
333int ShClEventUnregister(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID)
334{
335 AssertPtrReturn(pSource, VERR_INVALID_POINTER);
336
337 int rc;
338
339 LogFlowFunc(("uSource=%RU16, uEvent=%RU32\n", pSource->uID, uID));
340
341 PSHCLEVENT pEvent = shclEventGet(pSource, uID);
342 if (pEvent)
343 {
344 LogFlowFunc(("Event %RU32\n", pEvent->idEvent));
345
346 RTListNodeRemove(&pEvent->Node);
347
348 shClEventTerm(pEvent);
349
350 RTMemFree(pEvent);
351 pEvent = NULL;
352
353 rc = VINF_SUCCESS;
354 }
355 else
356 rc = VERR_NOT_FOUND;
357
358 LogFlowFuncLeaveRC(rc);
359 return rc;
360}
361
362/**
363 * Waits for an event to get signalled.
364 *
365 * @returns VBox status code.
366 * @param pSource Event source that contains the event to wait for.
367 * @param uID Event ID to wait for.
368 * @param uTimeoutMs Timeout (in ms) to wait.
369 * @param ppPayload Where to store the (allocated) event payload on success. Needs to be free'd with
370 * SharedClipboardPayloadFree(). Optional.
371 *
372 * @todo r=bird: Locking protocol is totally buggered here, or at least not
373 * explained in any way whatsoever. We cannot really do shclEventGet
374 * and shclEventPayloadDetachInternal w/o holding the critical section
375 * protecting that list, otherwise wtf is the point of the locking.
376 *
377 * More to the point, ShClEventSignal is called on the HGCM service
378 * thread and would be racing the host clipboard worker thread/whomever
379 * sent the request and is making this call closely followed by
380 * ShClEventRelease and ShClEventUnregister. The waiting here might be
381 * safe if there can only ever be one single thread making these kind
382 * of requests, but the unregistering is _not_ safe w/o holding the
383 * lock and that isn't explained anywhere that I can see.
384 */
385int ShClEventWait(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, RTMSINTERVAL uTimeoutMs, PSHCLEVENTPAYLOAD *ppPayload)
386{
387 AssertPtrReturn(pSource, VERR_INVALID_POINTER);
388 AssertPtrNullReturn(ppPayload, VERR_INVALID_POINTER);
389 LogFlowFuncEnter();
390
391 int rc;
392
393 PSHCLEVENT pEvent = shclEventGet(pSource, uID);
394 if (pEvent)
395 {
396 rc = RTSemEventMultiWait(pEvent->hEvtMulSem, uTimeoutMs);
397 if (RT_SUCCESS(rc))
398 {
399 if (ppPayload)
400 {
401 /* Make sure to detach payload here, as the caller now owns the data. */
402 *ppPayload = shclEventPayloadDetachInternal(pEvent);
403 }
404 }
405
406 if (RT_FAILURE(rc))
407 LogRel2(("Shared Clipboard: Waiting for event %RU32 failed, rc=%Rrc\n", uID, rc));
408 }
409 else
410 rc = VERR_NOT_FOUND;
411
412 LogFlowFuncLeaveRC(rc);
413 return rc;
414}
415
416/**
417 * Retains an event by increasing its reference count.
418 *
419 * @returns New reference count, or UINT32_MAX if failed.
420 * @param pSource Event source of event to retain.
421 * @param idEvent ID of event to retain.
422 */
423uint32_t ShClEventRetain(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent)
424{
425 PSHCLEVENT pEvent = shclEventGet(pSource, idEvent);
426 if (!pEvent)
427 {
428 AssertFailed();
429 return UINT32_MAX;
430 }
431
432 AssertReturn(pEvent->cRefs < 64, UINT32_MAX); /* Sanity. Yeah, not atomic. */
433
434 return ASMAtomicIncU32(&pEvent->cRefs);
435}
436
437/**
438 * Releases an event by decreasing its reference count.
439 *
440 * @returns New reference count, or UINT32_MAX if failed.
441 * @param pSource Event source of event to release.
442 * @param idEvent ID of event to release.
443 *
444 * @todo r=bird: The two places this is currently used make my head explode.
445 * First you release then you unregister it. Unregister frees is
446 * unconditionally.
447 *
448 * Any sane thinking person would assume that after we've release our
449 * reference to the @a idEvent, we cannot touch it any more because we
450 * don't have a valid reference any more. So, when ShClEventUnregister
451 * is then called and unconditionally frees the event: Boooooom!
452 *
453 * The locking interface here is generally not sane either, as the
454 * locking isn't done on the @a pSource but something the caller needs
455 * implements. Since we don't have access to the lock we cannot verify
456 * the locking protocol nor can we implement it (like in
457 * ShClEventWait).
458 *
459 * A better interface would return PSHCLEVENT instead of SHCLEVENTID,
460 * and then you could work directly on that as an object, rather via a
461 * slow object list. It would eliminate shclEventGet and any though
462 * that someone might be updating the list while shclEventGet traverses
463 * it.
464 */
465uint32_t ShClEventRelease(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent)
466{
467 PSHCLEVENT pEvent = shclEventGet(pSource, idEvent);
468 AssertReturn(pEvent, UINT32_MAX);
469 AssertReturn(pEvent->cRefs, UINT32_MAX); /* Sanity. Yeah, not atomic. */
470
471 return ASMAtomicDecU32(&pEvent->cRefs);
472}
473
474/**
475 * Signals an event.
476 *
477 * @returns VBox status code.
478 * @param pSource Event source of event to signal.
479 * @param uID Event ID to signal.
480 * @param pPayload Event payload to associate. Takes ownership on
481 * success. Optional.
482 *
483 * @note Caller must enter crit sect protecting the event source!
484 */
485int ShClEventSignal(PSHCLEVENTSOURCE pSource, SHCLEVENTID uID, PSHCLEVENTPAYLOAD pPayload)
486{
487 AssertPtrReturn(pSource, VERR_INVALID_POINTER);
488
489 int rc;
490
491 LogFlowFunc(("uSource=%RU16, uEvent=%RU32\n", pSource->uID, uID));
492
493 PSHCLEVENT pEvent = shclEventGet(pSource, uID);
494 if (pEvent)
495 {
496 Assert(pEvent->pPayload == NULL);
497
498 pEvent->pPayload = pPayload;
499
500 rc = RTSemEventMultiSignal(pEvent->hEvtMulSem);
501 if (RT_FAILURE(rc))
502 pEvent->pPayload = NULL; /* (no race condition if consumer also enters the critical section) */
503 }
504 else
505 rc = VERR_NOT_FOUND;
506
507 LogFlowFuncLeaveRC(rc);
508 return rc;
509}
510
511int ShClUtf16LenUtf8(PCRTUTF16 pcwszSrc, size_t cwcSrc, size_t *pchLen)
512{
513 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
514 AssertPtrReturn(pchLen, VERR_INVALID_POINTER);
515
516 size_t chLen = 0;
517 int rc = RTUtf16CalcUtf8LenEx(pcwszSrc, cwcSrc, &chLen);
518 if (RT_SUCCESS(rc))
519 *pchLen = chLen;
520 return rc;
521}
522
523int ShClConvUtf16CRLFToUtf8LF(PCRTUTF16 pcwszSrc, size_t cwcSrc,
524 char *pszBuf, size_t cbBuf, size_t *pcbLen)
525{
526 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
527 AssertReturn (cwcSrc, VERR_INVALID_PARAMETER);
528 AssertPtrReturn(pszBuf, VERR_INVALID_POINTER);
529 AssertPtrReturn(pcbLen, VERR_INVALID_POINTER);
530
531 int rc;
532
533 PRTUTF16 pwszTmp = NULL;
534 size_t cchTmp = 0;
535
536 size_t cbLen = 0;
537
538 /* How long will the converted text be? */
539 rc = ShClUtf16CRLFLenUtf8(pcwszSrc, cwcSrc, &cchTmp);
540 if (RT_SUCCESS(rc))
541 {
542 cchTmp++; /* Add space for terminator. */
543
544 pwszTmp = (PRTUTF16)RTMemAlloc(cchTmp * sizeof(RTUTF16));
545 if (pwszTmp)
546 {
547 rc = ShClConvUtf16CRLFToLF(pcwszSrc, cwcSrc, pwszTmp, cchTmp);
548 if (RT_SUCCESS(rc))
549 rc = RTUtf16ToUtf8Ex(pwszTmp + 1, cchTmp - 1, &pszBuf, cbBuf, &cbLen);
550
551 RTMemFree(reinterpret_cast<void *>(pwszTmp));
552 }
553 else
554 rc = VERR_NO_MEMORY;
555 }
556
557 if (RT_SUCCESS(rc))
558 {
559 *pcbLen = cbLen;
560 }
561
562 return rc;
563}
564
565int ShClConvUtf16LFToCRLFA(PCRTUTF16 pcwszSrc, size_t cwcSrc,
566 PRTUTF16 *ppwszDst, size_t *pcwDst)
567{
568 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
569 AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER);
570 AssertPtrReturn(pcwDst, VERR_INVALID_POINTER);
571
572 PRTUTF16 pwszDst = NULL;
573 size_t cchDst;
574
575 int rc = ShClUtf16LFLenUtf8(pcwszSrc, cwcSrc, &cchDst);
576 if (RT_SUCCESS(rc))
577 {
578 pwszDst = (PRTUTF16)RTMemAlloc((cchDst + 1 /* Leave space for terminator */) * sizeof(RTUTF16));
579 if (pwszDst)
580 {
581 rc = ShClConvUtf16LFToCRLF(pcwszSrc, cwcSrc, pwszDst, cchDst + 1 /* Include terminator */);
582 }
583 else
584 rc = VERR_NO_MEMORY;
585 }
586
587 if (RT_SUCCESS(rc))
588 {
589 *ppwszDst = pwszDst;
590 *pcwDst = cchDst;
591 }
592 else
593 RTMemFree(pwszDst);
594
595 LogFlowFuncLeaveRC(rc);
596 return rc;
597}
598
599int ShClConvUtf8LFToUtf16CRLF(const char *pcszSrc, size_t cbSrc,
600 PRTUTF16 *ppwszDst, size_t *pcwDst)
601{
602 AssertPtrReturn(pcszSrc, VERR_INVALID_POINTER);
603 AssertReturn(cbSrc, VERR_INVALID_PARAMETER);
604 AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER);
605 AssertPtrReturn(pcwDst, VERR_INVALID_POINTER);
606
607 /* Intermediate conversion to UTF-16. */
608 size_t cwcTmp;
609 PRTUTF16 pwcTmp = NULL;
610 int rc = RTStrToUtf16Ex(pcszSrc, cbSrc, &pwcTmp, 0, &cwcTmp);
611 if (RT_SUCCESS(rc))
612 {
613 rc = ShClConvUtf16LFToCRLFA(pwcTmp, cwcTmp, ppwszDst, pcwDst);
614 RTUtf16Free(pwcTmp);
615 }
616
617 return rc;
618}
619
620int ShClConvLatin1LFToUtf16CRLF(const char *pcszSrc, size_t cbSrc,
621 PRTUTF16 *ppwszDst, size_t *pcwDst)
622{
623 AssertPtrReturn(pcszSrc, VERR_INVALID_POINTER);
624 AssertReturn(cbSrc, VERR_INVALID_PARAMETER);
625 AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER);
626 AssertPtrReturn(pcwDst, VERR_INVALID_POINTER);
627
628 int rc = VINF_SUCCESS;
629
630 PRTUTF16 pwszDst = NULL;
631
632 /* Calculate the space needed. */
633 unsigned cwDst = 0;
634 for (unsigned i = 0; i < cbSrc && pcszSrc[i] != '\0'; ++i)
635 {
636 if (pcszSrc[i] == VBOX_SHCL_LINEFEED)
637 cwDst += 2; /* Space for VBOX_SHCL_CARRIAGERETURN + VBOX_SHCL_LINEFEED. */
638 else
639 ++cwDst;
640 }
641
642 pwszDst = (PRTUTF16)RTMemAlloc((cwDst + 1 /* Leave space for the terminator */) * sizeof(RTUTF16));
643 if (!pwszDst)
644 rc = VERR_NO_MEMORY;
645
646 /* Do the conversion, bearing in mind that Latin-1 expands "naturally" to UTF-16. */
647 if (RT_SUCCESS(rc))
648 {
649 for (unsigned i = 0, j = 0; i < cbSrc; ++i, ++j)
650 {
651 if (pcszSrc[i] != VBOX_SHCL_LINEFEED)
652 pwszDst[j] = pcszSrc[i];
653 else
654 {
655 pwszDst[j] = VBOX_SHCL_CARRIAGERETURN;
656 pwszDst[j + 1] = VBOX_SHCL_LINEFEED;
657 ++j;
658 }
659 }
660
661 pwszDst[cwDst] = '\0'; /* Make sure we are zero-terminated. */
662 }
663
664 if (RT_SUCCESS(rc))
665 {
666 *ppwszDst = pwszDst;
667 *pcwDst = cwDst;
668 }
669 else
670 RTMemFree(pwszDst);
671
672 return rc;
673}
674
675int ShClConvUtf16ToUtf8HTML(PCRTUTF16 pcwszSrc, size_t cwcSrc, char **ppszDst, size_t *pcbDst)
676{
677 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
678 AssertReturn (cwcSrc, VERR_INVALID_PARAMETER);
679 AssertPtrReturn(ppszDst, VERR_INVALID_POINTER);
680 AssertPtrReturn(pcbDst, VERR_INVALID_POINTER);
681
682 int rc = VINF_SUCCESS;
683
684 size_t cwTmp = cwcSrc;
685 PCRTUTF16 pwTmp = pcwszSrc;
686
687 char *pchDst = NULL;
688 size_t cbDst = 0;
689
690 size_t i = 0;
691 while (i < cwTmp)
692 {
693 /* Find zero symbol (end of string). */
694 for (; i < cwTmp && pcwszSrc[i] != 0; i++)
695 ;
696
697 /* Convert found string. */
698 char *psz = NULL;
699 size_t cch = 0;
700 rc = RTUtf16ToUtf8Ex(pwTmp, cwTmp, &psz, pwTmp - pcwszSrc, &cch);
701 if (RT_FAILURE(rc))
702 break;
703
704 /* Append new substring. */
705 char *pchNew = (char *)RTMemRealloc(pchDst, cbDst + cch + 1);
706 if (!pchNew)
707 {
708 RTStrFree(psz);
709 rc = VERR_NO_MEMORY;
710 break;
711 }
712
713 pchDst = pchNew;
714 memcpy(pchDst + cbDst, psz, cch + 1);
715
716 RTStrFree(psz);
717
718 cbDst += cch + 1;
719
720 /* Skip zero symbols. */
721 for (; i < cwTmp && pcwszSrc[i] == 0; i++)
722 ;
723
724 /* Remember start of string. */
725 pwTmp += i;
726 }
727
728 if (RT_SUCCESS(rc))
729 {
730 *ppszDst = pchDst;
731 *pcbDst = cbDst;
732
733 return VINF_SUCCESS;
734 }
735
736 RTMemFree(pchDst);
737
738 return rc;
739}
740
741int ShClUtf16LFLenUtf8(PCRTUTF16 pcwszSrc, size_t cwSrc, size_t *pchLen)
742{
743 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
744 AssertPtrReturn(pchLen, VERR_INVALID_POINTER);
745
746 AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
747 ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
748
749 size_t cLen = 0;
750
751 /* Don't copy the endian marker. */
752 size_t i = pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER ? 1 : 0;
753
754 /* Calculate the size of the destination text string. */
755 /* Is this Utf16 or Utf16-LE? */
756 for (; i < cwSrc; ++i, ++cLen)
757 {
758 /* Check for a single line feed */
759 if (pcwszSrc[i] == VBOX_SHCL_LINEFEED)
760 ++cLen;
761#ifdef RT_OS_DARWIN
762 /* Check for a single carriage return (MacOS) */
763 if (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN)
764 ++cLen;
765#endif
766 if (pcwszSrc[i] == 0)
767 {
768 /* Don't count this, as we do so below. */
769 break;
770 }
771 }
772
773 *pchLen = cLen;
774
775 return VINF_SUCCESS;
776}
777
778int ShClUtf16CRLFLenUtf8(PCRTUTF16 pcwszSrc, size_t cwSrc, size_t *pchLen)
779{
780 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
781 AssertReturn(cwSrc, VERR_INVALID_PARAMETER);
782 AssertPtrReturn(pchLen, VERR_INVALID_POINTER);
783
784 AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
785 ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
786
787 size_t cLen = 0;
788
789 /* Calculate the size of the destination text string. */
790 /* Is this Utf16 or Utf16-LE? */
791 if (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER)
792 cLen = 0;
793 else
794 cLen = 1;
795
796 for (size_t i = 0; i < cwSrc; ++i, ++cLen)
797 {
798 if ( (i + 1 < cwSrc)
799 && (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN)
800 && (pcwszSrc[i + 1] == VBOX_SHCL_LINEFEED))
801 {
802 ++i;
803 }
804 if (pcwszSrc[i] == 0)
805 break;
806 }
807
808 *pchLen = cLen;
809
810 return VINF_SUCCESS;
811}
812
813int ShClConvUtf16LFToCRLF(PCRTUTF16 pcwszSrc, size_t cwcSrc, PRTUTF16 pu16Dst, size_t cwDst)
814{
815 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
816 AssertPtrReturn(pu16Dst, VERR_INVALID_POINTER);
817 AssertReturn(cwDst, VERR_INVALID_PARAMETER);
818
819 AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
820 ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
821
822 int rc = VINF_SUCCESS;
823
824 /* Don't copy the endian marker. */
825 size_t i = pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER ? 1 : 0;
826 size_t j = 0;
827
828 for (; i < cwcSrc; ++i, ++j)
829 {
830 /* Don't copy the null byte, as we add it below. */
831 if (pcwszSrc[i] == 0)
832 break;
833
834 /* Not enough space in destination? */
835 if (j == cwDst)
836 {
837 rc = VERR_BUFFER_OVERFLOW;
838 break;
839 }
840
841 if (pcwszSrc[i] == VBOX_SHCL_LINEFEED)
842 {
843 pu16Dst[j] = VBOX_SHCL_CARRIAGERETURN;
844 ++j;
845
846 /* Not enough space in destination? */
847 if (j == cwDst)
848 {
849 rc = VERR_BUFFER_OVERFLOW;
850 break;
851 }
852 }
853#ifdef RT_OS_DARWIN
854 /* Check for a single carriage return (MacOS) */
855 else if (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN)
856 {
857 /* Set CR.r */
858 pu16Dst[j] = VBOX_SHCL_CARRIAGERETURN;
859 ++j;
860
861 /* Not enough space in destination? */
862 if (j == cwDst)
863 {
864 rc = VERR_BUFFER_OVERFLOW;
865 break;
866 }
867
868 /* Add line feed. */
869 pu16Dst[j] = VBOX_SHCL_LINEFEED;
870 continue;
871 }
872#endif
873 pu16Dst[j] = pcwszSrc[i];
874 }
875
876 if (j == cwDst)
877 rc = VERR_BUFFER_OVERFLOW;
878
879 if (RT_SUCCESS(rc))
880 {
881 /* Add terminator. */
882 pu16Dst[j] = 0;
883 }
884
885 return rc;
886}
887
888int ShClConvUtf16CRLFToLF(PCRTUTF16 pcwszSrc, size_t cwcSrc, PRTUTF16 pu16Dst, size_t cwDst)
889{
890 AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
891 AssertReturn(cwcSrc, VERR_INVALID_PARAMETER);
892 AssertPtrReturn(pu16Dst, VERR_INVALID_POINTER);
893 AssertReturn(cwDst, VERR_INVALID_PARAMETER);
894
895 AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
896 ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
897
898 /* Prepend the Utf16 byte order marker if it is missing. */
899 size_t cwDstPos;
900 if (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER)
901 {
902 cwDstPos = 0;
903 }
904 else
905 {
906 pu16Dst[0] = VBOX_SHCL_UTF16LEMARKER;
907 cwDstPos = 1;
908 }
909
910 for (size_t i = 0; i < cwcSrc; ++i, ++cwDstPos)
911 {
912 if (pcwszSrc[i] == 0)
913 break;
914
915 if (cwDstPos == cwDst)
916 return VERR_BUFFER_OVERFLOW;
917
918 if ( (i + 1 < cwcSrc)
919 && (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN)
920 && (pcwszSrc[i + 1] == VBOX_SHCL_LINEFEED))
921 {
922 ++i;
923 }
924
925 pu16Dst[cwDstPos] = pcwszSrc[i];
926 }
927
928 if (cwDstPos == cwDst)
929 return VERR_BUFFER_OVERFLOW;
930
931 /* Add terminating zero. */
932 pu16Dst[cwDstPos] = 0;
933
934 return VINF_SUCCESS;
935}
936
937int ShClDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDest, size_t *pcbDest)
938{
939 AssertPtrReturn(pvSrc, VERR_INVALID_POINTER);
940 AssertReturn(cbSrc, VERR_INVALID_PARAMETER);
941 AssertPtrReturn(ppvDest, VERR_INVALID_POINTER);
942 AssertPtrReturn(pcbDest, VERR_INVALID_POINTER);
943
944 PBMPWIN3XINFOHDR coreHdr = (PBMPWIN3XINFOHDR)pvSrc;
945 /** @todo Support all the many versions of the DIB headers. */
946 if ( cbSrc < sizeof(BMPWIN3XINFOHDR)
947 || RT_LE2H_U32(coreHdr->cbSize) < sizeof(BMPWIN3XINFOHDR)
948 || RT_LE2H_U32(coreHdr->cbSize) != sizeof(BMPWIN3XINFOHDR))
949 {
950 return VERR_INVALID_PARAMETER;
951 }
952
953 size_t offPixel = sizeof(BMPFILEHDR)
954 + RT_LE2H_U32(coreHdr->cbSize)
955 + RT_LE2H_U32(coreHdr->cClrUsed) * sizeof(uint32_t);
956 if (cbSrc < offPixel)
957 return VERR_INVALID_PARAMETER;
958
959 size_t cbDst = sizeof(BMPFILEHDR) + cbSrc;
960
961 void *pvDest = RTMemAlloc(cbDst);
962 if (!pvDest)
963 return VERR_NO_MEMORY;
964
965 PBMPFILEHDR fileHdr = (PBMPFILEHDR)pvDest;
966
967 fileHdr->uType = BMP_HDR_MAGIC;
968 fileHdr->cbFileSize = (uint32_t)RT_H2LE_U32(cbDst);
969 fileHdr->Reserved1 = 0;
970 fileHdr->Reserved2 = 0;
971 fileHdr->offBits = (uint32_t)RT_H2LE_U32(offPixel);
972
973 memcpy((uint8_t *)pvDest + sizeof(BMPFILEHDR), pvSrc, cbSrc);
974
975 *ppvDest = pvDest;
976 *pcbDest = cbDst;
977
978 return VINF_SUCCESS;
979}
980
981int ShClBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDest, size_t *pcbDest)
982{
983 AssertPtrReturn(pvSrc, VERR_INVALID_POINTER);
984 AssertReturn(cbSrc, VERR_INVALID_PARAMETER);
985 AssertPtrReturn(ppvDest, VERR_INVALID_POINTER);
986 AssertPtrReturn(pcbDest, VERR_INVALID_POINTER);
987
988 PBMPFILEHDR pBmpHdr = (PBMPFILEHDR)pvSrc;
989 if ( cbSrc < sizeof(BMPFILEHDR)
990 || pBmpHdr->uType != BMP_HDR_MAGIC
991 || RT_LE2H_U32(pBmpHdr->cbFileSize) != cbSrc)
992 {
993 return VERR_INVALID_PARAMETER;
994 }
995
996 *ppvDest = ((uint8_t *)pvSrc) + sizeof(BMPFILEHDR);
997 *pcbDest = cbSrc - sizeof(BMPFILEHDR);
998
999 return VINF_SUCCESS;
1000}
1001
1002#ifdef LOG_ENABLED
1003
1004int ShClDbgDumpHtml(const char *pcszSrc, size_t cbSrc)
1005{
1006 int rc = VINF_SUCCESS;
1007 char *pszBuf = (char *)RTMemTmpAllocZ(cbSrc + 1);
1008 if (pszBuf)
1009 {
1010 memcpy(pszBuf, pcszSrc, cbSrc);
1011 pszBuf[cbSrc] = '\0';
1012 for (size_t off = 0; off < cbSrc; ++off)
1013 if (pszBuf[off] == '\n' || pszBuf[off] == '\r')
1014 pszBuf[off] = ' ';
1015 LogFunc(("Removed \\r\\n: %s\n", pszBuf));
1016 RTMemTmpFree(pszBuf);
1017 }
1018 else
1019 rc = VERR_NO_MEMORY;
1020 return rc;
1021}
1022
1023void ShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT uFormat)
1024{
1025 if (LogIsEnabled())
1026 {
1027 if (uFormat & VBOX_SHCL_FMT_UNICODETEXT)
1028 {
1029 LogFunc(("VBOX_SHCL_FMT_UNICODETEXT:\n"));
1030 if (pv && cb)
1031 LogFunc(("%ls\n", pv));
1032 else
1033 LogFunc(("%p %zu\n", pv, cb));
1034 }
1035 else if (uFormat & VBOX_SHCL_FMT_BITMAP)
1036 LogFunc(("VBOX_SHCL_FMT_BITMAP\n"));
1037 else if (uFormat & VBOX_SHCL_FMT_HTML)
1038 {
1039 LogFunc(("VBOX_SHCL_FMT_HTML:\n"));
1040 if (pv && cb)
1041 {
1042 LogFunc(("%s\n", pv));
1043 ShClDbgDumpHtml((const char *)pv, cb);
1044 }
1045 else
1046 LogFunc(("%p %zu\n", pv, cb));
1047 }
1048 else
1049 LogFunc(("Invalid format %02X\n", uFormat));
1050 }
1051}
1052
1053#endif /* LOG_ENABLED */
1054
1055/**
1056 * Translates a Shared Clipboard host function number to a string.
1057 *
1058 * @returns Function ID string name.
1059 * @param uFn The function to translate.
1060 */
1061const char *ShClHostFunctionToStr(uint32_t uFn)
1062{
1063 switch (uFn)
1064 {
1065 RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_SET_MODE);
1066 RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_SET_TRANSFER_MODE);
1067 RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_SET_HEADLESS);
1068 RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_CANCEL);
1069 RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_ERROR);
1070 }
1071 return "Unknown";
1072}
1073
1074/**
1075 * Translates a Shared Clipboard host message enum to a string.
1076 *
1077 * @returns Message ID string name.
1078 * @param uMsg The message to translate.
1079 */
1080const char *ShClHostMsgToStr(uint32_t uMsg)
1081{
1082 switch (uMsg)
1083 {
1084 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_QUIT);
1085 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_READ_DATA);
1086 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_FORMATS_REPORT);
1087 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_CANCELED);
1088 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_READ_DATA_CID);
1089 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_STATUS);
1090 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ);
1091 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_WRITE);
1092 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ);
1093 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_WRITE);
1094 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_OPEN);
1095 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_CLOSE);
1096 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_READ);
1097 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_WRITE);
1098 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ);
1099 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_WRITE);
1100 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN);
1101 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_CLOSE);
1102 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_READ);
1103 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_WRITE);
1104 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_CANCEL);
1105 RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ERROR);
1106 }
1107 return "Unknown";
1108}
1109
1110/**
1111 * Translates a Shared Clipboard guest message enum to a string.
1112 *
1113 * @returns Message ID string name.
1114 * @param uMsg The message to translate.
1115 */
1116const char *ShClGuestMsgToStr(uint32_t uMsg)
1117{
1118 switch (uMsg)
1119 {
1120 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_OLD_GET_WAIT);
1121 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_REPORT_FORMATS);
1122 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_DATA_READ);
1123 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_DATA_WRITE);
1124 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_CONNECT);
1125 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_REPORT_FEATURES);
1126 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_QUERY_FEATURES);
1127 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT);
1128 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT);
1129 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_GET);
1130 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_CANCEL);
1131 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_REPLY);
1132 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ);
1133 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE);
1134 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ);
1135 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE);
1136 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_OPEN);
1137 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_CLOSE);
1138 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_HDR_READ);
1139 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE);
1140 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ);
1141 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE);
1142 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_OPEN);
1143 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_CLOSE);
1144 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_READ);
1145 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_WRITE);
1146 RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ERROR);
1147 }
1148 return "Unknown";
1149}
1150
1151/**
1152 * Converts Shared Clipboard formats to a string.
1153 *
1154 * @returns Stringified Shared Clipboard formats, or NULL on failure. Must be free'd with RTStrFree().
1155 * @param fFormats Shared Clipboard formats to convert.
1156 *
1157 */
1158char *ShClFormatsToStrA(SHCLFORMATS fFormats)
1159{
1160#define APPEND_FMT_TO_STR(_aFmt) \
1161 if (fFormats & VBOX_SHCL_FMT_##_aFmt) \
1162 { \
1163 if (pszFmts) \
1164 { \
1165 rc2 = RTStrAAppend(&pszFmts, ", "); \
1166 if (RT_FAILURE(rc2)) \
1167 break; \
1168 } \
1169 \
1170 rc2 = RTStrAAppend(&pszFmts, #_aFmt); \
1171 if (RT_FAILURE(rc2)) \
1172 break; \
1173 }
1174
1175 char *pszFmts = NULL;
1176 int rc2 = VINF_SUCCESS;
1177
1178 do
1179 {
1180 APPEND_FMT_TO_STR(UNICODETEXT);
1181 APPEND_FMT_TO_STR(BITMAP);
1182 APPEND_FMT_TO_STR(HTML);
1183# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
1184 APPEND_FMT_TO_STR(URI_LIST);
1185# endif
1186
1187 } while (0);
1188
1189 if (!pszFmts)
1190 rc2 = RTStrAAppend(&pszFmts, "NONE");
1191
1192 if ( RT_FAILURE(rc2)
1193 && pszFmts)
1194 {
1195 RTStrFree(pszFmts);
1196 pszFmts = NULL;
1197 }
1198
1199#undef APPEND_FMT_TO_STR
1200
1201 return pszFmts;
1202}
1203
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use