VirtualBox

source: vbox/trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibDragAndDrop.cpp

Last change on this file was 98103, checked in by vboxsync, 16 months ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 71.0 KB
Line 
1/* $Id: VBoxGuestR3LibDragAndDrop.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2/** @file
3 * VBoxGuestR3Lib - Ring-3 Support Library for VirtualBox guest additions, Drag & Drop.
4 */
5
6/*
7 * Copyright (C) 2011-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * The contents of this file may alternatively be used under the terms
26 * of the Common Development and Distribution License Version 1.0
27 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28 * in the VirtualBox distribution, in which case the provisions of the
29 * CDDL are applicable instead of those of the GPL.
30 *
31 * You may elect to license modified versions of this file under the
32 * terms and conditions of either the GPL or the CDDL or both.
33 *
34 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35 */
36
37
38/*********************************************************************************************************************************
39* Header Files *
40*********************************************************************************************************************************/
41#include <iprt/path.h>
42#include <iprt/dir.h>
43#include <iprt/file.h>
44#include <iprt/uri.h>
45#include <iprt/thread.h>
46
47#include <iprt/cpp/list.h>
48#include <iprt/cpp/ministring.h>
49
50#ifdef LOG_GROUP
51 #undef LOG_GROUP
52#endif
53#define LOG_GROUP LOG_GROUP_GUEST_DND
54#include <VBox/log.h>
55
56#include <VBox/VBoxGuestLib.h>
57#include <VBox/GuestHost/DragAndDrop.h>
58#include <VBox/HostServices/DragAndDropSvc.h>
59
60using namespace DragAndDropSvc;
61
62#include "VBoxGuestR3LibInternal.h"
63
64
65/*********************************************************************************************************************************
66* Private internal functions *
67*********************************************************************************************************************************/
68
69/**
70 * Receives the next upcoming message for a given DnD context.
71 *
72 * @returns IPRT status code.
73 * Will return VERR_CANCELLED (implemented by the host service) if we need to bail out.
74 * @param pCtx DnD context to use.
75 * @param puMsg Where to store the message type.
76 * @param pcParms Where to store the number of parameters required for receiving the message.
77 * @param fWait Whether to wait (block) for a new message to arrive or not.
78 */
79static int vbglR3DnDGetNextMsgType(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t *puMsg, uint32_t *pcParms, bool fWait)
80{
81 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
82 AssertPtrReturn(puMsg, VERR_INVALID_POINTER);
83 AssertPtrReturn(pcParms, VERR_INVALID_POINTER);
84
85 int rc;
86
87 do
88 {
89 HGCMMsgGetNext Msg;
90 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_DND_FN_GET_NEXT_HOST_MSG, 3);
91 Msg.uMsg.SetUInt32(0);
92 Msg.cParms.SetUInt32(0);
93 Msg.fBlock.SetUInt32(fWait ? 1 : 0);
94
95 rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
96 if (RT_SUCCESS(rc))
97 {
98 rc = Msg.uMsg.GetUInt32(puMsg); AssertRC(rc);
99 rc = Msg.cParms.GetUInt32(pcParms); AssertRC(rc);
100 }
101
102 LogRel(("DnD: Received message %s (%#x) from host\n", DnDHostMsgToStr(*puMsg), *puMsg));
103
104 } while (rc == VERR_INTERRUPTED);
105
106 return rc;
107}
108
109
110/**
111 * Sends a DnD error back to the host.
112 *
113 * @returns IPRT status code.
114 * @param pCtx DnD context to use.
115 * @param rcErr Error (IPRT-style) to send.
116 */
117VBGLR3DECL(int) VbglR3DnDSendError(PVBGLR3GUESTDNDCMDCTX pCtx, int rcErr)
118{
119 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
120
121 HGCMMsgGHError Msg;
122 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_DND_FN_EVT_ERROR, 2);
123 /** @todo Context ID not used yet. */
124 Msg.u.v3.uContext.SetUInt32(0);
125 Msg.u.v3.rc.SetUInt32((uint32_t)rcErr); /* uint32_t vs. int. */
126
127 int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
128
129 /*
130 * Never return an error if the host did not accept the error at the current
131 * time. This can be due to the host not having any appropriate callbacks
132 * set which would handle that error.
133 *
134 * bird: Looks like VERR_NOT_SUPPORTED is what the host will return if it
135 * doesn't an appropriate callback. The code used to ignore ALL errors
136 * the host would return, also relevant ones.
137 */
138 if (RT_FAILURE(rc))
139 LogFlowFunc(("Sending error %Rrc failed with rc=%Rrc\n", rcErr, rc));
140 if (rc == VERR_NOT_SUPPORTED)
141 rc = VINF_SUCCESS;
142
143 return rc;
144}
145
146/**
147 * Host -> Guest
148 * Utility function to receive a so-called "action message" from the host.
149 * Certain DnD messages use the same amount / sort of parameters and grouped as "action messages".
150 *
151 * @returns IPRT status code.
152 * @param pCtx DnD context to use.
153 * @param uMsg Which kind of message to receive.
154 * @param puScreenID Where to store the host screen ID the message is bound to. Optional.
155 * @param puX Where to store the absolute X coordinates. Optional.
156 * @param puY Where to store the absolute Y coordinates. Optional.
157 * @param puDefAction Where to store the default action to perform. Optional.
158 * @param puAllActions Where to store the available actions. Optional.
159 * @param ppszFormats Where to store List of formats. Optional.
160 * @param pcbFormats Size (in bytes) of where to store the list of formats. Optional.
161 *
162 * @todo r=andy Get rid of this function as soon as we resolved the protocol TODO #1.
163 * This was part of the initial protocol and needs to go.
164 */
165static int vbglR3DnDHGRecvAction(PVBGLR3GUESTDNDCMDCTX pCtx,
166 uint32_t uMsg,
167 uint32_t *puScreenID,
168 uint32_t *puX,
169 uint32_t *puY,
170 uint32_t *puDefAction,
171 uint32_t *puAllActions,
172 char **ppszFormats,
173 uint32_t *pcbFormats)
174{
175 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
176 /* The rest is optional. */
177
178 const uint32_t cbFormatsTmp = pCtx->cbMaxChunkSize;
179
180 char *pszFormatsTmp = static_cast<char *>(RTMemAlloc(cbFormatsTmp));
181 if (!pszFormatsTmp)
182 return VERR_NO_MEMORY;
183
184 HGCMMsgHGAction Msg;
185 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, uMsg, 8);
186 Msg.u.v3.uContext.SetUInt32(0);
187 Msg.u.v3.uScreenId.SetUInt32(0);
188 Msg.u.v3.uX.SetUInt32(0);
189 Msg.u.v3.uY.SetUInt32(0);
190 Msg.u.v3.uDefAction.SetUInt32(0);
191 Msg.u.v3.uAllActions.SetUInt32(0);
192 Msg.u.v3.pvFormats.SetPtr(pszFormatsTmp, cbFormatsTmp);
193 Msg.u.v3.cbFormats.SetUInt32(0);
194
195 int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
196 if (RT_SUCCESS(rc))
197 {
198 /** @todo Context ID not used yet. */
199 if (RT_SUCCESS(rc) && puScreenID)
200 rc = Msg.u.v3.uScreenId.GetUInt32(puScreenID);
201 if (RT_SUCCESS(rc) && puX)
202 rc = Msg.u.v3.uX.GetUInt32(puX);
203 if (RT_SUCCESS(rc) && puY)
204 rc = Msg.u.v3.uY.GetUInt32(puY);
205 if (RT_SUCCESS(rc) && puDefAction)
206 rc = Msg.u.v3.uDefAction.GetUInt32(puDefAction);
207 if (RT_SUCCESS(rc) && puAllActions)
208 rc = Msg.u.v3.uAllActions.GetUInt32(puAllActions);
209 if (RT_SUCCESS(rc) && pcbFormats)
210 rc = Msg.u.v3.cbFormats.GetUInt32(pcbFormats);
211
212 if (RT_SUCCESS(rc))
213 {
214 if (ppszFormats)
215 {
216 *ppszFormats = RTStrDup(pszFormatsTmp);
217 if (!*ppszFormats)
218 rc = VERR_NO_MEMORY;
219 }
220 }
221 }
222
223 RTStrFree(pszFormatsTmp);
224
225 return rc;
226}
227
228/**
229 * Host -> Guest
230 * Utility function to receive a HOST_DND_FN_HG_EVT_LEAVE message from the host.
231 *
232 * @returns IPRT status code.
233 * @param pCtx DnD context to use.
234 */
235static int vbglR3DnDHGRecvLeave(PVBGLR3GUESTDNDCMDCTX pCtx)
236{
237 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
238
239 HGCMMsgHGLeave Msg;
240 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, HOST_DND_FN_HG_EVT_LEAVE, 1);
241 /** @todo Context ID not used yet. */
242 Msg.u.v3.uContext.SetUInt32(0);
243
244 return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
245}
246
247/**
248 * Host -> Guest
249 * Utility function to receive a HOST_DND_FN_HG_EVT_CANCEL message from the host.
250 *
251 * @returns IPRT status code.
252 * @param pCtx DnD context to use.
253 */
254static int vbglR3DnDHGRecvCancel(PVBGLR3GUESTDNDCMDCTX pCtx)
255{
256 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
257
258 HGCMMsgHGCancel Msg;
259 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, HOST_DND_FN_CANCEL, 1);
260 /** @todo Context ID not used yet. */
261 Msg.u.v3.uContext.SetUInt32(0);
262
263 return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
264}
265
266/**
267 * Host -> Guest
268 * Utility function to receive a HOST_DND_FN_HG_SND_DIR message from the host.
269 *
270 * @returns IPRT status code.
271 * @param pCtx DnD context to use.
272 * @param pszDirname Where to store the directory name of the directory being created.
273 * @param cbDirname Size (in bytes) of where to store the directory name of the directory being created.
274 * @param pcbDirnameRecv Size (in bytes) of the actual directory name received.
275 * @param pfMode Where to store the directory creation mode.
276 */
277static int vbglR3DnDHGRecvDir(PVBGLR3GUESTDNDCMDCTX pCtx,
278 char *pszDirname,
279 uint32_t cbDirname,
280 uint32_t *pcbDirnameRecv,
281 uint32_t *pfMode)
282{
283 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
284 AssertPtrReturn(pszDirname, VERR_INVALID_POINTER);
285 AssertReturn(cbDirname, VERR_INVALID_PARAMETER);
286 AssertPtrReturn(pcbDirnameRecv, VERR_INVALID_POINTER);
287 AssertPtrReturn(pfMode, VERR_INVALID_POINTER);
288
289 HGCMMsgHGSendDir Msg;
290 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, HOST_DND_FN_HG_SND_DIR, 4);
291 /** @todo Context ID not used yet. */
292 Msg.u.v3.uContext.SetUInt32(0);
293 Msg.u.v3.pvName.SetPtr(pszDirname, cbDirname);
294 Msg.u.v3.cbName.SetUInt32(cbDirname);
295 Msg.u.v3.fMode.SetUInt32(0);
296
297 int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
298 if (RT_SUCCESS(rc))
299 {
300 /** @todo Context ID not used yet. */
301 rc = Msg.u.v3.cbName.GetUInt32(pcbDirnameRecv); AssertRC(rc);
302 rc = Msg.u.v3.fMode.GetUInt32(pfMode); AssertRC(rc);
303
304 AssertReturn(cbDirname >= *pcbDirnameRecv, VERR_TOO_MUCH_DATA);
305 }
306
307 return rc;
308}
309
310/**
311 * Host -> Guest
312 * Utility function to receive a HOST_DND_FN_HG_SND_FILE_DATA message from the host.
313 *
314 * @returns IPRT status code.
315 * @param pCtx DnD context to use.
316 * @param pvData Where to store the file data chunk.
317 * @param cbData Size (in bytes) of where to store the data chunk.
318 * @param pcbDataRecv Size (in bytes) of the actual data chunk size received.
319 */
320static int vbglR3DnDHGRecvFileData(PVBGLR3GUESTDNDCMDCTX pCtx,
321 void *pvData,
322 uint32_t cbData,
323 uint32_t *pcbDataRecv)
324{
325 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
326 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
327 AssertReturn(cbData, VERR_INVALID_PARAMETER);
328 AssertPtrReturn(pcbDataRecv, VERR_INVALID_POINTER);
329
330 HGCMMsgHGSendFileData Msg;
331 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, HOST_DND_FN_HG_SND_FILE_DATA, 5);
332 Msg.u.v3.uContext.SetUInt32(0);
333 Msg.u.v3.pvData.SetPtr(pvData, cbData);
334 Msg.u.v3.cbData.SetUInt32(0);
335 Msg.u.v3.pvChecksum.SetPtr(NULL, 0);
336 Msg.u.v3.cbChecksum.SetUInt32(0);
337
338 int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
339 if (RT_SUCCESS(rc))
340 {
341 /** @todo Context ID not used yet. */
342 rc = Msg.u.v3.cbData.GetUInt32(pcbDataRecv); AssertRC(rc);
343 AssertReturn(cbData >= *pcbDataRecv, VERR_TOO_MUCH_DATA);
344 /** @todo Add checksum support. */
345 }
346
347 return rc;
348}
349
350/**
351 * Host -> Guest
352 * Utility function to receive the HOST_DND_FN_HG_SND_FILE_HDR message from the host.
353 *
354 * @returns IPRT status code.
355 * @param pCtx DnD context to use.
356 * @param pszFilename Where to store the file name of the file being transferred.
357 * @param cbFilename Size (in bytes) of where to store the file name of the file being transferred.
358 * @param puFlags File transfer flags. Currently not being used.
359 * @param pfMode Where to store the file creation mode.
360 * @param pcbTotal Where to store the file size (in bytes).
361 */
362static int vbglR3DnDHGRecvFileHdr(PVBGLR3GUESTDNDCMDCTX pCtx,
363 char *pszFilename,
364 uint32_t cbFilename,
365 uint32_t *puFlags,
366 uint32_t *pfMode,
367 uint64_t *pcbTotal)
368{
369 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
370 AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
371 AssertReturn(cbFilename, VERR_INVALID_PARAMETER);
372 AssertPtrReturn(puFlags, VERR_INVALID_POINTER);
373 AssertPtrReturn(pfMode, VERR_INVALID_POINTER);
374 AssertReturn(pcbTotal, VERR_INVALID_POINTER);
375
376 HGCMMsgHGSendFileHdr Msg;
377 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, HOST_DND_FN_HG_SND_FILE_HDR, 6);
378 Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
379 Msg.pvName.SetPtr(pszFilename, cbFilename);
380 Msg.cbName.SetUInt32(cbFilename);
381 Msg.uFlags.SetUInt32(0);
382 Msg.fMode.SetUInt32(0);
383 Msg.cbTotal.SetUInt64(0);
384
385 int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
386 if (RT_SUCCESS(rc))
387 {
388 /** @todo Get context ID. */
389 rc = Msg.uFlags.GetUInt32(puFlags); AssertRC(rc);
390 rc = Msg.fMode.GetUInt32(pfMode); AssertRC(rc);
391 rc = Msg.cbTotal.GetUInt64(pcbTotal); AssertRC(rc);
392 }
393
394 return rc;
395}
396
397/**
398 * Host -> Guest
399 * Helper function for receiving URI data from the host. Do not call directly.
400 * This function also will take care of the file creation / locking on the guest.
401 *
402 * @returns IPRT status code.
403 * @retval VERR_CANCELLED if the transfer was cancelled by the host.
404 * @param pCtx DnD context to use.
405 * @param pDataHdr DnD data header to use. Needed for accounting.
406 * @param pDroppedFiles Dropped files object to use for maintaining the file creation / locking.
407 */
408static int vbglR3DnDHGRecvURIData(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDDATAHDR pDataHdr, PDNDDROPPEDFILES pDroppedFiles)
409{
410 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
411 AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
412 AssertPtrReturn(pDroppedFiles, VERR_INVALID_POINTER);
413
414 /* Only count the raw data minus the already received meta data. */
415 Assert(pDataHdr->cbTotal >= pDataHdr->cbMeta);
416 uint64_t cbToRecvBytes = pDataHdr->cbTotal - pDataHdr->cbMeta;
417 uint64_t cToRecvObjs = pDataHdr->cObjects;
418
419 LogFlowFunc(("cbToRecvBytes=%RU64, cToRecvObjs=%RU64, (cbTotal=%RU64, cbMeta=%RU32)\n",
420 cbToRecvBytes, cToRecvObjs, pDataHdr->cbTotal, pDataHdr->cbMeta));
421
422 /* Anything to do at all? */
423 /* Note: Do not check for cbToRecvBytes == 0 here, as this might be just
424 * a bunch of 0-byte files to be transferred. */
425 if (!cToRecvObjs)
426 return VINF_SUCCESS;
427
428 LogRel2(("DnD: Receiving URI data started\n"));
429
430 /*
431 * Allocate temporary chunk buffer.
432 */
433 uint32_t cbChunkMax = pCtx->cbMaxChunkSize;
434 void *pvChunk = RTMemAlloc(cbChunkMax);
435 if (!pvChunk)
436 return VERR_NO_MEMORY;
437 uint32_t cbChunkRead = 0;
438
439 uint64_t cbFileSize = 0; /* Total file size (in bytes). */
440 uint64_t cbFileWritten = 0; /* Written bytes. */
441
442 const char *pszDropDir = DnDDroppedFilesGetDirAbs(pDroppedFiles);
443 AssertPtr(pszDropDir);
444
445 int rc;
446
447 /*
448 * Enter the main loop of retieving files + directories.
449 */
450 DNDTRANSFEROBJECT objCur;
451 RT_ZERO(objCur);
452
453 char szPathName[RTPATH_MAX] = { 0 };
454 uint32_t cbPathName = 0;
455 uint32_t fFlags = 0;
456 uint32_t fMode = 0;
457
458 do
459 {
460 LogFlowFunc(("Waiting for new message ...\n"));
461
462 uint32_t uNextMsg;
463 uint32_t cNextParms;
464 rc = vbglR3DnDGetNextMsgType(pCtx, &uNextMsg, &cNextParms, true /* fWait */);
465 if (RT_SUCCESS(rc))
466 {
467 LogFlowFunc(("uNextMsg=%RU32, cNextParms=%RU32\n", uNextMsg, cNextParms));
468
469 switch (uNextMsg)
470 {
471 case HOST_DND_FN_HG_SND_DIR:
472 {
473 rc = vbglR3DnDHGRecvDir(pCtx,
474 szPathName,
475 sizeof(szPathName),
476 &cbPathName,
477 &fMode);
478 LogFlowFunc(("HOST_DND_FN_HG_SND_DIR: "
479 "pszPathName=%s, cbPathName=%RU32, fMode=0x%x, rc=%Rrc\n",
480 szPathName, cbPathName, fMode, rc));
481
482 char *pszPathAbs = RTPathJoinA(pszDropDir, szPathName);
483 if (pszPathAbs)
484 {
485#ifdef RT_OS_WINDOWS
486 uint32_t fCreationMode = (fMode & RTFS_DOS_MASK) | RTFS_DOS_NT_NORMAL;
487#else
488 uint32_t fCreationMode = (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRWXU;
489#endif
490 rc = RTDirCreate(pszPathAbs, fCreationMode, 0);
491 if (RT_SUCCESS(rc))
492 rc = DnDDroppedFilesAddDir(pDroppedFiles, pszPathAbs);
493
494 if (RT_SUCCESS(rc))
495 {
496 Assert(cToRecvObjs);
497 cToRecvObjs--;
498 }
499
500 RTStrFree(pszPathAbs);
501 }
502 else
503 rc = VERR_NO_MEMORY;
504 break;
505 }
506 case HOST_DND_FN_HG_SND_FILE_HDR:
507 RT_FALL_THROUGH();
508 case HOST_DND_FN_HG_SND_FILE_DATA:
509 {
510 if (uNextMsg == HOST_DND_FN_HG_SND_FILE_HDR)
511 {
512 rc = vbglR3DnDHGRecvFileHdr(pCtx,
513 szPathName,
514 sizeof(szPathName),
515 &fFlags,
516 &fMode,
517 &cbFileSize);
518 LogFlowFunc(("HOST_DND_FN_HG_SND_FILE_HDR: "
519 "szPathName=%s, fFlags=0x%x, fMode=0x%x, cbFileSize=%RU64, rc=%Rrc\n",
520 szPathName, fFlags, fMode, cbFileSize, rc));
521 }
522 else
523 {
524 rc = vbglR3DnDHGRecvFileData(pCtx,
525 pvChunk,
526 cbChunkMax,
527 &cbChunkRead);
528 LogFlowFunc(("HOST_DND_FN_HG_SND_FILE_DATA: "
529 "cbChunkRead=%RU32, rc=%Rrc\n", cbChunkRead, rc));
530 }
531
532 if ( RT_SUCCESS(rc)
533 && uNextMsg == HOST_DND_FN_HG_SND_FILE_HDR)
534 {
535 char *pszPathAbs = RTPathJoinA(pszDropDir, szPathName);
536 if (pszPathAbs)
537 {
538 LogFlowFunc(("Opening pszPathName=%s, cbPathName=%RU32, fMode=0x%x, cbFileSize=%zu\n",
539 szPathName, cbPathName, fMode, cbFileSize));
540
541 uint64_t fOpen = RTFILE_O_WRITE | RTFILE_O_DENY_WRITE
542 | RTFILE_O_CREATE_REPLACE;
543
544 /* Is there already a file open, e.g. in transfer? */
545 if (!DnDTransferObjectIsOpen(&objCur))
546 {
547#ifdef RT_OS_WINDOWS
548 uint32_t fCreationMode = (fMode & RTFS_DOS_MASK) | RTFS_DOS_NT_NORMAL;
549#else
550 uint32_t fCreationMode = (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR;
551#endif
552 rc = DnDTransferObjectInitEx(&objCur, DNDTRANSFEROBJTYPE_FILE,
553 pszDropDir /* Source (base) path */, szPathName /* Destination path */);
554 if (RT_SUCCESS(rc))
555 {
556 rc = DnDTransferObjectOpen(&objCur, fOpen, fCreationMode, DNDTRANSFEROBJECT_FLAGS_NONE);
557 if (RT_SUCCESS(rc))
558 {
559 rc = DnDDroppedFilesAddFile(pDroppedFiles, pszPathAbs);
560 if (RT_SUCCESS(rc))
561 {
562 cbFileWritten = 0;
563 DnDTransferObjectSetSize(&objCur, cbFileSize);
564 }
565 }
566 }
567 }
568 else
569 {
570 AssertMsgFailed(("ObjType=%RU32\n", DnDTransferObjectGetType(&objCur)));
571 rc = VERR_WRONG_ORDER;
572 }
573
574 RTStrFree(pszPathAbs);
575 }
576 else
577 rc = VERR_NO_MEMORY;
578 }
579
580 if ( RT_SUCCESS(rc)
581 && uNextMsg == HOST_DND_FN_HG_SND_FILE_DATA
582 && cbChunkRead)
583 {
584 uint32_t cbChunkWritten;
585 rc = DnDTransferObjectWrite(&objCur, pvChunk, cbChunkRead, &cbChunkWritten);
586 if (RT_SUCCESS(rc))
587 {
588 LogFlowFunc(("HOST_DND_FN_HG_SND_FILE_DATA: "
589 "cbChunkRead=%RU32, cbChunkWritten=%RU32, cbFileWritten=%RU64 cbFileSize=%RU64\n",
590 cbChunkRead, cbChunkWritten, cbFileWritten + cbChunkWritten, cbFileSize));
591
592 cbFileWritten += cbChunkWritten;
593
594 Assert(cbChunkRead <= cbToRecvBytes);
595 cbToRecvBytes -= cbChunkRead;
596 }
597 }
598
599 /* Data transfer complete? Close the file. */
600 bool fClose = DnDTransferObjectIsComplete(&objCur);
601 if (fClose)
602 {
603 Assert(cToRecvObjs);
604 cToRecvObjs--;
605 }
606
607 /* Only since protocol v2 we know the file size upfront. */
608 Assert(cbFileWritten <= cbFileSize);
609
610 if (fClose)
611 {
612 LogFlowFunc(("Closing file\n"));
613 DnDTransferObjectDestroy(&objCur);
614 }
615
616 break;
617 }
618 case HOST_DND_FN_CANCEL:
619 {
620 rc = vbglR3DnDHGRecvCancel(pCtx);
621 if (RT_SUCCESS(rc))
622 rc = VERR_CANCELLED;
623 break;
624 }
625 default:
626 {
627 LogRel(("DnD: Warning: Message %s (%#x) from host not supported or in wrong order\n", DnDHostMsgToStr(uNextMsg), uNextMsg));
628 rc = VERR_NOT_SUPPORTED;
629 break;
630 }
631 }
632 }
633
634 if (RT_FAILURE(rc))
635 break;
636
637 LogFlowFunc(("cbToRecvBytes=%RU64, cToRecvObjs=%RU64\n", cbToRecvBytes, cToRecvObjs));
638 if ( !cbToRecvBytes
639 && !cToRecvObjs)
640 {
641 break;
642 }
643
644 } while (RT_SUCCESS(rc));
645
646 LogFlowFunc(("Loop ended with %Rrc\n", rc));
647
648 /* All URI data processed? */
649 if (rc == VERR_NO_DATA)
650 rc = VINF_SUCCESS;
651
652 /* Delete temp buffer again. */
653 if (pvChunk)
654 RTMemFree(pvChunk);
655
656 /* Cleanup on failure or if the user has canceled the operation or
657 * something else went wrong. */
658 if (RT_FAILURE(rc))
659 {
660 if (rc == VERR_CANCELLED)
661 LogRel2(("DnD: Receiving URI data was cancelled by the host\n"));
662 else
663 LogRel(("DnD: Receiving URI data failed with %Rrc\n", rc));
664
665 DnDTransferObjectDestroy(&objCur);
666 DnDDroppedFilesRollback(pDroppedFiles);
667 }
668 else
669 {
670 LogRel2(("DnD: Receiving URI data finished\n"));
671
672 /** @todo Compare the transfer list with the dirs/files we really transferred. */
673 /** @todo Implement checksum verification, if any. */
674 }
675
676 /*
677 * Close the dropped files directory.
678 * Don't try to remove it here, however, as the files are being needed
679 * by the client's drag'n drop operation lateron.
680 */
681 int rc2 = DnDDroppedFilesReset(pDroppedFiles, false /* fRemoveDropDir */);
682 if (RT_FAILURE(rc2)) /* Not fatal, don't report back to host. */
683 LogFlowFunc(("Closing dropped files directory failed with %Rrc\n", rc2));
684
685 LogFlowFuncLeaveRC(rc);
686 return rc;
687}
688
689/**
690 * Host -> Guest
691 * Utility function to receive the HOST_DND_FN_HG_SND_DATA message from the host.
692 *
693 * @returns IPRT status code.
694 * @param pCtx DnD context to use.
695 * @param pDataHdr DnD data header to use. Need for accounting and stuff.
696 * @param pvData Where to store the received data from the host.
697 * @param cbData Size (in bytes) of where to store the received data.
698 * @param pcbDataRecv Where to store the received amount of data (in bytes).
699 */
700static int vbglR3DnDHGRecvDataRaw(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDDATAHDR pDataHdr,
701 void *pvData, uint32_t cbData, uint32_t *pcbDataRecv)
702{
703 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
704 AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
705 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
706 AssertReturn(cbData, VERR_INVALID_PARAMETER);
707 AssertPtrNullReturn(pcbDataRecv, VERR_INVALID_POINTER);
708
709 LogFlowFunc(("pvDate=%p, cbData=%RU32\n", pvData, cbData));
710
711 HGCMMsgHGSendData Msg;
712 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, HOST_DND_FN_HG_SND_DATA, 5);
713 Msg.u.v3.uContext.SetUInt32(0);
714 Msg.u.v3.pvData.SetPtr(pvData, cbData);
715 Msg.u.v3.cbData.SetUInt32(0);
716 Msg.u.v3.pvChecksum.SetPtr(NULL, 0);
717 Msg.u.v3.cbChecksum.SetUInt32(0);
718
719 int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
720 if (RT_SUCCESS(rc))
721 {
722 uint32_t cbDataRecv;
723 rc = Msg.u.v3.cbData.GetUInt32(&cbDataRecv);
724 AssertRC(rc);
725 if (RT_SUCCESS(rc))
726 {
727 /** @todo Use checksum for validating the received data. */
728 if (pcbDataRecv)
729 *pcbDataRecv = cbDataRecv;
730 LogFlowFuncLeaveRC(rc);
731 return rc;
732 }
733 }
734
735 /* failure */
736 LogFlowFuncLeaveRC(rc);
737 return rc;
738}
739
740/**
741 * Host -> Guest
742 * Utility function to receive the HOST_DND_FN_HG_SND_DATA_HDR message from the host.
743 *
744 * @returns IPRT status code.
745 * @param pCtx DnD context to use.
746 * @param pDataHdr Where to store the receivd DnD data header.
747 */
748static int vbglR3DnDHGRecvDataHdr(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDDATAHDR pDataHdr)
749{
750 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
751 AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
752
753 Assert(pCtx->uProtocolDeprecated >= 3); /* Only for protocol v3 and up. */
754
755 HGCMMsgHGSendDataHdr Msg;
756 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, HOST_DND_FN_HG_SND_DATA_HDR, 12);
757 Msg.uContext.SetUInt32(0);
758 Msg.uFlags.SetUInt32(0);
759 Msg.uScreenId.SetUInt32(0);
760 Msg.cbTotal.SetUInt64(0);
761 Msg.cbMeta.SetUInt32(0);
762 Msg.pvMetaFmt.SetPtr(pDataHdr->pvMetaFmt, pDataHdr->cbMetaFmt);
763 Msg.cbMetaFmt.SetUInt32(0);
764 Msg.cObjects.SetUInt64(0);
765 Msg.enmCompression.SetUInt32(0);
766 Msg.enmChecksumType.SetUInt32(0);
767 Msg.pvChecksum.SetPtr(pDataHdr->pvChecksum, pDataHdr->cbChecksum);
768 Msg.cbChecksum.SetUInt32(0);
769
770 int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
771 if (RT_SUCCESS(rc))
772 {
773 /* Msg.uContext not needed here. */
774 Msg.uFlags.GetUInt32(&pDataHdr->uFlags);
775 Msg.uScreenId.GetUInt32(&pDataHdr->uScreenId);
776 Msg.cbTotal.GetUInt64(&pDataHdr->cbTotal);
777 Msg.cbMeta.GetUInt32(&pDataHdr->cbMeta);
778 Msg.cbMetaFmt.GetUInt32(&pDataHdr->cbMetaFmt);
779 Msg.cObjects.GetUInt64(&pDataHdr->cObjects);
780 Msg.enmCompression.GetUInt32(&pDataHdr->enmCompression);
781 Msg.enmChecksumType.GetUInt32((uint32_t *)&pDataHdr->enmChecksumType);
782 Msg.cbChecksum.GetUInt32(&pDataHdr->cbChecksum);
783 }
784
785 LogFlowFuncLeaveRC(rc);
786 return rc;
787}
788
789/**
790 * Host -> Guest
791 * Helper function for receiving the actual DnD data from the host. Do not call directly.
792 *
793 * @returns IPRT status code.
794 * @param pCtx DnD context to use.
795 * @param pDataHdr Where to store the data header data.
796 * @param ppvData Returns the received meta data. Needs to be free'd by the caller.
797 * @param pcbData Where to store the size (in bytes) of the received meta data.
798 */
799static int vbglR3DnDHGRecvDataLoop(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDDATAHDR pDataHdr,
800 void **ppvData, uint64_t *pcbData)
801{
802 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
803 AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
804 AssertPtrReturn(ppvData, VERR_INVALID_POINTER);
805 AssertPtrReturn(pcbData, VERR_INVALID_POINTER);
806
807 int rc;
808 uint32_t cbDataRecv;
809
810 LogFlowFuncEnter();
811
812 rc = vbglR3DnDHGRecvDataHdr(pCtx, pDataHdr);
813 if (RT_FAILURE(rc))
814 return rc;
815
816 LogFlowFunc(("cbTotal=%RU64, cbMeta=%RU32, cObjects=%RU32\n", pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->cObjects));
817 if (pDataHdr->cbMeta)
818 {
819 uint64_t cbDataTmp = 0;
820 void *pvDataTmp = RTMemAlloc(pDataHdr->cbMeta);
821 if (!pvDataTmp)
822 rc = VERR_NO_MEMORY;
823
824 if (RT_SUCCESS(rc))
825 {
826 uint8_t *pvDataOff = (uint8_t *)pvDataTmp;
827 while (cbDataTmp < pDataHdr->cbMeta)
828 {
829 rc = vbglR3DnDHGRecvDataRaw(pCtx, pDataHdr,
830 pvDataOff, RT_MIN(pDataHdr->cbMeta - cbDataTmp, pCtx->cbMaxChunkSize),
831 &cbDataRecv);
832 if (RT_SUCCESS(rc))
833 {
834 LogFlowFunc(("cbDataRecv=%RU32, cbDataTmp=%RU64\n", cbDataRecv, cbDataTmp));
835 Assert(cbDataTmp + cbDataRecv <= pDataHdr->cbMeta);
836 cbDataTmp += cbDataRecv;
837 pvDataOff += cbDataRecv;
838 }
839 else
840 break;
841 }
842
843 if (RT_SUCCESS(rc))
844 {
845 Assert(cbDataTmp == pDataHdr->cbMeta);
846
847 LogFlowFunc(("Received %RU64 bytes of data\n", cbDataTmp));
848
849 *ppvData = pvDataTmp;
850 *pcbData = cbDataTmp;
851 }
852 else
853 RTMemFree(pvDataTmp);
854 }
855 }
856 else
857 {
858 *ppvData = NULL;
859 *pcbData = 0;
860 }
861
862 LogFlowFuncLeaveRC(rc);
863 return rc;
864}
865
866/**
867 * Host -> Guest
868 * Main function for receiving the actual DnD data from the host.
869 *
870 * @returns VBox status code.
871 * @retval VERR_CANCELLED if cancelled by the host.
872 * @param pCtx DnD context to use.
873 * @param pMeta Where to store the actual meta data received from the host.
874 */
875static int vbglR3DnDHGRecvDataMain(PVBGLR3GUESTDNDCMDCTX pCtx,
876 PVBGLR3GUESTDNDMETADATA pMeta)
877{
878 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
879 AssertPtrReturn(pMeta, VERR_INVALID_POINTER);
880
881 AssertMsgReturn(pCtx->cbMaxChunkSize, ("Maximum chunk size must not be 0\n"), VERR_INVALID_PARAMETER);
882
883 VBOXDNDDATAHDR dataHdr;
884 RT_ZERO(dataHdr);
885 dataHdr.cbMetaFmt = pCtx->cbMaxChunkSize;
886 dataHdr.pvMetaFmt = RTMemAlloc(dataHdr.cbMetaFmt);
887 if (!dataHdr.pvMetaFmt)
888 return VERR_NO_MEMORY;
889
890 void *pvData = NULL;
891 uint64_t cbData = 0;
892 int rc = vbglR3DnDHGRecvDataLoop(pCtx, &dataHdr, &pvData, &cbData);
893 if (RT_SUCCESS(rc))
894 {
895 LogRel2(("DnD: Received %RU64 bytes meta data in format '%s'\n", cbData, (char *)dataHdr.pvMetaFmt));
896
897 /**
898 * Check if this is an URI event. If so, let VbglR3 do all the actual
899 * data transfer + file/directory creation internally without letting
900 * the caller know.
901 *
902 * This keeps the actual (guest OS-)dependent client (like VBoxClient /
903 * VBoxTray) small by not having too much redundant code.
904 */
905 Assert(dataHdr.cbMetaFmt);
906 AssertPtr(dataHdr.pvMetaFmt);
907 if (DnDMIMEHasFileURLs((char *)dataHdr.pvMetaFmt, dataHdr.cbMetaFmt)) /* URI data. */
908 {
909 DNDDROPPEDFILES droppedFiles;
910 RT_ZERO(droppedFiles);
911
912 rc = DnDDroppedFilesInit(&droppedFiles);
913 if (RT_SUCCESS(rc))
914 rc = DnDDroppedFilesOpenTemp(&droppedFiles, DNDURIDROPPEDFILE_FLAGS_NONE);
915
916 if (RT_FAILURE(rc))
917 {
918 LogRel(("DnD: Initializing dropped files directory failed with %Rrc\n", rc));
919 }
920 else
921 {
922 AssertPtr(pvData);
923 Assert(cbData);
924
925 /* Use the dropped files directory as the root directory for the current transfer. */
926 rc = DnDTransferListInitEx(&pMeta->u.URI.Transfer, DnDDroppedFilesGetDirAbs(&droppedFiles),
927 DNDTRANSFERLISTFMT_NATIVE);
928 if (RT_SUCCESS(rc))
929 {
930 rc = DnDTransferListAppendRootsFromBuffer(&pMeta->u.URI.Transfer, DNDTRANSFERLISTFMT_URI, (const char *)pvData, cbData,
931 DND_PATH_SEPARATOR_STR, 0 /* fFlags */);
932 if (RT_SUCCESS(rc))
933 {
934 rc = vbglR3DnDHGRecvURIData(pCtx, &dataHdr, &droppedFiles);
935 if (RT_SUCCESS(rc))
936 {
937 pMeta->enmType = VBGLR3GUESTDNDMETADATATYPE_URI_LIST;
938 }
939 }
940 }
941 }
942 }
943 else /* Raw data. */
944 {
945 pMeta->u.Raw.cbMeta = cbData;
946 pMeta->u.Raw.pvMeta = pvData;
947
948 pMeta->enmType = VBGLR3GUESTDNDMETADATATYPE_RAW;
949 }
950
951 if (pvData)
952 RTMemFree(pvData);
953 }
954
955 if (dataHdr.pvMetaFmt)
956 RTMemFree(dataHdr.pvMetaFmt);
957
958 if (RT_FAILURE(rc))
959 {
960 if (rc != VERR_CANCELLED)
961 {
962 LogRel(("DnD: Receiving data failed with %Rrc\n", rc));
963
964 int rc2 = VbglR3DnDHGSendProgress(pCtx, DND_PROGRESS_ERROR, 100 /* Percent */, rc);
965 if (RT_FAILURE(rc2))
966 LogRel(("DnD: Unable to send progress error %Rrc to host: %Rrc\n", rc, rc2));
967 }
968 }
969
970 LogFlowFuncLeaveRC(rc);
971 return rc;
972}
973
974#ifdef VBOX_WITH_DRAG_AND_DROP_GH
975/**
976 * Guest -> Host
977 * Utility function to receive the HOST_DND_FN_GH_REQ_PENDING message from the host.
978 *
979 * @returns IPRT status code.
980 * @param pCtx DnD context to use.
981 * @param puScreenID For which screen on the host the request is for. Optional.
982 */
983static int vbglR3DnDGHRecvPending(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t *puScreenID)
984{
985 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
986 /* pScreenID is optional. */
987
988 HGCMMsgGHReqPending Msg;
989 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, HOST_DND_FN_GH_REQ_PENDING, 2);
990 /** @todo Context ID not used yet. */
991 Msg.u.v3.uContext.SetUInt32(0);
992 Msg.u.v3.uScreenId.SetUInt32(0);
993
994 int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
995 if (RT_SUCCESS(rc))
996 {
997 /** @todo Context ID not used yet. */
998 if (puScreenID)
999 rc = Msg.u.v3.uContext.GetUInt32(puScreenID);
1000 }
1001
1002 return rc;
1003}
1004
1005/**
1006 * Guest -> Host
1007 * Utility function to receive the HOST_DND_FN_GH_EVT_DROPPED message from the host.
1008 *
1009 * @returns IPRT status code.
1010 * @param pCtx DnD context to use.
1011 * @param ppszFormat Requested data format from the host. Optional.
1012 * @param pcbFormat Size of requested data format (in bytes). Optional.
1013 * @param puAction Requested action from the host. Optional.
1014 */
1015static int vbglR3DnDGHRecvDropped(PVBGLR3GUESTDNDCMDCTX pCtx,
1016 char **ppszFormat,
1017 uint32_t *pcbFormat,
1018 uint32_t *puAction)
1019{
1020 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1021 /* The rest is optional. */
1022
1023 const uint32_t cbFormatTmp = pCtx->cbMaxChunkSize;
1024
1025 char *pszFormatTmp = static_cast<char *>(RTMemAlloc(cbFormatTmp));
1026 if (!pszFormatTmp)
1027 return VERR_NO_MEMORY;
1028
1029 HGCMMsgGHDropped Msg;
1030 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, HOST_DND_FN_GH_EVT_DROPPED, 4);
1031 Msg.u.v3.uContext.SetUInt32(0);
1032 Msg.u.v3.pvFormat.SetPtr(pszFormatTmp, cbFormatTmp);
1033 Msg.u.v3.cbFormat.SetUInt32(0);
1034 Msg.u.v3.uAction.SetUInt32(0);
1035
1036 int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
1037 if (RT_SUCCESS(rc))
1038 {
1039 /** @todo Context ID not used yet. */
1040 if (pcbFormat)
1041 rc = Msg.u.v3.cbFormat.GetUInt32(pcbFormat);
1042 if (RT_SUCCESS(rc) && puAction)
1043 rc = Msg.u.v3.uAction.GetUInt32(puAction);
1044
1045 if (RT_SUCCESS(rc))
1046 {
1047 *ppszFormat = RTStrDup(pszFormatTmp);
1048 if (!*ppszFormat)
1049 rc = VERR_NO_MEMORY;
1050 }
1051 }
1052
1053 RTMemFree(pszFormatTmp);
1054
1055 return rc;
1056}
1057#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
1058
1059
1060/*********************************************************************************************************************************
1061* Public functions *
1062*********************************************************************************************************************************/
1063
1064/**
1065 * Connects a DnD context to the DnD host service.
1066 *
1067 * @returns IPRT status code.
1068 * @param pCtx DnD context to connect.
1069 */
1070VBGLR3DECL(int) VbglR3DnDConnect(PVBGLR3GUESTDNDCMDCTX pCtx)
1071{
1072 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1073
1074 /* Initialize header */
1075 int rc = VbglR3HGCMConnect("VBoxDragAndDropSvc", &pCtx->uClientID);
1076 if (RT_FAILURE(rc))
1077 return rc;
1078 Assert(pCtx->uClientID);
1079
1080 /* Set the default protocol version we would like to use.
1081 * Deprecated since VBox 6.1.x, but let this set to 3 to (hopefully) not break things. */
1082 pCtx->uProtocolDeprecated = 3;
1083
1084 pCtx->fHostFeatures = VBOX_DND_HF_NONE;
1085 pCtx->fGuestFeatures = VBOX_DND_GF_NONE;
1086
1087 /*
1088 * Get the VM's session ID.
1089 * This is not fatal in case we're running with an ancient VBox version.
1090 */
1091 pCtx->uSessionID = 0;
1092 int rc2 = VbglR3GetSessionId(&pCtx->uSessionID); RT_NOREF(rc2);
1093 LogFlowFunc(("uSessionID=%RU64, rc=%Rrc\n", pCtx->uSessionID, rc2));
1094
1095 /*
1096 * Try sending the connect message to tell the protocol version to use.
1097 * Note: This might fail when the Guest Additions run on an older VBox host (< VBox 5.0) which
1098 * does not implement this command.
1099 */
1100 HGCMMsgConnect Msg;
1101 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_DND_FN_CONNECT, 3);
1102 Msg.u.v3.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
1103 Msg.u.v3.uProtocol.SetUInt32(pCtx->uProtocolDeprecated); /* Deprecated since VBox 6.1.x. */
1104 Msg.u.v3.uFlags.SetUInt32(0); /* Unused at the moment. */
1105
1106 rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
1107 if (RT_SUCCESS(rc))
1108 {
1109 /* Set the protocol version we're going to use as told by the host. */
1110 rc = Msg.u.v3.uProtocol.GetUInt32(&pCtx->uProtocolDeprecated); AssertRC(rc);
1111
1112 /*
1113 * Next is reporting our features. If this fails, assume older host.
1114 */
1115 rc2 = VbglR3DnDReportFeatures(pCtx->uClientID, pCtx->fGuestFeatures, &pCtx->fHostFeatures);
1116 if (RT_SUCCESS(rc2))
1117 {
1118 LogRel2(("DnD: Guest features: %#RX64 - Host features: %#RX64\n",
1119 pCtx->fGuestFeatures, pCtx->fHostFeatures));
1120 }
1121 else /* Failing here is not fatal; might be running with an older host. */
1122 {
1123 AssertLogRelMsg(rc2 == VERR_NOT_SUPPORTED || rc2 == VERR_NOT_IMPLEMENTED,
1124 ("Reporting features failed: %Rrc\n", rc2));
1125 }
1126
1127 pCtx->cbMaxChunkSize = DND_DEFAULT_CHUNK_SIZE; /** @todo Use a scratch buffer on the heap? */
1128 }
1129 else
1130 pCtx->uProtocolDeprecated = 0; /* We're using protocol v0 (initial draft) as a fallback. */
1131
1132 LogFlowFunc(("uClient=%RU32, uProtocol=%RU32, rc=%Rrc\n", pCtx->uClientID, pCtx->uProtocolDeprecated, rc));
1133 return rc;
1134}
1135
1136/**
1137 * Disconnects a given DnD context from the DnD host service.
1138 *
1139 * @returns IPRT status code.
1140 * @param pCtx DnD context to disconnect.
1141 * The context is invalid afterwards on successful disconnection.
1142 */
1143VBGLR3DECL(int) VbglR3DnDDisconnect(PVBGLR3GUESTDNDCMDCTX pCtx)
1144{
1145 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1146
1147 if (!pCtx->uClientID) /* Already disconnected? Bail out early. */
1148 return VINF_SUCCESS;
1149
1150 int rc = VbglR3HGCMDisconnect(pCtx->uClientID);
1151 if (RT_SUCCESS(rc))
1152 pCtx->uClientID = 0;
1153
1154 return rc;
1155}
1156
1157/**
1158 * Reports features to the host and retrieve host feature set.
1159 *
1160 * @returns VBox status code.
1161 * @param idClient The client ID returned by VbglR3DnDConnect().
1162 * @param fGuestFeatures Features to report, VBOX_DND_GF_XXX.
1163 * @param pfHostFeatures Where to store the features VBOX_DND_HF_XXX.
1164 */
1165VBGLR3DECL(int) VbglR3DnDReportFeatures(uint32_t idClient, uint64_t fGuestFeatures, uint64_t *pfHostFeatures)
1166{
1167 int rc;
1168 do
1169 {
1170 struct
1171 {
1172 VBGLIOCHGCMCALL Hdr;
1173 HGCMFunctionParameter f64Features0;
1174 HGCMFunctionParameter f64Features1;
1175 } Msg;
1176 VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, GUEST_DND_FN_REPORT_FEATURES, 2);
1177 VbglHGCMParmUInt64Set(&Msg.f64Features0, fGuestFeatures);
1178 VbglHGCMParmUInt64Set(&Msg.f64Features1, VBOX_DND_GF_1_MUST_BE_ONE);
1179
1180 rc = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg));
1181 if (RT_SUCCESS(rc))
1182 {
1183 Assert(Msg.f64Features0.type == VMMDevHGCMParmType_64bit);
1184 Assert(Msg.f64Features1.type == VMMDevHGCMParmType_64bit);
1185 if (Msg.f64Features1.u.value64 & VBOX_DND_GF_1_MUST_BE_ONE)
1186 rc = VERR_NOT_SUPPORTED;
1187 else if (pfHostFeatures)
1188 *pfHostFeatures = Msg.f64Features0.u.value64;
1189 break;
1190 }
1191 } while (rc == VERR_INTERRUPTED);
1192 return rc;
1193
1194}
1195
1196/**
1197 * Receives the next upcoming DnD event.
1198 *
1199 * This is the main function DnD clients call in order to implement any DnD functionality.
1200 * The purpose of it is to abstract the actual DnD protocol handling as much as possible from
1201 * the clients -- those only need to react to certain events, regardless of how the underlying
1202 * protocol actually is working.
1203 *
1204 * @returns VBox status code.
1205 * @param pCtx DnD context to work with.
1206 * @param ppEvent Next DnD event received on success; needs to be free'd by the client calling
1207 * VbglR3DnDEventFree() when done.
1208 */
1209VBGLR3DECL(int) VbglR3DnDEventGetNext(PVBGLR3GUESTDNDCMDCTX pCtx, PVBGLR3DNDEVENT *ppEvent)
1210{
1211 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1212 AssertPtrReturn(ppEvent, VERR_INVALID_POINTER);
1213
1214 PVBGLR3DNDEVENT pEvent = (PVBGLR3DNDEVENT)RTMemAllocZ(sizeof(VBGLR3DNDEVENT));
1215 if (!pEvent)
1216 return VERR_NO_MEMORY;
1217
1218 uint32_t uMsg = 0;
1219 uint32_t cParms = 0;
1220 int rc = vbglR3DnDGetNextMsgType(pCtx, &uMsg, &cParms, true /* fWait */);
1221 if (RT_SUCCESS(rc))
1222 {
1223 /* Check for VM session change. */
1224 uint64_t uSessionID;
1225 int rc2 = VbglR3GetSessionId(&uSessionID);
1226 if ( RT_SUCCESS(rc2)
1227 && (uSessionID != pCtx->uSessionID))
1228 {
1229 LogRel2(("DnD: VM session ID changed to %RU64\n", uSessionID));
1230 rc = VbglR3DnDDisconnect(pCtx);
1231 if (RT_SUCCESS(rc))
1232 rc = VbglR3DnDConnect(pCtx);
1233 }
1234 }
1235
1236 if (rc == VERR_CANCELLED) /* Host service told us that we have to bail out. */
1237 {
1238 LogRel2(("DnD: Host service requested termination\n"));
1239
1240 pEvent->enmType = VBGLR3DNDEVENTTYPE_QUIT;
1241 *ppEvent = pEvent;
1242
1243 return VINF_SUCCESS;
1244 }
1245
1246 if (RT_SUCCESS(rc))
1247 {
1248 LogFunc(("Handling uMsg=%RU32\n", uMsg));
1249
1250 switch(uMsg)
1251 {
1252 case HOST_DND_FN_HG_EVT_ENTER:
1253 {
1254 rc = vbglR3DnDHGRecvAction(pCtx,
1255 uMsg,
1256 &pEvent->u.HG_Enter.uScreenID,
1257 NULL /* puXPos */,
1258 NULL /* puYPos */,
1259 NULL /* uDefAction */,
1260 &pEvent->u.HG_Enter.dndLstActionsAllowed,
1261 &pEvent->u.HG_Enter.pszFormats,
1262 &pEvent->u.HG_Enter.cbFormats);
1263 if (RT_SUCCESS(rc))
1264 pEvent->enmType = VBGLR3DNDEVENTTYPE_HG_ENTER;
1265 break;
1266 }
1267 case HOST_DND_FN_HG_EVT_MOVE:
1268 {
1269 rc = vbglR3DnDHGRecvAction(pCtx,
1270 uMsg,
1271 NULL /* puScreenId */,
1272 &pEvent->u.HG_Move.uXpos,
1273 &pEvent->u.HG_Move.uYpos,
1274 &pEvent->u.HG_Move.dndActionDefault,
1275 NULL /* puAllActions */,
1276 NULL /* pszFormats */,
1277 NULL /* pcbFormats */);
1278 if (RT_SUCCESS(rc))
1279 pEvent->enmType = VBGLR3DNDEVENTTYPE_HG_MOVE;
1280 break;
1281 }
1282 case HOST_DND_FN_HG_EVT_DROPPED:
1283 {
1284 rc = vbglR3DnDHGRecvAction(pCtx,
1285 uMsg,
1286 NULL /* puScreenId */,
1287 &pEvent->u.HG_Drop.uXpos,
1288 &pEvent->u.HG_Drop.uYpos,
1289 &pEvent->u.HG_Drop.dndActionDefault,
1290 NULL /* puAllActions */,
1291 NULL /* pszFormats */,
1292 NULL /* pcbFormats */);
1293 if (RT_SUCCESS(rc))
1294 pEvent->enmType = VBGLR3DNDEVENTTYPE_HG_DROP;
1295 break;
1296 }
1297 case HOST_DND_FN_HG_EVT_LEAVE:
1298 {
1299 rc = vbglR3DnDHGRecvLeave(pCtx);
1300 if (RT_SUCCESS(rc))
1301 pEvent->enmType = VBGLR3DNDEVENTTYPE_HG_LEAVE;
1302 break;
1303 }
1304 case HOST_DND_FN_HG_SND_DATA_HDR:
1305 {
1306 rc = vbglR3DnDHGRecvDataMain(pCtx, &pEvent->u.HG_Received.Meta);
1307 if (RT_SUCCESS(rc))
1308 pEvent->enmType = VBGLR3DNDEVENTTYPE_HG_RECEIVE;
1309 break;
1310 }
1311 case HOST_DND_FN_HG_SND_DIR:
1312 RT_FALL_THROUGH();
1313 case HOST_DND_FN_HG_SND_FILE_HDR:
1314 RT_FALL_THROUGH();
1315 case HOST_DND_FN_HG_SND_FILE_DATA:
1316 {
1317 /*
1318 * All messages for this block are handled internally
1319 * by vbglR3DnDHGRecvDataMain(), see above.
1320 *
1321 * So if we land here our code is buggy.
1322 */
1323 rc = VERR_WRONG_ORDER;
1324 break;
1325 }
1326 case HOST_DND_FN_CANCEL:
1327 {
1328 rc = vbglR3DnDHGRecvCancel(pCtx);
1329 if (RT_SUCCESS(rc))
1330 rc = VERR_CANCELLED; /* Will emit a cancel event below. */
1331 break;
1332 }
1333#ifdef VBOX_WITH_DRAG_AND_DROP_GH
1334 case HOST_DND_FN_GH_REQ_PENDING:
1335 {
1336 rc = vbglR3DnDGHRecvPending(pCtx, &pEvent->u.GH_IsPending.uScreenID);
1337 if (RT_SUCCESS(rc))
1338 pEvent->enmType = VBGLR3DNDEVENTTYPE_GH_REQ_PENDING;
1339 break;
1340 }
1341 case HOST_DND_FN_GH_EVT_DROPPED:
1342 {
1343 rc = vbglR3DnDGHRecvDropped(pCtx,
1344 &pEvent->u.GH_Drop.pszFormat,
1345 &pEvent->u.GH_Drop.cbFormat,
1346 &pEvent->u.GH_Drop.dndActionRequested);
1347 if (RT_SUCCESS(rc))
1348 pEvent->enmType = VBGLR3DNDEVENTTYPE_GH_DROP;
1349 break;
1350 }
1351#endif
1352 default:
1353 {
1354 rc = VERR_NOT_SUPPORTED;
1355 break;
1356 }
1357 }
1358 }
1359
1360 if (RT_FAILURE(rc))
1361 {
1362 /* Current operation cancelled? Set / overwrite event type and tell the caller. */
1363 if (rc == VERR_CANCELLED)
1364 {
1365 pEvent->enmType = VBGLR3DNDEVENTTYPE_CANCEL;
1366 rc = VINF_SUCCESS; /* Deliver the event to the caller. */
1367 }
1368 else
1369 {
1370 VbglR3DnDEventFree(pEvent);
1371 LogRel(("DnD: Handling message %s (%#x) failed with %Rrc\n", DnDHostMsgToStr(uMsg), uMsg, rc));
1372 }
1373 }
1374
1375 if (RT_SUCCESS(rc))
1376 *ppEvent = pEvent;
1377
1378 LogFlowFuncLeaveRC(rc);
1379 return rc;
1380}
1381
1382/**
1383 * Frees (destroys) a formerly allocated DnD event.
1384 *
1385 * @returns IPRT status code.
1386 * @param pEvent Event to free (destroy).
1387 */
1388VBGLR3DECL(void) VbglR3DnDEventFree(PVBGLR3DNDEVENT pEvent)
1389{
1390 if (!pEvent)
1391 return;
1392
1393 /* Some messages require additional cleanup. */
1394 switch (pEvent->enmType)
1395 {
1396 case VBGLR3DNDEVENTTYPE_HG_ENTER:
1397 {
1398 if (pEvent->u.HG_Enter.pszFormats)
1399 RTStrFree(pEvent->u.HG_Enter.pszFormats);
1400 break;
1401 }
1402
1403#ifdef VBOX_WITH_DRAG_AND_DROP_GH
1404 case VBGLR3DNDEVENTTYPE_GH_DROP:
1405 {
1406 if (pEvent->u.GH_Drop.pszFormat)
1407 RTStrFree(pEvent->u.GH_Drop.pszFormat);
1408 break;
1409 }
1410#endif
1411 case VBGLR3DNDEVENTTYPE_HG_RECEIVE:
1412 {
1413 PVBGLR3GUESTDNDMETADATA pMeta = &pEvent->u.HG_Received.Meta;
1414 switch (pMeta->enmType)
1415 {
1416 case VBGLR3GUESTDNDMETADATATYPE_RAW:
1417 {
1418 if (pMeta->u.Raw.pvMeta)
1419 {
1420 Assert(pMeta->u.Raw.cbMeta);
1421 RTMemFree(pMeta->u.Raw.pvMeta);
1422 pMeta->u.Raw.cbMeta = 0;
1423 }
1424 break;
1425 }
1426
1427 case VBGLR3GUESTDNDMETADATATYPE_URI_LIST:
1428 {
1429 DnDTransferListDestroy(&pMeta->u.URI.Transfer);
1430 break;
1431 }
1432
1433 default:
1434 break;
1435 }
1436 break;
1437 }
1438
1439 default:
1440 break;
1441 }
1442
1443 RTMemFree(pEvent);
1444 pEvent = NULL;
1445}
1446
1447VBGLR3DECL(int) VbglR3DnDHGSendAckOp(PVBGLR3GUESTDNDCMDCTX pCtx, VBOXDNDACTION dndAction)
1448{
1449 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1450
1451 HGCMMsgHGAck Msg;
1452 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_DND_FN_HG_ACK_OP, 2);
1453 /** @todo Context ID not used yet. */
1454 Msg.u.v3.uContext.SetUInt32(0);
1455 Msg.u.v3.uAction.SetUInt32(dndAction);
1456
1457 return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
1458}
1459
1460/**
1461 * Host -> Guest
1462 * Requests the actual DnD data to be sent from the host.
1463 *
1464 * @returns IPRT status code.
1465 * @param pCtx DnD context to use.
1466 * @param pcszFormat Format to request the data from the host in.
1467 */
1468VBGLR3DECL(int) VbglR3DnDHGSendReqData(PVBGLR3GUESTDNDCMDCTX pCtx, const char* pcszFormat)
1469{
1470 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1471 AssertPtrReturn(pcszFormat, VERR_INVALID_POINTER);
1472 if (!RTStrIsValidEncoding(pcszFormat))
1473 return VERR_INVALID_PARAMETER;
1474
1475 const uint32_t cbFormat = (uint32_t)strlen(pcszFormat) + 1; /* Include termination */
1476
1477 HGCMMsgHGReqData Msg;
1478 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_DND_FN_HG_REQ_DATA, 3);
1479 /** @todo Context ID not used yet. */
1480 Msg.u.v3.uContext.SetUInt32(0);
1481 Msg.u.v3.pvFormat.SetPtr((void*)pcszFormat, cbFormat);
1482 Msg.u.v3.cbFormat.SetUInt32(cbFormat);
1483
1484 return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
1485}
1486
1487/**
1488 * Host -> Guest
1489 * Reports back its progress back to the host.
1490 *
1491 * @returns IPRT status code.
1492 * @param pCtx DnD context to use.
1493 * @param uStatus DnD status to report.
1494 * @param uPercent Overall progress (in percent) to report.
1495 * @param rcErr Error code (IPRT-style) to report.
1496 */
1497VBGLR3DECL(int) VbglR3DnDHGSendProgress(PVBGLR3GUESTDNDCMDCTX pCtx, uint32_t uStatus, uint8_t uPercent, int rcErr)
1498{
1499 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1500 AssertReturn(uStatus > DND_PROGRESS_UNKNOWN, VERR_INVALID_PARAMETER);
1501
1502 HGCMMsgHGProgress Msg;
1503 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_DND_FN_HG_EVT_PROGRESS, 4);
1504 /** @todo Context ID not used yet. */
1505 Msg.u.v3.uContext.SetUInt32(0);
1506 Msg.u.v3.uStatus.SetUInt32(uStatus);
1507 Msg.u.v3.uPercent.SetUInt32(uPercent);
1508 Msg.u.v3.rc.SetUInt32((uint32_t)rcErr); /* uint32_t vs. int. */
1509
1510 return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
1511}
1512
1513#ifdef VBOX_WITH_DRAG_AND_DROP_GH
1514/**
1515 * Guest -> Host
1516 * Acknowledges that there currently is a drag'n drop operation in progress on the guest,
1517 * which eventually could be dragged over to the host.
1518 *
1519 * @returns IPRT status code.
1520 * @param pCtx DnD context to use.
1521 * @param dndActionDefault Default action for the operation to report.
1522 * @param dndLstActionsAllowed All available actions for the operation to report.
1523 * @param pcszFormats Available formats for the operation to report.
1524 * @param cbFormats Size (in bytes) of formats to report.
1525 */
1526VBGLR3DECL(int) VbglR3DnDGHSendAckPending(PVBGLR3GUESTDNDCMDCTX pCtx,
1527 VBOXDNDACTION dndActionDefault, VBOXDNDACTIONLIST dndLstActionsAllowed,
1528 const char* pcszFormats, uint32_t cbFormats)
1529{
1530 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1531 AssertPtrReturn(pcszFormats, VERR_INVALID_POINTER);
1532 AssertReturn(cbFormats, VERR_INVALID_PARAMETER);
1533
1534 if (!RTStrIsValidEncoding(pcszFormats))
1535 return VERR_INVALID_UTF8_ENCODING;
1536
1537 HGCMMsgGHAckPending Msg;
1538 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_DND_FN_GH_ACK_PENDING, 5);
1539 /** @todo Context ID not used yet. */
1540 Msg.u.v3.uContext.SetUInt32(0);
1541 Msg.u.v3.uDefAction.SetUInt32(dndActionDefault);
1542 Msg.u.v3.uAllActions.SetUInt32(dndLstActionsAllowed);
1543 Msg.u.v3.pvFormats.SetPtr((void*)pcszFormats, cbFormats);
1544 Msg.u.v3.cbFormats.SetUInt32(cbFormats);
1545
1546 return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
1547}
1548
1549/**
1550 * Guest -> Host
1551 * Utility function to send DnD data from guest to the host.
1552 *
1553 * @returns IPRT status code.
1554 * @param pCtx DnD context to use.
1555 * @param pvData Data block to send.
1556 * @param cbData Size (in bytes) of data block to send.
1557 * @param pDataHdr Data header to use -- needed for accounting.
1558 */
1559static int vbglR3DnDGHSendDataInternal(PVBGLR3GUESTDNDCMDCTX pCtx,
1560 void *pvData, uint64_t cbData, PVBOXDNDSNDDATAHDR pDataHdr)
1561{
1562 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1563 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
1564 AssertReturn(cbData, VERR_INVALID_PARAMETER);
1565 AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
1566
1567 HGCMMsgGHSendDataHdr MsgHdr;
1568 VBGL_HGCM_HDR_INIT(&MsgHdr.hdr, pCtx->uClientID, GUEST_DND_FN_GH_SND_DATA_HDR, 12);
1569 MsgHdr.uContext.SetUInt32(0); /** @todo Not used yet. */
1570 MsgHdr.uFlags.SetUInt32(0); /** @todo Not used yet. */
1571 MsgHdr.uScreenId.SetUInt32(0); /** @todo Not used for guest->host (yet). */
1572 MsgHdr.cbTotal.SetUInt64(pDataHdr->cbTotal);
1573 MsgHdr.cbMeta.SetUInt32(pDataHdr->cbMeta);
1574 MsgHdr.pvMetaFmt.SetPtr(pDataHdr->pvMetaFmt, pDataHdr->cbMetaFmt);
1575 MsgHdr.cbMetaFmt.SetUInt32(pDataHdr->cbMetaFmt);
1576 MsgHdr.cObjects.SetUInt64(pDataHdr->cObjects);
1577 MsgHdr.enmCompression.SetUInt32(0); /** @todo Not used yet. */
1578 MsgHdr.enmChecksumType.SetUInt32(RTDIGESTTYPE_INVALID); /** @todo Not used yet. */
1579 MsgHdr.pvChecksum.SetPtr(NULL, 0); /** @todo Not used yet. */
1580 MsgHdr.cbChecksum.SetUInt32(0); /** @todo Not used yet. */
1581
1582 int rc = VbglR3HGCMCall(&MsgHdr.hdr, sizeof(MsgHdr));
1583
1584 LogFlowFunc(("cbTotal=%RU64, cbMeta=%RU32, cObjects=%RU64, rc=%Rrc\n",
1585 pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->cObjects, rc));
1586
1587 if (RT_SUCCESS(rc))
1588 {
1589 HGCMMsgGHSendData MsgData;
1590 VBGL_HGCM_HDR_INIT(&MsgData.hdr, pCtx->uClientID, GUEST_DND_FN_GH_SND_DATA, 5);
1591 MsgData.u.v3.uContext.SetUInt32(0); /** @todo Not used yet. */
1592 MsgData.u.v3.pvChecksum.SetPtr(NULL, 0); /** @todo Not used yet. */
1593 MsgData.u.v3.cbChecksum.SetUInt32(0); /** @todo Not used yet. */
1594
1595 uint32_t cbCurChunk;
1596 const uint32_t cbMaxChunk = pCtx->cbMaxChunkSize;
1597 uint32_t cbSent = 0;
1598
1599 while (cbSent < cbData)
1600 {
1601 cbCurChunk = RT_MIN(cbData - cbSent, cbMaxChunk);
1602 MsgData.u.v3.pvData.SetPtr(static_cast<uint8_t *>(pvData) + cbSent, cbCurChunk);
1603 MsgData.u.v3.cbData.SetUInt32(cbCurChunk);
1604
1605 rc = VbglR3HGCMCall(&MsgData.hdr, sizeof(MsgData));
1606 if (RT_FAILURE(rc))
1607 break;
1608
1609 cbSent += cbCurChunk;
1610 }
1611
1612 LogFlowFunc(("cbMaxChunk=%RU32, cbData=%RU64, cbSent=%RU32, rc=%Rrc\n",
1613 cbMaxChunk, cbData, cbSent, rc));
1614
1615 if (RT_SUCCESS(rc))
1616 Assert(cbSent == cbData);
1617 }
1618
1619 LogFlowFuncLeaveRC(rc);
1620 return rc;
1621}
1622
1623/**
1624 * Guest -> Host
1625 * Utility function to send a guest directory to the host.
1626 *
1627 * @returns IPRT status code.
1628 * @param pCtx DnD context to use.
1629 * @param pObj transfer object containing the directory to send.
1630 */
1631static int vbglR3DnDGHSendDir(PVBGLR3GUESTDNDCMDCTX pCtx, DNDTRANSFEROBJECT *pObj)
1632{
1633 AssertPtrReturn(pObj, VERR_INVALID_POINTER);
1634 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1635 AssertReturn(DnDTransferObjectGetType(pObj) == DNDTRANSFEROBJTYPE_DIRECTORY, VERR_INVALID_PARAMETER);
1636
1637 const char *pcszPath = DnDTransferObjectGetDestPath(pObj);
1638 const size_t cbPath = RTStrNLen(pcszPath, RTPATH_MAX) + 1 /* Include termination. */;
1639 const RTFMODE fMode = DnDTransferObjectGetMode(pObj);
1640
1641 LogFlowFunc(("strDir=%s (%zu bytes), fMode=0x%x\n", pcszPath, cbPath, fMode));
1642
1643 if (cbPath > RTPATH_MAX + 1) /* Can't happen, but check anyway. */
1644 return VERR_INVALID_PARAMETER;
1645
1646 HGCMMsgGHSendDir Msg;
1647 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_DND_FN_GH_SND_DIR, 4);
1648 /** @todo Context ID not used yet. */
1649 Msg.u.v3.uContext.SetUInt32(0);
1650 Msg.u.v3.pvName.SetPtr((void *)pcszPath, (uint32_t)cbPath);
1651 Msg.u.v3.cbName.SetUInt32((uint32_t)cbPath);
1652 Msg.u.v3.fMode.SetUInt32(fMode);
1653
1654 return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
1655}
1656
1657/**
1658 * Guest -> Host
1659 * Utility function to send a file from the guest to the host.
1660 *
1661 * @returns IPRT status code.
1662 * @param pCtx DnD context to use.
1663 * @param pObj Transfer object containing the file to send.
1664 */
1665static int vbglR3DnDGHSendFile(PVBGLR3GUESTDNDCMDCTX pCtx, PDNDTRANSFEROBJECT pObj)
1666{
1667 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1668 AssertPtrReturn(pObj, VERR_INVALID_POINTER);
1669 AssertReturn(DnDTransferObjectIsOpen(pObj) == false, VERR_INVALID_STATE);
1670 AssertReturn(DnDTransferObjectGetType(pObj) == DNDTRANSFEROBJTYPE_FILE, VERR_INVALID_PARAMETER);
1671
1672 uint64_t fOpen = RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE;
1673
1674 int rc = DnDTransferObjectOpen(pObj, fOpen, 0 /* fMode */, DNDTRANSFEROBJECT_FLAGS_NONE);
1675 if (RT_FAILURE(rc))
1676 return rc;
1677
1678 uint32_t cbBuf = pCtx->cbMaxChunkSize;
1679 AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
1680 void *pvBuf = RTMemAlloc(cbBuf); /** @todo Make this buffer part of PVBGLR3GUESTDNDCMDCTX? */
1681 if (!pvBuf)
1682 {
1683 int rc2 = DnDTransferObjectClose(pObj);
1684 AssertRC(rc2);
1685 return VERR_NO_MEMORY;
1686 }
1687
1688 const char *pcszPath = DnDTransferObjectGetDestPath(pObj);
1689 const size_t cchPath = RTStrNLen(pcszPath, RTPATH_MAX);
1690 const uint64_t cbSize = DnDTransferObjectGetSize(pObj);
1691 const RTFMODE fMode = DnDTransferObjectGetMode(pObj);
1692
1693 LogFlowFunc(("strFile=%s (%zu), cbSize=%RU64, fMode=0x%x\n", pcszPath, cchPath, cbSize, fMode));
1694
1695 HGCMMsgGHSendFileHdr MsgHdr;
1696 VBGL_HGCM_HDR_INIT(&MsgHdr.hdr, pCtx->uClientID, GUEST_DND_FN_GH_SND_FILE_HDR, 6);
1697 MsgHdr.uContext.SetUInt32(0); /* Context ID; unused at the moment. */
1698 MsgHdr.pvName.SetPtr((void *)pcszPath, (uint32_t)(cchPath + 1)); /* Include termination. */
1699 MsgHdr.cbName.SetUInt32((uint32_t)(cchPath + 1)); /* Ditto. */
1700 MsgHdr.uFlags.SetUInt32(0); /* Flags; unused at the moment. */
1701 MsgHdr.fMode.SetUInt32(fMode); /* File mode */
1702 MsgHdr.cbTotal.SetUInt64(cbSize); /* File size (in bytes). */
1703
1704 rc = VbglR3HGCMCall(&MsgHdr.hdr, sizeof(MsgHdr));
1705
1706 LogFlowFunc(("Sending file header resulted in %Rrc\n", rc));
1707
1708 if (RT_SUCCESS(rc))
1709 {
1710 /*
1711 * Send the actual file data, chunk by chunk.
1712 */
1713 HGCMMsgGHSendFileData Msg;
1714 VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_DND_FN_GH_SND_FILE_DATA, 5);
1715 Msg.u.v3.uContext.SetUInt32(0);
1716 Msg.u.v3.pvChecksum.SetPtr(NULL, 0);
1717 Msg.u.v3.cbChecksum.SetUInt32(0);
1718
1719 uint64_t cbToReadTotal = cbSize;
1720 uint64_t cbWrittenTotal = 0;
1721 while (cbToReadTotal)
1722 {
1723 uint32_t cbToRead = RT_MIN(cbToReadTotal, cbBuf);
1724 uint32_t cbRead = 0;
1725 if (cbToRead)
1726 rc = DnDTransferObjectRead(pObj, pvBuf, cbToRead, &cbRead);
1727
1728 LogFlowFunc(("cbToReadTotal=%RU64, cbToRead=%RU32, cbRead=%RU32, rc=%Rrc\n",
1729 cbToReadTotal, cbToRead, cbRead, rc));
1730
1731 if ( RT_SUCCESS(rc)
1732 && cbRead)
1733 {
1734 Msg.u.v3.pvData.SetPtr(pvBuf, cbRead);
1735 Msg.u.v3.cbData.SetUInt32(cbRead);
1736 /** @todo Calculate + set checksums. */
1737
1738 rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
1739 }
1740
1741 if (RT_FAILURE(rc))
1742 {
1743 LogFlowFunc(("Reading failed with rc=%Rrc\n", rc));
1744 break;
1745 }
1746
1747 Assert(cbRead <= cbToReadTotal);
1748 cbToReadTotal -= cbRead;
1749 cbWrittenTotal += cbRead;
1750
1751 LogFlowFunc(("%RU64/%RU64 -- %RU8%%\n", cbWrittenTotal, cbSize, cbWrittenTotal * 100 / cbSize));
1752 };
1753 }
1754
1755 RTMemFree(pvBuf);
1756 int rc2 = DnDTransferObjectClose(pObj);
1757 if (RT_SUCCESS(rc))
1758 rc = rc2;
1759
1760 LogFlowFuncLeaveRC(rc);
1761 return rc;
1762}
1763
1764/**
1765 * Guest -> Host
1766 * Utility function to send a transfer object from guest to the host.
1767 *
1768 * @returns IPRT status code.
1769 * @param pCtx DnD context to use.
1770 * @param pObj Transfer object to send from guest to the host.
1771 */
1772static int vbglR3DnDGHSendURIObject(PVBGLR3GUESTDNDCMDCTX pCtx, PDNDTRANSFEROBJECT pObj)
1773{
1774 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1775 AssertPtrReturn(pObj, VERR_INVALID_POINTER);
1776
1777 int rc;
1778
1779 const DNDTRANSFEROBJTYPE enmType = DnDTransferObjectGetType(pObj);
1780
1781 switch (enmType)
1782 {
1783 case DNDTRANSFEROBJTYPE_DIRECTORY:
1784 rc = vbglR3DnDGHSendDir(pCtx, pObj);
1785 break;
1786
1787 case DNDTRANSFEROBJTYPE_FILE:
1788 rc = vbglR3DnDGHSendFile(pCtx, pObj);
1789 break;
1790
1791 default:
1792 AssertMsgFailed(("Object type %ld not implemented\n", enmType));
1793 rc = VERR_NOT_IMPLEMENTED;
1794 break;
1795 }
1796
1797 return rc;
1798}
1799
1800/**
1801 * Guest -> Host
1802 * Utility function to send raw data from guest to the host.
1803 *
1804 * @returns IPRT status code.
1805 * @param pCtx DnD context to use.
1806 * @param pvData Block to raw data to send.
1807 * @param cbData Size (in bytes) of raw data to send.
1808 */
1809static int vbglR3DnDGHSendRawData(PVBGLR3GUESTDNDCMDCTX pCtx, void *pvData, size_t cbData)
1810{
1811 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1812 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
1813 /* cbData can be 0. */
1814
1815 VBOXDNDDATAHDR dataHdr;
1816 RT_ZERO(dataHdr);
1817
1818 dataHdr.cbMeta = (uint32_t)cbData;
1819 dataHdr.cbTotal = cbData;
1820
1821 return vbglR3DnDGHSendDataInternal(pCtx, pvData, cbData, &dataHdr);
1822}
1823
1824/**
1825 * Guest -> Host
1826 * Utility function to send transfer data from guest to the host.
1827 *
1828 * @returns IPRT status code.
1829 * @param pCtx DnD context to use.
1830 * @param pTransferList Dnd transfer list to send.
1831 */
1832static int vbglR3DnDGHSendTransferData(PVBGLR3GUESTDNDCMDCTX pCtx, PDNDTRANSFERLIST pTransferList)
1833{
1834 AssertPtrReturn(pCtx,VERR_INVALID_POINTER);
1835 AssertPtrReturn(pTransferList, VERR_INVALID_POINTER);
1836
1837 /*
1838 * Send the (meta) data; in case of URIs it's the root entries of a
1839 * transfer list the host needs to know upfront to set up the drag'n drop operation.
1840 */
1841 char *pszList = NULL;
1842 size_t cbList;
1843 int rc = DnDTransferListGetRoots(pTransferList, DNDTRANSFERLISTFMT_URI, &pszList, &cbList);
1844 if (RT_FAILURE(rc))
1845 return rc;
1846
1847 void *pvURIList = (void *)pszList;
1848 uint32_t cbURLIist = (uint32_t)cbList;
1849
1850 /* The total size also contains the size of the meta data. */
1851 uint64_t cbTotal = cbURLIist;
1852 cbTotal += DnDTransferListObjTotalBytes(pTransferList);
1853
1854 /* We're going to send a transfer list in text format. */
1855 const char szMetaFmt[] = "text/uri-list";
1856 const uint32_t cbMetaFmt = (uint32_t)strlen(szMetaFmt) + 1; /* Include termination. */
1857
1858 VBOXDNDDATAHDR dataHdr;
1859 dataHdr.uFlags = 0; /* Flags not used yet. */
1860 dataHdr.cbTotal = cbTotal;
1861 dataHdr.cbMeta = cbURLIist;
1862 dataHdr.pvMetaFmt = (void *)szMetaFmt;
1863 dataHdr.cbMetaFmt = cbMetaFmt;
1864 dataHdr.cObjects = DnDTransferListObjCount(pTransferList);
1865
1866 rc = vbglR3DnDGHSendDataInternal(pCtx, pvURIList, cbURLIist, &dataHdr);
1867
1868 if (RT_SUCCESS(rc))
1869 {
1870 while (DnDTransferListObjCount(pTransferList))
1871 {
1872 PDNDTRANSFEROBJECT pObj = DnDTransferListObjGetFirst(pTransferList);
1873
1874 rc = vbglR3DnDGHSendURIObject(pCtx, pObj);
1875 if (RT_FAILURE(rc))
1876 break;
1877
1878 DnDTransferListObjRemoveFirst(pTransferList);
1879 }
1880
1881 Assert(DnDTransferListObjCount(pTransferList) == 0);
1882 }
1883
1884 return rc;
1885}
1886
1887/**
1888 * Guest -> Host
1889 * Sends data, which either can be raw or URI data, from guest to the host. This function
1890 * initiates the actual data transfer from guest to the host.
1891 *
1892 * @returns IPRT status code.
1893 * @param pCtx DnD context to use.
1894 * @param pszFormat In which format the data will be sent.
1895 * @param pvData Data block to send.
1896 * For URI data this must contain the absolute local URI paths, separated by DND_PATH_SEPARATOR_STR.
1897 * @param cbData Size (in bytes) of data block to send.
1898 */
1899VBGLR3DECL(int) VbglR3DnDGHSendData(PVBGLR3GUESTDNDCMDCTX pCtx, const char *pszFormat, void *pvData, uint32_t cbData)
1900{
1901 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1902 AssertPtrReturn(pszFormat, VERR_INVALID_POINTER);
1903 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
1904 AssertReturn(cbData, VERR_INVALID_PARAMETER);
1905
1906 LogFlowFunc(("pszFormat=%s, pvData=%p, cbData=%RU32\n", pszFormat, pvData, cbData));
1907
1908 LogRel2(("DnD: Sending %RU32 bytes meta data in format '%s'\n", cbData, pszFormat));
1909
1910 int rc;
1911 if (DnDMIMEHasFileURLs(pszFormat, strlen(pszFormat)))
1912 {
1913 DNDTRANSFERLIST lstTransfer;
1914 RT_ZERO(lstTransfer);
1915
1916 rc = DnDTransferListInit(&lstTransfer);
1917 if (RT_SUCCESS(rc))
1918 {
1919 /** @todo Add symlink support (DNDTRANSFERLIST_FLAGS_RESOLVE_SYMLINKS) here. */
1920 /** @todo Add lazy loading (DNDTRANSFERLIST_FLAGS_LAZY) here. */
1921 const DNDTRANSFERLISTFLAGS fFlags = DNDTRANSFERLIST_FLAGS_RECURSIVE;
1922
1923 rc = DnDTransferListAppendPathsFromBuffer(&lstTransfer, DNDTRANSFERLISTFMT_URI, (const char *)pvData, cbData,
1924 DND_PATH_SEPARATOR_STR, fFlags);
1925 if (RT_SUCCESS(rc))
1926 rc = vbglR3DnDGHSendTransferData(pCtx, &lstTransfer);
1927 DnDTransferListDestroy(&lstTransfer);
1928 }
1929 }
1930 else
1931 rc = vbglR3DnDGHSendRawData(pCtx, pvData, cbData);
1932
1933 if (RT_FAILURE(rc))
1934 {
1935 LogRel(("DnD: Sending data failed with rc=%Rrc\n", rc));
1936
1937 if (rc != VERR_CANCELLED)
1938 {
1939 int rc2 = VbglR3DnDSendError(pCtx, rc);
1940 if (RT_FAILURE(rc2))
1941 LogFlowFunc(("Unable to send error (%Rrc) to host, rc=%Rrc\n", rc, rc2));
1942 }
1943 }
1944
1945 return rc;
1946}
1947#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
1948
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use