VirtualBox

Changeset 103366 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Feb 14, 2024 6:43:42 PM (12 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
161683
Message:

Shared Clipboard/Additions: Removed lots of code duplication for reading clipboard data from the host (partly introduced by r159772) [build fix].

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp

    r103365 r103366  
    476476            else
    477477            {
    478                 uint32_t const cbPrealloc = _4K;
    479                 uint32_t       cb         = 0;
    480 
    481                 /* Preallocate a buffer, most of small text transfers will fit into it. */
    482                 HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, cbPrealloc);
    483                 if (hMem)
    484                 {
    485                     void *pvMem = GlobalLock(hMem);
    486                     if (pvMem)
     478                void    *pvData = NULL;
     479                uint32_t cbData;
     480
     481                HANDLE hMem;
     482                int rc = VbglR3ClipboardReadDataEx(&pCtx->CmdCtx, uFmtVBox, &pvData, &cbData);
     483                if (RT_SUCCESS(rc))
     484                {
     485                    /* Verify the size of returned text, the memory block for clipboard must have the exact string size. */
     486                    if (uFmtVBox == VBOX_SHCL_FMT_UNICODETEXT)
    487487                    {
    488                         /* Read the host data to the preallocated buffer. */
    489                         int rc = VbglR3ClipboardReadDataEx(&pCtx->CmdCtx, uFmtVBox, pvMem, cbPrealloc, &cb);
     488                        size_t cwcActual = 0;
     489                        rc = RTUtf16NLenEx((PCRTUTF16)pvData, cbData / sizeof(RTUTF16), &cwcActual);
    490490                        if (RT_SUCCESS(rc))
     491                            cbData = (uint32_t)((cwcActual + 1 /* '\0' */) * sizeof(RTUTF16));
     492                        else
     493                            LogRel(("Shared Clipboard: Invalid UTF16 string from host: cb=%RU32, cwcActual=%zu, rc=%Rrc\n",
     494                                    cbData, cwcActual, rc));
     495                    }
     496                    else if (uFmtVBox == VBOX_SHCL_FMT_HTML)
     497                    {
     498                        /* Wrap content into CF_HTML clipboard format if needed. */
     499                        if (!SharedClipboardWinIsCFHTML((const char *)pvMem))
    491500                        {
    492                             if (cb == 0)
     501                            char    *pszWrapped = NULL;
     502                            uint32_t cbWrapped  = 0;
     503                            rc = SharedClipboardWinConvertMIMEToCFHTML((const char *)pvData, cbData, &pszWrapped, &cbWrapped);
     504                            if (RT_SUCCESS(rc))
    493505                            {
    494                                 /* 0 bytes returned means the clipboard is empty.
    495                                  * Deallocate the memory and set hMem to NULL to get to
    496                                  * the clipboard empty code path. */
    497                                 GlobalUnlock(hMem);
    498                                 GlobalFree(hMem);
    499                                 hMem = NULL;
    500                             }
    501                             else if (cb > cbPrealloc)
    502                             {
    503                                 GlobalUnlock(hMem);
    504 
    505                                 LogRel2(("Shared Clipboard: Buffer too small (%RU32), needs %RU32 bytes\n", cbPrealloc, cb));
    506 
    507                                 /* The preallocated buffer is too small, adjust the size. */
    508                                 hMem = GlobalReAlloc(hMem, cb, 0);
    509                                 if (hMem)
     506                                AssertBreakStmt(cbWrapped, rc = VERR_INVALID_PARAMETER);
     507                                pvData = RTMemReAlloc(pvData, cbWrapped);
     508                                if (pvData)
    510509                                {
    511                                     pvMem = GlobalLock(hMem);
    512                                     if (pvMem)
    513                                     {
    514                                         /* Read the host data to the preallocated buffer. */
    515                                         uint32_t cbNew = 0;
    516                                         rc = VbglR3ClipboardReadDataEx(&pCtx->CmdCtx, uFmtVBox, pvMem, cb, &cbNew);
    517                                         if (   RT_SUCCESS(rc)
    518                                             && cbNew <= cb)
    519                                         {
    520                                             cb = cbNew;
    521                                         }
    522                                         else
    523                                         {
    524                                             LogRel(("Shared Clipboard: Receiving host data failed with %Rrc\n", rc));
    525 
    526                                             GlobalUnlock(hMem);
    527                                             GlobalFree(hMem);
    528                                             hMem = NULL;
    529                                         }
    530                                     }
    531                                     else
    532                                     {
    533                                         LogRel(("Shared Clipboard: Error locking reallocated host data buffer\n"));
    534 
    535                                         GlobalFree(hMem);
    536                                         hMem = NULL;
    537                                     }
     510                                    memcpy(pvData, pszWrapped, cbWrapped);
     511                                    cbData = cbWrapped;
    538512                                }
    539513                                else
    540                                     LogRel(("Shared Clipboard: No memory for reallocating host data buffer\n"));
     514                                    rc = VERR_NO_MEMORY;
     515                                RTMemFree(pszWrapped);
    541516                            }
    542517
    543                             if (hMem)
     518                            if (RT_FAILURE(rc))
     519                                LogRel(("Shared Clipboard: Cannot convert HTML clipboard data into CF_HTML clipboard format, rc=%Rrc\n", rc));
     520                        }
     521                    }
     522
     523                    hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, cbData);
     524                    if (hMem)
     525                    {
     526                        void *pvMem = GlobalLock(hMem);
     527                        if (pvMem)
     528                        {
     529                            memcpy(pvMem, pvData, cbData);
     530                            GlobalUnlock(hMem);
     531
     532                            HANDLE hClip = SetClipboardData(uFmtWin, hMem);
     533                            if (!hClip)
    544534                            {
    545                                 /* pvMem is the address of the data. cb is the size of returned data. */
    546                                 /* Verify the size of returned text, the memory block for clipboard
    547                                  * must have the exact string size.
    548                                  */
    549                                 if (uFmtVBox == VBOX_SHCL_FMT_UNICODETEXT)
    550                                 {
    551                                     size_t cwcActual = 0;
    552                                     rc = RTUtf16NLenEx((PCRTUTF16)pvMem, cb / sizeof(RTUTF16), &cwcActual);
    553                                     if (RT_SUCCESS(rc))
    554                                         cb = (uint32_t)((cwcActual + 1 /* '\0' */) * sizeof(RTUTF16));
    555                                     else
    556                                     {
    557                                         LogRel(("Shared Clipboard: Invalid UTF16 string from host: cb=%RU32, cwcActual=%zu, rc=%Rrc\n",
    558                                                 cb, cwcActual, rc));
    559 
    560                                         /* Discard invalid data. */
    561                                         GlobalUnlock(hMem);
    562                                         GlobalFree(hMem);
    563                                         hMem = NULL;
    564                                     }
    565                                 }
    566                                 else if (uFmtVBox == VBOX_SHCL_FMT_HTML)
    567                                 {
    568                                     /* Wrap content into CF_HTML clipboard format if needed. */
    569                                     if (!SharedClipboardWinIsCFHTML((const char *)pvMem))
    570                                     {
    571                                         char *pszWrapped = NULL;
    572                                         uint32_t cbWrapped = 0;
    573                                         rc = SharedClipboardWinConvertMIMEToCFHTML((const char *)pvMem, cb,
    574                                                                                    &pszWrapped, &cbWrapped);
    575                                         if (RT_SUCCESS(rc))
    576                                         {
    577                                             if (GlobalUnlock(hMem) == 0)
    578                                             {
    579                                                 hMem = GlobalReAlloc(hMem, cbWrapped, 0);
    580                                                 if (hMem)
    581                                                 {
    582                                                     pvMem = GlobalLock(hMem);
    583                                                     if (pvMem)
    584                                                     {
    585                                                         /* Copy wrapped content back to memory passed to system clipboard. */
    586                                                         memcpy(pvMem, pszWrapped, cbWrapped);
    587                                                         cb = cbWrapped;
    588                                                     }
    589                                                     else
    590                                                     {
    591                                                         LogRel(("Shared Clipboard: Failed to lock memory (%u), HTML clipboard data won't be converted into CF_HTML clipboard format\n", GetLastError()));
    592                                                         GlobalFree(hMem);
    593                                                         hMem = NULL;
    594                                                     }
    595                                                 }
    596                                                 else
    597                                                     LogRel(("Shared Clipboard: Failed to re-allocate memory (%u), HTML clipboard data won't be converted into CF_HTML clipboard format\n", GetLastError()));
    598                                             }
    599                                             else
    600                                                 LogRel(("Shared Clipboard: Failed to unlock memory (%u), HTML clipboard data won't be converted into CF_HTML clipboard format\n", GetLastError()));
    601 
    602                                             RTMemFree(pszWrapped);
    603                                         }
    604                                         else
    605                                             LogRel(("Shared Clipboard: Cannot convert HTML clipboard data into CF_HTML clipboard format, rc=%Rrc\n", rc));
    606                                     }
    607                                 }
     535                                /* The hMem ownership has gone to the system. Finish the processing. */
     536                                break;
    608537                            }
    609 
    610                             if (hMem)
    611                             {
    612                                 GlobalUnlock(hMem);
    613 
    614                                 hMem = GlobalReAlloc(hMem, cb, 0);
    615                                 if (hMem)
    616                                 {
    617                                     /* 'hMem' contains the host clipboard data.
    618                                      * size is 'cb' and format is 'format'. */
    619                                     HANDLE hClip = SetClipboardData(uFmtWin, hMem);
    620                                     if (hClip)
    621                                     {
    622                                         /* The hMem ownership has gone to the system. Finish the processing. */
    623                                         break;
    624                                     }
    625                                     else
    626                                         LogRel(("Shared Clipboard: Setting host data buffer to clipboard failed with %ld\n",
    627                                                 GetLastError()));
    628 
    629                                     /* Cleanup follows. */
    630                                 }
    631                                 else
    632                                     LogRel(("Shared Clipboard: No memory for allocating final host data buffer\n"));
    633                             }
     538                            else
     539                                LogRel(("Shared Clipboard: Setting host data buffer to clipboard failed with %Rrc\n",
     540                                        RTErrConvertFromWin32(GetLastError())));
    634541                        }
    635 
    636                         if (hMem)
    637                             GlobalUnlock(hMem);
     542                        else
     543                            LogRel(("Shared Clipboard: Failed to lock memory (%Rrc)\n", RTErrConvertFromWin32(GetLastError())));
     544                        GlobalFree(hMem);
    638545                    }
    639546                    else
    640547                        LogRel(("Shared Clipboard: No memory for allocating host data buffer\n"));
    641 
    642                     if (hMem)
    643                         GlobalFree(hMem);
    644548                }
    645549            }
Note: See TracChangeset for help on using the changeset viewer.

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