Changeset 50508 in vbox for trunk/src/VBox/HostServices/DragAndDrop
- Timestamp:
- Feb 19, 2014 3:45:58 PM (11 years ago)
- svn:sync-xref-src-repo-rev:
- 92350
- Location:
- trunk/src/VBox/HostServices/DragAndDrop
- Files:
-
- 2 edited
-
dndmanager.cpp (modified) (13 diffs)
-
service.cpp (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/HostServices/DragAndDrop/dndmanager.cpp
r50477 r50508 49 49 public: 50 50 51 DnDHGSendDirPrivate(const RTCString &strPath, 52 uint32_t fMode, uint64_t cbSize, 51 DnDHGSendDirPrivate(DnDURIObject URIObject, 53 52 PFNDNDPRIVATEPROGRESS pfnProgressCallback, void *pvProgressUser) 54 : m_strPath(strPath) 55 , m_cbSize(cbSize) 53 : m_URIObject(URIObject) 56 54 , m_pfnProgressCallback(pfnProgressCallback) 57 55 , m_pvProgressUser(pvProgressUser) 58 56 { 59 57 VBOXHGCMSVCPARM paTmpParms[3]; 60 paTmpParms[0].setString(m_ strPath.c_str());61 paTmpParms[1].setUInt32((uint32_t)(m_ strPath.length() + 1));62 paTmpParms[2].setUInt32( fMode);58 paTmpParms[0].setString(m_URIObject.GetDestPath().c_str()); 59 paTmpParms[1].setUInt32((uint32_t)(m_URIObject.GetDestPath().length() + 1)); 60 paTmpParms[2].setUInt32(m_URIObject.GetMode()); 63 61 64 62 m_pNextMsg = new HGCM::Message(DragAndDropSvc::HOST_DND_HG_SND_DIR, 3, paTmpParms); … … 71 69 if ( RT_SUCCESS(rc) 72 70 && m_pfnProgressCallback) 73 rc = m_pfnProgressCallback(m_ cbSize, m_pvProgressUser);71 rc = m_pfnProgressCallback(m_URIObject.GetSize(), m_pvProgressUser); 74 72 75 73 return rc; … … 77 75 78 76 protected: 79 RTCString m_strPath; 77 78 DnDURIObject m_URIObject; 80 79 81 80 /* Progress stuff */ 82 size_t m_cbSize;83 81 PFNDNDPRIVATEPROGRESS m_pfnProgressCallback; 84 82 void *m_pvProgressUser; … … 94 92 public: 95 93 96 DnDHGSendFilePrivate(const RTCString &strHostPath, 97 const RTCString &strGuestPath, 98 uint32_t fMode, uint64_t cbSize, 94 DnDHGSendFilePrivate(DnDURIObject URIObject, 99 95 PFNDNDPRIVATEPROGRESS pfnProgressCallback, void *pvProgressUser); 100 96 virtual ~DnDHGSendFilePrivate(void); … … 103 99 104 100 protected: 105 RTCString m_strHostPath; 106 RTCString m_strGuestPath; 107 uint64_t m_cbFileSize; 108 uint64_t m_cbFileProcessed; 109 RTFILE m_hCurFile; 101 102 DnDURIObject m_URIObject; 110 103 VBOXHGCMSVCPARM m_paSkelParms[5]; 111 104 … … 144 137 145 138 /****************************************************************************** 146 * DnDHGSendFilePrivate *139 * DnDHGSendFilePrivate * 147 140 ******************************************************************************/ 148 141 149 DnDHGSendFilePrivate::DnDHGSendFilePrivate(const RTCString &strHostPath, const RTCString &strGuestPath, 150 uint32_t fMode, uint64_t cbSize, 142 DnDHGSendFilePrivate::DnDHGSendFilePrivate(DnDURIObject URIObject, 151 143 PFNDNDPRIVATEPROGRESS pfnProgressCallback, void *pvProgressUser) 152 : m_strHostPath(strHostPath) 153 , m_strGuestPath(strGuestPath) 154 , m_cbFileSize(cbSize) 155 , m_cbFileProcessed(0) 156 , m_hCurFile(0) 144 : m_URIObject(URIObject) 157 145 , m_pfnProgressCallback(pfnProgressCallback) 158 146 , m_pvProgressUser(pvProgressUser) 159 147 { 160 m_paSkelParms[0].setString(m_ strGuestPath.c_str());161 m_paSkelParms[1].setUInt32((uint32_t)(m_ strGuestPath.length() + 1));148 m_paSkelParms[0].setString(m_URIObject.GetDestPath().c_str()); 149 m_paSkelParms[1].setUInt32((uint32_t)(m_URIObject.GetDestPath().length() + 1)); 162 150 m_paSkelParms[2].setPointer(NULL, 0); 163 151 m_paSkelParms[3].setUInt32(0); 164 m_paSkelParms[4].setUInt32( fMode);152 m_paSkelParms[4].setUInt32(m_URIObject.GetMode()); 165 153 166 154 m_pNextMsg = new HGCM::Message(DragAndDropSvc::HOST_DND_HG_SND_FILE, 5, m_paSkelParms); … … 169 157 DnDHGSendFilePrivate::~DnDHGSendFilePrivate(void) 170 158 { 171 if (m_hCurFile)172 RTFileClose(m_hCurFile);173 159 } 174 160 … … 184 170 return rc; 185 171 186 if (!m_hCurFile) 187 { 188 /* Open files on the host with RTFILE_O_DENY_WRITE to prevent races where the host 189 * writes to the file while the guest transfers it over. */ 190 rc = RTFileOpen(&m_hCurFile, m_strHostPath.c_str(), 191 RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE); 192 } 193 194 size_t cbRead; 172 uint32_t cbRead; 195 173 if (RT_SUCCESS(rc)) 196 174 { … … 200 178 void *pvBuf = paParms[2].u.pointer.addr; 201 179 AssertPtr(pvBuf); 202 rc = RTFileRead(m_hCurFile, pvBuf, cbToRead, &cbRead); 180 181 rc = m_URIObject.Read(pvBuf, cbToRead, &cbRead); 203 182 if (RT_LIKELY(RT_SUCCESS(rc))) 204 183 { 205 /* Advance. */206 m_cbFileProcessed += cbRead;207 Assert(m_cbFileProcessed <= m_cbFileSize);208 209 184 /* Tell the guest the actual size. */ 210 185 paParms[3].setUInt32((uint32_t)cbRead); … … 214 189 if (RT_SUCCESS(rc)) 215 190 { 216 /* Check if we are done. */ 217 Assert(m_cbFileProcessed <= m_cbFileSize); 218 bool fDone = m_cbFileSize == m_cbFileProcessed; 219 if (!fDone) 191 if (!m_URIObject.IsComplete()) 220 192 { 221 193 try 222 194 { 223 /* More data !Prepare the next message. */195 /* More data needed to send over. Prepare the next message. */ 224 196 m_pNextMsg = new HGCM::Message(DragAndDropSvc::HOST_DND_HG_SND_FILE, 5 /* cParms */, 225 197 m_paSkelParms); … … 236 208 { 237 209 rc = m_pfnProgressCallback(cbRead, m_pvProgressUser); 238 }239 240 if ( fDone241 || RT_FAILURE(rc))242 {243 RTFileClose(m_hCurFile);244 m_hCurFile = NIL_RTFILE;245 210 } 246 211 } … … 365 330 if (!lstURIOrg.isEmpty()) 366 331 { 367 rc = m_lstURI.Append PathsFromList(lstURIOrg, 0 /* fFlags */);332 rc = m_lstURI.AppendNativePathsFromList(lstURIOrg, 0 /* fFlags */); 368 333 if (RT_SUCCESS(rc)) 369 334 { 370 335 /* Add the total size of all meta data + files transferred to 371 * the message's total count. */336 * the message's total byte count. */ 372 337 m_cbTotal += m_lstURI.TotalBytes(); 373 338 374 339 /* We have to change the actual DnD data. Remove any host paths and 375 * just decode the filename into the new data. The guest tools will376 * add the correct path again ,before sending the DnD drop event to340 * just decode the filename into the new data. The Guest Additions will 341 * add the correct path again before sending the DnD drop event to 377 342 * some window. */ 378 343 strNewURIs = m_lstURI.RootToString(); … … 445 410 /* Create new messages based on our internal path list. Currently 446 411 * this could be directories or regular files. */ 447 const DnDURI Path &nextPath= m_lstURI.First();412 const DnDURIObject &nextObj = m_lstURI.First(); 448 413 try 449 414 { 415 uint32_t fMode = nextObj.GetMode(); 450 416 LogFlowFunc(("Processing srcPath=%s, dstPath=%s, fMode=0x%x, cbSize=%RU32, fIsDir=%RTbool, fIsFile=%RTbool\n", 451 nextPath.m_strSrcPath.c_str(), nextPath.m_strDstPath.c_str(), 452 nextPath.m_fMode, nextPath.m_cbSize, 453 RTFS_IS_DIRECTORY(nextPath.m_fMode), RTFS_IS_FILE(nextPath.m_fMode))); 454 455 if (RTFS_IS_DIRECTORY(nextPath.m_fMode)) 456 m_pNextPathMsg = new DnDHGSendDirPrivate(nextPath.m_strDstPath, 457 nextPath.m_fMode, nextPath.m_cbSize, 458 &DnDHGSendDataMessage::progressCallback, 417 nextObj.GetSourcePath().c_str(), nextObj.GetDestPath().c_str(), 418 fMode, nextObj.GetSize(), 419 RTFS_IS_DIRECTORY(fMode), RTFS_IS_FILE(fMode))); 420 421 if (RTFS_IS_DIRECTORY(fMode)) 422 m_pNextPathMsg = new DnDHGSendDirPrivate(nextObj, 423 &DnDHGSendDataMessage::progressCallback /* pfnProgressCallback */, 459 424 this /* pvProgressUser */); 460 else if (RTFS_IS_FILE(nextPath.m_fMode)) 461 m_pNextPathMsg = new DnDHGSendFilePrivate(nextPath.m_strSrcPath, nextPath.m_strDstPath, 462 nextPath.m_fMode, nextPath.m_cbSize, 463 &DnDHGSendDataMessage::progressCallback, 425 else if (RTFS_IS_FILE(fMode)) 426 m_pNextPathMsg = new DnDHGSendFilePrivate(nextObj, 427 &DnDHGSendDataMessage::progressCallback /* pfnProgressCallback */, 464 428 this /* pvProgressUser */); 465 429 else 466 430 AssertMsgFailedReturn(("fMode=0x%x is not supported for srcPath=%s, dstPath=%s\n", 467 nextPath.m_fMode, nextPath.m_strSrcPath.c_str(), nextPath.m_strDstPath.c_str()),431 fMode, nextObj.GetSourcePath().c_str(), nextObj.GetDestPath().c_str()), 468 432 VERR_NO_DATA); 469 433 -
trunk/src/VBox/HostServices/DragAndDrop/service.cpp
r50463 r50508 169 169 } 170 170 171 void DragAndDropService::guestCall(VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID, void *pvClient, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) 171 void DragAndDropService::guestCall(VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID, 172 void *pvClient, uint32_t u32Function, 173 uint32_t cParms, VBOXHGCMSVCPARM paParms[]) 172 174 { 173 175 LogFlowFunc(("u32ClientID=%RU32, u32Function=%RU32, cParms=%RU32\n", 174 176 u32ClientID, u32Function, cParms)); 175 177 176 int rc = VINF_SUCCESS; 178 /* Check if we've the right mode set. */ 179 bool fIgnoreRequest = true; /* Play safe. */ 177 180 switch (u32Function) 178 181 { 179 /* Note: Older VBox versions with enabled DnD guest->host support (< 4.4)180 * used the same ID (300) for GUEST_DND_GET_NEXT_HOST_MSG and181 * HOST_DND_GH_REQ_PENDING, which led this service returning182 * VERR_INVALID_PARAMETER when the guest wanted to actually183 * handle HOST_DND_GH_REQ_PENDING. */184 182 case DragAndDropSvc::GUEST_DND_GET_NEXT_HOST_MSG: 185 { 186 LogFlowFunc(("GUEST_DND_GET_NEXT_HOST_MSG\n")); 187 if ( cParms != 3 188 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* message */ 189 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* parameter count */ 190 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* blocking */) 191 rc = VERR_INVALID_PARAMETER; 183 if (modeGet() != VBOX_DRAG_AND_DROP_MODE_OFF) 184 { 185 fIgnoreRequest = false; 186 } 192 187 else 193 { 194 rc = m_pManager->nextMessageInfo(&paParms[0].u.uint32, &paParms[1].u.uint32); 195 if ( RT_FAILURE(rc) 196 && paParms[2].u.uint32) /* Blocking? */ 197 { 198 m_clientQueue.append(new HGCM::Client(u32ClientID, callHandle, u32Function, cParms, paParms)); 199 rc = VINF_HGCM_ASYNC_EXECUTE; 200 } 201 } 188 LogFlowFunc(("Drag'n drop disabled, ignoring request\n")); 202 189 break; 203 }204 190 case DragAndDropSvc::GUEST_DND_HG_ACK_OP: 205 { 206 LogFlowFunc(("GUEST_DND_HG_ACK_OP\n")); 207 if ( modeGet() != VBOX_DRAG_AND_DROP_MODE_BIDIRECTIONAL 208 && modeGet() != VBOX_DRAG_AND_DROP_MODE_HOST_TO_GUEST) 209 { 210 LogFlowFunc(("Wrong DnD mode, ignoring request\n")); 211 break; 212 } 213 214 if ( cParms != 1 215 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* action */) 216 rc = VERR_INVALID_PARAMETER; 191 case DragAndDropSvc::GUEST_DND_HG_REQ_DATA: 192 if ( modeGet() == VBOX_DRAG_AND_DROP_MODE_BIDIRECTIONAL 193 || modeGet() == VBOX_DRAG_AND_DROP_MODE_HOST_TO_GUEST) 194 { 195 fIgnoreRequest = false; 196 } 217 197 else 218 { 219 DragAndDropSvc::VBOXDNDCBHGACKOPDATA data; 220 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_HG_ACK_OP; 221 paParms[0].getUInt32(&data.uAction); 222 if (m_pfnHostCallback) 223 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data)); 224 // m_pHelpers->pfnCallComplete(callHandle, rc); 225 } 198 LogFlowFunc(("Host -> guest DnD mode disabled, ignoring request\n")); 226 199 break; 227 }228 case DragAndDropSvc::GUEST_DND_HG_REQ_DATA:229 {230 LogFlowFunc(("GUEST_DND_HG_REQ_DATA\n"));231 if ( modeGet() != VBOX_DRAG_AND_DROP_MODE_BIDIRECTIONAL232 && modeGet() != VBOX_DRAG_AND_DROP_MODE_HOST_TO_GUEST)233 {234 LogFlowFunc(("Wrong DnD mode, ignoring request\n"));235 break;236 }237 238 if ( cParms != 1239 || paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* format */)240 rc = VERR_INVALID_PARAMETER;241 else242 {243 DragAndDropSvc::VBOXDNDCBHGREQDATADATA data;244 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_HG_REQ_DATA;245 uint32_t cTmp;246 paParms[0].getPointer((void**)&data.pszFormat, &cTmp);247 if (m_pfnHostCallback)248 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data));249 // m_pHelpers->pfnCallComplete(callHandle, rc);250 // if (data.pszFormat)251 // RTMemFree(data.pszFormat);252 // if (data.pszTmpPath)253 // RTMemFree(data.pszTmpPath);254 }255 break;256 }257 200 #ifdef VBOX_WITH_DRAG_AND_DROP_GH 258 201 case DragAndDropSvc::GUEST_DND_GH_ACK_PENDING: 259 { 260 LogFlowFunc(("GUEST_DND_GH_ACK_PENDING\n")); 261 if ( modeGet() != VBOX_DRAG_AND_DROP_MODE_BIDIRECTIONAL 262 && modeGet() != VBOX_DRAG_AND_DROP_MODE_GUEST_TO_HOST) 263 { 264 LogFlowFunc(("Wrong DnD mode, ignoring request\n")); 265 break; 266 } 267 268 if ( cParms != 3 269 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* defaction */ 270 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* allactions */ 271 || paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* format */) 272 rc = VERR_INVALID_PARAMETER; 202 case DragAndDropSvc::GUEST_DND_GH_SND_DATA: 203 case DragAndDropSvc::GUEST_DND_GH_SND_DIR: 204 case DragAndDropSvc::GUEST_DND_GH_SND_FILE: 205 case DragAndDropSvc::GUEST_DND_GH_EVT_ERROR: 206 if ( modeGet() == VBOX_DRAG_AND_DROP_MODE_BIDIRECTIONAL 207 || modeGet() == VBOX_DRAG_AND_DROP_MODE_GUEST_TO_HOST) 208 { 209 fIgnoreRequest = false; 210 } 273 211 else 274 { 275 DragAndDropSvc::VBOXDNDCBGHACKPENDINGDATA data; 276 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_ACK_PENDING; 277 paParms[0].getUInt32(&data.uDefAction); 278 paParms[1].getUInt32(&data.uAllActions); 279 uint32_t cTmp; 280 paParms[2].getPointer((void**)&data.pszFormat, &cTmp); 281 if (m_pfnHostCallback) 282 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data)); 283 } 212 LogFlowFunc(("Guest -> host DnD mode disabled, ignoring request\n")); 284 213 break; 285 }286 case DragAndDropSvc::GUEST_DND_GH_SND_DATA:287 {288 LogFlowFunc(("GUEST_DND_GH_SND_DATA\n"));289 if ( modeGet() != VBOX_DRAG_AND_DROP_MODE_BIDIRECTIONAL290 && modeGet() != VBOX_DRAG_AND_DROP_MODE_GUEST_TO_HOST)291 {292 LogFlowFunc(("Wrong DnD mode, ignoring request\n"));293 break;294 }295 296 if ( cParms != 2297 || paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* data */298 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* size */)299 rc = VERR_INVALID_PARAMETER;300 else301 {302 DragAndDropSvc::VBOXDNDCBSNDDATADATA data;303 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_SND_DATA;304 paParms[0].getPointer((void**)&data.pvData, &data.cbData);305 paParms[1].getUInt32(&data.cbAllSize);306 if (m_pfnHostCallback)307 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data));308 }309 break;310 }311 case DragAndDropSvc::GUEST_DND_GH_EVT_ERROR:312 {313 LogFlowFunc(("GUEST_DND_GH_EVT_ERROR\n"));314 if ( modeGet() != VBOX_DRAG_AND_DROP_MODE_BIDIRECTIONAL315 && modeGet() != VBOX_DRAG_AND_DROP_MODE_GUEST_TO_HOST)316 {317 LogFlowFunc(("Wrong DnD mode, ignoring request\n"));318 break;319 }320 321 if ( cParms != 1322 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* rc */)323 rc = VERR_INVALID_PARAMETER;324 else325 {326 DragAndDropSvc::VBOXDNDCBEVTERRORDATA data;327 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_EVT_ERROR;328 uint32_t rcOp;329 paParms[0].getUInt32(&rcOp);330 data.rc = rcOp;331 if (m_pfnHostCallback)332 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data));333 }334 break;335 }336 214 #endif 337 215 default: 216 /* Reach through to DnD manager. */ 217 fIgnoreRequest = false; 218 break; 219 } 220 221 int rc; 222 if (!fIgnoreRequest) 223 { 224 rc = VINF_SUCCESS; 225 switch (u32Function) 338 226 { 339 /* All other messages are handled by the DnD manager. */ 340 rc = m_pManager->nextMessage(u32Function, cParms, paParms); 341 break; 227 /* Note: Older VBox versions with enabled DnD guest->host support (< 4.4) 228 * used the same message ID (300) for GUEST_DND_GET_NEXT_HOST_MSG and 229 * HOST_DND_GH_REQ_PENDING, which led this service returning 230 * VERR_INVALID_PARAMETER when the guest wanted to actually 231 * handle HOST_DND_GH_REQ_PENDING. */ 232 case DragAndDropSvc::GUEST_DND_GET_NEXT_HOST_MSG: 233 { 234 LogFlowFunc(("GUEST_DND_GET_NEXT_HOST_MSG\n")); 235 if ( cParms != 3 236 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* message */ 237 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* parameter count */ 238 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* blocking */) 239 rc = VERR_INVALID_PARAMETER; 240 else 241 { 242 rc = m_pManager->nextMessageInfo(&paParms[0].u.uint32, &paParms[1].u.uint32); 243 if ( RT_FAILURE(rc) 244 && paParms[2].u.uint32) /* Blocking? */ 245 { 246 m_clientQueue.append(new HGCM::Client(u32ClientID, callHandle, u32Function, cParms, paParms)); 247 rc = VINF_HGCM_ASYNC_EXECUTE; 248 } 249 } 250 break; 251 } 252 case DragAndDropSvc::GUEST_DND_HG_ACK_OP: 253 { 254 LogFlowFunc(("GUEST_DND_HG_ACK_OP\n")); 255 if ( cParms != 1 256 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* action */) 257 rc = VERR_INVALID_PARAMETER; 258 else 259 { 260 DragAndDropSvc::VBOXDNDCBHGACKOPDATA data; 261 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_HG_ACK_OP; 262 paParms[0].getUInt32(&data.uAction); 263 if (m_pfnHostCallback) 264 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data)); 265 // m_pHelpers->pfnCallComplete(callHandle, rc); 266 } 267 break; 268 } 269 case DragAndDropSvc::GUEST_DND_HG_REQ_DATA: 270 { 271 LogFlowFunc(("GUEST_DND_HG_REQ_DATA\n")); 272 if ( cParms != 1 273 || paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* format */) 274 rc = VERR_INVALID_PARAMETER; 275 else 276 { 277 DragAndDropSvc::VBOXDNDCBHGREQDATADATA data; 278 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_HG_REQ_DATA; 279 uint32_t cTmp; 280 paParms[0].getPointer((void**)&data.pszFormat, &cTmp); 281 if (m_pfnHostCallback) 282 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data)); 283 // m_pHelpers->pfnCallComplete(callHandle, rc); 284 // if (data.pszFormat) 285 // RTMemFree(data.pszFormat); 286 // if (data.pszTmpPath) 287 // RTMemFree(data.pszTmpPath); 288 } 289 break; 290 } 291 #ifdef VBOX_WITH_DRAG_AND_DROP_GH 292 case DragAndDropSvc::GUEST_DND_GH_ACK_PENDING: 293 { 294 LogFlowFunc(("GUEST_DND_GH_ACK_PENDING\n")); 295 if ( cParms != 3 296 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* defaction */ 297 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* allactions */ 298 || paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* format */) 299 rc = VERR_INVALID_PARAMETER; 300 else 301 { 302 DragAndDropSvc::VBOXDNDCBGHACKPENDINGDATA data; 303 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_ACK_PENDING; 304 paParms[0].getUInt32(&data.uDefAction); 305 paParms[1].getUInt32(&data.uAllActions); 306 uint32_t cTmp; 307 paParms[2].getPointer((void**)&data.pszFormat, &cTmp); 308 if (m_pfnHostCallback) 309 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data)); 310 } 311 break; 312 } 313 case DragAndDropSvc::GUEST_DND_GH_SND_DATA: 314 { 315 LogFlowFunc(("GUEST_DND_GH_SND_DATA\n")); 316 if ( cParms != 2 317 || paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* data */ 318 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* size */) 319 rc = VERR_INVALID_PARAMETER; 320 else 321 { 322 DragAndDropSvc::VBOXDNDCBSNDDATADATA data; 323 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_SND_DATA; 324 paParms[0].getPointer((void**)&data.pvData, &data.cbData); 325 paParms[1].getUInt32(&data.cbTotalSize); 326 if (m_pfnHostCallback) 327 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data)); 328 } 329 break; 330 } 331 case DragAndDropSvc::GUEST_DND_GH_SND_DIR: 332 { 333 LogFlowFunc(("GUEST_DND_GH_SND_DIR\n")); 334 if ( cParms != 3 335 || paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* path */ 336 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* path length */ 337 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* creation mode */) 338 rc = VERR_INVALID_PARAMETER; 339 else 340 { 341 DragAndDropSvc::VBOXDNDCBSNDDIRDATA data; 342 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_SND_DIR; 343 uint32_t cTmp; 344 paParms[0].getPointer((void**)&data.pszPath, &cTmp); 345 paParms[1].getUInt32(&data.cbPath); 346 paParms[2].getUInt32(&data.fMode); 347 #ifdef DEBUG_andy 348 LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x\n", 349 data.pszPath, data.cbPath, data.fMode)); 350 #endif 351 if (m_pfnHostCallback) 352 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data)); 353 } 354 break; 355 } 356 case DragAndDropSvc::GUEST_DND_GH_SND_FILE: 357 { 358 LogFlowFunc(("GUEST_DND_GH_SND_FILE\n")); 359 if ( cParms != 5 360 || paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* file path */ 361 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* file path length */ 362 || paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* file data */ 363 || paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* file data length */ 364 || paParms[4].type != VBOX_HGCM_SVC_PARM_32BIT /* creation mode */) 365 rc = VERR_INVALID_PARAMETER; 366 else 367 { 368 DragAndDropSvc::VBOXDNDCBSNDFILEDATA data; 369 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_SND_FILE; 370 uint32_t cTmp; 371 paParms[0].getPointer((void**)&data.pszFilePath, &cTmp); 372 paParms[1].getUInt32(&data.cbFilePath); 373 paParms[2].getPointer((void**)&data.pvData, &data.cbData); 374 /* paParms[3] is cbData. */ 375 paParms[4].getUInt32(&data.fMode); 376 #ifdef DEBUG_andy 377 LogFlowFunc(("pszFilePath=%s, cbData=%RU32, pvData=0x%p, fMode=0x%x\n", 378 data.pszFilePath, data.cbData, data.pvData, data.fMode)); 379 #endif 380 if (m_pfnHostCallback) 381 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data)); 382 } 383 break; 384 } 385 case DragAndDropSvc::GUEST_DND_GH_EVT_ERROR: 386 { 387 LogFlowFunc(("GUEST_DND_GH_EVT_ERROR\n")); 388 if ( cParms != 1 389 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* rc */) 390 rc = VERR_INVALID_PARAMETER; 391 else 392 { 393 DragAndDropSvc::VBOXDNDCBEVTERRORDATA data; 394 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_EVT_ERROR; 395 uint32_t rcOp; 396 paParms[0].getUInt32(&rcOp); 397 data.rc = rcOp; 398 if (m_pfnHostCallback) 399 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data)); 400 } 401 break; 402 } 403 #endif /* VBOX_WITH_DRAG_AND_DROP_GH */ 404 default: 405 { 406 /* All other messages are handled by the DnD manager. */ 407 rc = m_pManager->nextMessage(u32Function, cParms, paParms); 408 break; 409 } 342 410 } 343 411 } 412 else 413 rc = VERR_NOT_SUPPORTED; 414 344 415 /* If async execute is requested, we didn't notify the guest about 345 416 * completion. The client is queued into the waiters list and will be
Note:
See TracChangeset
for help on using the changeset viewer.
