Changeset 85828 in vbox for trunk/src/VBox/GuestHost/SharedClipboard

Timestamp:

Aug 19, 2020 9:12:33 AM (4 years ago)

Author:

vboxsync

Message:

Shared Clipboard/X11: Major cleanup for string conversion functions. Not fully tested yet.

Location:

trunk/src/VBox/GuestHost/SharedClipboard

Files:

• clipboard-common.cpp (modified) (8 diffs)
• clipboard-x11.cpp (modified) (14 diffs)

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp

@@ -25 +25 @@
 #include <iprt/path.h>
 #include <iprt/rand.h>
+#include <iprt/utf16.h>
 
 #include <iprt/errcore.h>
@@ -457 +458 @@
 }
 
-/** @todo Delinuxify the code (*Lin* -> *Host*); use AssertLogRel*. */
-
-int ShClUtf16GetWinSize(PCRTUTF16 pcwszSrc, size_t cwSrc, size_t *pcwDest)
-{
-    size_t cwDest, i;
-
-    LogFlowFunc(("pcwszSrc=%.*ls, cwSrc=%u\n", cwSrc, pcwszSrc, cwSrc));
-    AssertLogRelMsgReturn(pcwszSrc != NULL, ("vboxClipboardUtf16GetWinSize: received a null Utf16 string, returning VERR_INVALID_PARAMETER\n"), VERR_INVALID_PARAMETER);
-    if (cwSrc == 0)
-    {
-        *pcwDest = 0;
-        LogFlowFunc(("empty source string, returning\n"));
+int ShClUtf16LenUtf8(PCRTUTF16 pcwszSrc, size_t cwcSrc, size_t *pchLen)
+{
+    AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
+    AssertPtrReturn(pchLen, VERR_INVALID_POINTER);
+
+    size_t chLen = 0;
+    int rc = RTUtf16CalcUtf8LenEx(pcwszSrc, cwcSrc, &chLen);
+    if (RT_SUCCESS(rc))
+        *pchLen = chLen + 1; /* Include terminator. */
+    return rc;
+}
+
+int ShClConvUtf16CRLFToUtf8LF(PRTUTF16 pwszSrc, size_t cwcSrc,
+                              char *pszBuf, size_t cbBuf, size_t *pcbLen)
+{
+    AssertPtrReturn(pwszSrc, VERR_INVALID_POINTER);
+    AssertReturn   (cwcSrc,  VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszBuf,  VERR_INVALID_POINTER);
+    AssertPtrReturn(pcbLen,  VERR_INVALID_POINTER);
+
+    int rc;
+
+    PRTUTF16 pwszTmp = NULL;
+    size_t   cchTmp  = 0;
+
+    size_t   cbLen = 0;
+
+    /* How long will the converted text be? */
+    rc = ShClUtf16CRLFLenUtf8(pwszSrc, cwcSrc, &cchTmp);
+    if (RT_SUCCESS(rc))
+    {
+        if (cchTmp)
+        {
+            pwszTmp = (PRTUTF16)RTMemAlloc(cchTmp * sizeof(RTUTF16));
+            if (pwszTmp)
+            {
+                rc = ShClConvUtf16CRLFToLF(pwszSrc, cwcSrc, pwszTmp, cchTmp);
+                if (RT_SUCCESS(rc))
+                    rc = RTUtf16ToUtf8Ex(pwszTmp + 1, cchTmp - 1, &pszBuf, cbBuf, &cbLen);
+
+                RTMemFree(reinterpret_cast<void *>(pwszTmp));
+            }
+            else
+                rc = VERR_NO_MEMORY;
+        }
+        else
+            rc = VERR_NO_DATA;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        *pcbLen = cbLen + 1 /* Include terminator */;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int ShClConvUtf16LFToCRLFA(RTUTF16 *pwcSrc, size_t cwcSrc,
+                           PRTUTF16 *ppwszDst, size_t *pcwDst)
+{
+    AssertPtrReturn(pwcSrc, VERR_INVALID_POINTER);
+    AssertReturn(cwcSrc, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcwDst, VERR_INVALID_POINTER);
+
+    PRTUTF16 pwszDst = NULL;
+    size_t   cchDst;
+
+    int rc = ShClUtf16LFLenUtf8(pwcSrc, cwcSrc, &cchDst);
+    if (RT_SUCCESS(rc))
+    {
+        Assert(cchDst);
+        pwszDst = (PRTUTF16)RTMemAlloc(cchDst * sizeof(RTUTF16));
+        if (pwszDst)
+        {
+            rc = ShClConvUtf16LFToCRLF(pwcSrc, cwcSrc, pwszDst, cchDst);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        *ppwszDst = pwszDst;
+        *pcwDst   = cchDst;
+    }
+    else
+        RTMemFree(pwszDst);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int ShClConvUtf8LFToUtf16CRLF(const char *pcSrc, unsigned cbSrc,
+                              PRTUTF16 *ppwszDst, size_t *pcwDst)
+{
+    AssertPtrReturn(pcSrc, VERR_INVALID_POINTER);
+    AssertReturn(cbSrc, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcwDst, VERR_INVALID_POINTER);
+
+    /* Intermediate conversion to UTF-16. */
+    size_t   cwcTmp;
+    PRTUTF16 pwcTmp = NULL;
+    int rc = RTStrToUtf16Ex(pcSrc, cbSrc, &pwcTmp, 0, &cwcTmp);
+    if (RT_SUCCESS(rc))
+    {
+        rc = ShClConvUtf16LFToCRLFA(pwcTmp, cwcTmp, ppwszDst, pcwDst);
+        RTUtf16Free(pwcTmp);
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int ShClConvLatin1LFToUtf16CRLF(const char *pcSrc, unsigned cbSrc,
+                                PRTUTF16 *ppwszDst, size_t *pcwDst)
+{
+    AssertPtrReturn(pcSrc, VERR_INVALID_POINTER);
+    AssertReturn(cbSrc, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcwDst, VERR_INVALID_POINTER);
+
+    int rc = VINF_SUCCESS;
+
+    PRTUTF16 pwszDst = NULL;
+
+    /* Calculate the space needed. */
+    unsigned cbDst = 0;
+    for (unsigned i = 0; i < cbSrc && pcSrc[i] != '\0'; ++i)
+    {
+        if (pcSrc[i] == VBOX_SHCL_LINEFEED)
+            cbDst += sizeof(RTUTF16);
+        else
+            ++cbDst;
+    }
+
+    ++cbDst; /* Leave space for the terminator. */
+
+    pwszDst = (PRTUTF16)RTMemAlloc(cbDst * sizeof(RTUTF16));
+    if (!pwszDst)
+        rc = VERR_NO_MEMORY;
+
+    /* Do the conversion, bearing in mind that Latin-1 expands "naturally" to UTF-16. */
+    if (RT_SUCCESS(rc))
+    {
+        for (unsigned i = 0, j = 0; i < cbSrc; ++i, ++j)
+        {
+            if (pcSrc[i] != VBOX_SHCL_LINEFEED)
+                pwszDst[j] = pcSrc[i];
+            else
+            {
+                pwszDst[j]     = VBOX_SHCL_CARRIAGERETURN;
+                pwszDst[j + 1] = VBOX_SHCL_LINEFEED;
+                ++j;
+            }
+        }
+
+        pwszDst[cbDst - 1] = '\0';  /* Make sure we are zero-terminated. */
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        *ppwszDst = pwszDst;
+        *pcwDst   = cbDst * sizeof(RTUTF16);
+    }
+    else
+        RTMemFree(pwszDst);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int ShClConvUtf16ToUtf8HTML(RTUTF16 *pwcSrc, size_t cwSrc, char **ppszDst, size_t *pcbDst)
+{
+    AssertPtrReturn(pwcSrc,  VERR_INVALID_POINTER);
+    AssertReturn   (cwSrc,   VERR_INVALID_PARAMETER);
+    AssertPtrReturn(ppszDst, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcbDst,  VERR_INVALID_POINTER);
+
+    int rc;
+
+    size_t   cwTmp = cwSrc;
+    RTUTF16 *pwTmp = pwcSrc;
+
+    char  *pchDst = NULL;
+    size_t cbDst  = 0;
+
+    size_t i = 0;
+    while (i < cwTmp)
+    {
+        /* Find  zero symbol (end of string). */
+        for (; i < cwTmp && pwcSrc[i] != 0; i++)
+            ;
+
+        /* Convert found string. */
+        char  *psz = NULL;
+        size_t cch = 0;
+        rc = RTUtf16ToUtf8Ex(pwTmp, cwTmp, &psz, pwTmp - pwcSrc, &cch);
+        if (RT_FAILURE(rc))
+            break;
+
+        /* Append new substring. */
+        char *pchNew = (char *)RTMemRealloc(pchDst, cbDst + cch + 1);
+        if (!pchNew)
+        {
+            RTStrFree(psz);
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        pchDst = pchNew;
+        memcpy(pchDst + cbDst, psz, cch + 1);
+
+        RTStrFree(psz);
+
+        cbDst += cch + 1;
+
+        /* Skip zero symbols. */
+        for (; i < cwTmp && pwcSrc[i] == 0; i++)
+            ;
+
+        /* Remember start of string. */
+        pwTmp += i;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        *ppszDst = pchDst;
+        *pcbDst  = cbDst;
+
         return VINF_SUCCESS;
     }
-/** @todo convert the remainder of the Assert stuff to AssertLogRel. */
-    /* We only take little endian Utf16 */
-    if (pcwszSrc[0] == VBOX_SHCL_UTF16BEMARKER)
-    {
-        LogRel(("Shared Clipboard: vboxClipboardUtf16GetWinSize: received a big endian Utf16 string, returning VERR_INVALID_PARAMETER\n"));
-        AssertReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER, VERR_INVALID_PARAMETER);
-    }
-    cwDest = 0;
+
+    RTMemFree(pchDst);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int ShClUtf16LFLenUtf8(PCRTUTF16 pcwszSrc, size_t cwSrc, size_t *pchLen)
+{
+    AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
+    AssertReturn(cwSrc, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pchLen, VERR_INVALID_POINTER);
+
+    AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
+                    ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
+
+    size_t cLen = 0;
+
+    /* Don't copy the endian marker. */
+    size_t i = pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER ? 1 : 0;
+
     /* Calculate the size of the destination text string. */
     /* Is this Utf16 or Utf16-LE? */
-    for (i = (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER ? 1 : 0); i < cwSrc; ++i, ++cwDest)
+    for (; i < cwSrc; ++i, ++cLen)
     {
         /* Check for a single line feed */
         if (pcwszSrc[i] == VBOX_SHCL_LINEFEED)
-            ++cwDest;
+            ++cLen;
 #ifdef RT_OS_DARWIN
         /* Check for a single carriage return (MacOS) */
         if (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN)
-            ++cwDest;
+            ++cLen;
 #endif
         if (pcwszSrc[i] == 0)
@@ -497 +731 @@
         }
     }
-    /* Count the terminating null byte. */
-    ++cwDest;
-    LogFlowFunc(("returning VINF_SUCCESS, %d 16bit words\n", cwDest));
-    *pcwDest = cwDest;
+
+    /* Add terminator. */
+    ++cLen;
+
+    *pchLen = cLen;
+
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
     return VINF_SUCCESS;
 }
 
-int ShClUtf16LinToWin(PCRTUTF16 pcwszSrc, size_t cwSrc, PRTUTF16 pu16Dest, size_t cwDest)
-{
-    size_t i, j;
-    LogFlowFunc(("pcwszSrc=%.*ls, cwSrc=%u\n", cwSrc, pcwszSrc, cwSrc));
-    if (!VALID_PTR(pcwszSrc) || !VALID_PTR(pu16Dest))
-    {
-        LogRel(("Shared Clipboard: vboxClipboardUtf16LinToWin: received an invalid pointer, returning VERR_INVALID_PARAMETER\n"));
-        AssertReturn(VALID_PTR(pcwszSrc) && VALID_PTR(pu16Dest), VERR_INVALID_PARAMETER);
-    }
-    if (cwSrc == 0)
-    {
-        if (cwDest == 0)
-        {
-            LogFlowFunc(("returning VERR_BUFFER_OVERFLOW\n"));
-            return VERR_BUFFER_OVERFLOW;
-        }
-        pu16Dest[0] = 0;
-        LogFlowFunc(("empty source string, returning\n"));
-        return VINF_SUCCESS;
-    }
-    /* We only take little endian Utf16 */
-    if (pcwszSrc[0] == VBOX_SHCL_UTF16BEMARKER)
-    {
-        LogRel(("Shared Clipboard: vboxClipboardUtf16LinToWin: received a big endian Utf16 string, returning VERR_INVALID_PARAMETER\n"));
-        AssertReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER, VERR_INVALID_PARAMETER);
-    }
+int ShClUtf16CRLFLenUtf8(PCRTUTF16 pcwszSrc, size_t cwSrc, size_t *pchLen)
+{
+    AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
+    AssertReturn(cwSrc, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pchLen, VERR_INVALID_POINTER);
+
+    AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
+                    ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
+
+    size_t cLen = 0;
+
+    /* Calculate the size of the destination text string. */
+    /* Is this Utf16 or Utf16-LE? */
+    if (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER)
+        cLen = 0;
+    else
+        cLen = 1;
+
+    for (size_t i = 0; i < cwSrc; ++i, ++cLen)
+    {
+        if (   (i + 1 < cwSrc)
+            && (pcwszSrc[i]     == VBOX_SHCL_CARRIAGERETURN)
+            && (pcwszSrc[i + 1] == VBOX_SHCL_LINEFEED))
+        {
+            ++i;
+        }
+        if (pcwszSrc[i] == 0)
+            break;
+    }
+
+    /* Add terminating zero. */
+    ++cLen;
+
+    *pchLen = cLen;
+
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
+    return VINF_SUCCESS;
+}
+
+int ShClConvUtf16LFToCRLF(PCRTUTF16 pcwszSrc, size_t cwSrc, PRTUTF16 pu16Dst, size_t cwDst)
+{
+    AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
+    AssertReturn(cwSrc, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pu16Dst, VERR_INVALID_POINTER);
+    AssertReturn(cwDst, VERR_INVALID_PARAMETER);
+
+    AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
+                    ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
+
+    int rc = VINF_SUCCESS;
+
     /* Don't copy the endian marker. */
-    for (i = (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER ? 1 : 0), j = 0; i < cwSrc; ++i, ++j)
+    size_t i = pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER ? 1 : 0;
+    size_t j = 0;
+
+    for (; i < cwSrc; ++i, ++j)
     {
         /* Don't copy the null byte, as we add it below. */
         if (pcwszSrc[i] == 0)
             break;
-        if (j == cwDest)
-        {
-            LogFlowFunc(("returning VERR_BUFFER_OVERFLOW\n"));
-            return VERR_BUFFER_OVERFLOW;
-        }
+
+        /* Not enough space in destination? */
+        if (j == cwDst)
+        {
+            rc = VERR_BUFFER_OVERFLOW;
+            break;
+        }
+
         if (pcwszSrc[i] == VBOX_SHCL_LINEFEED)
         {
-            pu16Dest[j] = VBOX_SHCL_CARRIAGERETURN;
+            pu16Dst[j] = VBOX_SHCL_CARRIAGERETURN;
             ++j;
-            if (j == cwDest)
+
+            /* Not enough space in destination? */
+            if (j == cwDst)
             {
-                LogFlowFunc(("returning VERR_BUFFER_OVERFLOW\n"));
-                return VERR_BUFFER_OVERFLOW;
+                rc = VERR_BUFFER_OVERFLOW;
+                break;
             }
         }
@@ -555 +825 @@
         else if (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN)
         {
-            /* set cr */
-            pu16Dest[j] = VBOX_SHCL_CARRIAGERETURN;
+            /* Set CR.r */
+            pu16Dst[j] = VBOX_SHCL_CARRIAGERETURN;
             ++j;
-            if (j == cwDest)
+
+            /* Not enough space in destination? */
+            if (j == cwDst)
             {
-                LogFlowFunc(("returning VERR_BUFFER_OVERFLOW\n"));
-                return VERR_BUFFER_OVERFLOW;
+                rc = VERR_BUFFER_OVERFLOW;
+                break;
             }
-            /* add the lf */
-            pu16Dest[j] = VBOX_SHCL_LINEFEED;
+
+            /* Add line feed. */
+            pu16Dst[j] = VBOX_SHCL_LINEFEED;
             continue;
         }
 #endif
-        pu16Dest[j] = pcwszSrc[i];
-    }
-    /* Add the trailing null. */
-    if (j == cwDest)
-    {
-        LogFlowFunc(("returning VERR_BUFFER_OVERFLOW\n"));
+        pu16Dst[j] = pcwszSrc[i];
+    }
+
+    if (j == cwDst)
+        rc = VERR_BUFFER_OVERFLOW;
+
+    if (RT_SUCCESS(rc))
+    {
+        /* Add terminator. */
+        pu16Dst[j] = 0;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int ShClConvUtf16CRLFToLF(PCRTUTF16 pcwszSrc, size_t cwSrc, PRTUTF16 pu16Dst, size_t cwDst)
+{
+    AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER);
+    AssertReturn(cwSrc, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pu16Dst, VERR_INVALID_POINTER);
+    AssertReturn(cwDst, VERR_INVALID_PARAMETER);
+
+    AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER,
+                    ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED);
+
+    /* Prepend the Utf16 byte order marker if it is missing. */
+    size_t cwDstPos;
+    if (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER)
+    {
+        cwDstPos = 0;
+    }
+    else
+    {
+        pu16Dst[0] = VBOX_SHCL_UTF16LEMARKER;
+        cwDstPos = 1;
+    }
+
+    for (size_t i = 0; i < cwSrc; ++i, ++cwDstPos)
+    {
+        if (pcwszSrc[i] == 0)
+            break;
+
+        if (cwDstPos == cwDst)
+            return VERR_BUFFER_OVERFLOW;
+
+        if (   (i + 1 < cwSrc)
+            && (pcwszSrc[i]     == VBOX_SHCL_CARRIAGERETURN)
+            && (pcwszSrc[i + 1] == VBOX_SHCL_LINEFEED))
+        {
+            ++i;
+        }
+
+        pu16Dst[cwDstPos] = pcwszSrc[i];
+    }
+
+    if (cwDstPos == cwDst)
         return VERR_BUFFER_OVERFLOW;
-    }
-    pu16Dest[j] = 0;
-    LogFlowFunc(("rc=VINF_SUCCESS, pu16Dest=%ls\n", pu16Dest));
+
+    /* Add terminating zero. */
+    pu16Dst[cwDstPos] = 0;
+
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
     return VINF_SUCCESS;
 }
 
-int ShClUtf16GetLinSize(PCRTUTF16 pcwszSrc, size_t cwSrc, size_t *pcwDest)
-{
-    size_t cwDest;
-
-    LogFlowFunc(("pcwszSrc=%.*ls, cwSrc=%u\n", cwSrc, pcwszSrc, cwSrc));
-    if (!VALID_PTR(pcwszSrc))
-    {
-        LogRel(("Shared Clipboard: vboxClipboardUtf16GetLinSize: received an invalid Utf16 string, returning VERR_INVALID_PARAMETER\n"));
-        AssertReturn(VALID_PTR(pcwszSrc), VERR_INVALID_PARAMETER);
-    }
-    if (cwSrc == 0)
-    {
-        LogFlowFunc(("empty source string, returning VINF_SUCCESS\n"));
-        *pcwDest = 0;
-        return VINF_SUCCESS;
-    }
-    /* We only take little endian Utf16 */
-    if (pcwszSrc[0] == VBOX_SHCL_UTF16BEMARKER)
-    {
-        LogRel(("Shared Clipboard: vboxClipboardUtf16GetLinSize: received a big endian Utf16 string, returning VERR_INVALID_PARAMETER\n"));
-        AssertReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER, VERR_INVALID_PARAMETER);
-    }
-    /* Calculate the size of the destination text string. */
-    /* Is this Utf16 or Utf16-LE? */
-    if (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER)
-        cwDest = 0;
-    else
-        cwDest = 1;
-    for (size_t i = 0; i < cwSrc; ++i, ++cwDest)
-    {
-        if (   (i + 1 < cwSrc)
-            && (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN)
-            && (pcwszSrc[i + 1] == VBOX_SHCL_LINEFEED))
-        {
-            ++i;
-        }
-        if (pcwszSrc[i] == 0)
-        {
-            break;
-        }
-    }
-    /* Terminating zero */
-    ++cwDest;
-    LogFlowFunc(("returning %d\n", cwDest));
-    *pcwDest = cwDest;
-    return VINF_SUCCESS;
-}
-
-int ShClUtf16WinToLin(PCRTUTF16 pcwszSrc, size_t cwSrc, PRTUTF16 pu16Dest, size_t cwDest)
-{
-    size_t cwDestPos;
-
-    LogFlowFunc(("pcwszSrc=%.*ls, cwSrc=%u, pu16Dest=%p, cwDest=%u\n",
-                 cwSrc, pcwszSrc, cwSrc, pu16Dest, cwDest));
-    /* A buffer of size 0 may not be an error, but it is not a good idea either. */
-    Assert(cwDest > 0);
-    if (!VALID_PTR(pcwszSrc) || !VALID_PTR(pu16Dest))
-    {
-        LogRel(("Shared Clipboard: vboxClipboardUtf16WinToLin: received an invalid pointer, returning VERR_INVALID_PARAMETER\n"));
-        AssertReturn(VALID_PTR(pcwszSrc) && VALID_PTR(pu16Dest), VERR_INVALID_PARAMETER);
-    }
-    /* We only take little endian Utf16 */
-    if (pcwszSrc[0] == VBOX_SHCL_UTF16BEMARKER)
-    {
-        LogRel(("Shared Clipboard: vboxClipboardUtf16WinToLin: received a big endian Utf16 string, returning VERR_INVALID_PARAMETER\n"));
-        AssertMsgFailedReturn(("received a big endian string\n"), VERR_INVALID_PARAMETER);
-    }
-    if (cwDest == 0)
-    {
-        LogFlowFunc(("returning VERR_BUFFER_OVERFLOW\n"));
-        return VERR_BUFFER_OVERFLOW;
-    }
-    if (cwSrc == 0)
-    {
-        pu16Dest[0] = 0;
-        LogFlowFunc(("received empty string.  Returning VINF_SUCCESS\n"));
-        return VINF_SUCCESS;
-    }
-    /* Prepend the Utf16 byte order marker if it is missing. */
-    if (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER)
-    {
-        cwDestPos = 0;
-    }
-    else
-    {
-        pu16Dest[0] = VBOX_SHCL_UTF16LEMARKER;
-        cwDestPos = 1;
-    }
-    for (size_t i = 0; i < cwSrc; ++i, ++cwDestPos)
-    {
-        if (pcwszSrc[i] == 0)
-        {
-            break;
-        }
-        if (cwDestPos == cwDest)
-        {
-            LogFlowFunc(("returning VERR_BUFFER_OVERFLOW\n"));
-            return VERR_BUFFER_OVERFLOW;
-        }
-        if (   (i + 1 < cwSrc)
-            && (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN)
-            && (pcwszSrc[i + 1] == VBOX_SHCL_LINEFEED))
-        {
-            ++i;
-        }
-        pu16Dest[cwDestPos] = pcwszSrc[i];
-    }
-    /* Terminating zero */
-    if (cwDestPos == cwDest)
-    {
-        LogFlowFunc(("returning VERR_BUFFER_OVERFLOW\n"));
-        return VERR_BUFFER_OVERFLOW;
-    }
-    pu16Dest[cwDestPos] = 0;
-    LogFlowFunc(("set string %ls.  Returning\n", pu16Dest + 1));
-    return VINF_SUCCESS;
-}
-
 int ShClDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDest, size_t *pcbDest)
 {
-    size_t        cb            = sizeof(BMFILEHEADER) + cbSrc;
-    PBMFILEHEADER pFileHeader   = NULL;
-    void         *pvDest        = NULL;
-    size_t        offPixel      = 0;
-
-    AssertPtrReturn(pvSrc,   VERR_INVALID_PARAMETER);
-    AssertPtrReturn(ppvDest, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(pcbDest, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pvSrc,   VERR_INVALID_POINTER);
+    AssertReturn(cbSrc,      VERR_INVALID_PARAMETER);
+    AssertPtrReturn(ppvDest, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcbDest, VERR_INVALID_POINTER);
 
     PBMINFOHEADER pBitmapInfoHeader = (PBMINFOHEADER)pvSrc;
@@ -716 +920 @@
         || RT_LE2H_U32(pBitmapInfoHeader->uSize) != sizeof(BMINFOHEADER))
     {
-        Log(("vboxClipboardDibToBmp: invalid or unsupported bitmap data\n"));
         return VERR_INVALID_PARAMETER;
     }
 
-    offPixel = sizeof(BMFILEHEADER)
-                + RT_LE2H_U32(pBitmapInfoHeader->uSize)
-                + RT_LE2H_U32(pBitmapInfoHeader->uClrUsed) * sizeof(uint32_t);
+    size_t offPixel = sizeof(BMFILEHEADER)
+                    + RT_LE2H_U32(pBitmapInfoHeader->uSize)
+                    + RT_LE2H_U32(pBitmapInfoHeader->uClrUsed) * sizeof(uint32_t);
     if (cbSrc < offPixel)
-    {
-        Log(("vboxClipboardDibToBmp: invalid bitmap data\n"));
         return VERR_INVALID_PARAMETER;
-    }
-
-    pvDest = RTMemAlloc(cb);
+
+    size_t cbDst = sizeof(BMFILEHEADER) + cbSrc;
+
+    void *pvDest = RTMemAlloc(cbDst);
     if (!pvDest)
-    {
-        Log(("writeToPasteboard: cannot allocate memory for bitmap\n"));
         return VERR_NO_MEMORY;
-    }
-
-    pFileHeader = (PBMFILEHEADER)pvDest;
+
+    PBMFILEHEADER pFileHeader = (PBMFILEHEADER)pvDest;
+
     pFileHeader->uType        = BITMAPHEADERMAGIC;
-    pFileHeader->uSize        = (uint32_t)RT_H2LE_U32(cb);
+    pFileHeader->uSize        = (uint32_t)RT_H2LE_U32(cbDst);
     pFileHeader->uReserved1   = pFileHeader->uReserved2 = 0;
     pFileHeader->uOffBits     = (uint32_t)RT_H2LE_U32(offPixel);
+
     memcpy((uint8_t *)pvDest + sizeof(BMFILEHEADER), pvSrc, cbSrc);
+
     *ppvDest = pvDest;
-    *pcbDest = cb;
+    *pcbDest = cbDst;
+
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
     return VINF_SUCCESS;
 }
@@ -749 +953 @@
 int ShClBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDest, size_t *pcbDest)
 {
-    AssertPtrReturn(pvSrc,   VERR_INVALID_PARAMETER);
-    AssertPtrReturn(ppvDest, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(pcbDest, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pvSrc,   VERR_INVALID_POINTER);
+    AssertReturn(cbSrc,      VERR_INVALID_PARAMETER);
+    AssertPtrReturn(ppvDest, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcbDest, VERR_INVALID_POINTER);
 
     PBMFILEHEADER pFileHeader = (PBMFILEHEADER)pvSrc;
@@ -758 +963 @@
         || RT_LE2H_U32(pFileHeader->uSize) != cbSrc)
     {
-        Log(("vboxClipboardBmpGetDib: invalid bitmap data\n"));
         return VERR_INVALID_PARAMETER;
     }
@@ -764 +968 @@
     *ppvDest = ((uint8_t *)pvSrc) + sizeof(BMFILEHEADER);
     *pcbDest = cbSrc - sizeof(BMFILEHEADER);
+
     return VINF_SUCCESS;
 }

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp

@@ -707 +707 @@
 
     Atom *pAtoms = (Atom *)pValue;
-    unsigned i, j;
 
     LogFlowFunc(("pValue=%p, *pcLen=%u, *atomType=%d%s\n",
                  pValue, *pcLen, *atomType, *atomType == XT_CONVERT_FAIL ? " (XT_CONVERT_FAIL)" : ""));
 
+    unsigned cFormats = *pcLen;
+
+    LogRel2(("Shared Clipboard: %u formats were found\n", cFormats));
+
     SHCLX11FMTIDX *pFormats = NULL;
-    if (   *pcLen
+    if (   cFormats
         && pValue
         && (*atomType != XT_CONVERT_FAIL /* time out */))
     {
-       pFormats = (SHCLX11FMTIDX *)RTMemAllocZ(*pcLen * sizeof(SHCLX11FMTIDX));
+        /* Allocated array to hold the format indices. */
+        pFormats = (SHCLX11FMTIDX *)RTMemAllocZ(cFormats * sizeof(SHCLX11FMTIDX));
     }
 
@@ -723 +727 @@
     if (pValue)
     {
-        for (i = 0; i < *pcLen; ++i)
+        for (unsigned i = 0; i < cFormats; ++i)
         {
             if (pAtoms[i])
@@ -739 +743 @@
     if (pFormats)
     {
-        for (i = 0; i < *pcLen; ++i)
-        {
-            for (j = 0; j < RT_ELEMENTS(g_aFormats); ++j)
+        for (unsigned i = 0; i < cFormats; ++i)
+        {
+            for (unsigned j = 0; j < RT_ELEMENTS(g_aFormats); ++j)
             {
                 Atom target = XInternAtom(XtDisplay(widget),
@@ -748 +752 @@
                     pFormats[i] = j;
             }
-#if defined(DEBUG) && !defined(TESTCASE)
-            LogRel2(("%s: reporting format %d (%s)\n", __FUNCTION__,
-                     pFormats[i], g_aFormats[pFormats[i]].pcszAtom));
+#if !defined(TESTCASE)
+            if (pFormats[i] != SHCLX11FMT_INVALID)
+                LogRel2(("Shared Clipboard: Reporting format '%s'\n", g_aFormats[pFormats[i]].pcszAtom));
 #endif
         }
@@ -757 +761 @@
         LogFunc(("Reporting empty targets (none reported or allocation failure)\n"));
 
-    clipUpdateX11Targets(pCtx, pFormats, *pcLen);
+    clipUpdateX11Targets(pCtx, pFormats, cFormats);
     RTMemFree(pFormats);
 
@@ -1307 +1311 @@
 
 /**
- * Calculates a buffer size large enough to hold the source Windows format
- * text converted into Unix Utf8, including the null terminator.
- *
- * @returns VBox status code.
- * @param  pwsz                 The source text in UCS-2 with Windows EOLs.
- * @param  cwc                  The size in USC-2 elements of the source text, with or
- *                              without the terminator.
- * @param  pcbActual            Where to store the buffer size needed.
- */
-static int clipWinTxtBufSizeForUtf8(PRTUTF16 pwsz, size_t cwc,
-                                    size_t *pcbActual)
-{
-    size_t cbRet = 0;
-    int rc = RTUtf16CalcUtf8LenEx(pwsz, cwc, &cbRet);
-    if (RT_SUCCESS(rc))
-        *pcbActual = cbRet + 1;  /* null terminator */
-    return rc;
-}
-
-/**
- * Converts text from Windows format (UCS-2 with CRLF line endings) to standard UTF-8.
- *
- * @returns VBox status code.
- * @param  pwszSrc              The text to be converted.
- * @param  cbSrc                The length of @a pwszSrc in bytes.
- * @param  pszBuf               Where to write the converted string.
- * @param  cbBuf                The size of the buffer pointed to by @a pszBuf.
- * @param  pcbActual            Where to store the size of the converted string.
- *                              optional.
- */
-static int clipWinTxtToUtf8(PRTUTF16 pwszSrc, size_t cbSrc, char *pszBuf,
-                            size_t cbBuf, size_t *pcbActual)
-{
-    PRTUTF16 pwszTmp = NULL;
-    size_t cwSrc = cbSrc / 2, cwTmp = 0, cbDest = 0;
-    int rc = VINF_SUCCESS;
-
-    LogFlowFunc (("pwszSrc=%.*ls, cbSrc=%u\n", cbSrc, pwszSrc, cbSrc));
-    /* How long will the converted text be? */
-    AssertPtr(pwszSrc);
-    AssertPtr(pszBuf);
-    rc = ShClUtf16GetLinSize(pwszSrc, cwSrc, &cwTmp);
-    if (RT_SUCCESS(rc) && cwTmp == 0)
-        rc = VERR_NO_DATA;
-    if (RT_SUCCESS(rc))
-        pwszTmp = (PRTUTF16)RTMemAlloc(cwTmp * 2);
-    if (!pwszTmp)
-        rc = VERR_NO_MEMORY;
-    /* Convert the text. */
-    if (RT_SUCCESS(rc))
-        rc = ShClUtf16WinToLin(pwszSrc, cwSrc, pwszTmp, cwTmp);
-    if (RT_SUCCESS(rc))
-    {
-        /* Convert the UTF-16 string to Utf8. */
-        rc = RTUtf16ToUtf8Ex(pwszTmp + 1, cwTmp - 1, &pszBuf, cbBuf,
-                             &cbDest);
-    }
-    RTMemFree(reinterpret_cast<void *>(pwszTmp));
-    if (pcbActual)
-        *pcbActual = cbDest + 1;
-
-    if (RT_SUCCESS(rc))
-        LogFlowFunc (("converted string is %.*s. Returning.\n", cbDest, pszBuf));
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-/**
- * Satisfies a request from X11 to convert the clipboard text to UTF-8.  We
- * return null-terminated text, but can cope with non-null-terminated input.
- *
- * @returns VBox status code.
+ * Satisfies a request from X11 to convert the clipboard text to UTF-8 LF.
+ *
+ * @returns VBox status code. VERR_NO_DATA if no data was converted.
  * @param  pDisplay             An X11 display structure, needed for conversions
  *                              performed by Xlib.
@@ -1395 +1329 @@
  *                              data we are returning.
  */
-static int clipWinTxtToUtf8ForX11CB(Display *pDisplay, PRTUTF16 pwszSrc,
-                                    size_t cbSrc, Atom *atomTarget,
-                                    Atom *atomTypeReturn,
-                                    XtPointer *pValReturn,
-                                    unsigned long *pcLenReturn,
-                                    int *piFormatReturn)
-{
-    RT_NOREF(pDisplay, pcLenReturn);
+static int clipUtf16CRLFToUtf8LF(Display *pDisplay, PRTUTF16 pwszSrc,
+                                 size_t cbSrc, Atom *atomTarget,
+                                 Atom *atomTypeReturn,
+                                 XtPointer *pValReturn,
+                                 unsigned long *pcLenReturn,
+                                 int *piFormatReturn)
+{
+    RT_NOREF(pDisplay);
+
+    const size_t cwcSrc = cbSrc / sizeof(RTUTF16);
+    if (!cwcSrc)
+        return VERR_NO_DATA;
 
     /* This may slightly overestimate the space needed. */
-    size_t cbDest = 0;
-    int rc = clipWinTxtBufSizeForUtf8(pwszSrc, cbSrc / 2, &cbDest);
+    size_t chDst = 0;
+    int rc = ShClUtf16LenUtf8(pwszSrc, cwcSrc, &chDst);
     if (RT_SUCCESS(rc))
     {
-        char  *pszDest  = (char *)XtMalloc(cbDest);
+        char  *pszDest  = (char *)XtMalloc(chDst);
         size_t cbActual = 0;
         if (pszDest)
         {
-            rc = clipWinTxtToUtf8(pwszSrc, cbSrc, pszDest, cbDest, &cbActual);
+            rc = ShClConvUtf16CRLFToUtf8LF(pwszSrc, cwcSrc, pszDest, chDst, &cbActual);
         }
         else
@@ -1421 +1359 @@
         {
             *atomTypeReturn = *atomTarget;
-            *pValReturn = (XtPointer)pszDest;
-            *pcLenReturn = cbActual;
+            *pValReturn     = (XtPointer)pszDest;
+            *pcLenReturn    = cbActual;
             *piFormatReturn = 8;
         }
     }
+
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -1527 +1467 @@
             rc = VERR_NO_DATA;
         if (RT_SUCCESS(rc) && ((clipFormat == SHCLX11FMT_UTF8) || (clipFormat == SHCLX11FMT_TEXT)))
-            rc = clipWinTxtToUtf8ForX11CB(XtDisplay(pCtx->pWidget),
-                                          (PRTUTF16)pv, cb, atomTarget,
-                                          atomTypeReturn, pValReturn,
-                                          pcLenReturn, piFormatReturn);
+            rc = clipUtf16CRLFToUtf8LF(XtDisplay(pCtx->pWidget),
+                                       (PRTUTF16)pv, cb, atomTarget,
+                                       atomTypeReturn, pValReturn,
+                                       pcLenReturn, piFormatReturn);
         if (RT_SUCCESS(rc))
             clipTrimTrailingNul(*(XtPointer *)pValReturn, pcLenReturn, clipFormat);
@@ -1769 +1709 @@
 
 /**
- * Massages generic UTF-16 with CR end-of-lines into the format Windows expects
- * and return the result in a RTMemAlloc allocated buffer.
- *
- * @returns VBox status code.
- * @param  pwcSrc               The source as UTF-16.
- * @param  cwcSrc               The number of 16bit elements in @a pwcSrc, not counting
- *                              the terminating zero.
- * @param  ppwszDest            Where to store the buffer address.
- * @param  pcbDest              On success, where to store the number of bytes written.
- *                              Undefined otherwise.  Optional.
- */
-static int clipUtf16ToWinTxt(RTUTF16 *pwcSrc, size_t cwcSrc,
-                             PRTUTF16 *ppwszDest, uint32_t *pcbDest)
-{
-    AssertPtrReturn(pwcSrc, VERR_INVALID_POINTER);
-    AssertPtrReturn(ppwszDest, VERR_INVALID_POINTER);
-
-    LogFlowFunc(("pwcSrc=%p, cwcSrc=%u, ppwszDest=%p\n", pwcSrc, cwcSrc, ppwszDest));
-
-    if (pcbDest)
-        *pcbDest = 0;
-
-    PRTUTF16 pwszDest = NULL;
-    size_t   cwcDest;
-    int rc = ShClUtf16GetWinSize(pwcSrc, cwcSrc + 1, &cwcDest);
-    if (RT_SUCCESS(rc))
-    {
-        pwszDest = (PRTUTF16)RTMemAlloc(cwcDest * sizeof(RTUTF16));
-        if (!pwszDest)
-            rc = VERR_NO_MEMORY;
-    }
-
-    if (RT_SUCCESS(rc))
-        rc = ShClUtf16LinToWin(pwcSrc, cwcSrc + 1, pwszDest, cwcDest);
-
-    if (RT_SUCCESS(rc))
-    {
-        LogFlowFunc(("Converted string is %.*ls\n", cwcDest, pwszDest));
-
-        *ppwszDest = pwszDest;
-
-        if (pcbDest)
-            *pcbDest = cwcDest * sizeof(RTUTF16);
-    }
-    else
-        RTMemFree(pwszDest);
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-/**
- * Converts UTF-8 text with CR end-of-lines into UTF-16 as Windows expects it
- * and return the result in a RTMemAlloc allocated buffer.
- *
- * @returns VBox status code.
- * @param  pcSrc                The source UTF-8.
- * @param  cbSrc                The size of the source in bytes, not counting the
- *                              terminating zero.
- * @param  ppwszDest            Where to store the buffer address.
- * @param  pcbDest              On success, where to store the number of bytes written.
- *                              Undefined otherwise.  Optional.
- */
-static int clipUtf8ToWinTxt(const char *pcSrc, unsigned cbSrc,
-                            PRTUTF16 *ppwszDest, uint32_t *pcbDest)
-{
-    AssertPtrReturn(pcSrc, VERR_INVALID_POINTER);
-    AssertPtrReturn(ppwszDest, VERR_INVALID_POINTER);
-
-    LogFlowFunc(("pcSrc=%p, cbSrc=%u, ppwszDest=%p\n", pcSrc, cbSrc, ppwszDest));
-
-    if (pcbDest)
-        *pcbDest = 0;
-
-    /* Intermediate conversion to UTF-16. */
-    size_t   cwcTmp;
-    PRTUTF16 pwcTmp = NULL;
-    int rc = RTStrToUtf16Ex(pcSrc, cbSrc, &pwcTmp, 0, &cwcTmp);
-    if (RT_SUCCESS(rc))
-        rc = clipUtf16ToWinTxt(pwcTmp, cwcTmp, ppwszDest, pcbDest);
-
-    RTUtf16Free(pwcTmp);
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-/**
- * Converts Latin-1 text with CR end-of-lines into UTF-16 as Windows expects
- * it and return the result in a RTMemAlloc allocated buffer.
- *
- * @returns VBox status code.
- * @param  pcSrc                The source text.
- * @param  cbSrc                The size of the source in bytes, not counting the
- *                              terminating zero.
- * @param  ppwszDest            Where to store the buffer address.
- * @param  pcbDest              On success, where to store the number of bytes written.
- *                              Undefined otherwise.  Optional.
- */
-static int clipLatin1ToWinTxt(char *pcSrc, unsigned cbSrc,
-                              PRTUTF16 *ppwszDest, uint32_t *pcbDest)
-{
-    AssertPtrReturn(pcSrc, VERR_INVALID_POINTER);
-    AssertPtrReturn(ppwszDest, VERR_INVALID_POINTER);
-
-    LogFlowFunc(("pcSrc=%.*s, cbSrc=%u, ppwszDest=%p\n", cbSrc, (char *) pcSrc, cbSrc, ppwszDest));
-
-    PRTUTF16 pwszDest = NULL;
-    int rc = VINF_SUCCESS;
-
-    /* Calculate the space needed. */
-    unsigned cwcDest = 0;
-    for (unsigned i = 0; i < cbSrc && pcSrc[i] != '\0'; ++i)
-    {
-        if (pcSrc[i] == VBOX_SHCL_LINEFEED)
-            cwcDest += 2;
-        else
-            ++cwcDest;
-    }
-
-    ++cwcDest;  /* Leave space for the terminator. */
-
-    if (pcbDest)
-        *pcbDest = cwcDest * sizeof(RTUTF16);
-
-    pwszDest = (PRTUTF16) RTMemAlloc(cwcDest * sizeof(RTUTF16));
-    if (!pwszDest)
-        rc = VERR_NO_MEMORY;
-
-    /* And do the conversion, bearing in mind that Latin-1 expands "naturally"
-     * to UTF-16. */
-    if (RT_SUCCESS(rc))
-    {
-        for (unsigned i = 0, j = 0; i < cbSrc; ++i, ++j)
-        {
-            if (pcSrc[i] != VBOX_SHCL_LINEFEED)
-                pwszDest[j] = pcSrc[i];
-            else
-            {
-                pwszDest[j] = VBOX_SHCL_CARRIAGERETURN;
-                pwszDest[j + 1] = VBOX_SHCL_LINEFEED;
-                ++j;
-            }
-        }
-
-        pwszDest[cwcDest - 1] = '\0';  /* Make sure we are zero-terminated. */
-
-        LogFlowFunc(("Converted text is %.*ls\n", cwcDest, pwszDest));
-    }
-
-    if (RT_SUCCESS(rc))
-    {
-        *ppwszDest = pwszDest;
-    }
-    else
-        RTMemFree(pwszDest);
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-/**
-* Converts UTF-16 text into UTF-8 as Windows expects
-* it and return the result in a RTMemAlloc allocated buffer.
-*
-* @returns VBox status code.
-* @param  pcSrc                 The source text.
-* @param  cbSrc                 The size of the source in bytes, not counting the
-*                               terminating zero.
-* @param  ppwszDest             Where to store the buffer address.
-* @param  pcbDest               On success, where to store the number of bytes written.
-*                               Undefined otherwise.  Optional.
-*/
-static int clipUTF16ToWinHTML(RTUTF16 *pwcBuf, size_t cb, char **ppszOut, uint32_t *pcOut)
-{
-    AssertPtrReturn(pwcBuf,  VERR_INVALID_POINTER);
-    AssertReturn   (cb,      VERR_INVALID_PARAMETER);
-    AssertPtrReturn(ppszOut, VERR_INVALID_POINTER);
-    AssertPtrReturn(pcOut,   VERR_INVALID_POINTER);
-
-    if (cb % 2)
-        return VERR_INVALID_PARAMETER;
-
-    size_t cwc = cb / 2;
-    size_t i = 0;
-    RTUTF16 *pwc = pwcBuf;
-    char *pchRes = NULL;
-    size_t cRes = 0;
-    LogFlowFunc(("src= %ls cb=%d i=%i, %x %x\n", pwcBuf, cb, i, ppszOut, pcOut));
-    while (i < cwc)
-    {
-        /* find  zero symbol (end of string) */
-        for (; i < cwc && pwcBuf[i] != 0; i++)
-            ;
-        LogFlowFunc(("skipped nulls i=%d cwc=%d\n", i, cwc));
-
-        /* convert found string */
-        char *psz = NULL;
-        size_t cch = 0;
-        int rc = RTUtf16ToUtf8Ex(pwc, cwc, &psz, pwc - pwcBuf, &cch);
-        LogFlowFunc(("utf16toutf8 src= %ls res=%s i=%i\n", pwc, psz, i));
-        if (RT_FAILURE(rc))
-        {
-            RTMemFree(pchRes);
-            return rc;
-        }
-
-        /* append new substring */
-        char *pchNew = (char *)RTMemRealloc(pchRes, cRes + cch + 1);
-        if (!pchNew)
-        {
-            RTMemFree(pchRes);
-            RTStrFree(psz);
-            return VERR_NO_MEMORY;
-        }
-        pchRes = pchNew;
-        memcpy(pchRes + cRes, psz, cch + 1);
-        LogFlowFunc(("Temp result res=%s\n", pchRes + cRes));
-
-        /* remove temporary buffer */
-        RTStrFree(psz);
-        cRes += cch + 1;
-        /* skip zero symbols */
-        for (; i < cwc && pwcBuf[i] == 0; i++)
-            ;
-        /* remember start of string */
-        pwc += i;
-    }
-    *ppszOut = pchRes;
-    *pcOut = cRes;
-
-    return VINF_SUCCESS;
-}
-
-/**
  * Converts the data obtained from the X11 clipboard to the required format,
  * place it in the buffer supplied and signal that data has arrived.
@@ -2024 +1729 @@
     int rc = VINF_SUCCESS;
 
-    void    *pvDst = NULL;
-    uint32_t cbDst = 0;
+    void  *pvDst = NULL;
+    size_t cbDst = 0;
 
     if (pvSrc == NULL)
@@ -2041 +1746 @@
             case SHCLX11FMT_TEXT:
             {
-                /* If we are given broken UTF-8, we treat it as Latin1. */ /** @todo Is this acceptable? */
+                size_t cwDst;
+
+                /* If we are given broken UTF-8, we treat it as Latin1. */ /** @todo BUGBUG Is this acceptable? */
                 if (RT_SUCCESS(RTStrValidateEncodingEx((char *)pvSrc, cbSrc, 0)))
+                    rc = ShClConvUtf8LFToUtf16CRLF((const char *)pvSrc, cbSrc,
+                                                   (PRTUTF16 *)&pvDst, &cwDst);
+                else
+                    rc = ShClConvLatin1LFToUtf16CRLF((char *)pvSrc, cbSrc,
+                                                     (PRTUTF16 *)&pvDst, &cbDst);
+                if (RT_SUCCESS(rc))
                 {
-                    rc = clipUtf8ToWinTxt((const char *)pvSrc, cbSrc,
-                                          (PRTUTF16 *)&pvDst, &cbDst);
-                }
-                else
-                {
-                    rc = clipLatin1ToWinTxt((char *)pvSrc, cbSrc,
-                                            (PRTUTF16 *)&pvDst, &cbDst);
+                    AssertBreakStmt(cwDst, rc = VERR_INVALID_PARAMETER);
+                    cbDst = cwDst * sizeof(RTUTF16); /* Convert RTUTF16 units to bytes. */
                 }
                 break;
@@ -2113 +1821 @@
                  * Some applications sends data in UTF-16, some in UTF-8,
                  * without indication it in MIME.
-                 * But in case of UTF-16, at least an OpenOffice adds Byte Order Mark - 0xfeff
-                 * at start of clipboard data.
+                 *
+                 * In case of UTF-16, at least [Open|Libre] Office adds an byte order mark (0xfeff)
+                 * at the start of the clipboard data.
                  */
                 if (   cbSrc >= sizeof(RTUTF16)
-                    && *(PRTUTF16)pvSrc == 0xfeff)
+                    && *(PRTUTF16)pvSrc == VBOX_SHCL_UTF16LEMARKER)
                 {
-                    LogFlowFunc((" \n"));
-                    rc = clipUTF16ToWinHTML((RTUTF16 *)pvSrc, cbSrc,
-                                            (char**)&pvDst, &cbDst);
+                    rc = ShClConvUtf16ToUtf8HTML((PRTUTF16)pvSrc, cbSrc / sizeof(RTUTF16), (char**)&pvDst, &cbDst);
+                    if (RT_SUCCESS(rc))
+                    {
+                        LogFlowFunc(("UTF-16 Unicode source (%u bytes):\n%ls\n\n", cbSrc, pvSrc));
+                        LogFlowFunc(("Byte Order Mark = %hx", ((PRTUTF16)pvSrc)[0]));
+                        LogFlowFunc(("UTF-8 Unicode dest (%u bytes):\n%s\n\n", cbDst, pvDst));
+                    }
+                    else
+                        LogRel(("Shared Clipboard: Converting UTF-16 Unicode failed with %Rrc\n", rc));
                 }
-                else
+                else /* Raw data. */
                 {
                    pvDst = RTMemAlloc(cbSrc);
@@ -2138 +1853 @@
                 }
 
-                LogFlowFunc(("Source unicode %ls, cbSrc = %d\n, Byte Order Mark = %hx", pvSrc, cbSrc, ((PRTUTF16)pvSrc)[0]));
-                LogFlowFunc(("converted to win unicode %s, cbDest = %d, rc = %Rrc\n", pvDst, cbDst, rc));
                 rc = VINF_SUCCESS;
                 break;