VirtualBox

Ignore:
Timestamp:
Dec 14, 2011 11:12:56 AM (13 years ago)
Author:
vboxsync
Message:

crHgsmi: cleanup

Location:
trunk/src/VBox/HostServices/SharedOpenGL
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp

    r39507 r39603  
    939939            if (cParms == 1 && paParms[0].type == VBOX_HGCM_SVC_PARM_PTR)
    940940            {
    941                 rc = crVBoxServerCrHgsmiCmd((PVBOXVDMACMD_CHROMIUM_CMD)paParms[0].u.pointer.addr);
     941                rc = crVBoxServerCrHgsmiCmd((PVBOXVDMACMD_CHROMIUM_CMD)paParms[0].u.pointer.addr, paParms[0].u.pointer.size);
    942942                if (VERR_NOT_SUPPORTED == rc)
    943943                {
     
    952952            Assert(cParms == 1 && paParms[0].type == VBOX_HGCM_SVC_PARM_PTR);
    953953            if (cParms == 1 && paParms[0].type == VBOX_HGCM_SVC_PARM_PTR)
    954                 rc = crVBoxServerCrHgsmiCtl((PVBOXVDMACMD_CHROMIUM_CTL)paParms[0].u.pointer.addr);
     954                rc = crVBoxServerCrHgsmiCtl((PVBOXVDMACMD_CHROMIUM_CTL)paParms[0].u.pointer.addr, paParms[0].u.pointer.size);
    955955            else
    956956                rc = VERR_INVALID_PARAMETER;
  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h

    r39288 r39603  
    2020
    2121extern uint8_t* g_pvVRamBase;
     22extern uint32_t g_cbVRam;
    2223extern HCRHGSMICMDCOMPLETION g_hCrHgsmiCompletion;
    2324extern PFNCRHGSMICMDCOMPLETION g_pfnCrHgsmiCompletion;
    2425
    2526#define VBOXCRHGSMI_PTR(_off, _t) ((_t*)(g_pvVRamBase + (_off)))
     27#define VBOXCRHGSMI_PTR_SAFE(_off, _cb, _t) ((_t*)crServerCrHgsmiPtrGet(_off, _cb))
     28
     29DECLINLINE(void*) crServerCrHgsmiPtrGet(VBOXVIDEOOFFSET offBuffer, uint32_t cbBuffer)
     30{
     31    return ((offBuffer) + (cbBuffer) <= g_cbVRam ? VBOXCRHGSMI_PTR(offBuffer, void) : NULL);
     32}
    2633
    2734DECLINLINE(void) crServerCrHgsmiCmdComplete(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd, int cmdProcessingRc)
  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c

    r39288 r39603  
    3333# include <VBox/HostServices/VBoxCrOpenGLSvc.h>
    3434uint8_t* g_pvVRamBase = NULL;
     35uint32_t g_cbVRam = 0;
    3536HCRHGSMICMDCOMPLETION g_hCrHgsmiCompletion = NULL;
    3637PFNCRHGSMICMDCOMPLETION g_pfnCrHgsmiCompletion = NULL;
     
    13531354 * NOTE: it is ALWAYS responsibility of the crVBoxServerCrHgsmiCmd to complete the command!
    13541355 * */
    1355 int32_t crVBoxServerCrHgsmiCmd(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd)
     1356int32_t crVBoxServerCrHgsmiCmd(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd, uint32_t cbCmd)
    13561357{
    13571358    int32_t rc;
    13581359    uint32_t cBuffers = pCmd->cBuffers;
    13591360    uint32_t cParams;
     1361    uint32_t cbHdr;
    13601362    CRVBOXHGSMIHDR *pHdr;
    13611363    uint32_t u32Function;
     
    13651367    if (!g_pvVRamBase)
    13661368    {
    1367         CRASSERT(0);
     1369        crWarning("g_pvVRamBase is not initialized");
    13681370        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_STATE);
    13691371        return VINF_SUCCESS;
     
    13721374    if (!cBuffers)
    13731375    {
    1374         CRASSERT(0);
     1376        crWarning("zero buffers passed in!");
    13751377        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
    13761378        return VINF_SUCCESS;
     
    13791381    cParams = cBuffers-1;
    13801382
    1381     pHdr = VBOXCRHGSMI_PTR(pCmd->aBuffers[0].offBuffer, CRVBOXHGSMIHDR);
     1383    cbHdr = pCmd->aBuffers[0].cbBuffer;
     1384    pHdr = VBOXCRHGSMI_PTR_SAFE(pCmd->aBuffers[0].offBuffer, cbHdr, CRVBOXHGSMIHDR);
     1385    if (!pHdr)
     1386    {
     1387        crWarning("invalid header buffer!");
     1388        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
     1389        return VINF_SUCCESS;
     1390    }
     1391
     1392    if (cbHdr < sizeof (*pHdr))
     1393    {
     1394        crWarning("invalid header buffer size!");
     1395        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
     1396        return VINF_SUCCESS;
     1397    }
     1398
    13821399    u32Function = pHdr->u32Function;
    13831400    u32ClientID = pHdr->u32ClientID;
     
    13951412                VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
    13961413                /* Fetch parameters. */
    1397                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    13981414                uint32_t cbBuffer = pBuf->cbBuffer;
    1399 
    1400                 CRASSERT(pBuffer);
     1415                uint8_t *pBuffer  = VBOXCRHGSMI_PTR_SAFE(pBuf->offBuffer, cbBuffer, uint8_t);
     1416
     1417                if (cbHdr < sizeof (*pFnCmd))
     1418                {
     1419                    crWarning("invalid write cmd buffer size!");
     1420                    rc = VERR_INVALID_PARAMETER;
     1421                    break;
     1422                }
     1423
    14011424                CRASSERT(cbBuffer);
     1425                if (!pBuffer)
     1426                {
     1427                    crWarning("invalid buffer data received from guest!");
     1428                    rc = VERR_INVALID_PARAMETER;
     1429                    break;
     1430                }
    14021431
    14031432                rc = crVBoxServerClientGet(u32ClientID, &pClient);
     
    14381467                uint32_t u32InjectClientID = pFnCmd->u32ClientID;
    14391468                VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
    1440                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    14411469                uint32_t cbBuffer = pBuf->cbBuffer;
    1442 
    1443                 CRASSERT(pBuffer);
     1470                uint8_t *pBuffer  = VBOXCRHGSMI_PTR_SAFE(pBuf->offBuffer, cbBuffer, uint8_t);
     1471
     1472                if (cbHdr < sizeof (*pFnCmd))
     1473                {
     1474                    crWarning("invalid inject cmd buffer size!");
     1475                    rc = VERR_INVALID_PARAMETER;
     1476                    break;
     1477                }
     1478
    14441479                CRASSERT(cbBuffer);
     1480                if (!pBuffer)
     1481                {
     1482                    crWarning("invalid buffer data received from guest!");
     1483                    rc = VERR_INVALID_PARAMETER;
     1484                    break;
     1485                }
    14451486
    14461487                rc = crVBoxServerClientGet(u32InjectClientID, &pClient);
     
    14771518                VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
    14781519                /* Fetch parameters. */
    1479                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    14801520                uint32_t cbBuffer = pBuf->cbBuffer;
     1521                uint8_t *pBuffer  = VBOXCRHGSMI_PTR_SAFE(pBuf->offBuffer, cbBuffer, uint8_t);
     1522
     1523                if (cbHdr < sizeof (*pFnCmd))
     1524                {
     1525                    crWarning("invalid read cmd buffer size!");
     1526                    rc = VERR_INVALID_PARAMETER;
     1527                    break;
     1528                }
     1529
     1530
     1531                if (!pBuffer)
     1532                {
     1533                    crWarning("invalid buffer data received from guest!");
     1534                    rc = VERR_INVALID_PARAMETER;
     1535                    break;
     1536                }
    14811537
    14821538                rc = crVBoxServerClientGet(u32ClientID, &pClient);
     
    15181574
    15191575                /* Fetch parameters. */
    1520                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    15211576                uint32_t cbBuffer = pBuf->cbBuffer;
    1522 
    1523                 uint8_t *pWriteback  = VBOXCRHGSMI_PTR(pWbBuf->offBuffer, uint8_t);
     1577                uint8_t *pBuffer  = VBOXCRHGSMI_PTR_SAFE(pBuf->offBuffer, cbBuffer, uint8_t);
     1578
    15241579                uint32_t cbWriteback = pWbBuf->cbBuffer;
    1525 
    1526                 CRASSERT(pBuffer);
     1580                uint8_t *pWriteback  = VBOXCRHGSMI_PTR_SAFE(pWbBuf->offBuffer, cbWriteback, uint8_t);
     1581
     1582                if (cbHdr < sizeof (*pFnCmd))
     1583                {
     1584                    crWarning("invalid write_read cmd buffer size!");
     1585                    rc = VERR_INVALID_PARAMETER;
     1586                    break;
     1587                }
     1588
     1589
    15271590                CRASSERT(cbBuffer);
    1528 
     1591                if (!pBuffer)
     1592                {
     1593                    crWarning("invalid write buffer data received from guest!");
     1594                    rc = VERR_INVALID_PARAMETER;
     1595                    break;
     1596                }
     1597
     1598                CRASSERT(cbWriteback);
     1599                if (!pWriteback)
     1600                {
     1601                    crWarning("invalid writeback buffer data received from guest!");
     1602                    rc = VERR_INVALID_PARAMETER;
     1603                    break;
     1604                }
    15291605                rc = crVBoxServerClientGet(u32ClientID, &pClient);
    15301606                if (RT_FAILURE(rc))
     
    15821658}
    15831659
    1584 int32_t crVBoxServerCrHgsmiCtl(struct VBOXVDMACMD_CHROMIUM_CTL *pCtl)
     1660int32_t crVBoxServerCrHgsmiCtl(struct VBOXVDMACMD_CHROMIUM_CTL *pCtl, uint32_t cbCtl)
    15851661{
    15861662    int rc = VINF_SUCCESS;
     
    15911667        {
    15921668            PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP pSetup = (PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP)pCtl;
    1593             g_pvVRamBase = (uint8_t*)pSetup->pvRamBase;
     1669            g_pvVRamBase = (uint8_t*)pSetup->pvVRamBase;
     1670            g_cbVRam = pSetup->cbVRam;
    15941671            rc = VINF_SUCCESS;
    15951672            break;
Note: See TracChangeset for help on using the changeset viewer.

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