VirtualBox

source: vbox/trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR0LibSharedFolders.c@ 35263

Last change on this file since 35263 was 33994, checked in by vboxsync, 14 years ago

shfl: Replaced RTFSOBJINFO and RTFSPROPERTIES with shared folder specific versions. IPRT structures like this should never have been exposed to the guest.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 24.3 KB
Line 
1/* $Revision: 33994 $ */
2/** @file
3 * VBoxGuestR0LibSharedFolders - Ring 0 Shared Folders calls.
4 */
5
6/*
7 * Copyright (C) 2006-2010 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27/* Entire file is ifdef'ed with !VBGL_VBOXGUEST */
28#ifndef VBGL_VBOXGUEST
29
30#ifdef RT_OS_LINUX
31# include "VBoxGuestR0LibSharedFolders.h"
32# define DbgPrint RTAssertMsg2Weak
33#else
34# include "VBoxGuestR0LibSharedFolders.h"
35#endif
36#include <iprt/time.h>
37#include <iprt/mem.h>
38#include <iprt/path.h>
39#include <iprt/string.h>
40
41#define SHFL_CPARMS_SET_UTF8 0
42#define SHFL_CPARMS_SET_SYMLINKS 0
43
44#define VBOX_INIT_CALL(a, b, c) \
45 (a)->result = VINF_SUCCESS; \
46 (a)->u32ClientID = (c)->ulClientID; \
47 (a)->u32Function = SHFL_FN_##b; \
48 (a)->cParms = SHFL_CPARMS_##b
49
50#ifndef RT_OS_WINDOWS
51# define RtlZeroMemory(a, b) memset (a, 0, b)
52#endif
53
54
55DECLVBGL(int) vboxInit (void)
56{
57 int rc = VINF_SUCCESS;
58
59 rc = VbglInit ();
60 return rc;
61}
62
63DECLVBGL(void) vboxUninit (void)
64{
65 VbglTerminate ();
66}
67
68DECLVBGL(int) vboxConnect (PVBSFCLIENT pClient)
69{
70 int rc = VINF_SUCCESS;
71
72 VBoxGuestHGCMConnectInfo data;
73
74 RtlZeroMemory (&data, sizeof (VBoxGuestHGCMConnectInfo));
75
76 pClient->handle = NULL;
77
78 data.result = VINF_SUCCESS;
79 data.Loc.type = VMMDevHGCMLoc_LocalHost_Existing;
80 strcpy (data.Loc.u.host.achName, "VBoxSharedFolders");
81
82 rc = VbglHGCMConnect (&pClient->handle, &data);
83
84/* Log(("VBOXSF: VBoxSF::vboxConnect: VbglHGCMConnect rc = %#x, result = %#x\n",
85 rc, data.result));
86*/
87 if (RT_SUCCESS (rc))
88 {
89 rc = data.result;
90 }
91
92 if (RT_SUCCESS (rc))
93 {
94 pClient->ulClientID = data.u32ClientID;
95 }
96 return rc;
97}
98
99DECLVBGL(void) vboxDisconnect (PVBSFCLIENT pClient)
100{
101 int rc;
102
103 VBoxGuestHGCMDisconnectInfo data;
104
105 if (pClient->handle == NULL)
106 return; /* not connected */
107
108 RtlZeroMemory (&data, sizeof (VBoxGuestHGCMDisconnectInfo));
109
110 data.result = VINF_SUCCESS;
111 data.u32ClientID = pClient->ulClientID;
112
113 rc = VbglHGCMDisconnect (pClient->handle, &data);
114/* Log(("VBOXSF: VBoxSF::vboxDisconnect: "
115 "VbglHGCMDisconnect rc = %#x, result = %#x\n", rc, data.result));
116*/
117 return;
118}
119
120DECLVBGL(int) vboxCallQueryMappings (PVBSFCLIENT pClient, SHFLMAPPING paMappings[],
121 uint32_t *pcMappings)
122{
123 int rc = VINF_SUCCESS;
124
125 VBoxSFQueryMappings data;
126
127 VBOX_INIT_CALL(&data.callInfo, QUERY_MAPPINGS, pClient);
128
129 data.flags.type = VMMDevHGCMParmType_32bit;
130 data.flags.u.value32 = SHFL_MF_UCS2;
131
132 data.numberOfMappings.type = VMMDevHGCMParmType_32bit;
133 data.numberOfMappings.u.value32 = *pcMappings;
134
135 data.mappings.type = VMMDevHGCMParmType_LinAddr;
136 data.mappings.u.Pointer.size = sizeof (SHFLMAPPING) * *pcMappings;
137 data.mappings.u.Pointer.u.linearAddr = (uintptr_t)&paMappings[0];
138
139/* Log(("VBOXSF: in ifs difference %d\n",
140 (char *)&data.flags.type - (char *)&data.callInfo.cParms));
141*/
142 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
143
144/*
145 Log(("VBOXSF: VBoxSF::vboxCallQueryMappings: "
146 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
147*/
148 if (RT_SUCCESS (rc))
149 {
150 rc = data.callInfo.result;
151 }
152
153 if (RT_SUCCESS (rc))
154 {
155 *pcMappings = data.numberOfMappings.u.value32;
156 }
157
158 return rc;
159}
160
161DECLVBGL(int) vboxCallQueryMapName (PVBSFCLIENT pClient, SHFLROOT root, SHFLSTRING *pString, uint32_t size)
162{
163 int rc = VINF_SUCCESS;
164
165 VBoxSFQueryMapName data;
166
167 VBOX_INIT_CALL(&data.callInfo, QUERY_MAP_NAME, pClient);
168
169 data.root.type = VMMDevHGCMParmType_32bit;
170 data.root.u.value32 = root;
171
172 data.name.type = VMMDevHGCMParmType_LinAddr;
173 data.name.u.Pointer.size = size;
174 data.name.u.Pointer.u.linearAddr = (uintptr_t)pString;
175
176 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
177
178/* Log(("VBOXSF: VBoxSF::vboxCallQueryMapName: "
179 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
180*/
181 if (RT_SUCCESS (rc))
182 {
183 rc = data.callInfo.result;
184 }
185
186 return rc;
187}
188
189DECLVBGL(int) vboxCallMapFolder(PVBSFCLIENT pClient, PSHFLSTRING szFolderName,
190 PVBSFMAP pMap)
191{
192 int rc = VINF_SUCCESS;
193
194 VBoxSFMapFolder data;
195
196 VBOX_INIT_CALL(&data.callInfo, MAP_FOLDER, pClient);
197
198 data.path.type = VMMDevHGCMParmType_LinAddr;
199 data.path.u.Pointer.size = ShflStringSizeOfBuffer (szFolderName);
200 data.path.u.Pointer.u.linearAddr = (uintptr_t)szFolderName;
201
202 data.root.type = VMMDevHGCMParmType_32bit;
203 data.root.u.value32 = 0;
204
205 data.delimiter.type = VMMDevHGCMParmType_32bit;
206 data.delimiter.u.value32 = RTPATH_DELIMITER;
207
208 data.fCaseSensitive.type = VMMDevHGCMParmType_32bit;
209#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
210 data.fCaseSensitive.u.value32 = 0;
211#else
212 data.fCaseSensitive.u.value32 = 1;
213#endif
214
215 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
216
217/* Log(("VBOXSF: VBoxSF::vboxCallMapFolder: "
218 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
219*/
220 if (RT_SUCCESS (rc))
221 {
222 pMap->root = data.root.u.value32;
223 rc = data.callInfo.result;
224 }
225 else if (rc == VERR_NOT_IMPLEMENTED)
226 {
227 /* try the legacy interface too; temporary to assure backwards compatibility */
228 VBoxSFMapFolder_Old OldData;
229
230 VBOX_INIT_CALL(&OldData.callInfo, MAP_FOLDER_OLD, pClient);
231
232 OldData.path.type = VMMDevHGCMParmType_LinAddr;
233 OldData.path.u.Pointer.size = ShflStringSizeOfBuffer (szFolderName);
234 OldData.path.u.Pointer.u.linearAddr = (uintptr_t)szFolderName;
235
236 OldData.root.type = VMMDevHGCMParmType_32bit;
237 OldData.root.u.value32 = 0;
238
239 OldData.delimiter.type = VMMDevHGCMParmType_32bit;
240 OldData.delimiter.u.value32 = RTPATH_DELIMITER;
241
242 rc = VbglHGCMCall (pClient->handle, &OldData.callInfo, sizeof (OldData));
243
244 if (RT_SUCCESS (rc))
245 {
246 pMap->root = OldData.root.u.value32;
247 rc = OldData.callInfo.result;
248 }
249 }
250 return rc;
251}
252
253DECLVBGL(int) vboxCallUnmapFolder(PVBSFCLIENT pClient, PVBSFMAP pMap)
254{
255 int rc = VINF_SUCCESS;
256
257 VBoxSFUnmapFolder data;
258
259 VBOX_INIT_CALL(&data.callInfo, UNMAP_FOLDER, pClient);
260
261 data.root.type = VMMDevHGCMParmType_32bit;
262 data.root.u.value32 = pMap->root;
263
264 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
265
266/* Log(("VBOXSF: VBoxSF::vboxCallUnmapFolder: "
267 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
268*/
269 if (RT_SUCCESS (rc))
270 {
271 rc = data.callInfo.result;
272 }
273 return rc;
274}
275
276DECLVBGL(int) vboxCallCreate (PVBSFCLIENT pClient, PVBSFMAP pMap,
277 PSHFLSTRING pParsedPath, PSHFLCREATEPARMS pCreateParms)
278{
279 /** @todo copy buffers to physical or mapped memory. */
280 int rc = VINF_SUCCESS;
281
282 VBoxSFCreate data;
283
284 VBOX_INIT_CALL(&data.callInfo, CREATE, pClient);
285
286 data.root.type = VMMDevHGCMParmType_32bit;
287 data.root.u.value32 = pMap->root;
288
289 data.path.type = VMMDevHGCMParmType_LinAddr;
290 data.path.u.Pointer.size = ShflStringSizeOfBuffer (pParsedPath);
291 data.path.u.Pointer.u.linearAddr = (uintptr_t)pParsedPath;
292
293 data.parms.type = VMMDevHGCMParmType_LinAddr;
294 data.parms.u.Pointer.size = sizeof (SHFLCREATEPARMS);
295 data.parms.u.Pointer.u.linearAddr = (uintptr_t)pCreateParms;
296
297 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
298
299/* Log(("VBOXSF: VBoxSF::vboxCallCreate: "
300 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
301*/
302 if (RT_SUCCESS (rc))
303 {
304 rc = data.callInfo.result;
305 }
306 return rc;
307}
308
309DECLVBGL(int) vboxCallClose (PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE Handle)
310{
311 int rc = VINF_SUCCESS;
312
313 VBoxSFClose data;
314
315 VBOX_INIT_CALL(&data.callInfo, CLOSE, pClient);
316
317 data.root.type = VMMDevHGCMParmType_32bit;
318 data.root.u.value32 = pMap->root;
319
320 data.handle.type = VMMDevHGCMParmType_64bit;
321 data.handle.u.value64 = Handle;
322
323 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
324
325/* Log(("VBOXSF: VBoxSF::vboxCallClose: "
326 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
327*/
328 if (RT_SUCCESS (rc))
329 {
330 rc = data.callInfo.result;
331 }
332
333 return rc;
334}
335
336DECLVBGL(int) vboxCallRemove (PVBSFCLIENT pClient, PVBSFMAP pMap,
337 PSHFLSTRING pParsedPath, uint32_t flags)
338{
339 int rc = VINF_SUCCESS;
340
341 VBoxSFRemove data;
342
343 VBOX_INIT_CALL(&data.callInfo, REMOVE, pClient);
344
345 data.root.type = VMMDevHGCMParmType_32bit;
346 data.root.u.value32 = pMap->root;
347
348 data.path.type = VMMDevHGCMParmType_LinAddr_In;
349 data.path.u.Pointer.size = ShflStringSizeOfBuffer (pParsedPath);
350 data.path.u.Pointer.u.linearAddr = (uintptr_t)pParsedPath;
351
352 data.flags.type = VMMDevHGCMParmType_32bit;
353 data.flags.u.value32 = flags;
354
355 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
356
357/* Log(("VBOXSF: VBoxSF::vboxCallRemove: "
358 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
359*/
360 if (RT_SUCCESS (rc))
361 {
362 rc = data.callInfo.result;
363 }
364
365 return rc;
366}
367
368DECLVBGL(int) vboxCallRename (PVBSFCLIENT pClient, PVBSFMAP pMap,
369 PSHFLSTRING pSrcPath, PSHFLSTRING pDestPath, uint32_t flags)
370{
371 int rc = VINF_SUCCESS;
372
373 VBoxSFRename data;
374
375 VBOX_INIT_CALL(&data.callInfo, RENAME, pClient);
376
377 data.root.type = VMMDevHGCMParmType_32bit;
378 data.root.u.value32 = pMap->root;
379
380 data.src.type = VMMDevHGCMParmType_LinAddr_In;
381 data.src.u.Pointer.size = ShflStringSizeOfBuffer (pSrcPath);
382 data.src.u.Pointer.u.linearAddr = (uintptr_t)pSrcPath;
383
384 data.dest.type = VMMDevHGCMParmType_LinAddr_In;
385 data.dest.u.Pointer.size = ShflStringSizeOfBuffer (pDestPath);
386 data.dest.u.Pointer.u.linearAddr = (uintptr_t)pDestPath;
387
388 data.flags.type = VMMDevHGCMParmType_32bit;
389 data.flags.u.value32 = flags;
390
391 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
392
393/* Log(("VBOXSF: VBoxSF::vboxCallRename: "
394 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
395*/
396 if (RT_SUCCESS (rc))
397 {
398 rc = data.callInfo.result;
399 }
400 return rc;
401}
402
403DECLVBGL(int) vboxCallRead(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
404 uint64_t offset, uint32_t *pcbBuffer, uint8_t *pBuffer, bool fLocked)
405{
406 int rc = VINF_SUCCESS;
407
408 VBoxSFRead data;
409
410 VBOX_INIT_CALL(&data.callInfo, READ, pClient);
411
412 data.root.type = VMMDevHGCMParmType_32bit;
413 data.root.u.value32 = pMap->root;
414
415 data.handle.type = VMMDevHGCMParmType_64bit;
416 data.handle.u.value64 = hFile;
417 data.offset.type = VMMDevHGCMParmType_64bit;
418 data.offset.u.value64 = offset;
419 data.cb.type = VMMDevHGCMParmType_32bit;
420 data.cb.u.value32 = *pcbBuffer;
421 data.buffer.type = (fLocked) ? VMMDevHGCMParmType_LinAddr_Locked_Out : VMMDevHGCMParmType_LinAddr_Out;
422 data.buffer.u.Pointer.size = *pcbBuffer;
423 data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
424
425 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
426
427/* Log(("VBOXSF: VBoxSF::vboxCallRead: "
428 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
429*/
430 if (RT_SUCCESS (rc))
431 {
432 rc = data.callInfo.result;
433 *pcbBuffer = data.cb.u.value32;
434 }
435 return rc;
436}
437
438DECLVBGL(int) vboxCallWrite(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
439 uint64_t offset, uint32_t *pcbBuffer, uint8_t *pBuffer, bool fLocked)
440{
441 int rc = VINF_SUCCESS;
442
443 VBoxSFWrite data;
444
445 VBOX_INIT_CALL(&data.callInfo, WRITE, pClient);
446
447 data.root.type = VMMDevHGCMParmType_32bit;
448 data.root.u.value32 = pMap->root;
449
450 data.handle.type = VMMDevHGCMParmType_64bit;
451 data.handle.u.value64 = hFile;
452 data.offset.type = VMMDevHGCMParmType_64bit;
453 data.offset.u.value64 = offset;
454 data.cb.type = VMMDevHGCMParmType_32bit;
455 data.cb.u.value32 = *pcbBuffer;
456 data.buffer.type = (fLocked) ? VMMDevHGCMParmType_LinAddr_Locked_In : VMMDevHGCMParmType_LinAddr_In;
457 data.buffer.u.Pointer.size = *pcbBuffer;
458 data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
459
460 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
461
462/* Log(("VBOXSF: VBoxSF::vboxCallWrite: "
463 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
464*/
465 if (RT_SUCCESS (rc))
466 {
467 rc = data.callInfo.result;
468 *pcbBuffer = data.cb.u.value32;
469 }
470 return rc;
471}
472
473DECLVBGL(int) VbglR0SfWritePhysCont(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile, uint64_t offset, uint32_t *pcbBuffer, RTCCPHYS PhysBuffer)
474{
475 uint32_t cbToWrite = *pcbBuffer;
476 uint32_t cPages = RT_ALIGN_32((PhysBuffer & PAGE_OFFSET_MASK) + cbToWrite, PAGE_SIZE) >> PAGE_SHIFT;
477 uint32_t cbData = sizeof(VBoxSFWrite) + RT_UOFFSETOF(HGCMPageListInfo, aPages[cPages]);
478 VBoxSFWrite *pData = (VBoxSFWrite *)RTMemTmpAlloc(cbData);
479 HGCMPageListInfo *pPgLst = (HGCMPageListInfo *)(pData + 1);
480 uint32_t iPage;
481 int rc;
482
483 if (RT_UNLIKELY(!pData))
484 return VERR_NO_TMP_MEMORY;
485
486 VBOX_INIT_CALL(&pData->callInfo, WRITE, pClient);
487
488 pData->root.type = VMMDevHGCMParmType_32bit;
489 pData->root.u.value32 = pMap->root;
490
491 pData->handle.type = VMMDevHGCMParmType_64bit;
492 pData->handle.u.value64 = hFile;
493 pData->offset.type = VMMDevHGCMParmType_64bit;
494 pData->offset.u.value64 = offset;
495 pData->cb.type = VMMDevHGCMParmType_32bit;
496 pData->cb.u.value32 = cbToWrite;
497 pData->buffer.type = VMMDevHGCMParmType_PageList;
498 pData->buffer.u.PageList.size = cbToWrite;
499 pData->buffer.u.PageList.offset = sizeof(VBoxSFWrite);
500
501 pPgLst->flags = VBOX_HGCM_F_PARM_DIRECTION_TO_HOST;
502 pPgLst->offFirstPage = PhysBuffer & PAGE_OFFSET_MASK;
503 pPgLst->cPages = cPages;
504 PhysBuffer &= ~(RTCCPHYS)PAGE_OFFSET_MASK;
505 for (iPage = 0; iPage < cPages; iPage++, PhysBuffer += PAGE_SIZE)
506 pPgLst->aPages[iPage] = PhysBuffer;
507
508 rc = VbglHGCMCall (pClient->handle, &pData->callInfo, cbData);
509 if (RT_SUCCESS (rc))
510 {
511 rc = pData->callInfo.result;
512 *pcbBuffer = pData->cb.u.value32;
513 }
514
515 RTMemTmpFree(pData);
516 return rc;
517
518}
519
520DECLVBGL(int) vboxCallFlush(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile)
521{
522 int rc = VINF_SUCCESS;
523
524 VBoxSFFlush data;
525
526 VBOX_INIT_CALL(&data.callInfo, FLUSH, pClient);
527
528 data.root.type = VMMDevHGCMParmType_32bit;
529 data.root.u.value32 = pMap->root;
530
531 data.handle.type = VMMDevHGCMParmType_64bit;
532 data.handle.u.value64 = hFile;
533
534 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
535
536/* Log(("VBOXSF: VBoxSF::vboxCallFlush: "
537 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
538*/
539 if (RT_SUCCESS (rc))
540 {
541 rc = data.callInfo.result;
542 }
543 return rc;
544}
545
546DECLVBGL(int) vboxCallDirInfo (
547 PVBSFCLIENT pClient,
548 PVBSFMAP pMap,
549 SHFLHANDLE hFile,
550 PSHFLSTRING ParsedPath,
551 uint32_t flags,
552 uint32_t index,
553 uint32_t *pcbBuffer,
554 PSHFLDIRINFO pBuffer,
555 uint32_t *pcFiles)
556{
557 int rc = VINF_SUCCESS;
558
559 VBoxSFList data;
560
561 VBOX_INIT_CALL(&data.callInfo, LIST, pClient);
562
563 data.root.type = VMMDevHGCMParmType_32bit;
564 data.root.u.value32 = pMap->root;
565
566 data.handle.type = VMMDevHGCMParmType_64bit;
567 data.handle.u.value64 = hFile;
568 data.flags.type = VMMDevHGCMParmType_32bit;
569 data.flags.u.value32 = flags;
570 data.cb.type = VMMDevHGCMParmType_32bit;
571 data.cb.u.value32 = *pcbBuffer;
572 data.path.type = VMMDevHGCMParmType_LinAddr_In;
573 data.path.u.Pointer.size =
574 (ParsedPath) ? ShflStringSizeOfBuffer(ParsedPath) : 0;
575 data.path.u.Pointer.u.linearAddr = (uintptr_t) ParsedPath;
576
577 data.buffer.type = VMMDevHGCMParmType_LinAddr_Out;
578 data.buffer.u.Pointer.size = *pcbBuffer;
579 data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
580
581 data.resumePoint.type = VMMDevHGCMParmType_32bit;
582 data.resumePoint.u.value32 = index;
583 data.cFiles.type = VMMDevHGCMParmType_32bit;
584 data.cFiles.u.value32 = 0; /* out parameters only */
585
586 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
587
588/* Log(("VBOXSF: VBoxSF::vboxCallDirInfo: "
589 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
590*/
591 if (RT_SUCCESS (rc))
592 {
593 rc = data.callInfo.result;
594 }
595 *pcbBuffer = data.cb.u.value32;
596 *pcFiles = data.cFiles.u.value32;
597 return rc;
598}
599
600DECLVBGL(int) vboxCallFSInfo(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
601 uint32_t flags, uint32_t *pcbBuffer, PSHFLDIRINFO pBuffer)
602{
603 int rc = VINF_SUCCESS;
604
605 VBoxSFInformation data;
606
607 VBOX_INIT_CALL(&data.callInfo, INFORMATION, pClient);
608
609 data.root.type = VMMDevHGCMParmType_32bit;
610 data.root.u.value32 = pMap->root;
611
612 data.handle.type = VMMDevHGCMParmType_64bit;
613 data.handle.u.value64 = hFile;
614 data.flags.type = VMMDevHGCMParmType_32bit;
615 data.flags.u.value32 = flags;
616 data.cb.type = VMMDevHGCMParmType_32bit;
617 data.cb.u.value32 = *pcbBuffer;
618 data.info.type = VMMDevHGCMParmType_LinAddr;
619 data.info.u.Pointer.size = *pcbBuffer;
620 data.info.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
621
622 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
623
624/* Log(("VBOXSF: VBoxSF::vboxCallFileInfo: "
625 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
626*/
627 if (RT_SUCCESS (rc))
628 {
629 rc = data.callInfo.result;
630 *pcbBuffer = data.cb.u.value32;
631 }
632 return rc;
633}
634
635DECLVBGL(int) vboxCallLock(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
636 uint64_t offset, uint64_t cbSize, uint32_t fLock)
637{
638 int rc = VINF_SUCCESS;
639
640 VBoxSFLock data;
641
642 VBOX_INIT_CALL(&data.callInfo, LOCK, pClient);
643
644 data.root.type = VMMDevHGCMParmType_32bit;
645 data.root.u.value32 = pMap->root;
646
647 data.handle.type = VMMDevHGCMParmType_64bit;
648 data.handle.u.value64 = hFile;
649 data.offset.type = VMMDevHGCMParmType_64bit;
650 data.offset.u.value64 = offset;
651 data.length.type = VMMDevHGCMParmType_64bit;
652 data.length.u.value64 = cbSize;
653
654 data.flags.type = VMMDevHGCMParmType_32bit;
655 data.flags.u.value32 = fLock;
656
657 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
658
659/* Log(("VBOXSF: VBoxSF::vboxCallLock: "
660 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
661*/
662 if (RT_SUCCESS (rc))
663 {
664 rc = data.callInfo.result;
665 }
666 return rc;
667}
668
669DECLVBGL(int) vboxCallSetUtf8 (PVBSFCLIENT pClient)
670{
671 int rc = VINF_SUCCESS;
672
673 VBoxGuestHGCMCallInfo callInfo;
674
675 VBOX_INIT_CALL (&callInfo, SET_UTF8, pClient);
676 rc = VbglHGCMCall (pClient->handle, &callInfo, sizeof (callInfo));
677 if (RT_SUCCESS (rc))
678 {
679 rc = callInfo.result;
680 }
681 return rc;
682}
683
684DECLVBGL(int) vboxReadLink (PVBSFCLIENT pClient, PVBSFMAP pMap, PSHFLSTRING pParsedPath,
685 uint32_t cbBuffer, uint8_t *pBuffer)
686{
687 int rc = VINF_SUCCESS;
688
689 VBoxSFReadLink data;
690
691 VBOX_INIT_CALL(&data.callInfo, READLINK, pClient);
692
693 data.root.type = VMMDevHGCMParmType_32bit;
694 data.root.u.value32 = pMap->root;
695
696 data.path.type = VMMDevHGCMParmType_LinAddr_In;
697 data.path.u.Pointer.size = ShflStringSizeOfBuffer (pParsedPath);
698 data.path.u.Pointer.u.linearAddr = (uintptr_t)pParsedPath;
699
700 data.buffer.type = VMMDevHGCMParmType_LinAddr_Out;
701 data.buffer.u.Pointer.size = cbBuffer;
702 data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
703
704 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
705
706/* Log(("VBOXSF: VBoxSF::vboxCallReadline: "
707 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
708*/
709 if (RT_SUCCESS (rc))
710 {
711 rc = data.callInfo.result;
712 }
713 return rc;
714}
715
716DECLVBGL(int) vboxCallSymlink (PVBSFCLIENT pClient, PVBSFMAP pMap, PSHFLSTRING pNewPath, PSHFLSTRING pOldPath,
717 PSHFLFSOBJINFO pBuffer)
718{
719 int rc = VINF_SUCCESS;
720
721 VBoxSFSymlink data;
722
723 VBOX_INIT_CALL(&data.callInfo, SYMLINK, pClient);
724
725 data.root.type = VMMDevHGCMParmType_32bit;
726 data.root.u.value32 = pMap->root;
727
728 data.newPath.type = VMMDevHGCMParmType_LinAddr_In;
729 data.newPath.u.Pointer.size = ShflStringSizeOfBuffer (pNewPath);
730 data.newPath.u.Pointer.u.linearAddr = (uintptr_t)pNewPath;
731
732 data.oldPath.type = VMMDevHGCMParmType_LinAddr_In;
733 data.oldPath.u.Pointer.size = ShflStringSizeOfBuffer (pOldPath);
734 data.oldPath.u.Pointer.u.linearAddr = (uintptr_t)pOldPath;
735
736 data.info.type = VMMDevHGCMParmType_LinAddr_Out;
737 data.info.u.Pointer.size = sizeof(SHFLFSOBJINFO);
738 data.info.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
739
740 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
741
742/* Log(("VBOXSF: VBoxSF::vboxCallSymlink: "
743 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
744*/
745 if (RT_SUCCESS (rc))
746 {
747 rc = data.callInfo.result;
748 }
749 return rc;
750}
751
752DECLVBGL(int) vboxCallSetSymlinks (PVBSFCLIENT pClient)
753{
754 int rc = VINF_SUCCESS;
755
756 VBoxGuestHGCMCallInfo callInfo;
757
758 VBOX_INIT_CALL (&callInfo, SET_SYMLINKS, pClient);
759 rc = VbglHGCMCall (pClient->handle, &callInfo, sizeof (callInfo));
760 if (RT_SUCCESS (rc))
761 {
762 rc = callInfo.result;
763 }
764 return rc;
765}
766
767
768#endif /* !VBGL_VBOXGUEST */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use