VirtualBox

Ignore:
Timestamp:
Dec 12, 2013 8:09:20 PM (11 years ago)
Author:
vboxsync
Message:

Merged private draganddrop branch into trunk.

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/src/VBox

  • trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibDragAndDrop.cpp

    r42261 r49891  
    55
    66/*
    7  * Copyright (C) 2011-2012 Oracle Corporation
     7 * Copyright (C) 2011-2013 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
     
    4141#include "VBox/HostServices/DragAndDropSvc.h"
    4242
    43 #define VERBOSE 1
    44 
    45 #if defined(VERBOSE) && defined(DEBUG_poetzsch)
    46 # include <iprt/stream.h>
    47 # define DO(s) RTPrintf s
    48 #else
    49 # define DO(s) do {} while(0)
    50 //# define DO(s) Log s
    51 #endif
    52 
    5343/* Here all the communication with the host over HGCM is handled platform
    5444 * neutral. Also the receiving of URIs content (directory trees and files) is
     
    6151 */
    6252
    63 /* Not really used at the moment (only one client is possible): */
    64 uint32_t g_clientId = 0;
    65 
    6653/******************************************************************************
    6754 *    Private internal functions                                              *
     
    7057static int vbglR3DnDCreateDropDir(char* pszDropDir, size_t cbSize)
    7158{
    72     /* Validate input */
    7359    AssertPtrReturn(pszDropDir, VERR_INVALID_POINTER);
    7460    AssertReturn(cbSize,        VERR_INVALID_PARAMETER);
    7561
    76     /* Get the users document directory (usually $HOME/Documents). */
    77     int rc = RTPathUserDocuments(pszDropDir, cbSize);
     62    /** @todo On Windows we also could use the registry to override
     63     *        this path, on Posix a dotfile and/or a guest property
     64     *        can be used. */
     65
     66    /* Get the users temp directory. Don't use the user's root directory (or
     67     * something inside it) because we don't know for how long/if the data will
     68     * be kept after the guest OS used it. */
     69    int rc = RTPathTemp(pszDropDir, cbSize);
    7870    if (RT_FAILURE(rc))
    7971        return rc;
     72
    8073    /* Append our base drop directory. */
    8174    rc = RTPathAppend(pszDropDir, cbSize, "VirtualBox Dropped Files");
    8275    if (RT_FAILURE(rc))
    8376        return rc;
     77
    8478    /* Create it when necessary. */
    8579    if (!RTDirExists(pszDropDir))
     
    8983            return rc;
    9084    }
     85
    9186    /* The actually drop directory consist of the current time stamp and a
    9287     * unique number when necessary. */
     
    9590    if (!RTTimeSpecToString(RTTimeNow(&time), pszTime, sizeof(pszTime)))
    9691        return VERR_BUFFER_OVERFLOW;
     92#ifdef RT_OS_WINDOWS
     93    /* Filter out characters not allowed on Windows platforms, put in by
     94       RTTimeSpecToString(). */
     95    /** @todo Use something like RTPathSanitize() when available. Later. */
     96    RTUNICP aCpSet[] =
     97        { ' ', ' ', '(', ')', '-', '.', '0', '9', 'A', 'Z', 'a', 'z', '_', '_',
     98          0xa0, 0xd7af, '\0' };
     99    RTStrPurgeComplementSet(pszTime, aCpSet, '_' /* Replacement */);
     100#endif
     101
    97102    rc = RTPathAppend(pszDropDir, cbSize, pszTime);
    98103    if (RT_FAILURE(rc))
     
    105110static int vbglR3DnDQueryNextHostMessageType(uint32_t uClientId, uint32_t *puMsg, uint32_t *pcParms, bool fWait)
    106111{
    107     /* Validate input */
    108112    AssertPtrReturn(puMsg,   VERR_INVALID_POINTER);
    109113    AssertPtrReturn(pcParms, VERR_INVALID_POINTER);
    110114
    111     /* Initialize header */
    112115    DragAndDropSvc::VBOXDNDNEXTMSGMSG Msg;
    113116    RT_ZERO(Msg);
     
    116119    Msg.hdr.u32Function = DragAndDropSvc::GUEST_DND_GET_NEXT_HOST_MSG;
    117120    Msg.hdr.cParms      = 3;
    118     /* Initialize parameter */
     121
    119122    Msg.msg.SetUInt32(0);
    120123    Msg.num_parms.SetUInt32(0);
    121124    Msg.block.SetUInt32(fWait);
    122     /* Do request */
     125
    123126    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    124127    if (RT_SUCCESS(rc))
     
    132135        }
    133136    }
     137
    134138    return rc;
    135139}
     
    146150                                           uint32_t *pcbFormatsRecv)
    147151{
    148     /* Validate input */
    149152    AssertPtrReturn(puScreenId,     VERR_INVALID_POINTER);
    150153    AssertPtrReturn(puX,            VERR_INVALID_POINTER);
     
    156159    AssertPtrReturn(pcbFormatsRecv, VERR_INVALID_POINTER);
    157160
    158     /* Initialize header */
    159161    DragAndDropSvc::VBOXDNDHGACTIONMSG Msg;
    160162    RT_ZERO(Msg);
     
    162164    Msg.hdr.u32Function = uMsg;
    163165    Msg.hdr.cParms      = 7;
    164     /* Initialize parameter */
     166
    165167    Msg.uScreenId.SetUInt32(0);
    166168    Msg.uX.SetUInt32(0);
     
    170172    Msg.pvFormats.SetPtr(pszFormats, cbFormats);
    171173    Msg.cFormats.SetUInt32(0);
    172     /* Do request */
     174
    173175    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    174176    if (RT_SUCCESS(rc))
     
    188190        }
    189191    }
     192
    190193    return rc;
    191194}
     
    193196static int vbglR3DnDHGProcessLeaveMessage(uint32_t uClientId)
    194197{
    195     /* Initialize header */
    196198    DragAndDropSvc::VBOXDNDHGLEAVEMSG Msg;
    197199    RT_ZERO(Msg);
     
    199201    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_HG_EVT_LEAVE;
    200202    Msg.hdr.cParms      = 0;
    201     /* Do request */
    202     int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    203     if (RT_SUCCESS(rc))
    204         rc = Msg.hdr.result;
     203
     204    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     205    if (RT_SUCCESS(rc))
     206        rc = Msg.hdr.result;
     207
    205208    return rc;
    206209}
     
    208211static int vbglR3DnDHGProcessCancelMessage(uint32_t uClientId)
    209212{
    210     /* Initialize header */
    211213    DragAndDropSvc::VBOXDNDHGCANCELMSG Msg;
    212214    RT_ZERO(Msg);
     
    214216    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_HG_EVT_CANCEL;
    215217    Msg.hdr.cParms      = 0;
    216     /* Do request */
    217     int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    218     if (RT_SUCCESS(rc))
    219         rc = Msg.hdr.result;
     218
     219    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     220    if (RT_SUCCESS(rc))
     221        rc = Msg.hdr.result;
     222
    220223    return rc;
    221224}
     
    227230                                            uint32_t *pfMode)
    228231{
    229     /* Validate input */
    230232    AssertPtrReturn(pszDirname,     VERR_INVALID_POINTER);
    231233    AssertReturn(cbDirname,         VERR_INVALID_PARAMETER);
     
    233235    AssertPtrReturn(pfMode,         VERR_INVALID_POINTER);
    234236
    235     /* Initialize header */
    236237    DragAndDropSvc::VBOXDNDHGSENDDIRMSG Msg;
    237238    RT_ZERO(Msg);
     
    239240    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_HG_SND_DIR;
    240241    Msg.hdr.cParms      = 3;
    241     /* Initialize parameter */
     242
    242243    Msg.pvName.SetPtr(pszDirname, cbDirname);
    243244    Msg.cName.SetUInt32(0);
    244245    Msg.fMode.SetUInt32(0);
    245     /* Do request */
     246
    246247    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    247248    if (RT_SUCCESS(rc))
     
    257258        }
    258259    }
     260
    259261    return rc;
    260262}
     
    269271                                             uint32_t *pfMode)
    270272{
    271     /* Validate input */
    272273    AssertPtrReturn(pszFilename,     VERR_INVALID_POINTER);
    273274    AssertReturn(cbFilename,         VERR_INVALID_PARAMETER);
     
    278279    AssertPtrReturn(pfMode,          VERR_INVALID_POINTER);
    279280
    280     /* Initialize header */
    281281    DragAndDropSvc::VBOXDNDHGSENDFILEMSG Msg;
    282282    RT_ZERO(Msg);
     
    284284    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_HG_SND_FILE;
    285285    Msg.hdr.cParms      = 5;
    286     /* Initialize parameter */
     286
    287287    Msg.pvName.SetPtr(pszFilename, cbFilename);
    288288    Msg.cName.SetUInt32(0);
     
    290290    Msg.cData.SetUInt32(0);
    291291    Msg.fMode.SetUInt32(0);
    292     /* Do request */
     292
    293293    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    294294    if (RT_SUCCESS(rc))
     
    306306        }
    307307    }
     308
    308309    return rc;
    309310}
     
    376377        uint32_t uNextMsg;
    377378        uint32_t cNextParms;
    378         rc = vbglR3DnDQueryNextHostMessageType(uClientId, &uNextMsg, &cNextParms, false);
    379         DO(("%Rrc - %d\n", rc , uNextMsg));
     379        rc = vbglR3DnDQueryNextHostMessageType(uClientId, &uNextMsg, &cNextParms, false /* fWait */);
    380380        if (RT_SUCCESS(rc))
    381381        {
     
    392392                    if (RT_SUCCESS(rc))
    393393                    {
    394                         DO(("Got drop dir: %s - %o - %Rrc\n", pszPathname, fMode, rc));
    395394                        char *pszNewDir = RTPathJoinA(pszDropDir, pszPathname);
    396395                        rc = RTDirCreate(pszNewDir, (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRWXU, 0);
     
    415414                    {
    416415                        char *pszNewFile = RTPathJoinA(pszDropDir, pszPathname);
    417                         DO(("Got drop file: %s - %d - %o - %Rrc\n", pszPathname, cbDataRecv, fMode, rc));
    418416                        RTFILE hFile;
     417                        /** @todo r=andy Keep the file open and locked during the actual file transfer. Otherwise this will
     418                         *               create all sorts of funny races because we don't know if the guest has
     419                         *               modified the file in between the file data send calls. */
    419420                        rc = RTFileOpen(&hFile, pszNewFile, RTFILE_O_WRITE | RTFILE_O_APPEND | RTFILE_O_DENY_ALL | RTFILE_O_OPEN_CREATE);
    420421                        if (RT_SUCCESS(rc))
     
    443444                    /* Break out of the loop. */
    444445                }
    445                 default: fLoop = false; break;
     446                default:
     447                    fLoop = false;
     448                    break;
    446449            }
    447         } else
     450        }
     451        else
    448452        {
    449453            if (rc == VERR_NO_DATA)
     
    451455            break;
    452456        }
    453     }while(fLoop);
     457
     458    } while (fLoop);
    454459
    455460    RTMemFree(pvTmpData);
     461
    456462    /* Cleanup on failure or if the user has canceled. */
    457463    if (RT_FAILURE(rc))
     
    477483                                                 uint32_t *pcbDataRecv)
    478484{
    479     /* Validate input */
    480485    AssertPtrReturn(puScreenId,    VERR_INVALID_POINTER);
    481486    AssertPtrReturn(pszFormat,     VERR_INVALID_POINTER);
     
    486491    AssertPtrReturn(pcbDataRecv,   VERR_INVALID_POINTER);
    487492
    488     /* Initialize header */
    489493    DragAndDropSvc::VBOXDNDHGSENDDATAMSG Msg;
    490494    RT_ZERO(Msg);
     
    492496    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_HG_SND_DATA;
    493497    Msg.hdr.cParms      = 5;
    494     /* Initialize parameter */
     498
    495499    Msg.uScreenId.SetUInt32(0);
    496500    Msg.pvFormat.SetPtr(pszFormat, cbFormat);
     
    498502    Msg.pvData.SetPtr(pvData, cbData);
    499503    Msg.cData.SetUInt32(0);
    500     /* Do request */
     504
    501505    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    502506    if (RT_SUCCESS(rc))
     
    515519        }
    516520    }
     521
    517522    return rc;
    518523}
     
    523528                                                     uint32_t *pcbDataRecv)
    524529{
    525     /* Validate input */
    526530    AssertPtrReturn(pvData,      VERR_INVALID_POINTER);
    527531    AssertReturn(cbData,         VERR_INVALID_PARAMETER);
    528532    AssertPtrReturn(pcbDataRecv, VERR_INVALID_POINTER);
    529533
    530     /* Initialize header */
    531534    DragAndDropSvc::VBOXDNDHGSENDMOREDATAMSG Msg;
    532535    RT_ZERO(Msg);
    533     Msg.hdr.u32ClientID = g_clientId;
     536    Msg.hdr.u32ClientID = uClientId;
    534537    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_HG_SND_MORE_DATA;
    535538    Msg.hdr.cParms      = 2;
    536     /* Initialize parameter */
     539
    537540    Msg.pvData.SetPtr(pvData, cbData);
    538541    Msg.cData.SetUInt32(0);
    539     /* Do request */
     542
    540543    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    541544    if (RT_SUCCESS(rc))
     
    554557}
    555558
    556 static int vbglR3DnDHGProcessSendDataMessages(uint32_t  uClientId,
    557                                               uint32_t *puScreenId,
    558                                               char     *pszFormat,
    559                                               uint32_t  cbFormat,
    560                                               uint32_t *pcbFormatRecv,
    561                                               void    **ppvData,
    562                                               uint32_t  cbData,
    563                                               size_t   *pcbDataRecv)
     559static int vbglR3DnDHGProcessSendDataMessageLoop(uint32_t  uClientId,
     560                                                 uint32_t *puScreenId,
     561                                                 char     *pszFormat,
     562                                                 uint32_t  cbFormat,
     563                                                 uint32_t *pcbFormatRecv,
     564                                                 void    **ppvData,
     565                                                 uint32_t  cbData,
     566                                                 size_t   *pcbDataRecv)
    564567{
    565568    uint32_t cbDataRecv = 0;
     
    572575                                                   cbData,
    573576                                                   &cbDataRecv);
    574 
    575     size_t cbAllDataRecv = cbDataRecv;
     577    uint32_t cbAllDataRecv = cbDataRecv;
    576578    while (rc == VERR_BUFFER_OVERFLOW)
    577579    {
     
    624626                                             size_t    *pcbDataRecv)
    625627{
    626     int rc = vbglR3DnDHGProcessSendDataMessages(uClientId,
    627                                                 puScreenId,
    628                                                 pszFormat,
    629                                                 cbFormat,
    630                                                 pcbFormatRecv,
    631                                                 ppvData,
    632                                                 cbData,
    633                                                 pcbDataRecv);
    634     if (RT_SUCCESS(rc))
    635     {
    636         /* Check if this is a uri-event */
     628    int rc = vbglR3DnDHGProcessSendDataMessageLoop(uClientId,
     629                                                   puScreenId,
     630                                                   pszFormat,
     631                                                   cbFormat,
     632                                                   pcbFormatRecv,
     633                                                   ppvData,
     634                                                   cbData,
     635                                                   pcbDataRecv);
     636    if (RT_SUCCESS(rc))
     637    {
     638        /* Check if this is a uri-event. If so, let VbglR3 do all the actual
     639         * data transfer + file /directory creation internally without letting
     640         * the caller know. */
    637641        if (RTStrNICmp(pszFormat, "text/uri-list", *pcbFormatRecv) == 0)
    638642            rc = vbglR3DnDHGProcessURIMessages(uClientId,
     
    645649                                               pcbDataRecv);
    646650    }
     651
    647652    return rc;
    648653}
     
    651656                                                   uint32_t *puScreenId)
    652657{
    653     /* Validate input */
    654658    AssertPtrReturn(puScreenId, VERR_INVALID_POINTER);
    655659
    656     /* Initialize header */
    657660    DragAndDropSvc::VBOXDNDGHREQPENDINGMSG Msg;
    658661    RT_ZERO(Msg);
     
    660663    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_GH_REQ_PENDING;
    661664    Msg.hdr.cParms      = 1;
    662     /* Initialize parameter */
     665
    663666    Msg.uScreenId.SetUInt32(0);
    664     /* Do request */
     667
    665668    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    666669    if (RT_SUCCESS(rc))
     
    673676        }
    674677    }
     678
    675679    return rc;
    676680}
     
    682686                                            uint32_t *puAction)
    683687{
    684     /* Validate input */
    685688    AssertPtrReturn(pszFormat,     VERR_INVALID_POINTER);
    686689    AssertReturn(cbFormat,         VERR_INVALID_PARAMETER);
     
    688691    AssertPtrReturn(puAction,      VERR_INVALID_POINTER);
    689692
    690     /* Initialize header */
    691693    DragAndDropSvc::VBOXDNDGHDROPPEDMSG Msg;
    692694    RT_ZERO(Msg);
     
    694696    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_GH_EVT_DROPPED;
    695697    Msg.hdr.cParms      = 3;
    696     /* Initialize parameter */
     698
    697699    Msg.pvFormat.SetPtr(pszFormat, cbFormat);
    698700    Msg.cFormat.SetUInt32(0);
    699701    Msg.uAction.SetUInt32(0);
    700     /* Do request */
     702
    701703    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    702704    if (RT_SUCCESS(rc))
     
    712714        }
    713715    }
     716
    714717    return rc;
    715718}
     
    719722 ******************************************************************************/
    720723
    721 /**
    722  * Initialize Drag & Drop.
    723  *
    724  * This will enable the Drag & Drop events.
    725  *
    726  * @returns VBox status code.
    727  */
    728 VBGLR3DECL(int) VbglR3DnDInit(void)
    729 {
    730     return VbglR3DnDConnect(&g_clientId);
    731 }
    732 
    733 /**
    734  * Terminate Drag and Drop.
    735  *
    736  * This will Drag and Drop events.
    737  *
    738  * @returns VBox status.
    739  */
    740 VBGLR3DECL(int) VbglR3DnDTerm(void)
    741 {
    742     return VbglR3DnDDisconnect(g_clientId);
    743 }
    744 
    745724VBGLR3DECL(int) VbglR3DnDConnect(uint32_t *pu32ClientId)
    746725{
    747     /* Validate input */
    748726    AssertPtrReturn(pu32ClientId, VERR_INVALID_POINTER);
    749727
     
    770748VBGLR3DECL(int) VbglR3DnDDisconnect(uint32_t u32ClientId)
    771749{
    772     /* Initialize header */
    773750    VBoxGuestHGCMDisconnectInfo Info;
    774751    Info.result      = VERR_WRONG_ORDER;
    775752    Info.u32ClientID = u32ClientId;
     753
    776754    /* Do request */
    777755    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_DISCONNECT, &Info, sizeof(Info));
    778756    if (RT_SUCCESS(rc))
    779757        rc = Info.result;
    780     return rc;
    781 }
    782 
    783 VBGLR3DECL(int) VbglR3DnDProcessNextMessage(CPVBGLR3DNDHGCMEVENT pEvent)
    784 {
    785     /* Validate input */
     758
     759    return rc;
     760}
     761
     762VBGLR3DECL(int) VbglR3DnDProcessNextMessage(uint32_t u32ClientId, CPVBGLR3DNDHGCMEVENT pEvent)
     763{
    786764    AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
    787765
     
    789767    uint32_t       uNumParms  = 0;
    790768    const uint32_t ccbFormats = _64K;
    791     const uint32_t ccbData    = _1M;
    792     int rc = vbglR3DnDQueryNextHostMessageType(g_clientId, &uMsg, &uNumParms, true);
    793     if (RT_SUCCESS(rc))
    794     {
    795         DO(("Got message %d\n", uMsg));
     769    const uint32_t ccbData    = _64K;
     770    int rc = vbglR3DnDQueryNextHostMessageType(u32ClientId, &uMsg, &uNumParms,
     771                                               true /* fWait */);
     772    if (RT_SUCCESS(rc))
     773    {
    796774        switch(uMsg)
    797775        {
     
    803781                pEvent->pszFormats = static_cast<char*>(RTMemAlloc(ccbFormats));
    804782                if (!pEvent->pszFormats)
    805                     return VERR_NO_MEMORY;
    806                 rc = vbglR3DnDHGProcessActionMessage(g_clientId,
    807                                                      uMsg,
    808                                                      &pEvent->uScreenId,
    809                                                      &pEvent->u.a.uXpos,
    810                                                      &pEvent->u.a.uYpos,
    811                                                      &pEvent->u.a.uDefAction,
    812                                                      &pEvent->u.a.uAllActions,
    813                                                      pEvent->pszFormats,
    814                                                      ccbFormats,
    815                                                      &pEvent->cbFormats);
     783                    rc = VERR_NO_MEMORY;
     784
     785                if (RT_SUCCESS(rc))
     786                    rc = vbglR3DnDHGProcessActionMessage(u32ClientId,
     787                                                         uMsg,
     788                                                         &pEvent->uScreenId,
     789                                                         &pEvent->u.a.uXpos,
     790                                                         &pEvent->u.a.uYpos,
     791                                                         &pEvent->u.a.uDefAction,
     792                                                         &pEvent->u.a.uAllActions,
     793                                                         pEvent->pszFormats,
     794                                                         ccbFormats,
     795                                                         &pEvent->cbFormats);
    816796                break;
    817797            }
     
    819799            {
    820800                pEvent->uType = uMsg;
    821                 rc = vbglR3DnDHGProcessLeaveMessage(g_clientId);
     801                rc = vbglR3DnDHGProcessLeaveMessage(u32ClientId);
    822802                break;
    823803            }
     
    827807                pEvent->pszFormats = static_cast<char*>(RTMemAlloc(ccbFormats));
    828808                if (!pEvent->pszFormats)
    829                     return VERR_NO_MEMORY;
    830                 pEvent->u.b.pvData = RTMemAlloc(ccbData);
    831                 if (!pEvent->u.b.pvData)
     809                    rc = VERR_NO_MEMORY;
     810
     811                if (RT_SUCCESS(rc))
    832812                {
    833                     RTMemFree(pEvent->pszFormats);
    834                     pEvent->pszFormats = NULL;
    835                     return VERR_NO_MEMORY;
     813                    pEvent->u.b.pvData = RTMemAlloc(ccbData);
     814                    if (!pEvent->u.b.pvData)
     815                    {
     816                        RTMemFree(pEvent->pszFormats);
     817                        pEvent->pszFormats = NULL;
     818                        rc = VERR_NO_MEMORY;
     819                    }
    836820                }
    837                 rc = vbglR3DnDHGProcessSendDataMessage(g_clientId,
    838                                                        &pEvent->uScreenId,
    839                                                        pEvent->pszFormats,
    840                                                        ccbFormats,
    841                                                        &pEvent->cbFormats,
    842                                                        &pEvent->u.b.pvData,
    843                                                        ccbData,
    844                                                        &pEvent->u.b.cbData);
     821
     822                if (RT_SUCCESS(rc))
     823                    rc = vbglR3DnDHGProcessSendDataMessage(u32ClientId,
     824                                                           &pEvent->uScreenId,
     825                                                           pEvent->pszFormats,
     826                                                           ccbFormats,
     827                                                           &pEvent->cbFormats,
     828                                                           &pEvent->u.b.pvData,
     829                                                           ccbData,
     830                                                           &pEvent->u.b.cbData);
     831                break;
     832            }
     833            case DragAndDropSvc::HOST_DND_HG_EVT_CANCEL:
     834            {
     835                pEvent->uType = uMsg;
     836                rc = vbglR3DnDHGProcessCancelMessage(u32ClientId);
    845837                break;
    846838            }
     
    849841            {
    850842                pEvent->uType = uMsg;
    851                 rc = vbglR3DnDGHProcessRequestPendingMessage(g_clientId,
     843                rc = vbglR3DnDGHProcessRequestPendingMessage(u32ClientId,
    852844                                                             &pEvent->uScreenId);
    853845                break;
     
    858850                pEvent->pszFormats = static_cast<char*>(RTMemAlloc(ccbFormats));
    859851                if (!pEvent->pszFormats)
    860                     return VERR_NO_MEMORY;
    861                 rc = vbglR3DnDGHProcessDroppedMessage(g_clientId,
    862                                                       pEvent->pszFormats,
    863                                                       ccbFormats,
    864                                                       &pEvent->cbFormats,
    865                                                       &pEvent->u.a.uDefAction);
     852                    rc = VERR_NO_MEMORY;
     853
     854                if (RT_SUCCESS(rc))
     855                    rc = vbglR3DnDGHProcessDroppedMessage(u32ClientId,
     856                                                          pEvent->pszFormats,
     857                                                          ccbFormats,
     858                                                          &pEvent->cbFormats,
     859                                                          &pEvent->u.a.uDefAction);
    866860                break;
    867861            }
    868862#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
    869             case DragAndDropSvc::HOST_DND_HG_EVT_CANCEL:
    870             {
    871                 pEvent->uType = uMsg;
    872                 rc = vbglR3DnDHGProcessCancelMessage(g_clientId);
    873                 if (RT_SUCCESS(rc))
    874                     rc = VERR_CANCELLED;
     863            default:
     864                AssertMsgFailedReturn(("Message %u isn't expected in this context", uMsg),
     865                                      VERR_INVALID_PARAMETER);
    875866                break;
    876             }
    877             default: AssertMsgFailedReturn(("Message %u isn't expected in this context", uMsg), VERR_INVALID_PARAMETER); break;
    878         }
    879     }
    880     return rc;
    881 }
    882 
    883 VBGLR3DECL(int) VbglR3DnDHGAcknowledgeOperation(uint32_t uAction)
    884 {
    885     DO(("ACK: %u\n", uAction));
    886     /* Initialize header */
     867        }
     868    }
     869
     870    return rc;
     871}
     872
     873VBGLR3DECL(int) VbglR3DnDHGAcknowledgeOperation(uint32_t u32ClientId, uint32_t uAction)
     874{
    887875    DragAndDropSvc::VBOXDNDHGACKOPMSG Msg;
    888876    RT_ZERO(Msg);
    889877    Msg.hdr.result      = VERR_WRONG_ORDER;
    890     Msg.hdr.u32ClientID = g_clientId;
     878    Msg.hdr.u32ClientID = u32ClientId;
    891879    Msg.hdr.u32Function = DragAndDropSvc::GUEST_DND_HG_ACK_OP;
    892880    Msg.hdr.cParms      = 1;
     
    897885    if (RT_SUCCESS(rc))
    898886        rc = Msg.hdr.result;
    899     return rc;
    900 }
    901 
    902 VBGLR3DECL(int) VbglR3DnDHGRequestData(const char* pcszFormat)
    903 {
    904     DO(("DATA_REQ: '%s'\n", pcszFormat));
    905     /* Validate input */
     887
     888    return rc;
     889}
     890
     891VBGLR3DECL(int) VbglR3DnDHGRequestData(uint32_t u32ClientId, const char* pcszFormat)
     892{
    906893    AssertPtrReturn(pcszFormat, VERR_INVALID_PARAMETER);
    907894
    908     /* Initialize header */
    909895    DragAndDropSvc::VBOXDNDHGREQDATAMSG Msg;
    910896    RT_ZERO(Msg);
    911897    Msg.hdr.result      = VERR_WRONG_ORDER;
    912     Msg.hdr.u32ClientID = g_clientId;
     898    Msg.hdr.u32ClientID = u32ClientId;
    913899    Msg.hdr.u32Function = DragAndDropSvc::GUEST_DND_HG_REQ_DATA;
    914900    Msg.hdr.cParms      = 1;
     
    918904    if (RT_SUCCESS(rc))
    919905        rc = Msg.hdr.result;
    920     return rc;
    921 }
    922 
    923 VBGLR3DECL(int) VbglR3DnDGHAcknowledgePending(uint32_t uDefAction, uint32_t uAllActions, const char* pcszFormat)
    924 {
    925     DO(("PEND: %u: %u (%s)\n", uDefAction, uAllActions, pcszFormat));
    926     /* Validate input */
     906
     907    return rc;
     908}
     909
     910VBGLR3DECL(int) VbglR3DnDGHAcknowledgePending(uint32_t u32ClientId,
     911                                              uint32_t uDefAction, uint32_t uAllActions,
     912                                              const char* pcszFormat)
     913{
    927914    AssertPtrReturn(pcszFormat, VERR_INVALID_POINTER);
    928915
    929     /* Initialize header */
    930916    DragAndDropSvc::VBOXDNDGHACKPENDINGMSG Msg;
    931917    RT_ZERO(Msg);
    932918    Msg.hdr.result      = VERR_WRONG_ORDER;
    933     Msg.hdr.u32ClientID = g_clientId;
     919    Msg.hdr.u32ClientID = u32ClientId;
    934920    Msg.hdr.u32Function = DragAndDropSvc::GUEST_DND_GH_ACK_PENDING;
    935921    Msg.hdr.cParms      = 3;
     
    942928    if (RT_SUCCESS(rc))
    943929        rc = Msg.hdr.result;
    944     return rc;
    945 }
    946 
    947 VBGLR3DECL(int) VbglR3DnDGHSendData(void *pvData, uint32_t cbData)
    948 {
    949     DO(("DATA: %x (%u)\n", pvData, cbData));
    950     /* Validate input */
     930
     931    return rc;
     932}
     933
     934VBGLR3DECL(int) VbglR3DnDGHSendData(uint32_t u32ClientId, void *pvData, uint32_t cbData)
     935{
    951936    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
    952937    AssertReturn(cbData,    VERR_INVALID_PARAMETER);
     
    962947     */
    963948
    964     /* Initialize header */
    965949    DragAndDropSvc::VBOXDNDGHSENDDATAMSG Msg;
    966950    RT_ZERO(Msg);
    967951    Msg.hdr.result      = VERR_WRONG_ORDER;
    968     Msg.hdr.u32ClientID = g_clientId;
     952    Msg.hdr.u32ClientID = u32ClientId;
    969953    Msg.hdr.u32Function = DragAndDropSvc::GUEST_DND_GH_SND_DATA;
    970954    Msg.hdr.cParms      = 2;
     
    992976//        RTThreadSleep(500);
    993977    }
    994     return rc;
    995 }
    996 
    997 VBGLR3DECL(int) VbglR3DnDGHErrorEvent(int rcOp)
    998 {
    999     DO(("GH_ERROR\n"));
    1000 
    1001     /* Initialize header */
     978
     979    return rc;
     980}
     981
     982VBGLR3DECL(int) VbglR3DnDGHErrorEvent(uint32_t u32ClientId, int rcOp)
     983{
    1002984    DragAndDropSvc::VBOXDNDGHEVTERRORMSG Msg;
    1003985    RT_ZERO(Msg);
    1004986    Msg.hdr.result      = VERR_WRONG_ORDER;
    1005     Msg.hdr.u32ClientID = g_clientId;
     987    Msg.hdr.u32ClientID = u32ClientId;
    1006988    Msg.hdr.u32Function = DragAndDropSvc::GUEST_DND_GH_EVT_ERROR;
    1007989    Msg.hdr.cParms      = 1;
     
    1012994    if (RT_SUCCESS(rc))
    1013995        rc = Msg.hdr.result;
    1014     return rc;
    1015 }
     996
     997    return rc;
     998}
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