VirtualBox

Ignore:
Timestamp:
Jun 13, 2019 10:08:33 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
131284
Message:

Shared Clipboard/URI: Update.

Location:
trunk/src/VBox/HostServices/SharedClipboard
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h

    r79107 r79120  
    137137int  vboxSvcClipboardURIReportMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Msg, uint32_t u32Formats);
    138138bool vboxSvcClipboardURIReturnMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    139 bool vboxSvcClipboardURIDataHdrIsValid(PVBOXCLIPBOARDDATAHDR pDataHdr);
    140 bool vboxSvcClipboardURIDataChunkIsValid(PVBOXCLIPBOARDDATACHUNK pDataChunk);
    141 void vboxSvcClipboardURIDirDataDestroy(PVBOXCLIPBOARDDIRDATA pDirData);
    142 bool vboxSvcClipboardURIDirDataIsValid(PVBOXCLIPBOARDDIRDATA pDirData);
    143 void vboxSvcClipboardURIFileHdrDestroy(PVBOXCLIPBOARDFILEHDR pFileHdr);
    144 bool vboxSvcClipboardURIFileHdrIsValid(PVBOXCLIPBOARDFILEHDR pFileHdr, PVBOXCLIPBOARDDATAHDR pDataHdr);
    145 void vboxSvcClipboardURIFileDataDestroy(PVBOXCLIPBOARDFILEDATA pFileData);
    146 bool vboxSvcClipboardURIFileDataIsValid(PVBOXCLIPBOARDFILEDATA pFileData, PVBOXCLIPBOARDDATAHDR pDataHdr);
    147139# endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    148140

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

    r79107 r79120  
    4848 * @param   pDirData            VBOXCLIPBOARDDIRDATA structure to destroy.
    4949 */
    50 void vboxSvcClipboardURIDirDataDestroy(PVBOXCLIPBOARDDIRDATA pDirData)
     50void SharedClipboardURIDirDataDestroy(PVBOXCLIPBOARDDIRDATA pDirData)
    5151{
    5252    if (!pDirData)
    … …  
    6666 * @param   pFileHdr            VBOXCLIPBOARDFILEHDR structure to destroy.
    6767 */
    68 void vboxSvcClipboardURIFileHdrDestroy(PVBOXCLIPBOARDFILEHDR pFileHdr)
     68void SharedClipboardURIFileHdrDestroy(PVBOXCLIPBOARDFILEHDR pFileHdr)
    6969{
    7070    if (!pFileHdr)
    … …  
    8484 * @param   pFileData           VBOXCLIPBOARDFILEDATA structure to destroy.
    8585 */
    86 void vboxSvcClipboardURIFileDataDestroy(PVBOXCLIPBOARDFILEDATA pFileData)
     86void SharedClipboardURIFileDataDestroy(PVBOXCLIPBOARDFILEDATA pFileData)
    8787{
    8888    if (!pFileData)
    … …  
    9595        pFileData->pvData = NULL;
    9696    }
     97}
     98
     99int VBoxSvcClipboardURIReadDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr)
     100{
     101    if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_HDR)
     102        return VERR_INVALID_PARAMETER;
     103
     104    RT_BZERO(pDataHdr, sizeof(VBOXCLIPBOARDDATAHDR));
     105
     106    /* Note: Context ID (paParms[0]) not used yet. */
     107    int rc = HGCMSvcGetU32(&paParms[1], &pDataHdr->uFlags);
     108    if (RT_SUCCESS(rc))
     109        rc = HGCMSvcGetU32(&paParms[2], &pDataHdr->uScreenId);
     110    if (RT_SUCCESS(rc))
     111        rc = HGCMSvcGetU64(&paParms[3], &pDataHdr->cbTotal);
     112    if (RT_SUCCESS(rc))
     113        rc = HGCMSvcGetU32(&paParms[4], &pDataHdr->cbMeta);
     114    if (RT_SUCCESS(rc))
     115        rc = HGCMSvcGetPv(&paParms[5], &pDataHdr->pvMetaFmt, &pDataHdr->cbMetaFmt);
     116    if (RT_SUCCESS(rc))
     117        rc = HGCMSvcGetU32(&paParms[6], &pDataHdr->cbMetaFmt);
     118    if (RT_SUCCESS(rc))
     119        rc = HGCMSvcGetU64(&paParms[7], &pDataHdr->cObjects);
     120    if (RT_SUCCESS(rc))
     121        rc = HGCMSvcGetU32(&paParms[8], &pDataHdr->enmCompression);
     122    if (RT_SUCCESS(rc))
     123        rc = HGCMSvcGetU32(&paParms[9], (uint32_t *)&pDataHdr->enmChecksumType);
     124    if (RT_SUCCESS(rc))
     125        rc = HGCMSvcGetPv(&paParms[10], &pDataHdr->pvChecksum, &pDataHdr->cbChecksum);
     126    if (RT_SUCCESS(rc))
     127        rc = HGCMSvcGetU32(&paParms[11], &pDataHdr->cbChecksum);
     128
     129    LogFlowFunc(("fFlags=0x%x, cbMeta=%RU32, cbTotalSize=%RU64, cObj=%RU64\n",
     130                 pDataHdr->uFlags, pDataHdr->cbMeta, pDataHdr->cbTotal, pDataHdr->cObjects));
     131
     132    if (RT_SUCCESS(rc))
     133    {
     134        /** @todo Validate pvMetaFmt + cbMetaFmt. */
     135        /** @todo Validate header checksum. */
     136    }
     137
     138    LogFlowFuncLeaveRC(rc);
     139    return rc;
     140}
     141
     142int VBoxSvcClipboardURIReadDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk)
     143{
     144    if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_CHUNK)
     145        return VERR_INVALID_PARAMETER;
     146
     147    RT_BZERO(pDataChunk, sizeof(VBOXCLIPBOARDDATACHUNK));
     148
     149    /* Note: Context ID (paParms[0]) not used yet. */
     150    int rc = HGCMSvcGetPv(&paParms[1], (void**)&pDataChunk->pvData, &pDataChunk->cbData);
     151    if (RT_SUCCESS(rc))
     152        rc = HGCMSvcGetU32(&paParms[2], &pDataChunk->cbData);
     153    if (RT_SUCCESS(rc))
     154        rc = HGCMSvcGetPv(&paParms[3], (void**)&pDataChunk->pvChecksum, &pDataChunk->cbChecksum);
     155    if (RT_SUCCESS(rc))
     156        rc = HGCMSvcGetU32(&paParms[4], &pDataChunk->cbChecksum);
     157
     158    if (RT_SUCCESS(rc))
     159    {
     160        if (!SharedClipboardURIDataChunkIsValid(pDataChunk))
     161            rc = VERR_INVALID_PARAMETER;
     162    }
     163
     164    LogFlowFuncLeaveRC(rc);
     165    return rc;
     166}
     167
     168int VBoxSvcClipboardURIReadDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData)
     169{
     170    if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DIR)
     171        return VERR_INVALID_PARAMETER;
     172
     173    RT_BZERO(pDirData, sizeof(VBOXCLIPBOARDDIRDATA));
     174
     175    /* Note: Context ID (paParms[0]) not used yet. */
     176    int rc = HGCMSvcGetPv(&paParms[1], (void**)&pDirData->pszPath, &pDirData->cbPath);
     177    if (RT_SUCCESS(rc))
     178        rc = HGCMSvcGetU32(&paParms[2], &pDirData->cbPath);
     179    if (RT_SUCCESS(rc))
     180        rc = HGCMSvcGetU32(&paParms[3], &pDirData->fMode);
     181
     182    LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x\n", pDirData->pszPath, pDirData->cbPath, pDirData->fMode));
     183
     184    if (RT_SUCCESS(rc))
     185    {
     186        if (!SharedClipboardURIDirDataIsValid(pDirData))
     187            rc = VERR_INVALID_PARAMETER;
     188    }
     189
     190    LogFlowFuncLeaveRC(rc);
     191    return rc;
     192}
     193
     194int VBoxSvcClipboardURIReadFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr)
     195{
     196    if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_FILE_HDR)
     197        return VERR_INVALID_PARAMETER;
     198
     199    RT_BZERO(pFileHdr, sizeof(VBOXCLIPBOARDFILEHDR));
     200
     201    /* Note: Context ID (paParms[0]) not used yet. */
     202    int rc = HGCMSvcGetPv(&paParms[1], (void**)&pFileHdr->pszFilePath, &pFileHdr->cbFilePath);
     203    if (RT_SUCCESS(rc))
     204        rc = HGCMSvcGetU32(&paParms[2], &pFileHdr->cbFilePath);
     205    if (RT_SUCCESS(rc))
     206        rc = HGCMSvcGetU32(&paParms[3], &pFileHdr->fFlags);
     207    if (RT_SUCCESS(rc))
     208        rc = HGCMSvcGetU32(&paParms[4], &pFileHdr->fMode);
     209    if (RT_SUCCESS(rc))
     210        rc = HGCMSvcGetU64(&paParms[5], &pFileHdr->cbSize);
     211
     212    LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x, cbSize=%RU64\n",
     213                 pFileHdr->pszFilePath, pFileHdr->cbFilePath, pFileHdr->fMode, pFileHdr->cbSize));
     214
     215    LogFlowFuncLeaveRC(rc);
     216    return rc;
     217}
     218
     219int VBoxSvcClipboardURIReadFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData)
     220{
     221    if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_FILE_DATA)
     222        return VERR_INVALID_PARAMETER;
     223
     224    RT_BZERO(pFileData, sizeof(VBOXCLIPBOARDFILEDATA));
     225
     226    /* Note: Context ID (paParms[0]) not used yet. */
     227    int rc = HGCMSvcGetPv(&paParms[1], (void**)&pFileData->pvData, &pFileData->cbData);
     228    if (RT_SUCCESS(rc))
     229        rc = HGCMSvcGetU32(&paParms[2], &pFileData->cbData);
     230    if (RT_SUCCESS(rc))
     231        rc = HGCMSvcGetPv(&paParms[3], (void**)&pFileData->pvChecksum, &pFileData->cbChecksum);
     232    if (RT_SUCCESS(rc))
     233        rc = HGCMSvcGetU32(&paParms[4], &pFileData->cbChecksum);
     234
     235    LogFlowFunc(("pvData=0x%p, cbData=%RU32\n", pFileData->pvData, pFileData->cbData));
     236
     237    LogFlowFuncLeaveRC(rc);
     238    return rc;
    97239}
    98240
    … …  
    151293    switch (u32Function)
    152294    {
    153         case VBOX_SHARED_CLIPBOARD_FN_READ_DATA_HDR:
     295        case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_HDR:
    154296        {
    155297            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_DATA_HDR\n"));
    … …  
    172314        }
    173315
    174         case VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_HDR:
    175         {
    176             LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_HDR\n"));
    177             if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_HDR)
    178             {
    179                 if (SharedClipboardURICtxMaximumTransfersReached(&pClientData->URI))
    180                 {
    181                     rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
    182                     break;
    183                 }
    184 
    185                 RT_ZERO(pTransfer->Header);
    186                 /* Note: Context ID (paParms[0]) not used yet. */
    187                 rc = HGCMSvcGetU32(&paParms[1], &pTransfer->Header.uFlags);
    188                 if (RT_SUCCESS(rc))
    189                     rc = HGCMSvcGetU32(&paParms[2], &pTransfer->Header.uScreenId);
    190                 if (RT_SUCCESS(rc))
    191                     rc = HGCMSvcGetU64(&paParms[3], &pTransfer->Header.cbTotal);
    192                 if (RT_SUCCESS(rc))
    193                     rc = HGCMSvcGetU32(&paParms[4], &pTransfer->Header.cbMeta);
    194                 if (RT_SUCCESS(rc))
    195                     rc = HGCMSvcGetPv(&paParms[5], &pTransfer->Header.pvMetaFmt, &pTransfer->Header.cbMetaFmt);
    196                 if (RT_SUCCESS(rc))
    197                     rc = HGCMSvcGetU32(&paParms[6], &pTransfer->Header.cbMetaFmt);
    198                 if (RT_SUCCESS(rc))
    199                     rc = HGCMSvcGetU64(&paParms[7], &pTransfer->Header.cObjects);
    200                 if (RT_SUCCESS(rc))
    201                     rc = HGCMSvcGetU32(&paParms[8], &pTransfer->Header.enmCompression);
    202                 if (RT_SUCCESS(rc))
    203                     rc = HGCMSvcGetU32(&paParms[9], (uint32_t *)&pTransfer->Header.enmChecksumType);
    204                 if (RT_SUCCESS(rc))
    205                     rc = HGCMSvcGetPv(&paParms[10], &pTransfer->Header.pvChecksum, &pTransfer->Header.cbChecksum);
    206                 if (RT_SUCCESS(rc))
    207                     rc = HGCMSvcGetU32(&paParms[11], &pTransfer->Header.cbChecksum);
    208 
    209                 LogFlowFunc(("fFlags=0x%x, cbMeta=%RU32, cbTotalSize=%RU64, cObj=%RU64\n",
    210                              pTransfer->Header.uFlags, pTransfer->Header.cbMeta, pTransfer->Header.cbTotal, pTransfer->Header.cObjects));
    211 
    212                 if (RT_SUCCESS(rc))
    213                 {
    214                     /** @todo Validate pvMetaFmt + cbMetaFmt. */
    215                     /** @todo Validate checksum. */
    216                     rc = SharedClipboardMetaDataResize(&pTransfer->Meta, pTransfer->Header.cbMeta);
    217                 }
    218             }
    219 
    220             break;
    221         }
    222 
    223         case VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_CHUNK:
     316        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR:
     317            RT_FALL_THROUGH();
     318#if 0
     319            case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_CHUNK:
     320            RT_FALL_THROUGH();
     321        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR:
     322            RT_FALL_THROUGH();
     323        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_HDR:
     324            RT_FALL_THROUGH();
     325        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_DATA:
     326            RT_FALL_THROUGH();
     327        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_CANCEL:
     328            RT_FALL_THROUGH();
     329        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_ERROR:
     330        {
     331            if (   u32Function == VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR
     332                && SharedClipboardURICtxMaximumTransfersReached(&pClientData->URI))
     333            {
     334                rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
     335                break;
     336            }
     337
     338            SHAREDCLIPBOARDPROVIDERWRITEPARMS writeParms;
     339            RT_ZERO(writeParms);
     340
     341            writeParms.u.HostService.uMsg    = u32Function;
     342            writeParms.u.HostService.cParms  = cParms;
     343            writeParms.u.HostService.paParms = paParms;
     344
     345            rc = pTransfer->pProvider->Write(&writeParms);
     346
     347
     348
     349            break;
     350        }
     351#endif
     352
     353        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_CHUNK:
    224354        {
    225355            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_CHUNK\n"));
    226             if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_CHUNK)
    227             {
    228                 if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
    229                 {
    230                     rc = VERR_WRONG_ORDER;
    231                     break;
    232                 }
    233 
    234                 VBOXCLIPBOARDDATACHUNK data;
    235                 RT_ZERO(data);
    236                 /* Note: Context ID (paParms[0]) not used yet. */
    237                 rc = HGCMSvcGetPv(&paParms[1], (void**)&data.pvData, &data.cbData);
    238                 if (RT_SUCCESS(rc))
    239                     rc = HGCMSvcGetU32(&paParms[2], &data.cbData);
    240                 if (RT_SUCCESS(rc))
    241                     rc = HGCMSvcGetPv(&paParms[3], (void**)&data.pvChecksum, &data.cbChecksum);
    242                 if (RT_SUCCESS(rc))
    243                     rc = HGCMSvcGetU32(&paParms[4], &data.cbChecksum);
    244 
    245                 if (RT_SUCCESS(rc))
    246                 {
    247                     if (!vboxSvcClipboardURIDataChunkIsValid(&data))
    248                         rc = VERR_INVALID_PARAMETER;
    249                 }
    250 
    251                 if (RT_SUCCESS(rc))
    252                 {
    253                     /** @todo Validate checksum. */
    254                     rc = SharedClipboardMetaDataAdd(&pTransfer->Meta, data.pvData, data.cbData);
    255                     if (   RT_SUCCESS(rc)
    256                         && SharedClipboardMetaDataGetUsed(&pTransfer->Meta) == pTransfer->Header.cbMeta) /* Meta data transfer complete? */
     356
     357            if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
     358            {
     359                rc = VERR_WRONG_ORDER;
     360                break;
     361            }
     362
     363#if 0
     364            if (RT_SUCCESS(rc))
     365            {
     366                /** @todo Validate checksum. */
     367                rc = SharedClipboardMetaDataAdd(&pTransfer->Meta, data.pvData, data.cbData);
     368                if (   RT_SUCCESS(rc)
     369                    && SharedClipboardMetaDataGetUsed(&pTransfer->Meta) == pTransfer->Header.cbMeta) /* Meta data transfer complete? */
     370                {
     371                    if (RT_SUCCESS(rc))
    257372                    {
    258                         if (RT_SUCCESS(rc))
    259                         {
    260 
    261                         }
    262 
    263                         /* We're done processing the meta data, so just destroy it. */
    264                         SharedClipboardMetaDataDestroy(&pTransfer->Meta);
     373
    265374                    }
    266                 }
    267             }
    268             break;
    269         }
    270 
    271         case VBOX_SHARED_CLIPBOARD_FN_READ_DIR:
     375
     376                    /* We're done processing the meta data, so just destroy it. */
     377                    SharedClipboardMetaDataDestroy(&pTransfer->Meta);
     378                }
     379            }
     380#endif
     381            break;
     382        }
     383
     384        case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DIR:
    272385        {
    273386            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_DIR\n"));
    … …  
    289402                    HGCMSvcSetU32(&paParms[3], data.fMode);
    290403
    291                     vboxSvcClipboardURIDirDataDestroy(&data);
    292                 }
    293             }
    294             break;
    295         }
    296 
    297         case VBOX_SHARED_CLIPBOARD_FN_WRITE_DIR:
     404                    SharedClipboardURIDirDataDestroy(&data);
     405                }
     406            }
     407            break;
     408        }
     409
     410        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR:
    298411        {
    299412            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_DIR\n"));
    300             if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DIR)
    301             {
    302                 if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
    303                 {
    304                     rc = VERR_WRONG_ORDER;
    305                     break;
    306                 }
    307 
    308                 VBOXCLIPBOARDDIRDATA data;
    309                 RT_ZERO(data);
    310                 /* Note: Context ID (paParms[0]) not used yet. */
    311                 rc = HGCMSvcGetPv(&paParms[1], (void**)&data.pszPath, &data.cbPath);
    312                 if (RT_SUCCESS(rc))
    313                     rc = HGCMSvcGetU32(&paParms[2], &data.cbPath);
    314                 if (RT_SUCCESS(rc))
    315                     rc = HGCMSvcGetU32(&paParms[3], &data.fMode);
    316 
    317                 LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x\n", data.pszPath, data.cbPath, data.fMode));
    318 
    319                 if (RT_SUCCESS(rc))
    320                 {
    321                     if (!vboxSvcClipboardURIDirDataIsValid(&data))
    322                         rc = VERR_INVALID_PARAMETER;
    323                 }
    324 
    325                 if (RT_SUCCESS(rc))
    326                 {
    327                     SharedClipboardArea *pArea = SharedClipboardURITransferGetArea(pTransfer);
    328                     AssertPtrBreakStmt(pArea, rc = VERR_INVALID_POINTER);
    329 
    330                     const char *pszCacheDir = pArea->GetDirAbs();
    331                     char *pszDir = RTPathJoinA(pszCacheDir, data.pszPath);
    332                     if (pszDir)
     413
     414            if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
     415            {
     416                rc = VERR_WRONG_ORDER;
     417                break;
     418            }
     419
     420#if 0
     421            if (RT_SUCCESS(rc))
     422            {
     423                SharedClipboardArea *pArea = SharedClipboardURITransferGetArea(pTransfer);
     424                AssertPtrBreakStmt(pArea, rc = VERR_INVALID_POINTER);
     425
     426                const char *pszCacheDir = pArea->GetDirAbs();
     427                char *pszDir = RTPathJoinA(pszCacheDir, data.pszPath);
     428                if (pszDir)
     429                {
     430                    LogFlowFunc(("pszDir=%s\n", pszDir));
     431
     432                    rc = RTDirCreateFullPath(pszDir, data.fMode);
     433                    if (RT_SUCCESS(rc))
    333434                    {
    334                         LogFlowFunc(("pszDir=%s\n", pszDir));
    335 
    336                         rc = RTDirCreateFullPath(pszDir, data.fMode);
    337                         if (RT_SUCCESS(rc))
    338                         {
    339                             /* Add for having a proper rollback. */
    340                             int rc2 = pArea->AddDir(pszDir);
    341                             AssertRC(rc2);
    342                         }
    343 
    344                         RTStrFree(pszDir);
     435                        /* Add for having a proper rollback. */
     436                        int rc2 = pArea->AddDir(pszDir);
     437                        AssertRC(rc2);
    345438                    }
    346                     else
    347                         rc = VERR_NO_MEMORY;
    348                 }
    349             }
    350             break;
    351         }
    352 
    353         case VBOX_SHARED_CLIPBOARD_FN_READ_FILE_HDR:
     439
     440                    RTStrFree(pszDir);
     441                }
     442                else
     443                    rc = VERR_NO_MEMORY;
     444            }
     445#endif
     446            break;
     447        }
     448
     449        case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR:
    354450        {
    355451            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_FILE_HDR\n"));
    … …  
    373469                    HGCMSvcSetU64(&paParms[5], hdr.cbSize);
    374470
    375                     vboxSvcClipboardURIFileHdrDestroy(&hdr);
    376                 }
    377             }
    378             break;
    379         }
    380 
    381         case VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_HDR:
     471                    SharedClipboardURIFileHdrDestroy(&hdr);
     472                }
     473            }
     474            break;
     475        }
     476
     477        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_HDR:
    382478        {
    383479            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_HDR\n"));
    384             if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_FILE_HDR)
    385             {
     480
    386481                if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
    387482                {
    … …  
    390485                }
    391486
    392                 VBOXCLIPBOARDFILEHDR data;
    393                 RT_ZERO(data);
    394                 /* Note: Context ID (paParms[0]) not used yet. */
    395                 rc = HGCMSvcGetPv(&paParms[1], (void**)&data.pszFilePath, &data.cbFilePath);
    396                 if (RT_SUCCESS(rc))
    397                     rc = HGCMSvcGetU32(&paParms[2], &data.cbFilePath);
    398                 if (RT_SUCCESS(rc))
    399                     rc = HGCMSvcGetU32(&paParms[3], &data.fFlags);
    400                 if (RT_SUCCESS(rc))
    401                     rc = HGCMSvcGetU32(&paParms[4], &data.fMode);
    402                 if (RT_SUCCESS(rc))
    403                     rc = HGCMSvcGetU64(&paParms[5], &data.cbSize);
    404 
    405                 LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x, cbSize=%RU64\n",
    406                              data.pszFilePath, data.cbFilePath, data.fMode, data.cbSize));
    407 
     487#if 0
    408488                if (RT_SUCCESS(rc))
    409489                {
    … …  
    471551                        }
    472552                    }
    473                 }
    474             }
    475             break;
    476         }
    477 
    478         case VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA:
     553            }
     554#endif
     555            break;
     556        }
     557
     558        case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_DATA:
    479559        {
    480560            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA\n"));
    … …  
    497577                    HGCMSvcSetU32(&paParms[4], data.cbChecksum);
    498578
    499                     vboxSvcClipboardURIFileDataDestroy(&data);
    500                 }
    501             }
    502             break;
    503         }
    504 
    505         case VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA:
     579                    SharedClipboardURIFileDataDestroy(&data);
     580                }
     581            }
     582            break;
     583        }
     584
     585        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_DATA:
    506586        {
    507587            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA\n"));
    508             if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_FILE_DATA)
    509             {
    510                 if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
    511                 {
     588
     589            if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI))
     590            {
     591                rc = VERR_WRONG_ORDER;
     592                break;
     593            }
     594
     595#if 0
     596            if (RT_SUCCESS(rc))
     597            {
     598                if (!vboxSvcClipboardURIFileDataIsValid(&data, &pTransfer->Header))
     599                    rc = VERR_INVALID_PARAMETER;
     600
     601                if (!SharedClipboardURIObjCtxIsValid(&pTransfer->ObjCtx))
    512602                    rc = VERR_WRONG_ORDER;
    513                     break;
    514                 }
    515 
    516                 VBOXCLIPBOARDFILEDATA data;
    517                 RT_ZERO(data);
    518                 /* Note: Context ID (paParms[0]) not used yet. */
    519                 rc = HGCMSvcGetPv(&paParms[1], (void**)&data.pvData, &data.cbData);
     603            }
     604
     605            if (RT_SUCCESS(rc))
     606            {
     607                SharedClipboardURIObject *pObj = SharedClipboardURIObjCtxGetObj(&pTransfer->ObjCtx);
     608                AssertPtrBreakStmt(pObj, VERR_INVALID_POINTER);
     609
     610                uint32_t cbWritten;
     611                rc = pObj->Write(data.pvData, data.cbData, &cbWritten);
    520612                if (RT_SUCCESS(rc))
    521                     rc = HGCMSvcGetU32(&paParms[2], &data.cbData);
    522                 if (RT_SUCCESS(rc))
    523                     rc = HGCMSvcGetPv(&paParms[3], (void**)&data.pvChecksum, &data.cbChecksum);
    524                 if (RT_SUCCESS(rc))
    525                     rc = HGCMSvcGetU32(&paParms[4], &data.cbChecksum);
    526 
    527                 LogFlowFunc(("pvData=0x%p, cbData=%RU32\n", data.pvData, data.cbData));
    528 
    529                 if (RT_SUCCESS(rc))
    530                 {
    531                     if (!vboxSvcClipboardURIFileDataIsValid(&data, &pTransfer->Header))
    532                         rc = VERR_INVALID_PARAMETER;
    533 
    534                     if (!SharedClipboardURIObjCtxIsValid(&pTransfer->ObjCtx))
    535                         rc = VERR_WRONG_ORDER;
    536                 }
    537 
    538                 if (RT_SUCCESS(rc))
    539                 {
    540                     SharedClipboardURIObject *pObj = SharedClipboardURIObjCtxGetObj(&pTransfer->ObjCtx);
    541                     AssertPtrBreakStmt(pObj, VERR_INVALID_POINTER);
    542 
    543                     uint32_t cbWritten;
    544                     rc = pObj->Write(data.pvData, data.cbData, &cbWritten);
    545                     if (RT_SUCCESS(rc))
     613                {
     614                    Assert(cbWritten <= data.cbData);
     615                    if (cbWritten < data.cbData)
    546616                    {
    547                         Assert(cbWritten <= data.cbData);
    548                         if (cbWritten < data.cbData)
    549                         {
    550                             /** @todo What to do when the host's disk is full? */
    551                             rc = VERR_DISK_FULL;
    552                         }
    553 
    554                         if (   pObj->IsComplete()
    555                             || RT_FAILURE(rc))
    556                             SharedClipboardURIObjCtxUninit(&pTransfer->ObjCtx);
     617                        /** @todo What to do when the host's disk is full? */
     618                        rc = VERR_DISK_FULL;
    557619                    }
    558                     else
    559                         LogRel(("Clipboard: Error writing guest file data for '%s', rc=%Rrc\n", pObj->GetDestPathAbs().c_str(), rc));
    560                 }
    561             }
    562             break;
    563         }
    564 
    565         case VBOX_SHARED_CLIPBOARD_FN_WRITE_CANCEL:
     620
     621                    if (   pObj->IsComplete()
     622                        || RT_FAILURE(rc))
     623                        SharedClipboardURIObjCtxUninit(&pTransfer->ObjCtx);
     624                }
     625                else
     626                    LogRel(("Clipboard: Error writing guest file data for '%s', rc=%Rrc\n", pObj->GetDestPathAbs().c_str(), rc));
     627            }
     628#endif
     629            break;
     630        }
     631
     632        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_CANCEL:
    566633            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_CANCEL\n"));
    567634            AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
    568635            break;
    569636
    570         case VBOX_SHARED_CLIPBOARD_FN_WRITE_ERROR:
     637        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_ERROR:
    571638            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_ERROR\n"));
    572639            AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
    … …  
    618685}
    619686
     687/**
     688 * Registers an URI clipboard area.
     689 *
     690 * @returns VBox status code.
     691 * @param   pClientState        Client state to use.
     692 * @param   pTransfer           URI transfer to register a clipboard area for.
     693 */
    620694int vboxSvcClipboardURIAreaRegister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer)
    621695{
    … …  
    633707
    634708    parms.uID                  = NIL_SHAREDCLIPBOARDAREAID;
    635     parms.u.fn_register.pvData = SharedClipboardMetaDataMutableRaw(&pTransfer->Meta);
    636     parms.u.fn_register.cbData = (uint32_t)SharedClipboardMetaDataGetUsed(&pTransfer->Meta);
     709    parms.u.fn_register.pvData = SharedClipboardMetaDataMutableRaw(&pTransfer->Cache.Meta);
     710    parms.u.fn_register.cbData = (uint32_t)SharedClipboardMetaDataGetUsed(&pTransfer->Cache.Meta);
    637711
    638712    /* As the meta data is now complete, register a new clipboard on the host side. */
    639713    int rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_REGISTER, &parms, sizeof(parms));
    640714    if (RT_SUCCESS(rc))
    641         rc = pTransfer->pArea->OpenTemp(parms.uID /* Area ID */);
     715        rc = pTransfer->pArea->OpenTemp(parms.uID /* Area ID */,
     716                                        SHAREDCLIPBOARDAREA_OPEN_FLAGS_MUST_NOT_EXIST);
    642717
    643718    LogFlowFunc(("Registered new clipboard area (%RU32) by client %RU32 with rc=%Rrc\n",
    … …  
    648723}
    649724
     725/**
     726 * Unregisters an URI clipboard area.
     727 *
     728 * @returns VBox status code.
     729 * @param   pClientState        Client state to use.
     730 * @param   pTransfer           URI transfer to unregister a clipboard area from.
     731 */
     732int vboxSvcClipboardURIAreaUnregister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer)
     733{
     734    LogFlowFuncEnter();
     735
     736    if (!pTransfer->pArea)
     737        return VINF_SUCCESS;
     738
     739    VBOXCLIPBOARDEXTAREAPARMS parms;
     740    RT_ZERO(parms);
     741
     742    parms.uID = pTransfer->pArea->GetID();
     743
     744    int rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_AREA_UNREGISTER, &parms, sizeof(parms));
     745    if (RT_SUCCESS(rc))
     746    {
     747        rc = pTransfer->pArea->Close();
     748        if (RT_SUCCESS(rc))
     749        {
     750            delete pTransfer->pArea;
     751            pTransfer->pArea = NULL;
     752        }
     753    }
     754
     755    LogFlowFunc(("Unregistered clipboard area (%RU32) by client %RU32 with rc=%Rrc\n",
     756                 parms.uID, pClientState->u32ClientID, rc));
     757
     758    LogFlowFuncLeaveRC(rc);
     759    return rc;
     760}
     761
     762/**
     763 * Attaches to an existing (registered) URI clipboard area.
     764 *
     765 * @returns VBox status code.
     766 * @param   pClientState        Client state to use.
     767 * @param   pTransfer           URI transfer to attach a clipboard area to.
     768 */
    650769int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer)
    651770{
    … …  
    679798}
    680799
     800/**
     801 * Detaches from an URI clipboard area.
     802 *
     803 * @returns VBox status code.
     804 * @param   pClientState        Client state to use.
     805 * @param   pTransfer           URI transfer to detach a clipboard area from.
     806 */
    681807int vboxSvcClipboardURIAreaDetach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer)
    682808{

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

    r79107 r79120  
    2626
    2727int vboxSvcClipboardURIAreaRegister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer);
     28int vboxSvcClipboardURIAreaUnregister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    2829int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    2930int vboxSvcClipboardURIAreaDetach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer);

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

    r79107 r79120  
    168168    return fHandled;
    169169}
    170 
    171 /**
    172  * Returns whether a given clipboard data header is valid or not.
    173  *
    174  * @returns \c true if valid, \c false if not.
    175  * @param   pDataHdr            Clipboard data header to validate.
    176  */
    177 bool vboxSvcClipboardURIDataHdrIsValid(PVBOXCLIPBOARDDATAHDR pDataHdr)
    178 {
    179     RT_NOREF(pDataHdr);
    180     return true; /** @todo Implement this. */
    181 }
    182 
    183 /**
    184  * Returns whether a given clipboard data chunk is valid or not.
    185  *
    186  * @returns \c true if valid, \c false if not.
    187  * @param   pDataChunk          Clipboard data chunk to validate.
    188  */
    189 bool vboxSvcClipboardURIDataChunkIsValid(PVBOXCLIPBOARDDATACHUNK pDataChunk)
    190 {
    191     RT_NOREF(pDataChunk);
    192     return true; /** @todo Implement this. */
    193 }
    194 
    195 /**
    196  * Returns whether given clipboard directory data is valid or not.
    197  *
    198  * @returns \c true if valid, \c false if not.
    199  * @param   pDirData            Clipboard directory data to validate.
    200  */
    201 bool vboxSvcClipboardURIDirDataIsValid(PVBOXCLIPBOARDDIRDATA pDirData)
    202 {
    203     if (   !pDirData->cbPath
    204         || pDirData->cbPath > RTPATH_MAX)
    205         return false;
    206 
    207     if (!RTStrIsValidEncoding(pDirData->pszPath))
    208         return false;
    209 
    210     return true;
    211 }
    212 
    213 /**
    214  * Returns whether a given clipboard file header is valid or not.
    215  *
    216  * @returns \c true if valid, \c false if not.
    217  * @param   pFileHdr            Clipboard file header to validate.
    218  * @param   pDataHdr            Data header to use for validation.
    219  */
    220 bool vboxSvcClipboardURIFileHdrIsValid(PVBOXCLIPBOARDFILEHDR pFileHdr, PVBOXCLIPBOARDDATAHDR pDataHdr)
    221 {
    222     if (   !pFileHdr->cbFilePath
    223         || pFileHdr->cbFilePath > RTPATH_MAX)
    224         return false;
    225 
    226     if (!RTStrIsValidEncoding(pFileHdr->pszFilePath))
    227         return false;
    228 
    229     if (pFileHdr->cbSize > pDataHdr->cbTotal)
    230         return false;
    231 
    232     return true;
    233 }
    234 
    235 /**
    236  * Returns whether given clipboard file data is valid or not.
    237  *
    238  * @returns \c true if valid, \c false if not.
    239  * @param   pFileData           Clipboard file data to validate.
    240  * @param   pDataHdr            Data header to use for validation.
    241  */
    242 bool vboxSvcClipboardURIFileDataIsValid(PVBOXCLIPBOARDFILEDATA pFileData, PVBOXCLIPBOARDDATAHDR pDataHdr)
    243 {
    244     RT_NOREF(pFileData, pDataHdr);
    245     return true;
    246 }
    247170#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    248171

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

    r79108 r79120  
    511511    switch (u32Function)
    512512    {
    513         case VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG:
     513        case VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG:
    514514        {
    515515            /* The quest requests a host message. */
    … …  
    555555        } break;
    556556
    557         case VBOX_SHARED_CLIPBOARD_FN_REPORT_FORMATS:
     557        case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPORT_FORMATS:
    558558        {
    559559            /* The guest reports that some formats are available. */
    … …  
    601601
    602602                                PSHAREDCLIPBOARDURITRANSFER pTransfer;
    603                                 rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ, &creationCtx, &pTransfer);
     603                                rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ,
     604                                                                      &creationCtx, &pTransfer);
    604605                                if (RT_SUCCESS(rc))
     606                                {
    605607                                    rc = SharedClipboardURICtxTransferAdd(&pClientData->URI, pTransfer);
     608                                    if (RT_SUCCESS(rc))
     609                                        rc = vboxSvcClipboardURIAreaRegister(&pClientData->State, pTransfer);
     610                                }
    606611                            }
    607612                            else
    … …  
    617622        } break;
    618623
    619         case VBOX_SHARED_CLIPBOARD_FN_READ_DATA:
     624        case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA:
    620625        {
    621626            /* The guest wants to read data in the given format. */
    … …  
    716721        } break;
    717722
    718         case VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA:
     723        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA:
    719724        {
    720725            /* The guest writes the requested data. */

  • trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp

    r79036 r79120  
    118118    HGCMSvcSetU32(&parms[1], 0);
    119119    call.rc = VERR_TRY_AGAIN;
    120     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
     120    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG,
    121121                  2, parms, 0);
    122122    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
    … …  
    127127    RTTESTI_CHECK_RC_OK(call.rc);
    128128    call.rc = VERR_TRY_AGAIN;
    129     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
     129    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG,
    130130                  2, parms, 0);
    131131    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
    … …  
    138138    HGCMSvcSetU32(&parms[1], 0);
    139139    call.rc = VERR_TRY_AGAIN;
    140     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
     140    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG,
    141141                  2, parms, 0);
    142142    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    … …  
    144144    RTTESTI_CHECK_RC_OK(call.rc);
    145145    call.rc = VERR_TRY_AGAIN;
    146     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
     146    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG,
    147147                  2, parms, 0);
    148148    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
    … …  
    153153    HGCMSvcSetU32(&parms[1], 0);
    154154    call.rc = VERR_TRY_AGAIN;
    155     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
     155    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG,
    156156                  2, parms, 0);
    157157    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
    … …  
    162162    RTTESTI_CHECK_RC_OK(call.rc);
    163163    call.rc = VERR_TRY_AGAIN;
    164     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
     164    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG,
    165165                  2, parms, 0);
    166166    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    … …  
    168168    RTTESTI_CHECK_RC_OK(call.rc);
    169169    call.rc = VERR_TRY_AGAIN;
    170     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
     170    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG,
    171171                  2, parms, 0);
    172172    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
    … …  
    179179    HGCMSvcSetU32(&parms[1], 0);
    180180    call.rc = VERR_TRY_AGAIN;
    181     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
     181    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG,
    182182                  2, parms, 0);
    183183    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    … …  
    185185    RTTESTI_CHECK_RC_OK(call.rc);
    186186    call.rc = VERR_TRY_AGAIN;
    187     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
     187    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG,
    188188                  2, parms, 0);
    189189    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    … …  
    191191    RTTESTI_CHECK_RC_OK(call.rc);
    192192    call.rc = VERR_TRY_AGAIN;
    193     table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
     193    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG,
    194194                  2, parms, 0);
    195195    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
Note: See TracChangeset for help on using the changeset viewer.

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