VirtualBox

Ignore:
Timestamp:
Jun 21, 2019 10:11:59 AM (6 years ago)
Author:
vboxsync
Message:

Shared Clipboard/URI: Update.

Location:
trunk/src/VBox
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox

    • Property svn:mergeinfo

      •  

        old new  
        99/branches/VBox-5.1/src/VBox:112367,116543,116550,116568,116573
        1010/branches/VBox-5.2/src/VBox:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124263,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812,127158-127159,127162-127167,127180
        11 /branches/VBox-6.0/src/VBox:130474-130475,130477,130479
         11/branches/VBox-6.0/src/VBox:130474-130475,130477,130479,131352
        1212/branches/aeichner/vbox-chromium-cleanup/src/VBox:129818-129851,129853-129861,129871-129872,129876,129880,129882,130013-130015,130094-130095
        1313/branches/andy/draganddrop/src/VBox:90781-91268

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp

    r79176 r79267  
    4444
    4545/**
    46  * Destroys a VBOXCLIPBOARDDIRDATA structure.
    47  *
    48  * @param   pDirData            VBOXCLIPBOARDDIRDATA structure to destroy.
    49  */
    50 void SharedClipboardURIDirDataDestroy(PVBOXCLIPBOARDDIRDATA pDirData)
    51 {
    52     if (!pDirData)
    53         return;
    54 
    55     if (pDirData->pszPath)
    56     {
    57         Assert(pDirData->cbPath);
    58         RTStrFree(pDirData->pszPath);
    59         pDirData->pszPath = NULL;
    60     }
    61 }
    62 
    63 /**
    64  * Destroys a VBOXCLIPBOARDFILEHDR structure.
    65  *
    66  * @param   pFileHdr            VBOXCLIPBOARDFILEHDR structure to destroy.
    67  */
    68 void SharedClipboardURIFileHdrDestroy(PVBOXCLIPBOARDFILEHDR pFileHdr)
    69 {
    70     if (!pFileHdr)
    71         return;
    72 
    73     if (pFileHdr->pszFilePath)
    74     {
    75         Assert(pFileHdr->pszFilePath);
    76         RTStrFree(pFileHdr->pszFilePath);
    77         pFileHdr->pszFilePath = NULL;
    78     }
    79 }
    80 
    81 /**
    82  * Destroys a VBOXCLIPBOARDFILEDATA structure.
    83  *
    84  * @param   pFileData           VBOXCLIPBOARDFILEDATA structure to destroy.
    85  */
    86 void SharedClipboardURIFileDataDestroy(PVBOXCLIPBOARDFILEDATA pFileData)
    87 {
    88     if (!pFileData)
    89         return;
    90 
    91     if (pFileData->pvData)
    92     {
    93         Assert(pFileData->cbData);
    94         RTMemFree(pFileData->pvData);
    95         pFileData->pvData = NULL;
    96     }
    97 }
    98 
    99 /**
    10046 * Reads an URI data header from HGCM service parameters.
    10147 *
    … …  
    10753int VBoxSvcClipboardURIReadDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr)
    10854{
    109     if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_HDR)
    110         return VERR_INVALID_PARAMETER;
    111 
    112     RT_BZERO(pDataHdr, sizeof(VBOXCLIPBOARDDATAHDR));
    113 
    114     /* Note: Context ID (paParms[0]) not used yet. */
    115     int rc = HGCMSvcGetU32(&paParms[1], &pDataHdr->uFlags);
    116     if (RT_SUCCESS(rc))
    117         rc = HGCMSvcGetU32(&paParms[2], &pDataHdr->uScreenId);
    118     if (RT_SUCCESS(rc))
    119         rc = HGCMSvcGetU64(&paParms[3], &pDataHdr->cbTotal);
    120     if (RT_SUCCESS(rc))
    121         rc = HGCMSvcGetU32(&paParms[4], &pDataHdr->cbMeta);
    122     if (RT_SUCCESS(rc))
    123         rc = HGCMSvcGetPv(&paParms[5], &pDataHdr->pvMetaFmt, &pDataHdr->cbMetaFmt);
    124     if (RT_SUCCESS(rc))
    125         rc = HGCMSvcGetU32(&paParms[6], &pDataHdr->cbMetaFmt);
    126     if (RT_SUCCESS(rc))
    127         rc = HGCMSvcGetU64(&paParms[7], &pDataHdr->cObjects);
    128     if (RT_SUCCESS(rc))
    129         rc = HGCMSvcGetU32(&paParms[8], &pDataHdr->enmCompression);
    130     if (RT_SUCCESS(rc))
    131         rc = HGCMSvcGetU32(&paParms[9], (uint32_t *)&pDataHdr->enmChecksumType);
    132     if (RT_SUCCESS(rc))
    133         rc = HGCMSvcGetPv(&paParms[10], &pDataHdr->pvChecksum, &pDataHdr->cbChecksum);
    134     if (RT_SUCCESS(rc))
    135         rc = HGCMSvcGetU32(&paParms[11], &pDataHdr->cbChecksum);
    136 
    137     LogFlowFunc(("fFlags=0x%x, cbMeta=%RU32, cbTotalSize=%RU64, cObj=%RU64\n",
    138                  pDataHdr->uFlags, pDataHdr->cbMeta, pDataHdr->cbTotal, pDataHdr->cObjects));
    139 
    140     if (RT_SUCCESS(rc))
    141     {
    142         /** @todo Validate pvMetaFmt + cbMetaFmt. */
    143         /** @todo Validate header checksum. */
    144     }
     55    int rc;
     56
     57    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_HDR)
     58    {
     59        /* Note: Context ID (paParms[0]) not used yet. */
     60        rc = HGCMSvcGetU32(&paParms[1], &pDataHdr->uFlags);
     61        if (RT_SUCCESS(rc))
     62            rc = HGCMSvcGetU32(&paParms[2], &pDataHdr->uScreenId);
     63        if (RT_SUCCESS(rc))
     64            rc = HGCMSvcGetU64(&paParms[3], &pDataHdr->cbTotal);
     65        if (RT_SUCCESS(rc))
     66            rc = HGCMSvcGetU32(&paParms[4], &pDataHdr->cbMeta);
     67        if (RT_SUCCESS(rc))
     68            rc = HGCMSvcGetU32(&paParms[5], &pDataHdr->cbMetaFmt);
     69        if (RT_SUCCESS(rc))
     70            rc = HGCMSvcGetPv(&paParms[6], &pDataHdr->pvMetaFmt, &pDataHdr->cbMetaFmt);
     71        if (RT_SUCCESS(rc))
     72            rc = HGCMSvcGetU64(&paParms[7], &pDataHdr->cObjects);
     73        if (RT_SUCCESS(rc))
     74            rc = HGCMSvcGetU32(&paParms[8], &pDataHdr->enmCompression);
     75        if (RT_SUCCESS(rc))
     76            rc = HGCMSvcGetU32(&paParms[9], (uint32_t *)&pDataHdr->enmChecksumType);
     77        if (RT_SUCCESS(rc))
     78            rc = HGCMSvcGetU32(&paParms[10], &pDataHdr->cbChecksum);
     79        if (RT_SUCCESS(rc))
     80            rc = HGCMSvcGetPv(&paParms[11], &pDataHdr->pvChecksum, &pDataHdr->cbChecksum);
     81
     82        LogFlowFunc(("fFlags=0x%x, cbMeta=%RU32, cbTotalSize=%RU64, cObj=%RU64\n",
     83                     pDataHdr->uFlags, pDataHdr->cbMeta, pDataHdr->cbTotal, pDataHdr->cObjects));
     84
     85        if (RT_SUCCESS(rc))
     86        {
     87            /** @todo Validate pvMetaFmt + cbMetaFmt. */
     88            /** @todo Validate header checksum. */
     89        }
     90    }
     91    else
     92        rc = VERR_INVALID_PARAMETER;
    14593
    14694    LogFlowFuncLeaveRC(rc);
    … …  
    158106int VBoxSvcClipboardURIReadDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk)
    159107{
    160     if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_CHUNK)
    161         return VERR_INVALID_PARAMETER;
    162 
    163     RT_BZERO(pDataChunk, sizeof(VBOXCLIPBOARDDATACHUNK));
    164 
    165     /* Note: Context ID (paParms[0]) not used yet. */
    166     int rc = HGCMSvcGetPv(&paParms[1], (void**)&pDataChunk->pvData, &pDataChunk->cbData);
    167     if (RT_SUCCESS(rc))
    168         rc = HGCMSvcGetU32(&paParms[2], &pDataChunk->cbData);
    169     if (RT_SUCCESS(rc))
    170         rc = HGCMSvcGetPv(&paParms[3], (void**)&pDataChunk->pvChecksum, &pDataChunk->cbChecksum);
    171     if (RT_SUCCESS(rc))
    172         rc = HGCMSvcGetU32(&paParms[4], &pDataChunk->cbChecksum);
    173 
    174     if (RT_SUCCESS(rc))
    175     {
    176         if (!SharedClipboardURIDataChunkIsValid(pDataChunk))
    177             rc = VERR_INVALID_PARAMETER;
    178     }
     108    int rc;
     109
     110    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_CHUNK)
     111    {
     112        /* Note: Context ID (paParms[0]) not used yet. */
     113        rc = HGCMSvcGetU32(&paParms[1], &pDataChunk->cbData);
     114        if (RT_SUCCESS(rc))
     115            rc = HGCMSvcGetPv(&paParms[2], &pDataChunk->pvData, &pDataChunk->cbData);
     116        if (RT_SUCCESS(rc))
     117            rc = HGCMSvcGetU32(&paParms[3], &pDataChunk->cbChecksum);
     118        if (RT_SUCCESS(rc))
     119            rc = HGCMSvcGetPv(&paParms[4], &pDataChunk->pvChecksum, &pDataChunk->cbChecksum);
     120
     121        if (RT_SUCCESS(rc))
     122        {
     123            if (!SharedClipboardURIDataChunkIsValid(pDataChunk))
     124                rc = VERR_INVALID_PARAMETER;
     125        }
     126    }
     127    else
     128        rc = VERR_INVALID_PARAMETER;
    179129
    180130    LogFlowFuncLeaveRC(rc);
    … …  
    192142int VBoxSvcClipboardURIReadDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData)
    193143{
    194     if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DIR)
    195         return VERR_INVALID_PARAMETER;
    196 
    197     RT_BZERO(pDirData, sizeof(VBOXCLIPBOARDDIRDATA));
    198 
    199     /* Note: Context ID (paParms[0]) not used yet. */
    200     int rc = HGCMSvcGetPv(&paParms[1], (void**)&pDirData->pszPath, &pDirData->cbPath);
    201     if (RT_SUCCESS(rc))
    202         rc = HGCMSvcGetU32(&paParms[2], &pDirData->cbPath);
    203     if (RT_SUCCESS(rc))
    204         rc = HGCMSvcGetU32(&paParms[3], &pDirData->fMode);
    205 
    206     LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x\n", pDirData->pszPath, pDirData->cbPath, pDirData->fMode));
    207 
    208     if (RT_SUCCESS(rc))
    209     {
    210         if (!SharedClipboardURIDirDataIsValid(pDirData))
    211             rc = VERR_INVALID_PARAMETER;
    212     }
     144    int rc;
     145
     146    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DIR)
     147    {
     148        /* Note: Context ID (paParms[0]) not used yet. */
     149        rc = HGCMSvcGetU32(&paParms[1], &pDirData->cbPath);
     150        if (RT_SUCCESS(rc))
     151            rc = HGCMSvcGetPv(&paParms[2], (void **)&pDirData->pszPath, &pDirData->cbPath);
     152        if (RT_SUCCESS(rc))
     153            rc = HGCMSvcGetU32(&paParms[3], &pDirData->fMode);
     154
     155        LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x\n", pDirData->pszPath, pDirData->cbPath, pDirData->fMode));
     156
     157        if (RT_SUCCESS(rc))
     158        {
     159            if (!SharedClipboardURIDirDataIsValid(pDirData))
     160                rc = VERR_INVALID_PARAMETER;
     161        }
     162    }
     163    else
     164        rc = VERR_INVALID_PARAMETER;
    213165
    214166    LogFlowFuncLeaveRC(rc);
    … …  
    226178int VBoxSvcClipboardURIReadFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr)
    227179{
    228     if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_FILE_HDR)
    229         return VERR_INVALID_PARAMETER;
    230 
    231     RT_BZERO(pFileHdr, sizeof(VBOXCLIPBOARDFILEHDR));
    232 
    233     /* Note: Context ID (paParms[0]) not used yet. */
    234     int rc = HGCMSvcGetPv(&paParms[1], (void**)&pFileHdr->pszFilePath, &pFileHdr->cbFilePath);
    235     if (RT_SUCCESS(rc))
    236         rc = HGCMSvcGetU32(&paParms[2], &pFileHdr->cbFilePath);
    237     if (RT_SUCCESS(rc))
    238         rc = HGCMSvcGetU32(&paParms[3], &pFileHdr->fFlags);
    239     if (RT_SUCCESS(rc))
    240         rc = HGCMSvcGetU32(&paParms[4], &pFileHdr->fMode);
    241     if (RT_SUCCESS(rc))
    242         rc = HGCMSvcGetU64(&paParms[5], &pFileHdr->cbSize);
    243 
    244     LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x, cbSize=%RU64\n",
    245                  pFileHdr->pszFilePath, pFileHdr->cbFilePath, pFileHdr->fMode, pFileHdr->cbSize));
     180    int rc;
     181
     182    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_FILE_HDR)
     183    {
     184        /* Note: Context ID (paParms[0]) not used yet. */
     185        rc = HGCMSvcGetU32(&paParms[1], &pFileHdr->cbFilePath);
     186        if (RT_SUCCESS(rc))
     187            rc = HGCMSvcGetPv(&paParms[2], (void **)&pFileHdr->pszFilePath, &pFileHdr->cbFilePath);
     188        if (RT_SUCCESS(rc))
     189            rc = HGCMSvcGetU32(&paParms[3], &pFileHdr->fFlags);
     190        if (RT_SUCCESS(rc))
     191            rc = HGCMSvcGetU32(&paParms[4], &pFileHdr->fMode);
     192        if (RT_SUCCESS(rc))
     193            rc = HGCMSvcGetU64(&paParms[5], &pFileHdr->cbSize);
     194
     195        LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x, cbSize=%RU64\n",
     196                     pFileHdr->pszFilePath, pFileHdr->cbFilePath, pFileHdr->fMode, pFileHdr->cbSize));
     197    }
     198    else
     199        rc = VERR_INVALID_PARAMETER;
    246200
    247201    LogFlowFuncLeaveRC(rc);
    … …  
    259213int VBoxSvcClipboardURIReadFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData)
    260214{
    261     if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_FILE_DATA)
    262         return VERR_INVALID_PARAMETER;
    263 
    264     RT_BZERO(pFileData, sizeof(VBOXCLIPBOARDFILEDATA));
    265 
    266     /* Note: Context ID (paParms[0]) not used yet. */
    267     int rc = HGCMSvcGetPv(&paParms[1], (void**)&pFileData->pvData, &pFileData->cbData);
    268     if (RT_SUCCESS(rc))
    269         rc = HGCMSvcGetU32(&paParms[2], &pFileData->cbData);
    270     if (RT_SUCCESS(rc))
    271         rc = HGCMSvcGetPv(&paParms[3], (void**)&pFileData->pvChecksum, &pFileData->cbChecksum);
    272     if (RT_SUCCESS(rc))
    273         rc = HGCMSvcGetU32(&paParms[4], &pFileData->cbChecksum);
    274 
    275     LogFlowFunc(("pvData=0x%p, cbData=%RU32\n", pFileData->pvData, pFileData->cbData));
     215    int rc;
     216
     217    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_FILE_DATA)
     218    {
     219        /* Note: Context ID (paParms[0]) not used yet. */
     220        rc = HGCMSvcGetU32(&paParms[1], &pFileData->cbData);
     221        if (RT_SUCCESS(rc))
     222            rc = HGCMSvcGetPv(&paParms[2], &pFileData->pvData, &pFileData->cbData);
     223        if (RT_SUCCESS(rc))
     224            rc = HGCMSvcGetU32(&paParms[3], &pFileData->cbChecksum);
     225        if (RT_SUCCESS(rc))
     226            rc = HGCMSvcGetPv(&paParms[4], &pFileData->pvChecksum, &pFileData->cbChecksum);
     227
     228        LogFlowFunc(("pvData=0x%p, cbData=%RU32\n", pFileData->pvData, pFileData->cbData));
     229    }
     230    else
     231        rc = VERR_INVALID_PARAMETER;
    276232
    277233    LogFlowFuncLeaveRC(rc);
    … …  
    308264
    309265    /* Check if we've the right mode set. */
    310     int rc = VERR_ACCESS_DENIED; /* Play safe. */
    311 
    312266    if (!vboxSvcClipboardURIMsgIsAllowed(vboxSvcClipboardGetMode(), u32Function))
    313         return rc;
     267        return VERR_ACCESS_DENIED;
    314268
    315269    /* A (valid) service extension is needed because VBoxSVC needs to keep track of the
    … …  
    321275#endif
    322276        LogFunc(("Invalid / no service extension set, skipping URI handling\n"));
    323         rc = VERR_NOT_SUPPORTED;
    324     }
    325 
    326     if (RT_FAILURE(rc))
    327         return rc;
    328 
    329     const PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClientData->URI, 0 /* Index */);
    330 
    331     bool fWrite = false;
    332 
    333     rc = VERR_INVALID_PARAMETER; /* Play safe. */
     277        return VERR_NOT_SUPPORTED;
     278    }
     279
     280    if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
     281    {
     282        LogFunc(("No active transfers found\n"));
     283        return VERR_WRONG_ORDER;
     284    }
     285
     286    const uint32_t uTransferID = 0; /* Only one transfer is supported at the moment. */
     287
     288    const PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClientData->URI, uTransferID);
     289    if (!pTransfer)
     290    {
     291        LogFunc(("Transfer with ID %RU32 not found\n", uTransferID));
     292        return VERR_WRONG_ORDER;
     293    }
     294
     295    bool fDispatchToProvider = false; /* Whether to (also) dispatch the HCGCM data to the transfer provider. */
     296
     297    int rc = VERR_INVALID_PARAMETER; /* Play safe. */
    334298
    335299    switch (u32Function)
    … …  
    337301        case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_HDR:
    338302        {
    339             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_DATA_HDR\n"));
    340             if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_HDR)
    341             {
    342                 bool fDetach = false;
    343 
    344                 if (RT_SUCCESS(rc))
    345                 {
    346                     // pTransfer->Area. parms.uID
    347 
    348                     /** @todo Detach if header / meta size is 0. */
    349                 }
    350 
    351                 /* Do we need to detach again because we're done? */
    352                 if (fDetach)
    353                     vboxSvcClipboardURIAreaDetach(&pClientData->State, pTransfer);
    354             }
     303            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_HDR\n"));
    355304            break;
    356305        }
    … …  
    358307        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR:
    359308        {
    360 
    361             RT_BREAKPOINT();
    362 
    363             if (   u32Function == VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR
    364                 && SharedClipboardURICtxMaximumTransfersReached(&pClientData->URI))
    365             {
    366                 rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
    367                 break;
    368             }
    369 
    370             fWrite = true;
     309            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR\n"));
     310
     311            VBOXCLIPBOARDDATAHDR dataHdr;
     312            rc = SharedClipboardURIDataHdrInit(&dataHdr);
     313            if (RT_SUCCESS(rc))
     314                rc = VBoxSvcClipboardURIReadDataHdr(cParms, paParms, &dataHdr);
     315            if (RT_SUCCESS(rc))
     316            {
     317                AssertBreakStmt(pTransfer->State.pHeader == NULL, rc = VERR_WRONG_ORDER);
     318                pTransfer->State.pHeader = SharedClipboardURIDataHdrDup(&dataHdr);
     319                if (pTransfer->State.pHeader)
     320                {
     321                    LogFlowFunc(("Meta data size is %RU32\n", pTransfer->State.pHeader->cbMeta));
     322                }
     323                else
     324                    rc = VERR_NO_MEMORY;
     325            }
     326            break;
     327        }
     328
     329        case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_CHUNK:
     330        {
     331            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_CHUNK\n"));
    371332            break;
    372333        }
    … …  
    374335        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_CHUNK:
    375336        {
    376             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_CHUNK\n"));
    377 
    378             if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
    379             {
    380                 rc = VERR_WRONG_ORDER;
    381                 break;
    382             }
    383 
    384            fWrite = true;
    385 #if 0
     337            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_CHUNK\n"));
     338
     339            VBOXCLIPBOARDDATACHUNK dataChunk;
     340            rc = SharedClipboardURIDataChunkInit(&dataChunk);
    386341            if (RT_SUCCESS(rc))
    387             {
    388                 /** @todo Validate checksum. */
    389                 rc = SharedClipboardMetaDataAdd(&pTransfer->Meta, data.pvData, data.cbData);
     342                rc = VBoxSvcClipboardURIReadDataChunk(cParms, paParms, &dataChunk);
     343            if (RT_SUCCESS(rc))
     344            {
     345                AssertPtrBreakStmt(pTransfer->State.pHeader, rc = VERR_WRONG_ORDER);
     346
     347                rc = SharedClipboardURITransferMetaDataAdd(pTransfer, dataChunk.pvData, dataChunk.cbData);
    390348                if (   RT_SUCCESS(rc)
    391                     && SharedClipboardMetaDataGetUsed(&pTransfer->Meta) == pTransfer->Header.cbMeta) /* Meta data transfer complete? */
    392                 {
    393                     if (RT_SUCCESS(rc))
    394                     {
    395 
    396                     }
    397 
    398                     /* We're done processing the meta data, so just destroy it. */
    399                     SharedClipboardMetaDataDestroy(&pTransfer->Meta);
    400                 }
    401             }
    402 #endif
     349                    && SharedClipboardURITransferMetaDataIsComplete(pTransfer)) /* Meta data transfer complete? */
     350                {
     351                    rc = SharedClipboardURITransferPrepare(pTransfer);
     352                }
     353            }
     354
    403355            break;
    404356        }
    … …  
    406358        case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DIR:
    407359        {
    408             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_DIR\n"));
     360            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DIR\n"));
    409361            if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_DIR)
    410362            {
    … …  
    432384        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR:
    433385        {
    434             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_DIR\n"));
    435 
    436             if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
    437             {
    438                 rc = VERR_WRONG_ORDER;
    439                 break;
    440             }
    441 
    442 #if 0
     386            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR\n"));
     387
     388            VBOXCLIPBOARDDIRDATA dirData;
     389            rc = VBoxSvcClipboardURIReadDir(cParms, paParms, &dirData);
    443390            if (RT_SUCCESS(rc))
    444391            {
    … …  
    447394
    448395                const char *pszCacheDir = pArea->GetDirAbs();
    449                 char *pszDir = RTPathJoinA(pszCacheDir, data.pszPath);
     396                char *pszDir = RTPathJoinA(pszCacheDir, dirData.pszPath);
    450397                if (pszDir)
    451398                {
    452399                    LogFlowFunc(("pszDir=%s\n", pszDir));
    453400
    454                     rc = RTDirCreateFullPath(pszDir, data.fMode);
     401                    rc = RTDirCreateFullPath(pszDir, dirData.fMode);
    455402                    if (RT_SUCCESS(rc))
    456403                    {
    … …  
    465412                    rc = VERR_NO_MEMORY;
    466413            }
    467 #endif
    468414            break;
    469415        }
    … …  
    471417        case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR:
    472418        {
    473             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_FILE_HDR\n"));
     419            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR\n"));
    474420            if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_HDR)
    475421            {
    476                 if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
    477                 {
    478                     rc = VERR_WRONG_ORDER;
    479                     break;
    480                 }
    481 
    482422                VBOXCLIPBOARDFILEHDR hdr;
    483423                rc = VBoxClipboardSvcImplURIReadFileHdr(pClientData, &hdr);
    … …  
    499439        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_HDR:
    500440        {
    501             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_HDR\n"));
    502 
    503                 if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
    504                 {
    505                     rc = VERR_WRONG_ORDER;
    506                     break;
    507                 }
    508 
    509 #if 0
     441            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_HDR\n"));
     442
     443            if (!SharedClipboardURIObjCtxIsValid(SharedClipboardURITransferGetCurrentObjCtx(pTransfer)))
     444            {
     445                pTransfer->ObjCtx.pObj = new SharedClipboardURIObject(SharedClipboardURIObject::Type_File);
     446                if (pTransfer->ObjCtx.pObj) /** @todo Can this throw? */
     447                {
     448                    rc = VINF_SUCCESS;
     449                }
     450                else
     451                    rc = VERR_NO_MEMORY;
     452            }
     453            else /* There still is another object being processed? */
     454                rc = VERR_WRONG_ORDER;
     455
     456            if (RT_FAILURE(rc))
     457                break;
     458
     459            VBOXCLIPBOARDFILEHDR fileHdr;
     460            rc = VBoxSvcClipboardURIReadFileHdr(cParms, paParms, &fileHdr);
     461            if (RT_SUCCESS(rc))
     462            {
     463                SharedClipboardArea *pArea = SharedClipboardURITransferGetArea(pTransfer);
     464                AssertPtrBreakStmt(pArea, rc = VERR_WRONG_ORDER);
     465
     466                const char *pszCacheDir = pArea->GetDirAbs();
     467
     468    RT_BREAKPOINT();
     469
     470                char pszPathAbs[RTPATH_MAX];
     471                rc = RTPathJoin(pszPathAbs, sizeof(pszPathAbs), pszCacheDir, fileHdr.pszFilePath);
    510472                if (RT_SUCCESS(rc))
    511473                {
    512                     if (!vboxSvcClipboardURIFileHdrIsValid(&data, &pTransfer->Header))
    513                     {
    514                         rc = VERR_INVALID_PARAMETER;
    515                     }
    516                     else
    517                     {
    518                         if (pTransfer->ObjCtx.pObj == NULL)
    519                         {
    520                             pTransfer->ObjCtx.pObj = new SharedClipboardURIObject(SharedClipboardURIObject::Type_File);
    521                             if (!pTransfer->ObjCtx.pObj) /** @todo Can this throw? */
    522                                 rc = VERR_NO_MEMORY;
    523                         }
    524                         else /* There still is another object being processed? */
    525                            rc = VERR_WRONG_ORDER;
    526                     }
    527                 }
    528 
    529                 if (RT_SUCCESS(rc))
    530                 {
    531                     SharedClipboardArea *pArea = SharedClipboardURITransferGetArea(pTransfer);
    532                     AssertPtrBreakStmt(pArea, rc = VERR_INVALID_POINTER);
    533 
    534                     const char *pszCacheDir = pArea->GetDirAbs();
    535 
    536                     char pszPathAbs[RTPATH_MAX];
    537                     rc = RTPathJoin(pszPathAbs, sizeof(pszPathAbs), pszCacheDir, data.pszFilePath);
     474                    rc = SharedClipboardPathSanitize(pszPathAbs, sizeof(pszPathAbs));
    538475                    if (RT_SUCCESS(rc))
    539476                    {
    540                         rc = SharedClipboardPathSanitize(pszPathAbs, sizeof(pszPathAbs));
     477                        PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer);
     478                        AssertPtrBreakStmt(pObjCtx, VERR_INVALID_POINTER);
     479
     480                        SharedClipboardURIObject *pObj = pObjCtx->pObj;
     481                        AssertPtrBreakStmt(pObj, VERR_INVALID_POINTER);
     482
     483                        LogFlowFunc(("pszFile=%s\n", pszPathAbs));
     484
     485                        /** @todo Add sparse file support based on fFlags? (Use Open(..., fFlags | SPARSE). */
     486                        rc = pObj->OpenFileEx(pszPathAbs, SharedClipboardURIObject::View_Target,
     487                                              RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE,
     488                                              (fileHdr.fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR);
    541489                        if (RT_SUCCESS(rc))
    542490                        {
    543                             SharedClipboardURIObject *pObj = SharedClipboardURITransferGetObject(pTransfer, 0 /* Index */);
    544                             AssertPtrBreakStmt(pObj, VERR_INVALID_POINTER);
    545 
    546                             /** @todo Add sparse file support based on fFlags? (Use Open(..., fFlags | SPARSE). */
    547                             rc = pObj->OpenFileEx(pszPathAbs, SharedClipboardURIObject::View_Target,
    548                                                   RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE,
    549                                                   (data.fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR);
    550                             if (RT_SUCCESS(rc))
     491                            rc = pObj->SetSize(fileHdr.cbSize);
     492
     493                            /** @todo Unescape path before printing. */
     494                            LogRel2(("Clipboard: Transferring guest file '%s' to host (%RU64 bytes, mode 0x%x)\n",
     495                                     pObj->GetDestPathAbs().c_str(), pObj->GetSize(), pObj->GetMode()));
     496
     497                            if (pObj->IsComplete()) /* 0-byte file? We're done already. */
    551498                            {
    552                                 rc = pObj->SetSize(data.cbSize);
    553 
    554                                 /** @todo Unescape path before printing. */
    555                                 LogRel2(("Clipboard: Transferring guest file '%s' to host (%RU64 bytes, mode 0x%x)\n",
    556                                          pObj->GetDestPathAbs().c_str(), pObj->GetSize(), pObj->GetMode()));
    557 
    558                                 if (pObj->IsComplete()) /* 0-byte file? We're done already. */
    559                                 {
    560                                     /** @todo Sanitize path. */
    561                                     LogRel2(("Clipboard: Transferring guest file '%s' (0 bytes) to host complete\n",
    562                                              pObj->GetDestPathAbs().c_str()));
    563 
    564                                     SharedClipboardURIObjCtxUninit(&pTransfer->ObjCtx);
    565                                 }
    566 
    567                                 /* Add for having a proper rollback. */
    568                                 int rc2 = pArea->AddFile(pszPathAbs);
    569                                 AssertRC(rc2);
     499                                /** @todo Sanitize path. */
     500                                LogRel2(("Clipboard: Transferring guest file '%s' (0 bytes) to host complete\n",
     501                                         pObj->GetDestPathAbs().c_str()));
     502
     503                                SharedClipboardURIObjCtxDestroy(&pTransfer->ObjCtx);
    570504                            }
    571                             else
    572                                 LogRel(("Clipboard: Error opening/creating guest file '%s' on host, rc=%Rrc\n", pszPathAbs, rc));
     505
     506                            /* Add for having a proper rollback. */
     507                            int rc2 = pArea->AddFile(pszPathAbs);
     508                            AssertRC(rc2);
    573509                        }
     510                        else
     511                            LogRel(("Clipboard: Error opening/creating guest file '%s' on host, rc=%Rrc\n", pszPathAbs, rc));
    574512                    }
    575             }
    576 #endif
     513                }
     514            }
    577515            break;
    578516        }
    … …  
    609547            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA\n"));
    610548
    611             if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
     549            if (!SharedClipboardURIObjCtxIsValid(&pTransfer->ObjCtx))
    612550            {
    613551                rc = VERR_WRONG_ORDER;
    … …  
    615553            }
    616554
    617 #if 0
     555            VBOXCLIPBOARDFILEDATA fileData;
     556            rc = VBoxSvcClipboardURIReadFileData(cParms, paParms, &fileData);
    618557            if (RT_SUCCESS(rc))
    619558            {
    620                 if (!vboxSvcClipboardURIFileDataIsValid(&data, &pTransfer->Header))
    621                     rc = VERR_INVALID_PARAMETER;
    622 
    623                 if (!SharedClipboardURIObjCtxIsValid(&pTransfer->ObjCtx))
    624                     rc = VERR_WRONG_ORDER;
    625             }
    626 
    627             if (RT_SUCCESS(rc))
    628             {
    629                 SharedClipboardURIObject *pObj = SharedClipboardURIObjCtxGetObj(&pTransfer->ObjCtx);
     559                PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer);
     560                AssertPtrBreakStmt(pObjCtx, VERR_INVALID_POINTER);
     561
     562                SharedClipboardURIObject *pObj = pObjCtx->pObj;
    630563                AssertPtrBreakStmt(pObj, VERR_INVALID_POINTER);
    631564
    632565                uint32_t cbWritten;
    633                 rc = pObj->Write(data.pvData, data.cbData, &cbWritten);
     566                rc = pObj->Write(fileData.pvData, fileData.cbData, &cbWritten);
    634567                if (RT_SUCCESS(rc))
    635568                {
    636                     Assert(cbWritten <= data.cbData);
    637                     if (cbWritten < data.cbData)
     569                    Assert(cbWritten <= fileData.cbData);
     570                    if (cbWritten < fileData.cbData)
    638571                    {
    639572                        /** @todo What to do when the host's disk is full? */
    … …  
    643576                    if (   pObj->IsComplete()
    644577                        || RT_FAILURE(rc))
    645                         SharedClipboardURIObjCtxUninit(&pTransfer->ObjCtx);
     578                        SharedClipboardURIObjCtxDestroy(&pTransfer->ObjCtx);
    646579                }
    647580                else
    648581                    LogRel(("Clipboard: Error writing guest file data for '%s', rc=%Rrc\n", pObj->GetDestPathAbs().c_str(), rc));
    649582            }
    650 #endif
    651583            break;
    652584        }
    … …  
    667599    }
    668600
     601    if (fDispatchToProvider)
     602        rc = VINF_SUCCESS;
     603
    669604    if (RT_SUCCESS(rc))
    670605    {
    671         if (fWrite)
     606        if (fDispatchToProvider)
    672607        {
    673608            SHAREDCLIPBOARDPROVIDERWRITEPARMS writeParms;
    … …  
    740675        return VERR_NO_MEMORY;
    741676
    742     VBOXCLIPBOARDEXTAREAPARMS parms;
    743     RT_ZERO(parms);
    744 
    745     parms.uID                  = NIL_SHAREDCLIPBOARDAREAID;
    746     parms.u.fn_register.pvData = SharedClipboardMetaDataMutableRaw(&pTransfer->State.Meta);
    747     parms.u.fn_register.cbData = (uint32_t)SharedClipboardMetaDataGetUsed(&pTransfer->State.Meta);
    748 
    749     /* As the meta data is now complete, register a new clipboard on the host side. */
    750     int rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_REGISTER, &parms, sizeof(parms));
    751     if (RT_SUCCESS(rc))
    752     {
    753         /* Note: Do *not* specify SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST as flags here, as VBoxSVC took care of the
    754          *       clipboard area creation already. */
    755         rc = pTransfer->pArea->OpenTemp(parms.uID /* Area ID */,
    756                                         SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
    757     }
    758 
    759     LogFlowFunc(("Registered new clipboard area (%RU32) by client %RU32 with rc=%Rrc\n",
    760                  parms.uID, pClientState->u32ClientID, rc));
     677    int rc;
     678
     679    if (g_pfnExtension)
     680    {
     681        VBOXCLIPBOARDEXTAREAPARMS parms;
     682        RT_ZERO(parms);
     683
     684        parms.uID = NIL_SHAREDCLIPBOARDAREAID;
     685
     686        if (pTransfer->State.pMeta)
     687        {
     688            parms.u.fn_register.pvData = SharedClipboardMetaDataMutableRaw(pTransfer->State.pMeta);
     689            parms.u.fn_register.cbData = (uint32_t)SharedClipboardMetaDataGetUsed(pTransfer->State.pMeta);
     690        }
     691
     692        /* As the meta data is now complete, register a new clipboard on the host side. */
     693        rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_REGISTER, &parms, sizeof(parms));
     694        if (RT_SUCCESS(rc))
     695        {
     696            /* Note: Do *not* specify SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST as flags here, as VBoxSVC took care of the
     697             *       clipboard area creation already. */
     698            rc = pTransfer->pArea->OpenTemp(parms.uID /* Area ID */,
     699                                            SHAREDCLIPBOARDAREA_OPEN_FLAGS_NONE);
     700        }
     701
     702        LogFlowFunc(("Registered new clipboard area (%RU32) by client %RU32 with rc=%Rrc\n",
     703                     parms.uID, pClientState->u32ClientID, rc));
     704    }
     705    else
     706        rc = VERR_NOT_SUPPORTED;
    761707
    762708    LogFlowFuncLeaveRC(rc);
    … …  
    778724        return VINF_SUCCESS;
    779725
    780     VBOXCLIPBOARDEXTAREAPARMS parms;
    781     RT_ZERO(parms);
    782 
    783     parms.uID = pTransfer->pArea->GetID();
    784 
    785     int rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_UNREGISTER, &parms, sizeof(parms));
    786     if (RT_SUCCESS(rc))
    787     {
    788         rc = pTransfer->pArea->Close();
    789         if (RT_SUCCESS(rc))
    790         {
    791             delete pTransfer->pArea;
    792             pTransfer->pArea = NULL;
    793         }
    794     }
    795 
    796     LogFlowFunc(("Unregistered clipboard area (%RU32) by client %RU32 with rc=%Rrc\n",
    797                  parms.uID, pClientState->u32ClientID, rc));
     726    int rc = VINF_SUCCESS;
     727
     728    if (g_pfnExtension)
     729    {
     730        VBOXCLIPBOARDEXTAREAPARMS parms;
     731        RT_ZERO(parms);
     732
     733        parms.uID = pTransfer->pArea->GetID();
     734
     735        rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_UNREGISTER, &parms, sizeof(parms));
     736        if (RT_SUCCESS(rc))
     737        {
     738            rc = pTransfer->pArea->Close();
     739            if (RT_SUCCESS(rc))
     740            {
     741                delete pTransfer->pArea;
     742                pTransfer->pArea = NULL;
     743            }
     744        }
     745
     746        LogFlowFunc(("Unregistered clipboard area (%RU32) by client %RU32 with rc=%Rrc\n",
     747                     parms.uID, pClientState->u32ClientID, rc));
     748    }
     749
     750    delete pTransfer->pArea;
     751    pTransfer->pArea = NULL;
    798752
    799753    LogFlowFuncLeaveRC(rc);
    … …  
    819773        return VERR_NO_MEMORY;
    820774
    821     VBOXCLIPBOARDEXTAREAPARMS parms;
    822     RT_ZERO(parms);
    823 
    824     parms.uID = 0; /* 0 means most recent clipboard area. */
    825 
    826     /* The client now needs to attach to the most recent clipboard area
    827      * to keep a reference to it. The host does the actual book keeping / cleanup then.
    828      *
    829      * This might fail if the host does not have a most recent clipboard area (yet). */
    830     int rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_ATTACH, &parms, sizeof(parms));
    831     if (RT_SUCCESS(rc))
    832         rc = pTransfer->pArea->OpenTemp(parms.uID /* Area ID */);
    833 
    834     LogFlowFunc(("Attached client %RU32 to clipboard area %RU32 with rc=%Rrc\n",
    835                  pClientState->u32ClientID, parms.uID, rc));
     775    int rc = VINF_SUCCESS;
     776
     777    if (g_pfnExtension)
     778    {
     779        VBOXCLIPBOARDEXTAREAPARMS parms;
     780        RT_ZERO(parms);
     781
     782        parms.uID = 0; /* 0 means most recent clipboard area. */
     783
     784        /* The client now needs to attach to the most recent clipboard area
     785         * to keep a reference to it. The host does the actual book keeping / cleanup then.
     786         *
     787         * This might fail if the host does not have a most recent clipboard area (yet). */
     788        rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_ATTACH, &parms, sizeof(parms));
     789        if (RT_SUCCESS(rc))
     790            rc = pTransfer->pArea->OpenTemp(parms.uID /* Area ID */);
     791
     792        LogFlowFunc(("Attached client %RU32 to clipboard area %RU32 with rc=%Rrc\n",
     793                     pClientState->u32ClientID, parms.uID, rc));
     794    }
     795    else
     796        rc = VERR_NOT_SUPPORTED;
    836797
    837798    LogFlowFuncLeaveRC(rc);
    … …  
    869830    }
    870831
    871     LogFlowFuncLeaveRC(rc);
    872     return rc;
    873 }
    874 
     832    delete pTransfer->pArea;
     833    pTransfer->pArea = NULL;
     834
     835    LogFlowFuncLeaveRC(rc);
     836    return rc;
     837}
     838
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