VirtualBox

Changeset 4876 in vbox


Ignore:
Timestamp:
Sep 17, 2007 9:28:52 PM (17 years ago)
Author:
vboxsync
Message:

must include iprt/alloca.h when using alloca.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/ConsoleVRDPServer.cpp

    r4849 r4876  
    2929#include <iprt/asm.h>
    3030#include <iprt/ldr.h>
     31#include <iprt/alloca.h>
    3132
    3233#include <VBox/err.h>
    … …  
    380381{
    381382    memset (pu8DstAndMask, 0xFF, cbDstAndMask);
    382    
     383
    383384    int y;
    384385    for (y = 0; y < h; y++)
    385386    {
    386387        uint8_t bitmask = 0x80;
    387            
     388
    388389        int x;
    389390        for (x = 0; x < w; x++, bitmask >>= 1)
    … …  
    393394                bitmask = 0x80;
    394395            }
    395            
     396
    396397            /* Whether alpha channel value is not transparent enough for the pixel to be seen. */
    397398            if (pu8SrcAlpha[x * 4 + 3] > 0x7f)
    … …  
    400401            }
    401402        }
    402    
     403
    403404        /* Point to next source and dest scans. */
    404405        pu8SrcAlpha += w * 4;
    … …  
    645646            com::Bstr address;
    646647            server->mConsole->getVRDPServer ()->COMGETTER(NetAddress) (address.asOutParam());
    647            
     648
    648649            if (cbBuffer >= address.length ())
    649650            {
    … …  
    654655                rc = VINF_SUCCESS;
    655656            }
    656            
     657
    657658            *pcbOut = address.length ();
    658659        } break;
    … …  
    663664
    664665            server->mConsole->machine ()->COMGETTER(MonitorCount)(&cMonitors);
    665    
     666
    666667            if (cbBuffer >= sizeof (uint32_t))
    667668            {
    … …  
    687688{
    688689    ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
    689    
     690
    690691    return server->mConsole->VRDPClientLogon (u32ClientId, pszUser, pszPassword, pszDomain);
    691692}
    … …  
    694695{
    695696    ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
    696    
     697
    697698    server->mConsole->VRDPClientConnect (u32ClientId);
    698699}
    … …  
    701702{
    702703    ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
    703    
     704
    704705    server->mConsole->VRDPClientDisconnect (u32ClientId, fu32Intercepted);
    705706}
    … …  
    708709{
    709710    ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
    710    
     711
    711712    LogFlowFunc(("%x\n", fu32Intercept));
    712713
    … …  
    754755#else
    755756    return VERR_NOT_SUPPORTED;
    756 #endif 
     757#endif
    757758}
    758759
    … …  
    802803        pInfo->cBitsPerPixel = bitsPerPixel;
    803804        pInfo->cbLine = lineSize;
    804        
     805
    805806        pfb->Unlock ();
    806        
     807
    807808        fAvailable = true;
    808809    }
    … …  
    820821{
    821822    ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
    822    
     823
    823824    if (server->maFramebuffers[uScreenId])
    824825    {
    … …  
    830831{
    831832    ConsoleVRDPServer *server = static_cast <ConsoleVRDPServer *> (pvCallback);
    832    
     833
    833834    if (server->maFramebuffers[uScreenId])
    834835    {
    … …  
    928929    int rc = RTCritSectInit (&mCritSect);
    929930    AssertRC (rc);
    930    
     931
    931932    mcClipboardRefs = 0;
    932933    mpfnClipboardCallback = NULL;
    … …  
    935936    mUSBBackends.pHead = NULL;
    936937    mUSBBackends.pTail = NULL;
    937    
     938
    938939    mUSBBackends.thread = NIL_RTTHREAD;
    939940    mUSBBackends.fThreadRunning = false;
    … …  
    943944#ifdef VBOX_VRDP
    944945    mhServer = 0;
    945    
     946
    946947#ifdef VRDP_NO_COM
    947948    m_fGuestWantsAbsolute = false;
    948949    m_mousex = 0;
    949950    m_mousey = 0;
    950    
     951
    951952    memset (maFramebuffers, 0, sizeof (maFramebuffers));
    952    
     953
    953954    mConsoleCallback = new VRDPConsoleCallback(this);
    954955    mConsoleCallback->AddRef();
    … …  
    11291130
    11301131    LogFlow(("Console::threadRemoteUSB: start. owner = %p.\n", pOwner));
    1131    
     1132
    11321133    pOwner->notifyRemoteUSBThreadRunning (self);
    11331134
    … …  
    11351136    {
    11361137        RemoteUSBBackend *pRemoteUSBBackend = NULL;
    1137        
     1138
    11381139        while ((pRemoteUSBBackend = pOwner->usbBackendGetNext (pRemoteUSBBackend)) != NULL)
    11391140        {
    … …  
    11561157    AssertRC (rc);
    11571158}
    1158    
     1159
    11591160bool ConsoleVRDPServer::isRemoteUSBThreadRunning (void)
    11601161{
    11611162    return mUSBBackends.fThreadRunning;
    11621163}
    1163    
     1164
    11641165void ConsoleVRDPServer::waitRemoteUSBThreadEvent (unsigned cMillies)
    11651166{
    … …  
    11781179        mUSBBackends.event = 0;
    11791180    }
    1180    
     1181
    11811182    if (VBOX_SUCCESS (rc))
    11821183    {
    … …  
    11841185                             RTTHREADTYPE_VRDP_IO, RTTHREADFLAGS_WAITABLE, "remote usb");
    11851186    }
    1186    
     1187
    11871188    if (VBOX_FAILURE (rc))
    11881189    {
    … …  
    12021203{
    12031204    mUSBBackends.fThreadRunning = false;
    1204    
     1205
    12051206    if (mUSBBackends.thread != NIL_RTTHREAD)
    12061207    {
    12071208        Assert (mUSBBackends.event != 0);
    1208        
     1209
    12091210        RTSemEventSignal (mUSBBackends.event);
    1210        
     1211
    12111212        int rc = RTThreadWait (mUSBBackends.thread, 60000, NULL);
    12121213        AssertRC (rc);
    1213        
     1214
    12141215        mUSBBackends.thread = NIL_RTTHREAD;
    12151216    }
    1216    
     1217
    12171218    if (mUSBBackends.event)
    12181219    {
    … …  
    13711372
    13721373    int rc = VINF_SUCCESS;
    1373    
     1374
    13741375    ConsoleVRDPServer *pServer = static_cast <ConsoleVRDPServer *>(pvCallback);
    1375    
     1376
    13761377    NOREF(u32ClientId);
    1377    
     1378
    13781379    switch (u32Function)
    13791380    {
    … …  
    13871388                                                cbData);
    13881389            }
    1389         } break; 
    1390        
     1390        } break;
     1391
    13911392        case VRDP_CLIPBOARD_FUNCTION_DATA_READ:
    13921393        {
    … …  
    13981399                                                cbData);
    13991400            }
    1400         } break; 
    1401 
    1402         default: 
     1401        } break;
     1402
     1403        default:
    14031404            rc = VERR_NOT_SUPPORTED;
    14041405    }
    1405    
     1406
    14061407    return rc;
    14071408}
    … …  
    14141415    LogFlowFunc(("pvExtension = %p, u32Function = %d, pvParms = %p, cbParms = %d\n",
    14151416                 pvExtension, u32Function, pvParms, cbParms));
    1416    
     1417
    14171418    int rc = VINF_SUCCESS;
    1418    
     1419
    14191420#ifdef VBOX_VRDP
    14201421    ConsoleVRDPServer *pServer = static_cast <ConsoleVRDPServer *>(pvExtension);
    1421    
     1422
    14221423    VBOXCLIPBOARDEXTPARMS *pParms = (VBOXCLIPBOARDEXTPARMS *)pvParms;
    1423    
     1424
    14241425    switch (u32Function)
    14251426    {
    … …  
    14351436            if (mpEntryPoints && pServer->mhServer)
    14361437            {
    1437                 mpEntryPoints->VRDPClipboard (pServer->mhServer, 
     1438                mpEntryPoints->VRDPClipboard (pServer->mhServer,
    14381439                                              VRDP_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE,
    14391440                                              pParms->u32Format,
    … …  
    14451446            if (mpfnVRDPClipboard)
    14461447            {
    1447                 mpfnVRDPClipboard (pServer->mhServer, 
     1448                mpfnVRDPClipboard (pServer->mhServer,
    14481449                                   VRDP_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE,
    14491450                                   pParms->u32Format,
    … …  
    14641465            if (mpEntryPoints && pServer->mhServer)
    14651466            {
    1466                 mpEntryPoints->VRDPClipboard (pServer->mhServer, 
     1467                mpEntryPoints->VRDPClipboard (pServer->mhServer,
    14671468                                              VRDP_CLIPBOARD_FUNCTION_DATA_READ,
    14681469                                              pParms->u32Format,
    … …  
    14741475            if (mpfnVRDPClipboard)
    14751476            {
    1476                 mpfnVRDPClipboard (pServer->mhServer, 
     1477                mpfnVRDPClipboard (pServer->mhServer,
    14771478                                   VRDP_CLIPBOARD_FUNCTION_DATA_READ,
    14781479                                   pParms->u32Format,
    … …  
    14891490            if (mpEntryPoints && pServer->mhServer)
    14901491            {
    1491                 mpEntryPoints->VRDPClipboard (pServer->mhServer, 
     1492                mpEntryPoints->VRDPClipboard (pServer->mhServer,
    14921493                                              VRDP_CLIPBOARD_FUNCTION_DATA_WRITE,
    14931494                                              pParms->u32Format,
    … …  
    14991500            if (mpfnVRDPClipboard)
    15001501            {
    1501                 mpfnVRDPClipboard (pServer->mhServer, 
     1502                mpfnVRDPClipboard (pServer->mhServer,
    15021503                                   VRDP_CLIPBOARD_FUNCTION_DATA_WRITE,
    15031504                                   pParms->u32Format,
    … …  
    15081509#endif /* VRDP_NO_COM */
    15091510        } break;
    1510        
    1511         default: 
     1511
     1512        default:
    15121513            rc = VERR_NOT_SUPPORTED;
    15131514    }
    … …  
    15241525{
    15251526    int rc = lockConsoleVRDPServer ();
    1526        
     1527
    15271528    if (VBOX_SUCCESS (rc))
    15281529    {
    … …  
    15301531        {
    15311532            rc = HGCMHostRegisterServiceExtension (&mhClipboard, "VBoxSharedClipboard", ClipboardServiceExtension, this);
    1532            
     1533
    15331534            if (VBOX_SUCCESS (rc))
    15341535            {
    … …  
    15361537            }
    15371538        }
    1538        
     1539
    15391540#ifdef VRDP_NO_COM
    15401541#else
    … …  
    15531554{
    15541555    int rc = lockConsoleVRDPServer ();
    1555        
     1556
    15561557    if (VBOX_SUCCESS (rc))
    15571558    {
    15581559        mcClipboardRefs--;
    1559        
     1560
    15601561        if (mcClipboardRefs == 0)
    15611562        {
    … …  
    15781579#ifdef VBOX_WITH_USB
    15791580    LogFlow(("ConsoleVRDPServer::USBBackendCreate: u32ClientId = %d\n", u32ClientId));
    1580    
     1581
    15811582    /* Create a new instance of the USB backend for the new client. */
    15821583    RemoteUSBBackend *pRemoteUSBBackend = new RemoteUSBBackend (mConsole, this, u32ClientId);
    … …  
    15851586    {
    15861587        pRemoteUSBBackend->AddRef (); /* 'Release' called in USBBackendDelete. */
    1587            
     1588
    15881589        /* Append the new instance in the list. */
    15891590        int rc = lockConsoleVRDPServer ();
    1590        
     1591
    15911592        if (VBOX_SUCCESS (rc))
    15921593        {
    … …  
    16001601                mUSBBackends.pTail = pRemoteUSBBackend;
    16011602            }
    1602            
     1603
    16031604            mUSBBackends.pHead = pRemoteUSBBackend;
    1604            
     1605
    16051606            unlockConsoleVRDPServer ();
    1606            
     1607
    16071608#ifdef VRDP_NO_COM
    16081609            if (ppvIntercept)
    … …  
    16291630
    16301631    RemoteUSBBackend *pRemoteUSBBackend = NULL;
    1631    
     1632
    16321633    /* Find the instance. */
    16331634    int rc = lockConsoleVRDPServer ();
    1634        
     1635
    16351636    if (VBOX_SUCCESS (rc))
    16361637    {
    16371638        pRemoteUSBBackend = usbBackendFind (u32ClientId);
    1638        
     1639
    16391640        if (pRemoteUSBBackend)
    16401641        {
    … …  
    16421643            pRemoteUSBBackend->NotifyDelete ();
    16431644        }
    1644        
     1645
    16451646        unlockConsoleVRDPServer ();
    16461647    }
    1647    
     1648
    16481649    if (pRemoteUSBBackend)
    16491650    {
    … …  
    16581659#ifdef VBOX_WITH_USB
    16591660    RemoteUSBBackend *pRemoteUSBBackend = NULL;
    1660    
     1661
    16611662    /* Find the instance. */
    16621663    int rc = lockConsoleVRDPServer ();
    1663        
     1664
    16641665    if (VBOX_SUCCESS (rc))
    16651666    {
    16661667        pRemoteUSBBackend = usbBackendFind (u32ClientId);
    1667        
     1668
    16681669        if (pRemoteUSBBackend)
    16691670        {
    16701671            /* Inform the backend instance that it is referenced by the Guid. */
    16711672            bool fAdded = pRemoteUSBBackend->addUUID (pGuid);
    1672            
     1673
    16731674            if (fAdded)
    16741675            {
    … …  
    16811682            }
    16821683        }
    1683        
     1684
    16841685        unlockConsoleVRDPServer ();
    16851686    }
    1686    
     1687
    16871688    if (pRemoteUSBBackend)
    16881689    {
    16891690        return pRemoteUSBBackend->GetBackendCallbackPointer ();
    16901691    }
    1691    
     1692
    16921693#endif
    16931694    return NULL;
    … …  
    16981699#ifdef VBOX_WITH_USB
    16991700    RemoteUSBBackend *pRemoteUSBBackend = NULL;
    1700    
     1701
    17011702    /* Find the instance. */
    17021703    int rc = lockConsoleVRDPServer ();
    1703        
     1704
    17041705    if (VBOX_SUCCESS (rc))
    17051706    {
    17061707        pRemoteUSBBackend = usbBackendFindByUUID (pGuid);
    1707        
     1708
    17081709        if (pRemoteUSBBackend)
    17091710        {
    17101711            pRemoteUSBBackend->removeUUID (pGuid);
    17111712        }
    1712        
     1713
    17131714        unlockConsoleVRDPServer ();
    1714        
     1715
    17151716        if (pRemoteUSBBackend)
    17161717        {
    … …  
    17271728    RemoteUSBBackend *pNextRemoteUSBBackend = NULL;
    17281729#ifdef VBOX_WITH_USB
    1729        
     1730
    17301731    int rc = lockConsoleVRDPServer ();
    1731        
     1732
    17321733    if (VBOX_SUCCESS (rc))
    17331734    {
    … …  
    17421743            pNextRemoteUSBBackend = (RemoteUSBBackend *)pRemoteUSBBackend->pNext;
    17431744        }
    1744        
     1745
    17451746        if (pNextRemoteUSBBackend)
    17461747        {
    17471748            pNextRemoteUSBBackend->AddRef ();
    17481749        }
    1749        
     1750
    17501751        unlockConsoleVRDPServer ();
    1751        
     1752
    17521753        if (pRemoteUSBBackend)
    17531754        {
    … …  
    17561757    }
    17571758#endif
    1758    
     1759
    17591760    return pNextRemoteUSBBackend;
    17601761}
    … …  
    17651766{
    17661767    RemoteUSBBackend *pRemoteUSBBackend = mUSBBackends.pHead;
    1767        
     1768
    17681769    while (pRemoteUSBBackend)
    17691770    {
    … …  
    17721773            break;
    17731774        }
    1774            
     1775
    17751776        pRemoteUSBBackend = (RemoteUSBBackend *)pRemoteUSBBackend->pNext;
    17761777    }
    1777    
     1778
    17781779    return pRemoteUSBBackend;
    17791780}
    … …  
    17831784{
    17841785    RemoteUSBBackend *pRemoteUSBBackend = mUSBBackends.pHead;
    1785        
     1786
    17861787    while (pRemoteUSBBackend)
    17871788    {
    … …  
    17901791            break;
    17911792        }
    1792            
     1793
    17931794        pRemoteUSBBackend = (RemoteUSBBackend *)pRemoteUSBBackend->pNext;
    17941795    }
    1795    
     1796
    17961797    return pRemoteUSBBackend;
    17971798}
    … …  
    18041805    int rc = lockConsoleVRDPServer ();
    18051806    AssertRC (rc);
    1806        
     1807
    18071808    /* Exclude the found instance from the list. */
    18081809    if (pRemoteUSBBackend->pNext)
    … …  
    18141815        mUSBBackends.pTail = (RemoteUSBBackend *)pRemoteUSBBackend->pPrev;
    18151816    }
    1816                
     1817
    18171818    if (pRemoteUSBBackend->pPrev)
    18181819    {
    … …  
    18231824        mUSBBackends.pHead = (RemoteUSBBackend *)pRemoteUSBBackend->pNext;
    18241825    }
    1825                
     1826
    18261827    pRemoteUSBBackend->pNext = pRemoteUSBBackend->pPrev = NULL;
    1827    
     1828
    18281829    unlockConsoleVRDPServer ();
    18291830#endif
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