VirtualBox

Changeset 75737 in vbox


Ignore:
Timestamp:
Nov 26, 2018 3:44:41 PM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
126937
Message:

HGCM: Replace C++-style inline members on VBOXHGCMSVCPARM with simple functions.
bugref:9172: Shared folder performance tuning
Changes in bugref:9172 caused a build regression on Ubuntu 18.10 due to the
use of RT_ZERO on a structure containing an embedded VBOXHGCMSVCPARM, as
VBOXHGCMSVCPARM had member functions and was therefore not a simple plain-
old-data structure. Rather than just doing the sensible thing and zeroing
it in a different way, I converted the inline member getters and setters to
standard inline C functions, including fixing callers. Actually I had planned
this for some time, as the member function use seemed a bit gratuitous in
hindsight.

Location:
trunk
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/hgcmsvc.h

    r75501 r75737  
    190190        } pointer;
    191191    } u;
     192} VBOXHGCMSVCPARM;
     193
     194/** Extract an uint32_t value from an HGCM parameter structure. */
     195static inline int HGCMSvcGetU32(struct VBOXHGCMSVCPARM *pParm, uint32_t *pu32)
     196{
     197    AssertPtrReturn(pParm, VERR_INVALID_POINTER);
     198    AssertPtrReturn(pParm, VERR_INVALID_POINTER);
     199    AssertPtrReturn(pu32, VERR_INVALID_POINTER);
     200    int rc = VINF_SUCCESS;
     201    if (pParm->type != VBOX_HGCM_SVC_PARM_32BIT)
     202        rc = VERR_INVALID_PARAMETER;
     203    if (RT_SUCCESS(rc))
     204        *pu32 = pParm->u.uint32;
     205    return rc;
     206}
     207
     208/** Extract an uint64_t value from an HGCM parameter structure. */
     209static inline int HGCMSvcGetU64(struct VBOXHGCMSVCPARM *pParm, uint64_t *pu64)
     210{
     211    AssertPtrReturn(pParm, VERR_INVALID_POINTER);
     212    AssertPtrReturn(pParm, VERR_INVALID_POINTER);
     213    AssertPtrReturn(pu64, VERR_INVALID_POINTER);
     214    int rc = VINF_SUCCESS;
     215    if (pParm->type != VBOX_HGCM_SVC_PARM_64BIT)
     216        rc = VERR_INVALID_PARAMETER;
     217    if (RT_SUCCESS(rc))
     218        *pu64 = pParm->u.uint64;
     219    return rc;
     220}
     221
     222/** Extract an pointer value from an HGCM parameter structure. */
     223static inline int HGCMSvcGetPv(struct VBOXHGCMSVCPARM *pParm, void **ppv,
     224                               uint32_t *pcb)
     225{
     226    AssertPtrReturn(pParm, VERR_INVALID_POINTER);
     227    AssertPtrReturn(ppv, VERR_INVALID_POINTER);
     228    AssertPtrReturn(pcb, VERR_INVALID_POINTER);
     229    if (pParm->type == VBOX_HGCM_SVC_PARM_PTR)
     230    {
     231        *ppv = pParm->u.pointer.addr;
     232        *pcb = pParm->u.pointer.size;
     233        return VINF_SUCCESS;
     234    }
     235
     236    return VERR_INVALID_PARAMETER;
     237}
     238
     239/** Extract a constant pointer value from an HGCM parameter structure. */
     240static inline int HGCMSvcGetPcv(struct VBOXHGCMSVCPARM *pParm, const void **ppv,
     241                                uint32_t *pcb)
     242{
     243    AssertPtrReturn(pParm, VERR_INVALID_POINTER);
     244    AssertPtrReturn(ppv, VERR_INVALID_POINTER);
     245    AssertPtrReturn(pcb, VERR_INVALID_POINTER);
     246    if (pParm->type == VBOX_HGCM_SVC_PARM_PTR)
     247    {
     248        *ppv = (const void *)pParm->u.pointer.addr;
     249        *pcb = pParm->u.pointer.size;
     250        return VINF_SUCCESS;
     251    }
     252
     253    return VERR_INVALID_PARAMETER;
     254}
     255
     256/** Extract a valid pointer to a non-empty buffer from an HGCM parameter
     257 * structure. */
     258static inline int HGCMSvcGetBuf(struct VBOXHGCMSVCPARM *pParm, void **ppv,
     259                                uint32_t *pcb)
     260{
     261    AssertPtrReturn(pParm, VERR_INVALID_POINTER);
     262    AssertPtrReturn(ppv, VERR_INVALID_POINTER);
     263    AssertPtrReturn(pcb, VERR_INVALID_POINTER);
     264    if (   pParm->type == VBOX_HGCM_SVC_PARM_PTR
     265        && VALID_PTR(pParm->u.pointer.addr)
     266        && pParm->u.pointer.size > 0)
     267    {
     268        *ppv = pParm->u.pointer.addr;
     269        *pcb = pParm->u.pointer.size;
     270        return VINF_SUCCESS;
     271    }
     272
     273    return VERR_INVALID_PARAMETER;
     274}
     275
     276/** Extract a valid pointer to a non-empty constant buffer from an HGCM
     277 * parameter structure. */
     278static inline int HGCMSvcGetCBuf(struct VBOXHGCMSVCPARM *pParm,
     279                                 const void **ppv, uint32_t *pcb)
     280{
     281    AssertPtrReturn(pParm, VERR_INVALID_POINTER);
     282    AssertPtrReturn(ppv, VERR_INVALID_POINTER);
     283    AssertPtrReturn(pcb, VERR_INVALID_POINTER);
     284    if (   pParm->type == VBOX_HGCM_SVC_PARM_PTR
     285        && VALID_PTR(pParm->u.pointer.addr)
     286        && pParm->u.pointer.size > 0)
     287    {
     288        *ppv = (const void *)pParm->u.pointer.addr;
     289        *pcb = pParm->u.pointer.size;
     290        return VINF_SUCCESS;
     291    }
     292
     293    return VERR_INVALID_PARAMETER;
     294}
     295
     296/** Extract a string value from an HGCM parameter structure. */
     297static inline int HGCMSvcGetStr(struct VBOXHGCMSVCPARM *pParm, char **ppch,
     298                                uint32_t *pcb)
     299{
     300    AssertPtrReturn(pParm, VERR_INVALID_POINTER);
     301    AssertPtrReturn(ppch, VERR_INVALID_POINTER);
     302    AssertPtrReturn(pcb, VERR_INVALID_POINTER);
     303    if (   pParm->type == VBOX_HGCM_SVC_PARM_PTR
     304        && VALID_PTR(pParm->u.pointer.addr)
     305        && pParm->u.pointer.size > 0)
     306    {
     307        int rc = RTStrValidateEncodingEx((char *)pParm->u.pointer.addr,
     308                                         pParm->u.pointer.size,
     309                                         RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED);
     310        if (RT_FAILURE(rc))
     311            return rc;
     312        *ppch = (char *)pParm->u.pointer.addr;
     313        *pcb = pParm->u.pointer.size;
     314        return VINF_SUCCESS;
     315    }
     316
     317    return VERR_INVALID_PARAMETER;
     318}
     319
     320/** Extract a constant string value from an HGCM parameter structure. */
     321static inline int HGCMSvcGetCStr(struct VBOXHGCMSVCPARM *pParm,
     322                                 const char **ppch, uint32_t *pcb)
     323{
     324    AssertPtrReturn(pParm, VERR_INVALID_POINTER);
     325    AssertPtrReturn(ppch, VERR_INVALID_POINTER);
     326    AssertPtrReturn(pcb, VERR_INVALID_POINTER);
     327    if (   pParm->type == VBOX_HGCM_SVC_PARM_PTR
     328        && VALID_PTR(pParm->u.pointer.addr)
     329        && pParm->u.pointer.size > 0)
     330    {
     331        int rc = RTStrValidateEncodingEx((char *)pParm->u.pointer.addr,
     332                                         pParm->u.pointer.size,
     333                                         RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED);
     334        if (RT_FAILURE(rc))
     335            return rc;
     336        *ppch = (char *)pParm->u.pointer.addr;
     337        *pcb = pParm->u.pointer.size;
     338        return VINF_SUCCESS;
     339    }
     340
     341    return VERR_INVALID_PARAMETER;
     342}
     343
     344/** Extract a constant string value from an HGCM parameter structure. */
     345static inline int HGCMSvcGetPsz(struct VBOXHGCMSVCPARM *pParm, const char **ppch,
     346                                uint32_t *pcb)
     347{
     348    AssertPtrReturn(pParm, VERR_INVALID_POINTER);
     349    AssertPtrReturn(ppch, VERR_INVALID_POINTER);
     350    AssertPtrReturn(pcb, VERR_INVALID_POINTER);
     351    if (   pParm->type == VBOX_HGCM_SVC_PARM_PTR
     352        && VALID_PTR(pParm->u.pointer.addr)
     353        && pParm->u.pointer.size > 0)
     354    {
     355        int rc = RTStrValidateEncodingEx((const char *)pParm->u.pointer.addr,
     356                                         pParm->u.pointer.size,
     357                                         RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED);
     358        if (RT_FAILURE(rc))
     359            return rc;
     360        *ppch = (const char *)pParm->u.pointer.addr;
     361        *pcb = pParm->u.pointer.size;
     362        return VINF_SUCCESS;
     363    }
     364
     365    return VERR_INVALID_PARAMETER;
     366}
     367
     368/** Set a uint32_t value to an HGCM parameter structure */
     369static inline void HGCMSvcSetU32(struct VBOXHGCMSVCPARM *pParm, uint32_t u32)
     370{
     371    AssertPtr(pParm);
     372    pParm->type = VBOX_HGCM_SVC_PARM_32BIT;
     373    pParm->u.uint32 = u32;
     374}
     375
     376/** Set a uint64_t value to an HGCM parameter structure */
     377static inline void HGCMSvcSetU64(struct VBOXHGCMSVCPARM *pParm, uint64_t u64)
     378{
     379    AssertPtr(pParm);
     380    pParm->type = VBOX_HGCM_SVC_PARM_64BIT;
     381    pParm->u.uint64 = u64;
     382}
     383
     384/** Set a pointer value to an HGCM parameter structure */
     385static inline void HGCMSvcSetPv(struct VBOXHGCMSVCPARM *pParm, void *pv,
     386                                uint32_t cb)
     387{
     388    AssertPtr(pParm);
     389    pParm->u.pointer.addr = pv;
     390    pParm->u.pointer.size = cb;
     391}
     392
     393/** Set a pointer value to an HGCM parameter structure */
     394static inline void HGCMSvcSetStr(struct VBOXHGCMSVCPARM *pParm, const char *psz)
     395{
     396    AssertPtr(pParm);
     397    pParm->u.pointer.addr = (void *)psz;
     398    pParm->u.pointer.size = (uint32_t)strlen(psz) + 1;
     399}
     400
    192401#ifdef __cplusplus
    193     /** Extract an uint32_t value from an HGCM parameter structure */
    194     int getUInt32(uint32_t *u32)
    195     {
    196         AssertPtrReturn(u32, VERR_INVALID_POINTER);
    197         int rc = VINF_SUCCESS;
    198         if (type != VBOX_HGCM_SVC_PARM_32BIT)
    199             rc = VERR_INVALID_PARAMETER;
    200         if (RT_SUCCESS(rc))
    201             *u32 = u.uint32;
    202         return rc;
    203     }
    204 
    205     /** Extract a uint64_t value from an HGCM parameter structure */
    206     int getUInt64(uint64_t *u64)
    207     {
    208         AssertPtrReturn(u64, VERR_INVALID_POINTER);
    209         int rc = VINF_SUCCESS;
    210         if (type != VBOX_HGCM_SVC_PARM_64BIT)
    211             rc = VERR_INVALID_PARAMETER;
    212         if (RT_SUCCESS(rc))
    213             *u64 = u.uint64;
    214         return rc;
    215     }
    216 
    217     /** Extract a pointer value from an HGCM parameter structure */
    218     int getPointer(void **ppv, uint32_t *pcb)
    219     {
    220         AssertPtrReturn(ppv, VERR_INVALID_POINTER);
    221         AssertPtrReturn(pcb, VERR_INVALID_POINTER);
    222         if (type == VBOX_HGCM_SVC_PARM_PTR)
    223         {
    224             *ppv = u.pointer.addr;
    225             *pcb = u.pointer.size;
    226             return VINF_SUCCESS;
    227         }
    228 
    229         return VERR_INVALID_PARAMETER;
    230     }
    231 
    232     /** Extract a constant pointer value from an HGCM parameter structure */
    233     int getPointer(const void **ppcv, uint32_t *pcb)
    234     {
    235         AssertPtrReturn(ppcv, VERR_INVALID_POINTER);
    236         AssertPtrReturn(pcb, VERR_INVALID_POINTER);
    237         void *pv;
    238         int rc = getPointer(&pv, pcb);
    239         *ppcv = pv;
    240         return rc;
    241     }
    242 
    243     /** Extract a pointer value to a non-empty buffer from an HGCM parameter
    244      * structure */
    245     int getBuffer(void **ppv, uint32_t *pcb)
    246     {
    247         AssertPtrReturn(ppv, VERR_INVALID_POINTER);
    248         AssertPtrReturn(pcb, VERR_INVALID_POINTER);
    249         void *pv = NULL;
    250         uint32_t cb = 0;
    251         int rc = getPointer(&pv, &cb);
    252         if (   RT_SUCCESS(rc)
    253             && VALID_PTR(pv)
    254             && cb > 0)
    255         {
    256             *ppv = pv;
    257             *pcb = cb;
    258             return VINF_SUCCESS;
    259         }
    260 
    261         return VERR_INVALID_PARAMETER;
    262     }
    263 
    264     /** Extract a pointer value to a non-empty constant buffer from an HGCM
    265      * parameter structure */
    266     int getBuffer(const void **ppcv, uint32_t *pcb)
    267     {
    268         AssertPtrReturn(ppcv, VERR_INVALID_POINTER);
    269         AssertPtrReturn(pcb, VERR_INVALID_POINTER);
    270         void *pcv = NULL;
    271         int rc = getBuffer(&pcv, pcb);
    272         *ppcv = pcv;
    273         return rc;
    274     }
    275 
    276     /** Extract a string value from an HGCM parameter structure */
    277     int getString(char **ppch, uint32_t *pcb)
    278     {
    279         uint32_t cb = 0;
    280         char *pch = NULL;
    281         int rc = getBuffer((void **)&pch, &cb);
    282         if (RT_FAILURE(rc))
    283         {
    284             *ppch = NULL;
    285             *pcb = 0;
    286             return rc;
    287         }
    288         rc = RTStrValidateEncodingEx(pch, cb,
    289                                      RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED);
    290         *ppch = pch;
    291         *pcb = cb;
    292         return rc;
    293     }
    294 
    295     /** Extract a constant string value from an HGCM parameter structure */
    296     int getString(const char **ppch, uint32_t *pcb)
    297     {
    298         char *pch = NULL;
    299         int rc = getString(&pch, pcb);
    300         *ppch = pch;
    301         return rc;
    302     }
    303 
    304     /** Set a uint32_t value to an HGCM parameter structure */
    305     void setUInt32(uint32_t u32)
    306     {
    307         type = VBOX_HGCM_SVC_PARM_32BIT;
    308         u.uint32 = u32;
    309     }
    310 
    311     /** Set a uint64_t value to an HGCM parameter structure */
    312     void setUInt64(uint64_t u64)
    313     {
    314         type = VBOX_HGCM_SVC_PARM_64BIT;
    315         u.uint64 = u64;
    316     }
    317 
    318     /** Set a pointer value to an HGCM parameter structure */
    319     void setPointer(void *pv, uint32_t cb)
    320     {
    321         type = VBOX_HGCM_SVC_PARM_PTR;
    322         u.pointer.addr = pv;
    323         u.pointer.size = cb;
    324     }
    325 
    326     /** Set a const string value to an HGCM parameter structure */
    327     void setString(const char *psz)
    328     {
    329         type = VBOX_HGCM_SVC_PARM_PTR;
    330         u.pointer.addr = (void *)psz;
    331         u.pointer.size = (uint32_t)strlen(psz) + 1;
    332     }
    333 
    334 #ifdef ___iprt_cpp_ministring_h
    335     /** Set a const string value to an HGCM parameter structure */
    336     void setCppString(const RTCString &rString)
    337     {
    338         type = VBOX_HGCM_SVC_PARM_PTR;
    339         u.pointer.addr = (void *)rString.c_str();
    340         u.pointer.size = (uint32_t)rString.length() + 1;
    341     }
     402# ifdef ___iprt_cpp_ministring_h
     403/** Set a const string value to an HGCM parameter structure */
     404static inline void HGCMSvcSetRTCStr(struct VBOXHGCMSVCPARM *pParm,
     405                                    const RTCString &rString)
     406{
     407    AssertPtr(pParm);
     408    pParm->type = VBOX_HGCM_SVC_PARM_PTR;
     409    pParm->u.pointer.addr = (void *)rString.c_str();
     410    pParm->u.pointer.size = (uint32_t)rString.length() + 1;
     411}
     412# endif
    342413#endif
    343 
    344 #ifdef VBOX_TEST_HGCM_PARMS
    345     /** Test the getString member function.  Indirectly tests the getPointer
    346      * and getBuffer APIs.
    347      * @param  hTest  an running IPRT test
    348      * @param  aType  the type that the parameter should be set to before
    349      *                calling getString
    350      * @param  apcc   the value that the parameter should be set to before
    351      *                calling getString, and also the address (!) which we
    352      *                expect getString to return.  Stricter than needed of
    353      *                course, but I was feeling lazy.
    354      * @param  acb    the size that the parameter should be set to before
    355      *                calling getString, and also the size which we expect
    356      *                getString to return.
    357      * @param  rcExp  the expected return value of the call to getString.
    358      */
    359     void doTestGetString(RTTEST hTest, uint32_t aType, const char *apcc,
    360                          uint32_t acb, int rcExp)
    361     {
    362         /* An RTTest API like this, which would print out an additional line
    363          * of context if a test failed, would be nice.  This is because the
    364          * line number alone doesn't help much here, given that this is a
    365          * subroutine called many times. */
    366         /*
    367         RTTestContextF(hTest,
    368                        ("doTestGetString, aType=%u, apcc=%p, acp=%u, rcExp=%Rrc",
    369                         aType, apcc, acp, rcExp));
    370          */
    371         setPointer((void *)apcc, acb);
    372         type = aType;  /* in case we don't want VBOX_HGCM_SVC_PARM_PTR */
    373         const char *pcc = NULL;
    374         uint32_t cb = 0;
    375         int rc = getString(&pcc, &cb);
    376         RTTEST_CHECK_RC(hTest, rc, rcExp);
    377         if (RT_SUCCESS(rcExp))
    378         {
    379             RTTEST_CHECK_MSG_RETV(hTest, (pcc == apcc),
    380                                   (hTest, "expected %p, got %p", apcc, pcc));
    381             RTTEST_CHECK_MSG_RETV(hTest, (cb == acb),
    382                                   (hTest, "expected %u, got %u", acb, cb));
    383         }
    384     }
    385 
    386     /** Run some unit tests on the getString method and indirectly test
    387      * getPointer and getBuffer as well. */
    388     void testGetString(RTTEST hTest)
    389     {
    390         RTTestSub(hTest, "HGCM string parameter handling");
    391         doTestGetString(hTest, VBOX_HGCM_SVC_PARM_32BIT, "test", 3,
    392                         VERR_INVALID_PARAMETER);
    393         doTestGetString(hTest, VBOX_HGCM_SVC_PARM_PTR, "test", 5,
    394                         VINF_SUCCESS);
    395         doTestGetString(hTest, VBOX_HGCM_SVC_PARM_PTR, "test", 3,
    396                         VERR_BUFFER_OVERFLOW);
    397         doTestGetString(hTest, VBOX_HGCM_SVC_PARM_PTR, "test\xf0", 6,
    398                         VERR_INVALID_UTF8_ENCODING);
    399         doTestGetString(hTest, VBOX_HGCM_SVC_PARM_PTR, "test", 0,
    400                         VERR_INVALID_PARAMETER);
    401         doTestGetString(hTest, VBOX_HGCM_SVC_PARM_PTR, (const char *)0x1, 5,
    402                         VERR_INVALID_PARAMETER);
    403         RTTestSubDone(hTest);
    404     }
    405 #endif
    406 
    407     VBOXHGCMSVCPARM() : type(VBOX_HGCM_SVC_PARM_INVALID) {}
    408 #endif
    409 } VBOXHGCMSVCPARM;
    410414
    411415typedef VBOXHGCMSVCPARM *PVBOXHGCMSVCPARM;

  • trunk/src/VBox/HostServices/DragAndDrop/service.cpp

    r74439 r75737  
    457457                        {
    458458                            uint32_t fFlags = 0;
    459                             int rc2 = paParms[2].getUInt32(&fFlags);
     459                            int rc2 = HGCMSvcGetU32(&paParms[2], &fFlags);
    460460                            if (   RT_SUCCESS(rc2)
    461461                                && fFlags) /* Blocking flag set? */
    … …  
    484484                    data.hdr.uMagic = CB_MAGIC_DND_CONNECT;
    485485                    if (cParms >= 3)
    486                         rc = paParms[0].getUInt32(&data.hdr.uContextID);
     486                        rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
    487487                    else /* Older protocols don't have a context ID. */
    488488                        rc = VINF_SUCCESS;
    489489                    if (RT_SUCCESS(rc))
    490                         rc = paParms[idxProto].getUInt32(&data.uProtocol);
    491                     if (RT_SUCCESS(rc))
    492                         rc = paParms[idxProto + 1].getUInt32(&data.uFlags);
     490                        rc = HGCMSvcGetU32(&paParms[idxProto], &data.uProtocol);
     491                    if (RT_SUCCESS(rc))
     492                        rc = HGCMSvcGetU32(&paParms[idxProto + 1], &data.uFlags);
    493493                    if (RT_SUCCESS(rc))
    494494                        pClient->SetProtocolVer(data.uProtocol);
    … …  
    515515                        if (cParms == 2)
    516516                        {
    517                             rc = paParms[0].getUInt32(&data.hdr.uContextID);
    518                             if (RT_SUCCESS(rc))
    519                                 rc = paParms[1].getUInt32(&data.uAction); /* Get drop action. */
     517                            rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
     518                            if (RT_SUCCESS(rc))
     519                                rc = HGCMSvcGetU32(&paParms[1], &data.uAction); /* Get drop action. */
    520520                        }
    521521                        break;
    … …  
    526526                    {
    527527                        if (cParms == 1)
    528                             rc = paParms[0].getUInt32(&data.uAction); /* Get drop action. */
     528                            rc = HGCMSvcGetU32(&paParms[0], &data.uAction); /* Get drop action. */
    529529                        break;
    530530                    }
    … …  
    548548                        if (cParms == 3)
    549549                        {
    550                             rc = paParms[0].getUInt32(&data.hdr.uContextID);
    551                             if (RT_SUCCESS(rc))
    552                                 rc = paParms[1].getPointer((void **)&data.pszFormat, &data.cbFormat);
    553                             if (RT_SUCCESS(rc))
    554                                 rc = paParms[2].getUInt32(&data.cbFormat);
     550                            rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
     551                            if (RT_SUCCESS(rc))
     552                                rc = HGCMSvcGetPv(&paParms[1], (void **)&data.pszFormat, &data.cbFormat);
     553                            if (RT_SUCCESS(rc))
     554                                rc = HGCMSvcGetU32(&paParms[2], &data.cbFormat);
    555555                        }
    556556                        break;
    … …  
    561561                    {
    562562                        if (cParms == 1)
    563                             rc = paParms[0].getPointer((void**)&data.pszFormat, &data.cbFormat);
     563                            rc = HGCMSvcGetPv(&paParms[0], (void**)&data.pszFormat, &data.cbFormat);
    564564                        break;
    565565                    }
    … …  
    583583                        if (cParms == 4)
    584584                        {
    585                             rc = paParms[0].getUInt32(&data.uStatus);
    586                             if (RT_SUCCESS(rc))
    587                                 rc = paParms[1].getUInt32(&data.uStatus);
    588                             if (RT_SUCCESS(rc))
    589                                 rc = paParms[2].getUInt32(&data.uPercentage);
    590                             if (RT_SUCCESS(rc))
    591                                 rc = paParms[3].getUInt32(&data.rc);
     585                            rc = HGCMSvcGetU32(&paParms[0], &data.uStatus);
     586                            if (RT_SUCCESS(rc))
     587                                rc = HGCMSvcGetU32(&paParms[1], &data.uStatus);
     588                            if (RT_SUCCESS(rc))
     589                                rc = HGCMSvcGetU32(&paParms[2], &data.uPercentage);
     590                            if (RT_SUCCESS(rc))
     591                                rc = HGCMSvcGetU32(&paParms[3], &data.rc);
    592592                        }
    593593                        break;
    … …  
    599599                        if (cParms == 3)
    600600                        {
    601                             rc = paParms[0].getUInt32(&data.uStatus);
    602                             if (RT_SUCCESS(rc))
    603                                 rc = paParms[1].getUInt32(&data.uPercentage);
    604                             if (RT_SUCCESS(rc))
    605                                 rc = paParms[2].getUInt32(&data.rc);
     601                            rc = HGCMSvcGetU32(&paParms[0], &data.uStatus);
     602                            if (RT_SUCCESS(rc))
     603                                rc = HGCMSvcGetU32(&paParms[1], &data.uPercentage);
     604                            if (RT_SUCCESS(rc))
     605                                rc = HGCMSvcGetU32(&paParms[2], &data.rc);
    606606                        }
    607607                        break;
    … …  
    627627                        if (cParms == 5)
    628628                        {
    629                             rc = paParms[0].getUInt32(&data.hdr.uContextID);
    630                             if (RT_SUCCESS(rc))
    631                                 rc = paParms[1].getUInt32(&data.uDefAction);
    632                             if (RT_SUCCESS(rc))
    633                                 rc = paParms[2].getUInt32(&data.uAllActions);
    634                             if (RT_SUCCESS(rc))
    635                                 rc = paParms[3].getPointer((void**)&data.pszFormat, &data.cbFormat);
    636                             if (RT_SUCCESS(rc))
    637                                 rc = paParms[4].getUInt32(&data.cbFormat);
     629                            rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
     630                            if (RT_SUCCESS(rc))
     631                                rc = HGCMSvcGetU32(&paParms[1], &data.uDefAction);
     632                            if (RT_SUCCESS(rc))
     633                                rc = HGCMSvcGetU32(&paParms[2], &data.uAllActions);
     634                            if (RT_SUCCESS(rc))
     635                                rc = HGCMSvcGetPv(&paParms[3], (void**)&data.pszFormat, &data.cbFormat);
     636                            if (RT_SUCCESS(rc))
     637                                rc = HGCMSvcGetU32(&paParms[4], &data.cbFormat);
    638638                        }
    639639                        break;
    … …  
    645645                        if (cParms == 3)
    646646                        {
    647                             rc = paParms[0].getUInt32(&data.uDefAction);
    648                             if (RT_SUCCESS(rc))
    649                                 rc = paParms[1].getUInt32(&data.uAllActions);
    650                             if (RT_SUCCESS(rc))
    651                                 rc = paParms[2].getPointer((void**)&data.pszFormat, &data.cbFormat);
     647                            rc = HGCMSvcGetU32(&paParms[0], &data.uDefAction);
     648                            if (RT_SUCCESS(rc))
     649                                rc = HGCMSvcGetU32(&paParms[1], &data.uAllActions);
     650                            if (RT_SUCCESS(rc))
     651                                rc = HGCMSvcGetPv(&paParms[2], (void**)&data.pszFormat, &data.cbFormat);
    652652                        }
    653653                        break;
    … …  
    667667                    RT_ZERO(data);
    668668                    data.hdr.uMagic = CB_MAGIC_DND_GH_SND_DATA_HDR;
    669                     rc = paParms[0].getUInt32(&data.hdr.uContextID);
    670                     if (RT_SUCCESS(rc))
    671                         rc = paParms[1].getUInt32(&data.data.uFlags);
    672                     if (RT_SUCCESS(rc))
    673                         rc = paParms[2].getUInt32(&data.data.uScreenId);
    674                     if (RT_SUCCESS(rc))
    675                         rc = paParms[3].getUInt64(&data.data.cbTotal);
    676                     if (RT_SUCCESS(rc))
    677                         rc = paParms[4].getUInt32(&data.data.cbMeta);
    678                     if (RT_SUCCESS(rc))
    679                         rc = paParms[5].getPointer(&data.data.pvMetaFmt, &data.data.cbMetaFmt);
    680                     if (RT_SUCCESS(rc))
    681                         rc = paParms[6].getUInt32(&data.data.cbMetaFmt);
    682                     if (RT_SUCCESS(rc))
    683                         rc = paParms[7].getUInt64(&data.data.cObjects);
    684                     if (RT_SUCCESS(rc))
    685                         rc = paParms[8].getUInt32(&data.data.enmCompression);
    686                     if (RT_SUCCESS(rc))
    687                         rc = paParms[9].getUInt32((uint32_t *)&data.data.enmChecksumType);
    688                     if (RT_SUCCESS(rc))
    689                         rc = paParms[10].getPointer(&data.data.pvChecksum, &data.data.cbChecksum);
    690                     if (RT_SUCCESS(rc))
    691                         rc = paParms[11].getUInt32(&data.data.cbChecksum);
     669                    rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
     670                    if (RT_SUCCESS(rc))
     671                        rc = HGCMSvcGetU32(&paParms[1], &data.data.uFlags);
     672                    if (RT_SUCCESS(rc))
     673                        rc = HGCMSvcGetU32(&paParms[2], &data.data.uScreenId);
     674                    if (RT_SUCCESS(rc))
     675                        rc = HGCMSvcGetU64(&paParms[3], &data.data.cbTotal);
     676                    if (RT_SUCCESS(rc))
     677                        rc = HGCMSvcGetU32(&paParms[4], &data.data.cbMeta);
     678                    if (RT_SUCCESS(rc))
     679                        rc = HGCMSvcGetPv(&paParms[5], &data.data.pvMetaFmt, &data.data.cbMetaFmt);
     680                    if (RT_SUCCESS(rc))
     681                        rc = HGCMSvcGetU32(&paParms[6], &data.data.cbMetaFmt);
     682                    if (RT_SUCCESS(rc))
     683                        rc = HGCMSvcGetU64(&paParms[7], &data.data.cObjects);
     684                    if (RT_SUCCESS(rc))
     685                        rc = HGCMSvcGetU32(&paParms[8], &data.data.enmCompression);
     686                    if (RT_SUCCESS(rc))
     687                        rc = HGCMSvcGetU32(&paParms[9], (uint32_t *)&data.data.enmChecksumType);
     688                    if (RT_SUCCESS(rc))
     689                        rc = HGCMSvcGetPv(&paParms[10], &data.data.pvChecksum, &data.data.cbChecksum);
     690                    if (RT_SUCCESS(rc))
     691                        rc = HGCMSvcGetU32(&paParms[11], &data.data.cbChecksum);
    692692
    693693                    LogFlowFunc(("fFlags=0x%x, cbTotalSize=%RU64, cObj=%RU64\n",
    … …  
    709709                            RT_ZERO(data);
    710710                            data.hdr.uMagic = CB_MAGIC_DND_GH_SND_DATA;
    711                             rc = paParms[0].getUInt32(&data.hdr.uContextID);
    712                             if (RT_SUCCESS(rc))
    713                                 rc = paParms[1].getPointer((void**)&data.data.u.v3.pvData, &data.data.u.v3.cbData);
    714                             if (RT_SUCCESS(rc))
    715                                 rc = paParms[2].getUInt32(&data.data.u.v3.cbData);
    716                             if (RT_SUCCESS(rc))
    717                                 rc = paParms[3].getPointer((void**)&data.data.u.v3.pvChecksum, &data.data.u.v3.cbChecksum);
    718                             if (RT_SUCCESS(rc))
    719                                 rc = paParms[4].getUInt32(&data.data.u.v3.cbChecksum);
     711                            rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
     712                            if (RT_SUCCESS(rc))
     713                                rc = HGCMSvcGetPv(&paParms[1], (void**)&data.data.u.v3.pvData, &data.data.u.v3.cbData);
     714                            if (RT_SUCCESS(rc))
     715                                rc = HGCMSvcGetU32(&paParms[2], &data.data.u.v3.cbData);
     716                            if (RT_SUCCESS(rc))
     717                                rc = HGCMSvcGetPv(&paParms[3], (void**)&data.data.u.v3.pvChecksum, &data.data.u.v3.cbChecksum);
     718                            if (RT_SUCCESS(rc))
     719                                rc = HGCMSvcGetU32(&paParms[4], &data.data.u.v3.cbChecksum);
    720720                            DO_HOST_CALLBACK();
    721721                        }
    … …  
    731731                            RT_ZERO(data);
    732732                            data.hdr.uMagic = CB_MAGIC_DND_GH_SND_DATA;
    733                             rc = paParms[0].getPointer((void**)&data.data.u.v1.pvData, &data.data.u.v1.cbData);
    734                             if (RT_SUCCESS(rc))
    735                                 rc = paParms[1].getUInt32(&data.data.u.v1.cbTotalSize);
     733                            rc = HGCMSvcGetPv(&paParms[0], (void**)&data.data.u.v1.pvData, &data.data.u.v1.cbData);
     734                            if (RT_SUCCESS(rc))
     735                                rc = HGCMSvcGetU32(&paParms[1], &data.data.u.v1.cbTotalSize);
    736736                            DO_HOST_CALLBACK();
    737737                        }
    … …  
    755755                        if (cParms == 4)
    756756                        {
    757                             rc = paParms[0].getUInt32(&data.hdr.uContextID);
    758                             if (RT_SUCCESS(rc))
    759                                 rc = paParms[1].getPointer((void**)&data.pszPath, &data.cbPath);
    760                             if (RT_SUCCESS(rc))
    761                                 rc = paParms[2].getUInt32(&data.cbPath);
    762                             if (RT_SUCCESS(rc))
    763                                 rc = paParms[3].getUInt32(&data.fMode);
     757                            rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
     758                            if (RT_SUCCESS(rc))
     759                                rc = HGCMSvcGetPv(&paParms[1], (void**)&data.pszPath, &data.cbPath);
     760                            if (RT_SUCCESS(rc))
     761                                rc = HGCMSvcGetU32(&paParms[2], &data.cbPath);
     762                            if (RT_SUCCESS(rc))
     763                                rc = HGCMSvcGetU32(&paParms[3], &data.fMode);
    764764                        }
    765765                        break;
    … …  
    771771                        if (cParms == 3)
    772772                        {
    773                             rc = paParms[0].getPointer((void**)&data.pszPath, &data.cbPath);
    774                             if (RT_SUCCESS(rc))
    775                                 rc = paParms[1].getUInt32(&data.cbPath);
    776                             if (RT_SUCCESS(rc))
    777                                 rc = paParms[2].getUInt32(&data.fMode);
     773                            rc = HGCMSvcGetPv(&paParms[0], (void**)&data.pszPath, &data.cbPath);
     774                            if (RT_SUCCESS(rc))
     775                                rc = HGCMSvcGetU32(&paParms[1], &data.cbPath);
     776                            if (RT_SUCCESS(rc))
     777                                rc = HGCMSvcGetU32(&paParms[2], &data.fMode);
    778778                        }
    779779                        break;
    … …  
    794794                    data.hdr.uMagic = CB_MAGIC_DND_GH_SND_FILE_HDR;
    795795
    796                     rc = paParms[0].getUInt32(&data.hdr.uContextID);
    797                     if (RT_SUCCESS(rc))
    798                         rc = paParms[1].getPointer((void**)&data.pszFilePath, &data.cbFilePath);
    799                     if (RT_SUCCESS(rc))
    800                         rc = paParms[2].getUInt32(&data.cbFilePath);
    801                     if (RT_SUCCESS(rc))
    802                         rc = paParms[3].getUInt32(&data.fFlags);
    803                     if (RT_SUCCESS(rc))
    804                         rc = paParms[4].getUInt32(&data.fMode);
    805                     if (RT_SUCCESS(rc))
    806                         rc = paParms[5].getUInt64(&data.cbSize);
     796                    rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
     797                    if (RT_SUCCESS(rc))
     798                        rc = HGCMSvcGetPv(&paParms[1], (void**)&data.pszFilePath, &data.cbFilePath);
     799                    if (RT_SUCCESS(rc))
     800                        rc = HGCMSvcGetU32(&paParms[2], &data.cbFilePath);
     801                    if (RT_SUCCESS(rc))
     802                        rc = HGCMSvcGetU32(&paParms[3], &data.fFlags);
     803                    if (RT_SUCCESS(rc))
     804                        rc = HGCMSvcGetU32(&paParms[4], &data.fMode);
     805                    if (RT_SUCCESS(rc))
     806                        rc = HGCMSvcGetU64(&paParms[5], &data.cbSize);
    807807
    808808                    LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x, cbSize=%RU64\n",
    … …  
    827827                            data.hdr.uMagic = CB_MAGIC_DND_GH_SND_FILE_DATA;
    828828
    829                             rc = paParms[0].getUInt32(&data.hdr.uContextID);
    830                             if (RT_SUCCESS(rc))
    831                                 rc = paParms[1].getPointer((void**)&data.pvData, &data.cbData);
    832                             if (RT_SUCCESS(rc))
    833                                 rc = paParms[2].getUInt32(&data.cbData);
    834                             if (RT_SUCCESS(rc))
    835                                 rc = paParms[3].getPointer((void**)&data.u.v3.pvChecksum, &data.u.v3.cbChecksum);
    836                             if (RT_SUCCESS(rc))
    837                                 rc = paParms[4].getUInt32(&data.u.v3.cbChecksum);
     829                            rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
     830                            if (RT_SUCCESS(rc))
     831                                rc = HGCMSvcGetPv(&paParms[1], (void**)&data.pvData, &data.cbData);
     832                            if (RT_SUCCESS(rc))
     833                                rc = HGCMSvcGetU32(&paParms[2], &data.cbData);
     834                            if (RT_SUCCESS(rc))
     835                                rc = HGCMSvcGetPv(&paParms[3], (void**)&data.u.v3.pvChecksum, &data.u.v3.cbChecksum);
     836                            if (RT_SUCCESS(rc))
     837                                rc = HGCMSvcGetU32(&paParms[4], &data.u.v3.cbChecksum);
    838838
    839839                            LogFlowFunc(("pvData=0x%p, cbData=%RU32\n", data.pvData, data.cbData));
    … …  
    850850                            RT_ZERO(data);
    851851                            data.hdr.uMagic = CB_MAGIC_DND_GH_SND_FILE_DATA;
    852                             rc = paParms[0].getUInt32(&data.hdr.uContextID);
    853                             if (RT_SUCCESS(rc))
    854                                 rc = paParms[1].getPointer((void**)&data.pvData, &data.cbData);
    855                             if (RT_SUCCESS(rc))
    856                                 rc = paParms[2].getUInt32(&data.cbData);
     852                            rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
     853                            if (RT_SUCCESS(rc))
     854                                rc = HGCMSvcGetPv(&paParms[1], (void**)&data.pvData, &data.cbData);
     855                            if (RT_SUCCESS(rc))
     856                                rc = HGCMSvcGetU32(&paParms[2], &data.cbData);
    857857
    858858                            LogFlowFunc(("cbData=%RU32, pvData=0x%p\n", data.cbData, data.pvData));
    … …  
    870870                            data.hdr.uMagic = CB_MAGIC_DND_GH_SND_FILE_DATA;
    871871                            uint32_t cTmp;
    872                             rc = paParms[0].getPointer((void**)&data.u.v1.pszFilePath, &cTmp);
    873                             if (RT_SUCCESS(rc))
    874                                 rc = paParms[1].getUInt32(&data.u.v1.cbFilePath);
    875                             if (RT_SUCCESS(rc))
    876                                 rc = paParms[2].getPointer((void**)&data.pvData, &cTmp);
    877                             if (RT_SUCCESS(rc))
    878                                 rc = paParms[3].getUInt32(&data.cbData);
    879                             if (RT_SUCCESS(rc))
    880                                 rc = paParms[4].getUInt32(&data.u.v1.fMode);
     872                            rc = HGCMSvcGetPv(&paParms[0], (void**)&data.u.v1.pszFilePath, &cTmp);
     873                            if (RT_SUCCESS(rc))
     874                                rc = HGCMSvcGetU32(&paParms[1], &data.u.v1.cbFilePath);
     875                            if (RT_SUCCESS(rc))
     876                                rc = HGCMSvcGetPv(&paParms[2], (void**)&data.pvData, &cTmp);
     877                            if (RT_SUCCESS(rc))
     878                                rc = HGCMSvcGetU32(&paParms[3], &data.cbData);
     879                            if (RT_SUCCESS(rc))
     880                                rc = HGCMSvcGetU32(&paParms[4], &data.u.v1.fMode);
    881881
    882882                            LogFlowFunc(("pszFilePath=%s, cbData=%RU32, pvData=0x%p, fMode=0x%x\n",
    … …  
    903903                        if (cParms == 2)
    904904                        {
    905                             rc = paParms[0].getUInt32(&data.hdr.uContextID);
     905                            rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
    906906                            if (RT_SUCCESS(rc))
    907907                            {
    908908                                uint32_t rcOp;
    909                                 rc = paParms[1].getUInt32(&rcOp);
     909                                rc = HGCMSvcGetU32(&paParms[1], &rcOp);
    910910                                if (RT_SUCCESS(rc))
    911911                                    data.rc = rcOp;
    … …  
    921921                        {
    922922                            uint32_t rcOp;
    923                             rc = paParms[0].getUInt32(&rcOp);
     923                            rc = HGCMSvcGetU32(&paParms[0], &rcOp);
    924924                            if (RT_SUCCESS(rc))
    925925                                data.rc = (int32_t)rcOp;
    … …  
    953953                        /* Protocol v3+ at least requires the context ID. */
    954954                        if (cParms == 1)
    955                             rc = paParms[0].getUInt32(&data.hdr.uContextID);
     955                            rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
    956956
    957957                        break;

  • trunk/src/VBox/HostServices/GuestControl/service.cpp

    r75500 r75737  
    224224             * assign the context ID to the command.
    225225             */
    226             rc = mpParms[0].getUInt32(&mContextID);
     226            rc = HGCMSvcGetU32(&mpParms[0], &mContextID);
    227227
    228228            /* Set timestamp so that clients can distinguish between already
    … …  
    418418        if (pConnection->mNumParms >= 2)
    419419        {
    420             pConnection->mParms[0].setUInt32(mMsgType);   /* Message ID */
    421             pConnection->mParms[1].setUInt32(mParmCount); /* Required parameters for message */
     420            HGCMSvcSetU32(&pConnection->mParms[0], mMsgType);   /* Message ID */
     421            HGCMSvcSetU32(&pConnection->mParms[1], mParmCount); /* Required parameters for message */
    422422        }
    423423        else
    … …  
    777777            && mPendingCon.mNumParms >= 2)
    778778        {
    779             mPendingCon.mParms[0].setUInt32(HOST_CANCEL_PENDING_WAITS); /* Message ID. */
    780             mPendingCon.mParms[1].setUInt32(0);                         /* Required parameters for message. */
     779            HGCMSvcSetU32(&mPendingCon.mParms[0], HOST_CANCEL_PENDING_WAITS); /* Message ID. */
     780            HGCMSvcSetU32(&mPendingCon.mParms[1], 0);                         /* Required parameters for message. */
    781781
    782782            AssertPtr(mSvcHelpers);
    … …  
    11091109            uint32_t cParms = 0;
    11101110            VBOXHGCMSVCPARM arParms[2];
    1111             arParms[cParms++].setUInt32(pCurCmd->mContextID);
     1111            HGCMSvcSetU32(&arParms[cParms++], pCurCmd->mContextID);
    11121112
    11131113            int rc2 = hostCallback(GUEST_DISCONNECTED, cParms, arParms);
    … …  
    12071207
    12081208    uint32_t uValue;
    1209     int rc = paParms[0].getUInt32(&uValue);
     1209    int rc = HGCMSvcGetU32(&paParms[0], &uValue);
    12101210    if (RT_SUCCESS(rc))
    12111211    {
    12121212        uint32_t uMaskAdd;
    1213         rc = paParms[1].getUInt32(&uMaskAdd);
     1213        rc = HGCMSvcGetU32(&paParms[1], &uMaskAdd);
    12141214        if (RT_SUCCESS(rc))
    12151215        {
    12161216            uint32_t uMaskRemove;
    1217             rc = paParms[2].getUInt32(&uMaskRemove);
     1217            rc = HGCMSvcGetU32(&paParms[2], &uMaskRemove);
    12181218            /** @todo paParm[3] (flags) not used yet. */
    12191219            if (RT_SUCCESS(rc))
    … …  
    15841584
    15851585    uint32_t uContextID, uFlags;
    1586     int rc = paParms[0].getUInt32(&uContextID);
     1586    int rc = HGCMSvcGetU32(&paParms[0], &uContextID);
    15871587    if (RT_SUCCESS(rc))
    1588         rc = paParms[1].getUInt32(&uFlags);
     1588        rc = HGCMSvcGetU32(&paParms[1], &uFlags);
    15891589
    15901590    uint32_t uSessionID = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(uContextID);

  • trunk/src/VBox/HostServices/GuestControl/testcase/tstGuestControlSvc.cpp

    r75500 r75737  
    152152
    153153    VBOXHGCMSVCPARM aParms[1];
    154     aParms[0].setUInt32(1000 /* Context ID */);
     154    HGCMSvcSetU32(&aParms[0], 1000 /* Context ID */);
    155155
    156156    CMDHOST aCmdHostAll[] =
    … …  
    208208        /* No commands from host yet. */
    209209        VBOXHGCMSVCPARM aParmsGuest[8];
    210         aParmsGuest[0].setUInt32(0 /* Msg type */);
    211         aParmsGuest[1].setUInt32(0 /* Parameters */);
     210        HGCMSvcSetU32(&aParmsGuest[0], 0 /* Msg type */);
     211        HGCMSvcSetU32(&aParmsGuest[1], 0 /* Parameters */);
    212212        pTable->pfnCall(pTable->pvService, &callHandle, 1 /* Client ID */, NULL /* pvClient */,
    213213                        GUEST_MSG_WAIT, 2, &aParmsGuest[0], 0);
    … …  
    216216        /* Host: Add a dummy command. */
    217217        VBOXHGCMSVCPARM aParmsHost[8];
    218         aParmsHost[0].setUInt32(1000 /* Context ID */);
    219         aParmsHost[1].setString("foo.bar");
    220         aParmsHost[2].setString("baz");
     218        HGCMSvcSetU32(&aParmsHost[0], 1000 /* Context ID */);
     219        HGCMSvcSetStr(&aParmsHost[1], "foo.bar");
     220        HGCMSvcSetStr(&aParmsHost[2], "baz");
    221221
    222222        rc = pTable->pfnHostCall(pTable->pvService, HOST_EXEC_CMD, 3, &aParmsHost[0]);

  • trunk/src/VBox/HostServices/GuestProperties/service.cpp

    r75500 r75737  
    528528     */
    529529    if (   cParms != 4
    530         || RT_FAILURE(paParms[0].getPointer((void **)&papszNames, &cbDummy))
    531         || RT_FAILURE(paParms[1].getPointer((void **)&papszValues, &cbDummy))
    532         || RT_FAILURE(paParms[2].getPointer((void **)&pau64Timestamps, &cbDummy))
    533         || RT_FAILURE(paParms[3].getPointer((void **)&papszFlags, &cbDummy))
     530        || RT_FAILURE(HGCMSvcGetPv(&paParms[0], (void **)&papszNames, &cbDummy))
     531        || RT_FAILURE(HGCMSvcGetPv(&paParms[1], (void **)&papszValues, &cbDummy))
     532        || RT_FAILURE(HGCMSvcGetPv(&paParms[2], (void **)&pau64Timestamps, &cbDummy))
     533        || RT_FAILURE(HGCMSvcGetPv(&paParms[3], (void **)&papszFlags, &cbDummy))
    534534        )
    535535        rc = VERR_INVALID_PARAMETER;
    … …  
    624624    LogFlowThisFunc(("\n"));
    625625    if (   cParms != 4  /* Hardcoded value as the next lines depend on it. */
    626         || RT_FAILURE(paParms[0].getString(&pcszName, &cbName))  /* name */
    627         || RT_FAILURE(paParms[1].getBuffer((void **)&pchBuf, &cbBuf))  /* buffer */
     626        || RT_FAILURE(HGCMSvcGetCStr(&paParms[0], &pcszName, &cbName))  /* name */
     627        || RT_FAILURE(HGCMSvcGetBuf(&paParms[1], (void **)&pchBuf, &cbBuf))  /* buffer */
    628628       )
    629629        rc = VERR_INVALID_PARAMETER;
    … …  
    652652            size_t const cbValue  = pProp->mValue.size() + 1;
    653653            size_t const cbNeeded = cbValue + cbFlags;
    654             paParms[3].setUInt32((uint32_t)cbNeeded);
     654            HGCMSvcSetU32(&paParms[3], (uint32_t)cbNeeded);
    655655            if (cbBuf >= cbNeeded)
    656656            {
    … …  
    659659                memcpy(pchBuf + cbValue, szFlags, cbFlags);
    660660
    661                 paParms[2].setUInt64(pProp->mTimestamp);
     661                HGCMSvcSetU64(&paParms[2], pProp->mTimestamp);
    662662
    663663                /*
    … …  
    708708    if (   RT_SUCCESS(rc)
    709709        && (   (cParms < 2) || (cParms > 3)  /* Hardcoded value as the next lines depend on it. */
    710             || RT_FAILURE(paParms[0].getString(&pcszName, &cchName))  /* name */
    711             || RT_FAILURE(paParms[1].getString(&pcszValue, &cchValue))  /* value */
     710            || RT_FAILURE(HGCMSvcGetCStr(&paParms[0], &pcszName, &cchName))  /* name */
     711            || RT_FAILURE(HGCMSvcGetCStr(&paParms[1], &pcszValue, &cchValue))  /* value */
    712712            || (   (3 == cParms)
    713                 && RT_FAILURE(paParms[2].getString(&pcszFlags, &cchFlags)) /* flags */
     713                && RT_FAILURE(HGCMSvcGetCStr(&paParms[2], &pcszFlags, &cchFlags)) /* flags */
    714714               )
    715715           )
    … …  
    825825     */
    826826    if (   (cParms == 1)  /* Hardcoded value as the next lines depend on it. */
    827         && RT_SUCCESS(paParms[0].getString(&pcszName, &cbName))  /* name */
     827        && RT_SUCCESS(HGCMSvcGetCStr(&paParms[0], &pcszName, &cbName))  /* name */
    828828       )
    829829        rc = validateName(pcszName, cbName);
    … …  
    954954    LogFlowThisFunc(("\n"));
    955955    if (   (cParms != 3)  /* Hardcoded value as the next lines depend on it. */
    956         || RT_FAILURE(paParms[0].getString(&pchPatterns, &cbPatterns))  /* patterns */
    957         || RT_FAILURE(paParms[1].getBuffer((void **)&pchBuf, &cbBuf))  /* return buffer */
     956        || RT_FAILURE(HGCMSvcGetCStr(&paParms[0], &pchPatterns, &cbPatterns))  /* patterns */
     957        || RT_FAILURE(HGCMSvcGetBuf(&paParms[1], (void **)&pchBuf, &cbBuf))  /* return buffer */
    958958       )
    959959        rc = VERR_INVALID_PARAMETER;
    … …  
    989989        if (RT_SUCCESS(rc))
    990990        {
    991             paParms[2].setUInt32((uint32_t)(EnumData.cbNeeded + 4));
     991            HGCMSvcSetU32(&paParms[2], (uint32_t)(EnumData.cbNeeded + 4));
    992992            if (EnumData.cbLeft >= 4)
    993993            {
    … …  
    10481048    uint32_t cbBuf;
    10491049
    1050     int rc = paParms[2].getBuffer((void **)&pchBuf, &cbBuf);
     1050    int rc = HGCMSvcGetBuf(&paParms[2], (void **)&pchBuf, &cbBuf);
    10511051    if (RT_SUCCESS(rc))
    10521052    {
    … …  
    10661066            if (RT_SUCCESS(rc))
    10671067            {
    1068                 paParms[1].setUInt64(u64Timestamp);
    1069                 paParms[3].setUInt32((uint32_t)buffer.size());
     1068                HGCMSvcSetU64(&paParms[1], u64Timestamp);
     1069                HGCMSvcSetU32(&paParms[3], (uint32_t)buffer.size());
    10701070                if (buffer.size() <= cbBuf)
    10711071                    buffer.copy(pchBuf, cbBuf);
    … …  
    11051105    LogFlowThisFunc(("\n"));
    11061106    if (   cParms != 4  /* Hardcoded value as the next lines depend on it. */
    1107         || RT_FAILURE(paParms[0].getString(&pszPatterns, &cchPatterns))  /* patterns */
    1108         || RT_FAILURE(paParms[1].getUInt64(&u64Timestamp))  /* timestamp */
    1109         || RT_FAILURE(paParms[2].getBuffer((void **)&pchBuf, &cbBuf))  /* return buffer */
     1107        || RT_FAILURE(HGCMSvcGetStr(&paParms[0], &pszPatterns, &cchPatterns))  /* patterns */
     1108        || RT_FAILURE(HGCMSvcGetU64(&paParms[1], &u64Timestamp))  /* timestamp */
     1109        || RT_FAILURE(HGCMSvcGetBuf(&paParms[2], (void **)&pchBuf, &cbBuf))  /* return buffer */
    11101110       )
    11111111        rc = VERR_INVALID_PARAMETER;
    … …  
    11351135                    const char *pszPatternsExisting;
    11361136                    uint32_t cchPatternsExisting;
    1137                     int rc3 = it->mParms[0].getString(&pszPatternsExisting, &cchPatternsExisting);
     1137                    int rc3 = HGCMSvcGetCStr(&it->mParms[0], &pszPatternsExisting, &cchPatternsExisting);
    11381138
    11391139                    if (   RT_SUCCESS(rc3)
    … …  
    12131213            const char *pszPatterns;
    12141214            uint32_t cchPatterns;
    1215             it->mParms[0].getString(&pszPatterns, &cchPatterns);
     1215            HGCMSvcGetCStr(&it->mParms[0], &pszPatterns, &cchPatterns);
    12161216            if (prop.Matches(pszPatterns))
    12171217            {
    … …  
    15291529                {
    15301530                    uint32_t fFlags;
    1531                     rc = paParms[0].getUInt32(&fFlags);
     1531                    rc = HGCMSvcGetU32(&paParms[0], &fFlags);
    15321532                    if (RT_SUCCESS(rc))
    15331533                        mfGlobalFlags = fFlags;

  • trunk/src/VBox/HostServices/GuestProperties/testcase/tstGuestPropSvc.cpp

    r75500 r75737  
    225225
    226226    VBOXHGCMSVCPARM aParms[4];
    227     aParms[0].setPointer((void *)g_apcszNameBlock, 0);
    228     aParms[1].setPointer((void *)g_apcszValueBlock, 0);
    229     aParms[2].setPointer((void *)g_au64TimestampBlock, 0);
    230     aParms[3].setPointer((void *)g_apcszFlagsBlock, 0);
     227    HGCMSvcSetPv(&aParms[0], (void *)g_apcszNameBlock, 0);
     228    HGCMSvcSetPv(&aParms[1], (void *)g_apcszValueBlock, 0);
     229    HGCMSvcSetPv(&aParms[2], (void *)g_au64TimestampBlock, 0);
     230    HGCMSvcSetPv(&aParms[3], (void *)g_apcszFlagsBlock, 0);
    231231    RTTESTI_CHECK_RC(ptable->pfnHostCall(ptable->pvService, GUEST_PROP_FN_HOST_SET_PROPS, 4, &aParms[0]), VINF_SUCCESS);
    232232}
    … …  
    337337
    338338        /* Check that we get buffer overflow with a too small buffer. */
    339         aParms[0].setPointer((void *)g_aEnumStrings[i].pszPatterns, g_aEnumStrings[i].cchPatterns);
    340         aParms[1].setPointer((void *)abBuffer, g_aEnumStrings[i].cbBuffer - 1);
     339        HGCMSvcSetPv(&aParms[0], (void *)g_aEnumStrings[i].pszPatterns, g_aEnumStrings[i].cchPatterns);
     340        HGCMSvcSetPv(&aParms[1], (void *)abBuffer, g_aEnumStrings[i].cbBuffer - 1);
    341341        memset(abBuffer, 0x55, sizeof(abBuffer));
    342342        int rc2 = ptable->pfnHostCall(ptable->pvService, GUEST_PROP_FN_HOST_ENUM_PROPS, 3, aParms);
    … …  
    344344        {
    345345            uint32_t cbNeeded;
    346             RTTESTI_CHECK_RC(rc2 = aParms[2].getUInt32(&cbNeeded), VINF_SUCCESS);
     346            RTTESTI_CHECK_RC(rc2 = HGCMSvcGetU32(&aParms[2], &cbNeeded), VINF_SUCCESS);
    347347            if (RT_SUCCESS(rc2))
    348348                RTTESTI_CHECK_MSG(cbNeeded == g_aEnumStrings[i].cbBuffer,
    … …  
    353353
    354354        /* Make a successfull call. */
    355         aParms[0].setPointer((void *)g_aEnumStrings[i].pszPatterns, g_aEnumStrings[i].cchPatterns);
    356         aParms[1].setPointer((void *)abBuffer, g_aEnumStrings[i].cbBuffer);
     355        HGCMSvcSetPv(&aParms[0], (void *)g_aEnumStrings[i].pszPatterns, g_aEnumStrings[i].cchPatterns);
     356        HGCMSvcSetPv(&aParms[1], (void *)abBuffer, g_aEnumStrings[i].cbBuffer);
    357357        memset(abBuffer, 0x55, sizeof(abBuffer));
    358358        rc2 = ptable->pfnHostCall(ptable->pvService, GUEST_PROP_FN_HOST_ENUM_PROPS, 3, aParms);
    … …  
    416416    RTStrPrintf(szValue, sizeof(szValue), "%s", pcszValue);
    417417    RTStrPrintf(szFlags, sizeof(szFlags), "%s", pcszFlags);
    418     aParms[0].setString(szName);
    419     aParms[1].setString(szValue);
    420     aParms[2].setString(szFlags);
     418    HGCMSvcSetStr(&aParms[0], szName);
     419    HGCMSvcSetStr(&aParms[1], szValue);
     420    HGCMSvcSetStr(&aParms[2], szFlags);
    421421    if (isHost)
    422422        callHandle.rc = pTable->pfnHostCall(pTable->pvService, command,
    … …  
    505505        command = GUEST_PROP_FN_HOST_DEL_PROP;
    506506    VBOXHGCMSVCPARM aParms[1];
    507     aParms[0].setString(pcszName);
     507    HGCMSvcSetStr(&aParms[0], pcszName);
    508508    if (isHost)
    509509        callHandle.rc = pTable->pfnHostCall(pTable->pvService, command, 1, aParms);
    … …  
    606606        RTTESTI_CHECK_RETV(s_aGetProperties[i].cchValue < sizeof(szBuffer));
    607607
    608         aParms[0].setString(s_aGetProperties[i].pcszName);
     608        HGCMSvcSetStr(&aParms[0], s_aGetProperties[i].pcszName);
    609609        memset(szBuffer, 0x55, sizeof(szBuffer));
    610         aParms[1].setPointer(szBuffer, sizeof(szBuffer));
     610        HGCMSvcSetPv(&aParms[1], szBuffer, sizeof(szBuffer));
    611611        int rc2 = pTable->pfnHostCall(pTable->pvService, GUEST_PROP_FN_HOST_GET_PROP, 4, aParms);
    612612
    … …  
    630630
    631631            uint32_t u32ValueLen = UINT32_MAX;
    632             RTTESTI_CHECK_RC(rc2 = aParms[3].getUInt32(&u32ValueLen), VINF_SUCCESS);
     632            RTTESTI_CHECK_RC(rc2 = HGCMSvcGetU32(&aParms[3], &u32ValueLen), VINF_SUCCESS);
    633633            if (RT_SUCCESS(rc2))
    634634            {
    … …  
    643643            {
    644644                uint64_t u64Timestamp = UINT64_MAX;
    645                 RTTESTI_CHECK_RC(rc2 = aParms[2].getUInt64(&u64Timestamp), VINF_SUCCESS);
     645                RTTESTI_CHECK_RC(rc2 = HGCMSvcGetU64(&aParms[2], &u64Timestamp), VINF_SUCCESS);
    646646                if (u64Timestamp != s_aGetProperties[i].u64Timestamp)
    647647                    RTTestIFailed("Bad timestamp %llu for property '%s', expected %llu.",
    … …  
    700700        memset(pvBuf, 0x55, cbBuf);
    701701
    702         aParms[0].setPointer((void *)s_szPattern, sizeof(s_szPattern));
    703         aParms[1].setUInt64(1);
    704         aParms[2].setPointer(pvBuf, cbBuf);
     702        HGCMSvcSetPv(&aParms[0], (void *)s_szPattern, sizeof(s_szPattern));
     703        HGCMSvcSetU64(&aParms[1], 1);
     704        HGCMSvcSetPv(&aParms[2], pvBuf, cbBuf);
    705705        pTable->pfnCall(pTable->pvService, &callHandle, 0, NULL, GUEST_PROP_FN_GET_NOTIFICATION, 4, aParms, 0);
    706706
    707707        if (   callHandle.rc != VERR_BUFFER_OVERFLOW
    708             || RT_FAILURE(aParms[3].getUInt32(&cbRetNeeded))
     708            || RT_FAILURE(HGCMSvcGetU32(&aParms[3], &cbRetNeeded))
    709709            || cbRetNeeded != g_aGetNotifications[0].cbBuffer
    710710           )
    … …  
    726726        memset(pvBuf, 0x55, cbBuf);
    727727
    728         aParms[0].setPointer((void *)s_szPattern, sizeof(s_szPattern));
    729         aParms[1].setUInt64(u64Timestamp);
    730         aParms[2].setPointer(pvBuf, cbBuf);
     728        HGCMSvcSetPv(&aParms[0], (void *)s_szPattern, sizeof(s_szPattern));
     729        HGCMSvcSetU64(&aParms[1], u64Timestamp);
     730        HGCMSvcSetPv(&aParms[2], pvBuf, cbBuf);
    731731        pTable->pfnCall(pTable->pvService, &callHandle, 0, NULL, GUEST_PROP_FN_GET_NOTIFICATION, 4, aParms, 0);
    732732        if (   RT_FAILURE(callHandle.rc)
    733733            || (i == 0 && callHandle.rc != VWRN_NOT_FOUND)
    734             || RT_FAILURE(aParms[1].getUInt64(&u64Timestamp))
    735             || RT_FAILURE(aParms[3].getUInt32(&cbRetNeeded))
     734            || RT_FAILURE(HGCMSvcGetU64(&aParms[1], &u64Timestamp))
     735            || RT_FAILURE(HGCMSvcGetU32(&aParms[3], &cbRetNeeded))
    736736            || cbRetNeeded != g_aGetNotifications[i].cbBuffer
    737737            || memcmp(pvBuf, g_aGetNotifications[i].pchBuffer, cbRetNeeded) != 0
    … …  
    764764    static char s_szPattern[] = "";
    765765
    766     g_AsyncNotification.aParms[0].setPointer((void *)s_szPattern, sizeof(s_szPattern));
    767     g_AsyncNotification.aParms[1].setUInt64(0);
    768     g_AsyncNotification.aParms[2].setPointer((void *)g_AsyncNotification.abBuffer,
     766    HGCMSvcSetPv(&g_AsyncNotification.aParms[0], (void *)s_szPattern, sizeof(s_szPattern));
     767    HGCMSvcSetU64(&g_AsyncNotification.aParms[1], 0);
     768    HGCMSvcSetPv(&g_AsyncNotification.aParms[2], (void *)g_AsyncNotification.abBuffer,
    769769                                             sizeof(g_AsyncNotification.abBuffer));
    770770    g_AsyncNotification.callHandle.rc = VINF_HGCM_ASYNC_EXECUTE;
    … …  
    786786    uint32_t u32Size;
    787787    if (   g_AsyncNotification.callHandle.rc != VINF_SUCCESS
    788         || RT_FAILURE(g_AsyncNotification.aParms[1].getUInt64(&u64Timestamp))
    789         || RT_FAILURE(g_AsyncNotification.aParms[3].getUInt32(&u32Size))
     788        || RT_FAILURE(HGCMSvcGetU64(&g_AsyncNotification.aParms[1], &u64Timestamp))
     789        || RT_FAILURE(HGCMSvcGetU32(&g_AsyncNotification.aParms[3], &u32Size))
    790790        || u32Size != g_aGetNotifications[0].cbBuffer
    791791        || memcmp(g_AsyncNotification.abBuffer, g_aGetNotifications[0].pchBuffer, u32Size) != 0
    … …  
    834834{
    835835    VBOXHGCMSVCPARM paParm;
    836     paParm.setUInt32(fFlags);
     836    HGCMSvcSetU32(&paParm, fFlags);
    837837    int rc = pTable->pfnHostCall(pTable->pvService, GUEST_PROP_FN_HOST_SET_GLOBAL_FLAGS, 1, &paParm);
    838838    if (RT_FAILURE(rc))
    … …  
    10181018
    10191019            VBOXHGCMSVCPARM aParms[4];
    1020             aParms[0].setString(s_szProp);
    1021             aParms[1].setPointer(pvBuf, cbBuf);
     1020            HGCMSvcSetStr(&aParms[0], s_szProp);
     1021            HGCMSvcSetPv(&aParms[1], pvBuf, cbBuf);
    10221022            svcTable.pfnHostCall(svcTable.pvService, GUEST_PROP_FN_HOST_GET_PROP, RT_ELEMENTS(aParms), aParms);
    10231023
    … …  
    10541054
    10551055            VBOXHGCMSVCPARM aParms[3];
    1056             aParms[0].setString("*");
    1057             aParms[1].setPointer(pvBuf, cbBuf);
     1056            HGCMSvcSetStr(&aParms[0], "*");
     1057            HGCMSvcSetPv(&aParms[1], pvBuf, cbBuf);
    10581058            svcTable.pfnHostCall(svcTable.pvService, GUEST_PROP_FN_HOST_ENUM_PROPS, RT_ELEMENTS(aParms), aParms);
    10591059
    … …  
    11231123            VBOXHGCMSVCPARM aParms[4];
    11241124            char            szBuffer[256];
    1125             aParms[0].setPointer(szProp, (uint32_t)cchProp + 1);
    1126             aParms[1].setPointer(szBuffer, sizeof(szBuffer));
     1125            HGCMSvcSetPv(&aParms[0], szProp, (uint32_t)cchProp + 1);
     1126            HGCMSvcSetPv(&aParms[1], szBuffer, sizeof(szBuffer));
    11271127            RTTESTI_CHECK_RC_BREAK(svcTable.pfnHostCall(svcTable.pvService, GUEST_PROP_FN_HOST_GET_PROP, 4, aParms), VINF_SUCCESS);
    11281128        }

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

    r75500 r75737  
    6262    RTTESTI_CHECK_MSG_RETV(RT_SUCCESS(rc), ("rc=%Rrc\n", rc));
    6363    /* Reset global variable which doesn't reset itself. */
    64     parms[0].setUInt32(VBOX_SHARED_CLIPBOARD_MODE_OFF);
     64    HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_OFF);
    6565    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
    6666                           1, parms);
    … …  
    7575                           2, parms);
    7676    RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
    77     parms[0].setUInt64(99);
    78     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
    79                            1, parms);
    80     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
    81     parms[0].setUInt32(VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST);
     77    HGCMSvcSetU64(&parms[0], 99);
     78    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
     79                           1, parms);
     80    RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     81    HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST);
    8282    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
    8383                           1, parms);
    … …  
    8686    RTTESTI_CHECK_MSG(u32Mode == VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST,
    8787                      ("u32Mode=%u\n", (unsigned) u32Mode));
    88     parms[0].setUInt32(99);
     88    HGCMSvcSetU32(&parms[0], 99);
    8989    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
    9090                           1, parms);
    … …  
    107107    RTTESTI_CHECK_MSG_RETV(RT_SUCCESS(rc), ("rc=%Rrc\n", rc));
    108108    /* Unless we are bidirectional the host message requests will be dropped. */
    109     parms[0].setUInt32(VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL);
     109    HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL);
    110110    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
    111111                           1, parms);
    … …  
    114114    RTTestISub("Testing FN_GET_HOST_MSG, one format, waiting guest call.");
    115115    RT_ZERO(g_Client);
    116     parms[0].setUInt32(0);
    117     parms[1].setUInt32(0);
     116    HGCMSvcSetU32(&parms[0], 0);
     117    HGCMSvcSetU32(&parms[1], 0);
    118118    call.rc = VERR_TRY_AGAIN;
    119119    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
    … …  
    134134    vboxSvcClipboardReportMsg (&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    135135                               VBOX_SHARED_CLIPBOARD_FMT_HTML);
    136     parms[0].setUInt32(0);
    137     parms[1].setUInt32(0);
     136    HGCMSvcSetU32(&parms[0], 0);
     137    HGCMSvcSetU32(&parms[1], 0);
    138138    call.rc = VERR_TRY_AGAIN;
    139139    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
    … …  
    149149    RTTestISub("Testing FN_GET_HOST_MSG, two formats, waiting guest call.");
    150150    RT_ZERO(g_Client);
    151     parms[0].setUInt32(0);
    152     parms[1].setUInt32(0);
     151    HGCMSvcSetU32(&parms[0], 0);
     152    HGCMSvcSetU32(&parms[1], 0);
    153153    call.rc = VERR_TRY_AGAIN;
    154154    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
    … …  
    175175    vboxSvcClipboardReportMsg (&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    176176                               VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
    177     parms[0].setUInt32(0);
    178     parms[1].setUInt32(0);
     177    HGCMSvcSetU32(&parms[0], 0);
     178    HGCMSvcSetU32(&parms[1], 0);
    179179    call.rc = VERR_TRY_AGAIN;
    180180    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG,
    … …  
    207207    RTTESTI_CHECK_MSG_RETV(RT_SUCCESS(rc), ("rc=%Rrc\n", rc));
    208208    /* Reset global variable which doesn't reset itself. */
    209     parms[0].setUInt32(false);
     209    HGCMSvcSetU32(&parms[0], false);
    210210    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
    211211                           1, parms);
    … …  
    219219                           2, parms);
    220220    RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
    221     parms[0].setUInt64(99);
    222     rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
    223                            1, parms);
    224     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
    225     parms[0].setUInt32(true);
     221    HGCMSvcSetU64(&parms[0], 99);
     222    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
     223                           1, parms);
     224    RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     225    HGCMSvcSetU32(&parms[0], true);
    226226    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
    227227                           1, parms);
    … …  
    229229    fHeadless = vboxSvcClipboardGetHeadless();
    230230    RTTESTI_CHECK_MSG(fHeadless == true, ("fHeadless=%RTbool\n", fHeadless));
    231     parms[0].setUInt32(99);
     231    HGCMSvcSetU32(&parms[0], 99);
    232232    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
    233233                           1, parms);

  • trunk/src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.cpp

    r75570 r75737  
    659659    fillTestShflString(&Mapping, pcszMapping);
    660660    fillTestShflString(&AutoMountPoint, "");
    661     aParms[0].setPointer(&FolderName,   RT_UOFFSETOF(SHFLSTRING, String)
     661    HGCMSvcSetPv(&aParms[0], &FolderName,   RT_UOFFSETOF(SHFLSTRING, String)
    662662                                      + FolderName.string.u16Size);
    663     aParms[1].setPointer(&Mapping,   RT_UOFFSETOF(SHFLSTRING, String)
     663    HGCMSvcSetPv(&aParms[1], &Mapping,   RT_UOFFSETOF(SHFLSTRING, String)
    664664                                   + Mapping.string.u16Size);
    665     aParms[2].setUInt32(1);
    666     aParms[3].setPointer(&AutoMountPoint, SHFLSTRING_HEADER_SIZE + AutoMountPoint.string.u16Size);
     665    HGCMSvcSetU32(&aParms[2], 1);
     666    HGCMSvcSetPv(&aParms[3], &AutoMountPoint, SHFLSTRING_HEADER_SIZE + AutoMountPoint.string.u16Size);
    667667    rc = psvcTable->pfnHostCall(psvcTable->pvService, SHFL_FN_ADD_MAPPING,
    668668                                SHFL_CPARMS_ADD_MAPPING, aParms);
    669669    AssertReleaseRC(rc);
    670     aParms[0].setPointer(&Mapping,   RT_UOFFSETOF(SHFLSTRING, String)
     670    HGCMSvcSetPv(&aParms[0], &Mapping,   RT_UOFFSETOF(SHFLSTRING, String)
    671671                                   + Mapping.string.u16Size);
    672     aParms[1].setUInt32(0);  /* root */
    673     aParms[2].setUInt32('/');  /* delimiter */
    674     aParms[3].setUInt32(fCaseSensitive);
     672    HGCMSvcSetU32(&aParms[1], 0);  /* root */
     673    HGCMSvcSetU32(&aParms[2], '/');  /* delimiter */
     674    HGCMSvcSetU32(&aParms[3], fCaseSensitive);
    675675    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
    676676                       psvcTable->pvService, SHFL_FN_MAP_FOLDER,
    … …  
    692692    int rc;
    693693
    694     aParms[0].setUInt32(root);
     694    HGCMSvcSetU32(&aParms[0], root);
    695695    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
    696696                       psvcTable->pvService, SHFL_FN_UNMAP_FOLDER,
    … …  
    698698    AssertReleaseRC(callHandle.rc);
    699699    fillTestShflString(&FolderName, pcszFolderName);
    700     aParms[0].setPointer(&FolderName,   RT_UOFFSETOF(SHFLSTRING, String)
     700    HGCMSvcSetPv(&aParms[0], &FolderName,   RT_UOFFSETOF(SHFLSTRING, String)
    701701                                      + FolderName.string.u16Size);
    702702    rc = psvcTable->pfnHostCall(psvcTable->pvService, SHFL_FN_REMOVE_MAPPING,
    … …  
    717717    RT_ZERO(CreateParms);
    718718    CreateParms.CreateFlags = fCreateFlags;
    719     aParms[0].setUInt32(Root);
    720     aParms[1].setPointer(&Path,   RT_UOFFSETOF(SHFLSTRING, String)
     719    HGCMSvcSetU32(&aParms[0], Root);
     720    HGCMSvcSetPv(&aParms[1], &Path,   RT_UOFFSETOF(SHFLSTRING, String)
    721721                                + Path.string.u16Size);
    722     aParms[2].setPointer(&CreateParms, sizeof(CreateParms));
     722    HGCMSvcSetPv(&aParms[2], &CreateParms, sizeof(CreateParms));
    723723    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
    724724                       psvcTable->pvService, SHFL_FN_CREATE,
    … …  
    740740    VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
    741741
    742     aParms[0].setUInt32(Root);
    743     aParms[1].setUInt64((uint64_t) hFile);
    744     aParms[2].setUInt64(offSeek);
    745     aParms[3].setUInt32(cbRead);
    746     aParms[4].setPointer(pvBuf, cbBuf);
     742    HGCMSvcSetU32(&aParms[0], Root);
     743    HGCMSvcSetU64(&aParms[1], (uint64_t) hFile);
     744    HGCMSvcSetU64(&aParms[2], offSeek);
     745    HGCMSvcSetU32(&aParms[3], cbRead);
     746    HGCMSvcSetPv(&aParms[4], pvBuf, cbBuf);
    747747    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
    748748                       psvcTable->pvService, SHFL_FN_READ,
    … …  
    760760    VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
    761761
    762     aParms[0].setUInt32(Root);
    763     aParms[1].setUInt64((uint64_t) hFile);
    764     aParms[2].setUInt64(offSeek);
    765     aParms[3].setUInt32(cbWrite);
    766     aParms[4].setPointer((void *)pvBuf, cbBuf);
     762    HGCMSvcSetU32(&aParms[0], Root);
     763    HGCMSvcSetU64(&aParms[1], (uint64_t) hFile);
     764    HGCMSvcSetU64(&aParms[2], offSeek);
     765    HGCMSvcSetU32(&aParms[3], cbWrite);
     766    HGCMSvcSetPv(&aParms[4], (void *)pvBuf, cbBuf);
    767767    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
    768768                       psvcTable->pvService, SHFL_FN_WRITE,
    … …  
    779779    VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
    780780
    781     aParms[0].setUInt32(root);
    782     aParms[1].setUInt64(handle);
     781    HGCMSvcSetU32(&aParms[0], root);
     782    HGCMSvcSetU64(&aParms[1], handle);
    783783    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
    784784                       psvcTable->pvService, SHFL_FN_FLUSH,
    … …  
    796796    VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
    797797
    798     aParms[0].setUInt32(root);
    799     aParms[1].setUInt64(handle);
    800     aParms[2].setUInt32(fFlags);
    801     aParms[3].setUInt32(cbBuf);
     798    HGCMSvcSetU32(&aParms[0], root);
     799    HGCMSvcSetU64(&aParms[1], handle);
     800    HGCMSvcSetU32(&aParms[2], fFlags);
     801    HGCMSvcSetU32(&aParms[3], cbBuf);
    802802    if (pcszPath)
    803803    {
    804804        fillTestShflString(&Path, pcszPath);
    805         aParms[4].setPointer(&Path,   RT_UOFFSETOF(SHFLSTRING, String)
     805        HGCMSvcSetPv(&aParms[4], &Path,   RT_UOFFSETOF(SHFLSTRING, String)
    806806                                    + Path.string.u16Size);
    807807    }
    808808    else
    809         aParms[4].setPointer(NULL, 0);
    810     aParms[5].setPointer(pvBuf, cbBuf);
    811     aParms[6].setUInt32(resumePoint);
    812     aParms[7].setUInt32(0);
     809        HGCMSvcSetPv(&aParms[4], NULL, 0);
     810    HGCMSvcSetPv(&aParms[5], pvBuf, cbBuf);
     811    HGCMSvcSetU32(&aParms[6], resumePoint);
     812    HGCMSvcSetU32(&aParms[7], 0);
    813813    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
    814814                       psvcTable->pvService, SHFL_FN_LIST,
    … …  
    826826    VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
    827827
    828     aParms[0].setUInt32(root);
    829     aParms[1].setUInt64(handle);
    830     aParms[2].setUInt32(fFlags);
    831     aParms[3].setUInt32(cb);
    832     aParms[4].setPointer(pInfo, cb);
     828    HGCMSvcSetU32(&aParms[0], root);
     829    HGCMSvcSetU64(&aParms[1], handle);
     830    HGCMSvcSetU32(&aParms[2], fFlags);
     831    HGCMSvcSetU32(&aParms[3], cb);
     832    HGCMSvcSetPv(&aParms[4], pInfo, cb);
    833833    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
    834834                       psvcTable->pvService, SHFL_FN_INFORMATION,
    … …  
    844844    VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
    845845
    846     aParms[0].setUInt32(root);
    847     aParms[1].setUInt64(handle);
    848     aParms[2].setUInt64(offLock);
    849     aParms[3].setUInt64(cbLock);
    850     aParms[4].setUInt32(fFlags);
     846    HGCMSvcSetU32(&aParms[0], root);
     847    HGCMSvcSetU64(&aParms[1], handle);
     848    HGCMSvcSetU64(&aParms[2], offLock);
     849    HGCMSvcSetU64(&aParms[3], cbLock);
     850    HGCMSvcSetU32(&aParms[4], fFlags);
    851851    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
    852852                       psvcTable->pvService, SHFL_FN_LOCK,

  • trunk/src/VBox/HostServices/common/client.cpp

    r74213 r75737  
    222222        AssertPtrReturn(m_Deferred.paParms, VERR_BUFFER_OVERFLOW);
    223223
    224         m_Deferred.paParms[0].setUInt32(uMsg);
    225         m_Deferred.paParms[1].setUInt32(cParms);
     224        HGCMSvcSetU32(&m_Deferred.paParms[0], uMsg);
     225        HGCMSvcSetU32(&m_Deferred.paParms[1], cParms);
    226226
    227227        return VINF_SUCCESS;

  • trunk/src/VBox/HostServices/testcase/tstHGCMSvc.cpp

    r69500 r75737  
    2424#include <iprt/test.h>
    2525
     26/** Test the getString member function.  Indirectly tests the getPointer
     27 * and getBuffer APIs.
     28 * @param  hTest  an running IPRT test
     29 * @param  type  the type that the parameter should be set to before
     30 *                calling getString
     31 * @param  pcch   the value that the parameter should be set to before
     32 *                calling getString, and also the address (!) which we
     33 *                expect getString to return.  Stricter than needed of
     34 *                course, but I was feeling lazy.
     35 * @param  cb     the size that the parameter should be set to before
     36 *                calling getString, and also the size which we expect
     37 *                getString to return.
     38 * @param  rcExp  the expected return value of the call to getString.
     39 */
     40void doTestGetString(VBOXHGCMSVCPARM *pParm, RTTEST hTest, uint32_t type,
     41                     const char *pcch, uint32_t cb, int rcExp)
     42{
     43    /* An RTTest API like this, which would print out an additional line
     44     * of context if a test failed, would be nice.  This is because the
     45     * line number alone doesn't help much here, given that this is a
     46     * subroutine called many times. */
     47    /*
     48    RTTestContextF(hTest,
     49                   ("doTestGetString, type=%u, pcch=%p, acp=%u, rcExp=%Rrc",
     50                    type, pcch, acp, rcExp));
     51     */
     52    HGCMSvcSetPv(pParm, (void *)pcch, cb);
     53    pParm->type = type;  /* in case we don't want VBOX_HGCM_SVC_PARM_PTR */
     54    const char *pcch2 = NULL;
     55    uint32_t cb2 = 0;
     56    int rc = HGCMSvcGetCStr(pParm, &pcch2, &cb2);
     57    RTTEST_CHECK_RC(hTest, rc, rcExp);
     58    if (RT_SUCCESS(rcExp))
     59    {
     60        RTTEST_CHECK_MSG_RETV(hTest, (pcch2 == pcch),
     61                              (hTest, "expected %p, got %p", pcch, pcch2));
     62        RTTEST_CHECK_MSG_RETV(hTest, (cb2 == cb),
     63                              (hTest, "expected %u, got %u", cb, cb2));
     64    }
     65}
     66
     67/** Run some unit tests on the getString method and indirectly test
     68 * getPointer and getBuffer as well. */
     69void testGetString(VBOXHGCMSVCPARM *pParm, RTTEST hTest)
     70{
     71    RTTestSub(hTest, "HGCM string parameter handling");
     72    doTestGetString(pParm, hTest, VBOX_HGCM_SVC_PARM_32BIT, "test", 3,
     73                    VERR_INVALID_PARAMETER);
     74    doTestGetString(pParm, hTest, VBOX_HGCM_SVC_PARM_PTR, "test", 5,
     75                    VINF_SUCCESS);
     76    doTestGetString(pParm, hTest, VBOX_HGCM_SVC_PARM_PTR, "test", 3,
     77                    VERR_BUFFER_OVERFLOW);
     78    doTestGetString(pParm, hTest, VBOX_HGCM_SVC_PARM_PTR, "test\xf0", 6,
     79                    VERR_INVALID_UTF8_ENCODING);
     80    doTestGetString(pParm, hTest, VBOX_HGCM_SVC_PARM_PTR, "test", 0,
     81                    VERR_INVALID_PARAMETER);
     82    doTestGetString(pParm, hTest, VBOX_HGCM_SVC_PARM_PTR, (const char *)0x1, 5,
     83                    VERR_INVALID_PARAMETER);
     84    RTTestSubDone(hTest);
     85}
     86
    2687int main()
    2788{
    … …  
    39100     */
    40101    VBOXHGCMSVCPARM parm;
    41     parm.testGetString(hTest);
     102    testGetString(&parm, hTest);
    42103
    43104    /*

  • trunk/src/VBox/Main/include/GuestDnDPrivate.h

    r74714 r75737  
    887887        }
    888888
    889         pParm->setPointer(pvTmp, cbBuf);
     889        HGCMSvcSetPv(pParm, pvTmp, cbBuf);
    890890        return VINF_SUCCESS;
    891891    }
    … …  
    901901            return VERR_NO_MEMORY;
    902902
    903         pParm->setString(pszTemp);
     903        HGCMSvcSetStr(pParm, pszTemp);
    904904        return VINF_SUCCESS;
    905905    }
    … …  
    911911            return VERR_NO_MEMORY;
    912912
    913         pParm->setUInt32(u32Val);
     913        HGCMSvcSetU32(pParm, u32Val);
    914914        return VINF_SUCCESS;
    915915    }
    … …  
    921921            return VERR_NO_MEMORY;
    922922
    923         pParm->setUInt64(u64Val);
     923        HGCMSvcSetU64(pParm, u64Val);
    924924        return VINF_SUCCESS;
    925925    }

  • trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

    r75574 r75737  
    86498649        SHFLSTRING_TO_HGMC_PARAM(&aParams[0], pHostPath);
    86508650        SHFLSTRING_TO_HGMC_PARAM(&aParams[1], pName);
    8651         aParams[2].setUInt32(  (aData.m_fWritable  ? SHFL_ADD_MAPPING_F_WRITABLE : 0)
    8652                              | (aData.m_fAutoMount ? SHFL_ADD_MAPPING_F_AUTOMOUNT : 0)
    8653                              | (fSymlinksCreate    ? SHFL_ADD_MAPPING_F_CREATE_SYMLINKS : 0)
    8654                              | (fMissing           ? SHFL_ADD_MAPPING_F_MISSING : 0));
     8651        HGCMSvcSetU32(&aParams[2],
     8652                        (aData.m_fWritable  ? SHFL_ADD_MAPPING_F_WRITABLE : 0)
     8653                      | (aData.m_fAutoMount ? SHFL_ADD_MAPPING_F_AUTOMOUNT : 0)
     8654                      | (fSymlinksCreate    ? SHFL_ADD_MAPPING_F_CREATE_SYMLINKS : 0)
     8655                      | (fMissing           ? SHFL_ADD_MAPPING_F_MISSING : 0));
    86558656        SHFLSTRING_TO_HGMC_PARAM(&aParams[3], pAutoMountPoint);
    86568657        AssertCompile(SHFL_CPARMS_ADD_MAPPING == 4);

  • trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp

    r75700 r75737  
    30683068                    /* Setup the service. */
    30693069                    VBOXHGCMSVCPARM parm;
    3070                     parm.type = VBOX_HGCM_SVC_PARM_32BIT;
    3071                     parm.setUInt32(!i_useHostClipboard());
     3070                    HGCMSvcSetU32(&parm, !i_useHostClipboard());
    30723071                    pVMMDev->hgcmHostCall("VBoxSharedClipboard",
    30733072                                          VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS, 1, &parm);
    … …  
    60726071int configSetGlobalPropertyFlags(VMMDev * const pVMMDev, uint32_t fFlags)
    60736072{
    6074     VBOXHGCMSVCPARM paParm;
    6075     paParm.setUInt32(fFlags);
    6076     int rc = pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GUEST_PROP_FN_HOST_SET_GLOBAL_FLAGS, 1, &paParm);
     6073    VBOXHGCMSVCPARM parm;
     6074    HGCMSvcSetU32(&parm, fFlags);
     6075    int rc = pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GUEST_PROP_FN_HOST_SET_GLOBAL_FLAGS, 1, &parm);
    60776076    if (RT_FAILURE(rc))
    60786077    {

  • trunk/src/VBox/Main/src-client/GuestCtrlImpl.cpp

    r73003 r75737  
    106106    {
    107107        uint32_t uContextID;
    108         int rc = pSvcCb->mpaParms[0].getUInt32(&uContextID);
     108        int rc = HGCMSvcGetU32(&pSvcCb->mpaParms[0], &uContextID);
    109109        AssertMsgRCReturn(rc, ("Unable to extract callback context ID, pvData=%p\n", pSvcCb),
    110110                          VINF_SUCCESS /* Never return any errors back to the guest here */);
    … …  
    166166            CALLBACKDATA_PROC_STATUS dataCb;
    167167            /* pSvcCb->mpaParms[0] always contains the context ID. */
    168             pSvcCb->mpaParms[1].getUInt32(&dataCb.uPID);
    169             pSvcCb->mpaParms[2].getUInt32(&dataCb.uStatus);
    170             pSvcCb->mpaParms[3].getUInt32(&dataCb.uFlags);
    171             pSvcCb->mpaParms[4].getPointer(&dataCb.pvData, &dataCb.cbData);
     168            HGCMSvcGetU32(&pSvcCb->mpaParms[1], &dataCb.uPID);
     169            HGCMSvcGetU32(&pSvcCb->mpaParms[2], &dataCb.uStatus);
     170            HGCMSvcGetU32(&pSvcCb->mpaParms[3], &dataCb.uFlags);
     171            HGCMSvcGetPv(&pSvcCb->mpaParms[4], &dataCb.pvData, &dataCb.cbData);
    172172
    173173            if (   (         dataCb.uStatus == PROC_STS_ERROR)

  • trunk/src/VBox/Main/src-client/GuestCtrlPrivate.cpp

    r74752 r75737  
    748748                    CALLBACKDATA_MSG_REPLY dataCb;
    749749                    /* pSvcCb->mpaParms[0] always contains the context ID. */
    750                     vrc = pSvcCb->mpaParms[idx++].getUInt32(&dataCb.uType);
     750                    vrc = HGCMSvcGetU32(&pSvcCb->mpaParms[idx++], &dataCb.uType);
    751751                    AssertRCReturn(vrc, vrc);
    752                     vrc = pSvcCb->mpaParms[idx++].getUInt32(&dataCb.rc);
     752                    vrc = HGCMSvcGetU32(&pSvcCb->mpaParms[idx++], &dataCb.rc);
    753753                    AssertRCReturn(vrc, vrc);
    754                     vrc = pSvcCb->mpaParms[idx++].getPointer(&dataCb.pvPayload, &dataCb.cbPayload);
     754                    vrc = HGCMSvcGetPv(&pSvcCb->mpaParms[idx++], &dataCb.pvPayload,
     755                                       &dataCb.cbPayload);
    755756                    AssertRCReturn(vrc, vrc);
    756757

  • trunk/src/VBox/Main/src-client/GuestDirectoryImpl.cpp

    r73063 r75737  
    180180            CALLBACKDATA_DIR_NOTIFY dataCb;
    181181            /* pSvcCb->mpaParms[0] always contains the context ID. */
    182             pSvcCb->mpaParms[idx++].getUInt32(&dataCb.uType);
    183             pSvcCb->mpaParms[idx++].getUInt32(&dataCb.rc);
     182            HGCMSvcGetU32(&pSvcCb->mpaParms[idx++], &dataCb.uType);
     183            HGCMSvcGetU32(&pSvcCb->mpaParms[idx++], &dataCb.rc);
    184184
    185185            LogFlowFunc(("uType=%RU32, vrcGguest=%Rrc\n", dataCb.uType, (int)dataCb.rc));

  • trunk/src/VBox/Main/src-client/GuestFileImpl.cpp

    r75094 r75737  
    379379    VBOXHGCMSVCPARM paParms[4];
    380380    int i = 0;
    381     paParms[i++].setUInt32(pEvent->ContextID());
    382     paParms[i++].setUInt32(mObjectID /* Guest file ID */);
     381    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     382    HGCMSvcSetU32(&paParms[i++], mObjectID /* Guest file ID */);
    383383
    384384    vrc = sendCommand(HOST_FILE_CLOSE, i, paParms);
    … …  
    441441    CALLBACKDATA_FILE_NOTIFY dataCb;
    442442    /* pSvcCb->mpaParms[0] always contains the context ID. */
    443     pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.uType);
    444     pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.rc);
     443    HGCMSvcGetU32(&pSvcCbData->mpaParms[idx++], &dataCb.uType);
     444    HGCMSvcGetU32(&pSvcCbData->mpaParms[idx++], &dataCb.rc);
    445445
    446446    int rcGuest = (int)dataCb.rc; /* uint32_t vs. int. */
    … …  
    476476            if (pSvcCbData->mParms == 4)
    477477            {
    478                 rc = pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.u.open.uHandle);
     478                rc = HGCMSvcGetU32(&pSvcCbData->mpaParms[idx++], &dataCb.u.open.uHandle);
    479479                if (RT_FAILURE(rc))
    480480                    break;
    … …  
    496496            if (pSvcCbData->mParms == 4)
    497497            {
    498                 rc = pSvcCbData->mpaParms[idx++].getPointer(&dataCb.u.read.pvData, &dataCb.u.read.cbData);
     498                rc = HGCMSvcGetPv(&pSvcCbData->mpaParms[idx++], &dataCb.u.read.pvData,
     499                                  &dataCb.u.read.cbData);
    499500                if (RT_FAILURE(rc))
    500501                    break;
    … …  
    523524            if (pSvcCbData->mParms == 4)
    524525            {
    525                 rc = pSvcCbData->mpaParms[idx++].getUInt32(&dataCb.u.write.cbWritten);
     526                rc = HGCMSvcGetU32(&pSvcCbData->mpaParms[idx++], &dataCb.u.write.cbWritten);
    526527                if (RT_FAILURE(rc))
    527528                    break;
    … …  
    545546            if (pSvcCbData->mParms == 4)
    546547            {
    547                 rc = pSvcCbData->mpaParms[idx++].getUInt64(&dataCb.u.seek.uOffActual);
     548                rc = HGCMSvcGetU64(&pSvcCbData->mpaParms[idx++], &dataCb.u.seek.uOffActual);
    548549                if (RT_FAILURE(rc))
    549550                    break;
    … …  
    566567            if (pSvcCbData->mParms == 4)
    567568            {
    568                 rc = pSvcCbData->mpaParms[idx++].getUInt64(&dataCb.u.tell.uOffActual);
     569                rc = HGCMSvcGetU64(&pSvcCbData->mpaParms[idx++], &dataCb.u.tell.uOffActual);
    569570                if (RT_FAILURE(rc))
    570571                    break;
    … …  
    713714    VBOXHGCMSVCPARM paParms[8];
    714715    int i = 0;
    715     paParms[i++].setUInt32(pEvent->ContextID());
    716     paParms[i++].setPointer((void*)mData.mOpenInfo.mFileName.c_str(),
    717                             (ULONG)mData.mOpenInfo.mFileName.length() + 1);
    718     paParms[i++].setString(pszAccessMode);
    719     paParms[i++].setString(pszOpenAction);
    720     paParms[i++].setString(pszSharingMode);
    721     paParms[i++].setUInt32(mData.mOpenInfo.mCreationMode);
    722     paParms[i++].setUInt64(mData.mOpenInfo.muOffset);
     716    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     717    HGCMSvcSetPv(&paParms[i++], (void*)mData.mOpenInfo.mFileName.c_str(),
     718                 (ULONG)mData.mOpenInfo.mFileName.length() + 1);
     719    HGCMSvcSetStr(&paParms[i++], pszAccessMode);
     720    HGCMSvcSetStr(&paParms[i++], pszOpenAction);
     721    HGCMSvcSetStr(&paParms[i++], pszSharingMode);
     722    HGCMSvcSetU32(&paParms[i++], mData.mOpenInfo.mCreationMode);
     723    HGCMSvcSetU64(&paParms[i++], mData.mOpenInfo.muOffset);
    723724    /** @todo Next protocol version: add flags, replace strings, remove initial offset. */
    724725
    … …  
    774775    VBOXHGCMSVCPARM paParms[4];
    775776    int i = 0;
    776     paParms[i++].setUInt32(pEvent->ContextID());
    777     paParms[i++].setUInt32(mObjectID /* File handle */);
    778     paParms[i++].setUInt32(uSize /* Size (in bytes) to read */);
     777    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     778    HGCMSvcSetU32(&paParms[i++], mObjectID /* File handle */);
     779    HGCMSvcSetU32(&paParms[i++], uSize /* Size (in bytes) to read */);
    779780
    780781    alock.release(); /* Drop write lock before sending. */
    … …  
    833834    VBOXHGCMSVCPARM paParms[4];
    834835    int i = 0;
    835     paParms[i++].setUInt32(pEvent->ContextID());
    836     paParms[i++].setUInt32(mObjectID /* File handle */);
    837     paParms[i++].setUInt64(uOffset /* Offset (in bytes) to start reading */);
    838     paParms[i++].setUInt32(uSize /* Size (in bytes) to read */);
     836    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     837    HGCMSvcSetU32(&paParms[i++], mObjectID /* File handle */);
     838    HGCMSvcSetU64(&paParms[i++], uOffset /* Offset (in bytes) to start reading */);
     839    HGCMSvcSetU32(&paParms[i++], uSize /* Size (in bytes) to read */);
    839840
    840841    alock.release(); /* Drop write lock before sending. */
    … …  
    894895    VBOXHGCMSVCPARM paParms[4];
    895896    int i = 0;
    896     paParms[i++].setUInt32(pEvent->ContextID());
    897     paParms[i++].setUInt32(mObjectID /* File handle */);
    898     paParms[i++].setUInt32(eSeekType /* Seek method */);
     897    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     898    HGCMSvcSetU32(&paParms[i++], mObjectID /* File handle */);
     899    HGCMSvcSetU32(&paParms[i++], eSeekType /* Seek method */);
    899900    /** @todo uint64_t vs. int64_t! */
    900     paParms[i++].setUInt64((uint64_t)iOffset /* Offset (in bytes) to start reading */);
     901    HGCMSvcSetU64(&paParms[i++], (uint64_t)iOffset /* Offset (in bytes) to start reading */);
    901902
    902903    alock.release(); /* Drop write lock before sending. */
    … …  
    11591160    VBOXHGCMSVCPARM paParms[8];
    11601161    int i = 0;
    1161     paParms[i++].setUInt32(pEvent->ContextID());
    1162     paParms[i++].setUInt32(mObjectID /* File handle */);
    1163     paParms[i++].setUInt32(cbData /* Size (in bytes) to write */);
    1164     paParms[i++].setPointer(pvData, cbData);
     1162    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     1163    HGCMSvcSetU32(&paParms[i++], mObjectID /* File handle */);
     1164    HGCMSvcSetU32(&paParms[i++], cbData /* Size (in bytes) to write */);
     1165    HGCMSvcSetPv(&paParms[i++], pvData, cbData);
    11651166
    11661167    alock.release(); /* Drop write lock before sending. */
    … …  
    12221223    VBOXHGCMSVCPARM paParms[8];
    12231224    int i = 0;
    1224     paParms[i++].setUInt32(pEvent->ContextID());
    1225     paParms[i++].setUInt32(mObjectID /* File handle */);
    1226     paParms[i++].setUInt64(uOffset /* Offset where to starting writing */);
    1227     paParms[i++].setUInt32(cbData /* Size (in bytes) to write */);
    1228     paParms[i++].setPointer(pvData, cbData);
     1225    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     1226    HGCMSvcSetU32(&paParms[i++], mObjectID /* File handle */);
     1227    HGCMSvcSetU64(&paParms[i++], uOffset /* Offset where to starting writing */);
     1228    HGCMSvcSetU32(&paParms[i++], cbData /* Size (in bytes) to write */);
     1229    HGCMSvcSetPv(&paParms[i++], pvData, cbData);
    12291230
    12301231    alock.release(); /* Drop write lock before sending. */

  • trunk/src/VBox/Main/src-client/GuestProcessImpl.cpp

    r73505 r75737  
    610610    CALLBACKDATA_PROC_INPUT dataCb;
    611611    /* pSvcCb->mpaParms[0] always contains the context ID. */
    612     int vrc = pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
     612    int vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[1], &dataCb.uPID);
    613613    AssertRCReturn(vrc, vrc);
    614     vrc = pSvcCbData->mpaParms[2].getUInt32(&dataCb.uStatus);
     614    vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[2], &dataCb.uStatus);
    615615    AssertRCReturn(vrc, vrc);
    616     vrc = pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
     616    vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[3], &dataCb.uFlags);
    617617    AssertRCReturn(vrc, vrc);
    618     vrc = pSvcCbData->mpaParms[4].getUInt32(&dataCb.uProcessed);
     618    vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[4], &dataCb.uProcessed);
    619619    AssertRCReturn(vrc, vrc);
    620620
    … …  
    684684    CALLBACKDATA_PROC_STATUS dataCb;
    685685    /* pSvcCb->mpaParms[0] always contains the context ID. */
    686     int vrc = pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
     686    int vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[1], &dataCb.uPID);
    687687    AssertRCReturn(vrc, vrc);
    688     vrc = pSvcCbData->mpaParms[2].getUInt32(&dataCb.uStatus);
     688    vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[2], &dataCb.uStatus);
    689689    AssertRCReturn(vrc, vrc);
    690     vrc = pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
     690    vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[3], &dataCb.uFlags);
    691691    AssertRCReturn(vrc, vrc);
    692     vrc = pSvcCbData->mpaParms[4].getPointer(&dataCb.pvData, &dataCb.cbData);
     692    vrc = HGCMSvcGetPv(&pSvcCbData->mpaParms[4], &dataCb.pvData, &dataCb.cbData);
    693693    AssertRCReturn(vrc, vrc);
    694694
    … …  
    794794    CALLBACKDATA_PROC_OUTPUT dataCb;
    795795    /* pSvcCb->mpaParms[0] always contains the context ID. */
    796     int vrc = pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
     796    int vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[1], &dataCb.uPID);
    797797    AssertRCReturn(vrc, vrc);
    798     vrc = pSvcCbData->mpaParms[2].getUInt32(&dataCb.uHandle);
     798    vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[2], &dataCb.uHandle);
    799799    AssertRCReturn(vrc, vrc);
    800     vrc = pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
     800    vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[3], &dataCb.uFlags);
    801801    AssertRCReturn(vrc, vrc);
    802     vrc = pSvcCbData->mpaParms[4].getPointer(&dataCb.pvData, &dataCb.cbData);
     802    vrc = HGCMSvcGetPv(&pSvcCbData->mpaParms[4], &dataCb.pvData, &dataCb.cbData);
    803803    AssertRCReturn(vrc, vrc);
    804804
    … …  
    909909        VBOXHGCMSVCPARM paParms[8];
    910910        int i = 0;
    911         paParms[i++].setUInt32(pEvent->ContextID());
    912         paParms[i++].setUInt32(mData.mPID);
    913         paParms[i++].setUInt32(uHandle);
    914         paParms[i++].setUInt32(0 /* Flags, none set yet. */);
     911        HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     912        HGCMSvcSetU32(&paParms[i++], mData.mPID);
     913        HGCMSvcSetU32(&paParms[i++], uHandle);
     914        HGCMSvcSetU32(&paParms[i++], 0 /* Flags, none set yet. */);
    915915
    916916        alock.release(); /* Drop the write lock before sending. */
    … …  
    10941094        VBOXHGCMSVCPARM paParms[16];
    10951095        int i = 0;
    1096         paParms[i++].setUInt32(pEvent->ContextID());
    1097         paParms[i++].setCppString(mData.mProcess.mExecutable);
    1098         paParms[i++].setUInt32(mData.mProcess.mFlags);
    1099         paParms[i++].setUInt32((uint32_t)mData.mProcess.mArguments.size());
    1100         paParms[i++].setPointer(pszArgs, (uint32_t)cbArgs);
    1101         paParms[i++].setUInt32(mData.mProcess.mEnvironmentChanges.count());
    1102         paParms[i++].setUInt32((uint32_t)cbEnvBlock);
    1103         paParms[i++].setPointer(pszzEnvBlock, (uint32_t)cbEnvBlock);
     1096        HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     1097        HGCMSvcSetRTCStr(&paParms[i++], mData.mProcess.mExecutable);
     1098        HGCMSvcSetU32(&paParms[i++], mData.mProcess.mFlags);
     1099        HGCMSvcSetU32(&paParms[i++], (uint32_t)mData.mProcess.mArguments.size());
     1100        HGCMSvcSetPv(&paParms[i++], pszArgs, (uint32_t)cbArgs);
     1101        HGCMSvcSetU32(&paParms[i++], mData.mProcess.mEnvironmentChanges.count());
     1102        HGCMSvcSetU32(&paParms[i++], (uint32_t)cbEnvBlock);
     1103        HGCMSvcSetPv(&paParms[i++], pszzEnvBlock, (uint32_t)cbEnvBlock);
    11041104        if (uProtocol < 2)
    11051105        {
    … …  
    11071107             * call. In newer protocols these credentials are part of the opened guest
    11081108             * session, so not needed anymore here. */
    1109             paParms[i++].setCppString(sessionCreds.mUser);
    1110             paParms[i++].setCppString(sessionCreds.mPassword);
     1109            HGCMSvcSetRTCStr(&paParms[i++], sessionCreds.mUser);
     1110            HGCMSvcSetRTCStr(&paParms[i++], sessionCreds.mPassword);
    11111111        }
    11121112        /*
    … …  
    11171117         */
    11181118        if (mData.mProcess.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)
    1119             paParms[i++].setUInt32(UINT32_MAX /* Infinite timeout */);
     1119            HGCMSvcSetU32(&paParms[i++], UINT32_MAX /* Infinite timeout */);
    11201120        else
    1121             paParms[i++].setUInt32(mData.mProcess.mTimeoutMS);
     1121            HGCMSvcSetU32(&paParms[i++], mData.mProcess.mTimeoutMS);
    11221122        if (uProtocol >= 2)
    11231123        {
    1124             paParms[i++].setUInt32(mData.mProcess.mPriority);
     1124            HGCMSvcSetU32(&paParms[i++], mData.mProcess.mPriority);
    11251125            /* CPU affinity: We only support one CPU affinity block at the moment,
    11261126             * so that makes up to 64 CPUs total. This can be more in the future. */
    1127             paParms[i++].setUInt32(1);
     1127            HGCMSvcSetU32(&paParms[i++], 1);
    11281128            /* The actual CPU affinity blocks. */
    1129             paParms[i++].setPointer((void *)&mData.mProcess.mAffinity, sizeof(mData.mProcess.mAffinity));
     1129            HGCMSvcSetPv(&paParms[i++], (void *)&mData.mProcess.mAffinity, sizeof(mData.mProcess.mAffinity));
    11301130        }
    11311131
    … …  
    12461246            VBOXHGCMSVCPARM paParms[4];
    12471247            int i = 0;
    1248             paParms[i++].setUInt32(pEvent->ContextID());
    1249             paParms[i++].setUInt32(mData.mPID);
     1248            HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     1249            HGCMSvcSetU32(&paParms[i++], mData.mPID);
    12501250
    12511251            alock.release(); /* Drop the write lock before sending. */
    … …  
    17241724    VBOXHGCMSVCPARM paParms[5];
    17251725    int i = 0;
    1726     paParms[i++].setUInt32(pEvent->ContextID());
    1727     paParms[i++].setUInt32(mData.mPID);
    1728     paParms[i++].setUInt32(uFlags);
    1729     paParms[i++].setPointer(pvData, (uint32_t)cbData);
    1730     paParms[i++].setUInt32((uint32_t)cbData);
     1726    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     1727    HGCMSvcSetU32(&paParms[i++], mData.mPID);
     1728    HGCMSvcSetU32(&paParms[i++], uFlags);
     1729    HGCMSvcSetPv(&paParms[i++], pvData, (uint32_t)cbData);
     1730    HGCMSvcSetU32(&paParms[i++], (uint32_t)cbData);
    17311731
    17321732    alock.release(); /* Drop the write lock before sending. */

  • trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp

    r75605 r75737  
    713713    VBOXHGCMSVCPARM paParms[4];
    714714    int i = 0;
    715     paParms[i++].setUInt32(pEvent->ContextID());
    716     paParms[i++].setUInt32(uFlags);
     715    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     716    HGCMSvcSetU32(&paParms[i++], uFlags);
    717717
    718718    alock.release(); /* Drop the write lock before waiting. */
    … …  
    10661066    VBOXHGCMSVCPARM paParms[8];
    10671067    int i = 0;
    1068     paParms[i++].setUInt32(pEvent->ContextID());
    1069     paParms[i++].setPointer((void*)strPath.c_str(),
     1068    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     1069    HGCMSvcSetPv(&paParms[i++], (void*)strPath.c_str(),
    10701070                            (ULONG)strPath.length() + 1);
    1071     paParms[i++].setUInt32(uFlags);
     1071    HGCMSvcSetU32(&paParms[i++], uFlags);
    10721072
    10731073    alock.release(); /* Drop write lock before sending. */
    … …  
    17821782    CALLBACKDATA_SESSION_NOTIFY dataCb;
    17831783    /* pSvcCb->mpaParms[0] always contains the context ID. */
    1784     int vrc = pSvcCbData->mpaParms[1].getUInt32(&dataCb.uType);
     1784    int vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[1], &dataCb.uType);
    17851785    AssertRCReturn(vrc, vrc);
    1786     vrc = pSvcCbData->mpaParms[2].getUInt32(&dataCb.uResult);
     1786    vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[2], &dataCb.uResult);
    17871787    AssertRCReturn(vrc, vrc);
    17881788
    … …  
    19341934
    19351935    int i = 0;
    1936     paParms[i++].setUInt32(pEvent->ContextID());
    1937     paParms[i++].setUInt32(mData.mProtocolVersion);
    1938     paParms[i++].setPointer((void*)mData.mCredentials.mUser.c_str(),
     1936    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     1937    HGCMSvcSetU32(&paParms[i++], mData.mProtocolVersion);
     1938    HGCMSvcSetPv(&paParms[i++], (void*)mData.mCredentials.mUser.c_str(),
    19391939                            (ULONG)mData.mCredentials.mUser.length() + 1);
    1940     paParms[i++].setPointer((void*)mData.mCredentials.mPassword.c_str(),
     1940    HGCMSvcSetPv(&paParms[i++], (void*)mData.mCredentials.mPassword.c_str(),
    19411941                            (ULONG)mData.mCredentials.mPassword.length() + 1);
    1942     paParms[i++].setPointer((void*)mData.mCredentials.mDomain.c_str(),
     1942    HGCMSvcSetPv(&paParms[i++], (void*)mData.mCredentials.mDomain.c_str(),
    19431943                            (ULONG)mData.mCredentials.mDomain.length() + 1);
    1944     paParms[i++].setUInt32(mData.mSession.mOpenFlags);
     1944    HGCMSvcSetU32(&paParms[i++], mData.mSession.mOpenFlags);
    19451945
    19461946    alock.release(); /* Drop write lock before sending. */
    … …  
    21442144    VBOXHGCMSVCPARM paParms[8];
    21452145    int i = 0;
    2146     paParms[i++].setUInt32(pEvent->ContextID());
    2147     paParms[i++].setPointer((void*)strSource.c_str(),
     2146    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
     2147    HGCMSvcSetPv(&paParms[i++], (void*)strSource.c_str(),
    21482148                            (ULONG)strSource.length() + 1);
    2149     paParms[i++].setPointer((void*)strDest.c_str(),
     2149    HGCMSvcSetPv(&paParms[i++], (void*)strDest.c_str(),
    21502150                            (ULONG)strDest.length() + 1);
    2151     paParms[i++].setUInt32(uFlags);
     2151    HGCMSvcSetU32(&paParms[i++], uFlags);
    21522152
    21532153    alock.release(); /* Drop write lock before sending. */
    … …  
    21902190    VBOXHGCMSVCPARM paParms[2];
    21912191    int i = 0;
    2192     paParms[i++].setUInt32(pEvent->ContextID());
     2192    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
    21932193
    21942194    alock.release(); /* Drop write lock before sending. */
    … …  
    22402240    VBOXHGCMSVCPARM paParms[2];
    22412241    int i = 0;
    2242     paParms[i++].setUInt32(pEvent->ContextID());
     2242    HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
    22432243
    22442244    alock.release(); /* Drop write lock before sending. */
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