VirtualBox

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

Last change on this file since 63206 was 62521, checked in by vboxsync, 8 years ago

(C) 2016
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 28.2 KB
Line 
1/* $Id: VBoxGuestR0LibSharedFolders.c 62521 2016-07-22 19:16:33Z vboxsync $ */
2/** @file
3 * VBoxGuestR0LibSharedFolders - Ring 0 Shared Folders calls.
4 */
5
6/*
7 * Copyright (C) 2006-2016 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
31/*********************************************************************************************************************************
32* Header Files *
33*********************************************************************************************************************************/
34#define LOG_GROUP LOG_GROUP_SHARED_FOLDERS
35#include <VBox/VBoxGuestLibSharedFolders.h>
36#include <VBox/log.h>
37#include <iprt/time.h>
38#include <iprt/mem.h>
39#include <iprt/path.h>
40#include <iprt/string.h>
41
42
43/*********************************************************************************************************************************
44* Defined Constants And Macros *
45*********************************************************************************************************************************/
46#define SHFL_CPARMS_SET_UTF8 0
47#define SHFL_CPARMS_SET_SYMLINKS 0
48
49#define VBOX_INIT_CALL(a, b, c) \
50 LogFunc(("%s, idClient=%d\n", "SHFL_FN_" # b, (c)->idClient)); \
51 (a)->result = VINF_SUCCESS; \
52 (a)->u32ClientID = (c)->idClient; \
53 (a)->u32Function = SHFL_FN_##b; \
54 (a)->cParms = SHFL_CPARMS_##b
55
56
57
58DECLVBGL(int) VbglR0SfInit(void)
59{
60 return VbglInitClient();
61}
62
63DECLVBGL(void) VbglR0SfTerm(void)
64{
65 VbglTerminate();
66}
67
68DECLVBGL(int) VbglR0SfConnect(PVBGLSFCLIENT pClient)
69{
70 int rc;
71 VBoxGuestHGCMConnectInfo data;
72
73 pClient->handle = NULL;
74
75 RT_ZERO(data);
76 data.result = VINF_SUCCESS;
77 data.Loc.type = VMMDevHGCMLoc_LocalHost_Existing;
78 strcpy (data.Loc.u.host.achName, "VBoxSharedFolders");
79
80 rc = VbglHGCMConnect(&pClient->handle, &data);
81/* Log(("VBOXSF: VbglR0SfConnect: VbglHGCMConnect rc = %#x, result = %#x\n", rc, data.result)); */
82 if (RT_SUCCESS(rc))
83 rc = data.result;
84 if (RT_SUCCESS(rc))
85 {
86 pClient->idClient = data.u32ClientID;
87 LogFunc(("idClient=%d\n", pClient->idClient));
88 }
89 return rc;
90}
91
92DECLVBGL(void) VbglR0SfDisconnect(PVBGLSFCLIENT pClient)
93{
94 int rc;
95 VBoxGuestHGCMDisconnectInfo data;
96
97 LogFunc(("u32ClientID=%d\n", pClient->idClient));
98 if (pClient->handle == NULL)
99 return; /* not connected */
100
101 RT_ZERO(data);
102 data.result = VINF_SUCCESS;
103 data.u32ClientID = pClient->idClient;
104
105 rc = VbglHGCMDisconnect(pClient->handle, &data);
106 NOREF(rc);
107/* Log(("VBOXSF: VbglR0SfDisconnect: VbglHGCMDisconnect rc = %#x, result = %#x\n", rc, data.result)); */
108 return;
109}
110
111DECLVBGL(int) VbglR0SfQueryMappings(PVBGLSFCLIENT pClient, SHFLMAPPING paMappings[], uint32_t *pcMappings)
112{
113 int rc;
114 VBoxSFQueryMappings data;
115
116 VBOX_INIT_CALL(&data.callInfo, QUERY_MAPPINGS, pClient);
117
118 data.flags.type = VMMDevHGCMParmType_32bit;
119 data.flags.u.value32 = SHFL_MF_UCS2;
120
121 data.numberOfMappings.type = VMMDevHGCMParmType_32bit;
122 data.numberOfMappings.u.value32 = *pcMappings;
123
124 data.mappings.type = VMMDevHGCMParmType_LinAddr;
125 data.mappings.u.Pointer.size = sizeof(SHFLMAPPING) * *pcMappings;
126 data.mappings.u.Pointer.u.linearAddr = (uintptr_t)&paMappings[0];
127
128/* Log(("VBOXSF: in ifs difference %d\n", (char *)&data.flags.type - (char *)&data.callInfo.cParms)); */
129 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
130/* Log(("VBOXSF: VbglR0SfQueryMappings: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
131 if (RT_SUCCESS(rc))
132 rc = data.callInfo.result;
133 if (RT_SUCCESS(rc))
134 *pcMappings = data.numberOfMappings.u.value32;
135
136 return rc;
137}
138
139DECLVBGL(int) VbglR0SfQueryMapName(PVBGLSFCLIENT pClient, SHFLROOT root, SHFLSTRING *pString, uint32_t size)
140{
141 int rc;
142 VBoxSFQueryMapName data;
143
144 VBOX_INIT_CALL(&data.callInfo, QUERY_MAP_NAME, pClient);
145
146 data.root.type = VMMDevHGCMParmType_32bit;
147 data.root.u.value32 = root;
148
149 data.name.type = VMMDevHGCMParmType_LinAddr;
150 data.name.u.Pointer.size = size;
151 data.name.u.Pointer.u.linearAddr = (uintptr_t)pString;
152
153 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
154/* Log(("VBOXSF: VbglR0SfQueryMapName: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
155 if (RT_SUCCESS(rc))
156 rc = data.callInfo.result;
157
158 return rc;
159}
160
161DECLVBGL(int) VbglR0SfMapFolder(PVBGLSFCLIENT pClient, PSHFLSTRING szFolderName, PVBGLSFMAP pMap)
162{
163 int rc;
164 VBoxSFMapFolder data;
165
166 VBOX_INIT_CALL(&data.callInfo, MAP_FOLDER, pClient);
167
168 data.path.type = VMMDevHGCMParmType_LinAddr;
169 data.path.u.Pointer.size = ShflStringSizeOfBuffer(szFolderName);
170 data.path.u.Pointer.u.linearAddr = (uintptr_t)szFolderName;
171
172 data.root.type = VMMDevHGCMParmType_32bit;
173 data.root.u.value32 = 0;
174
175 data.delimiter.type = VMMDevHGCMParmType_32bit;
176 data.delimiter.u.value32 = RTPATH_DELIMITER;
177
178 data.fCaseSensitive.type = VMMDevHGCMParmType_32bit;
179#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
180 data.fCaseSensitive.u.value32 = 0;
181#else
182 data.fCaseSensitive.u.value32 = 1;
183#endif
184
185 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
186/* Log(("VBOXSF: VbglR0SfMapFolder: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
187 if (RT_SUCCESS(rc))
188 {
189 pMap->root = data.root.u.value32;
190 rc = data.callInfo.result;
191 }
192 else if (rc == VERR_NOT_IMPLEMENTED)
193 {
194 /* try the legacy interface too; temporary to assure backwards compatibility */
195 VBoxSFMapFolder_Old OldData;
196
197 VBOX_INIT_CALL(&OldData.callInfo, MAP_FOLDER_OLD, pClient);
198
199 OldData.path.type = VMMDevHGCMParmType_LinAddr;
200 OldData.path.u.Pointer.size = ShflStringSizeOfBuffer (szFolderName);
201 OldData.path.u.Pointer.u.linearAddr = (uintptr_t)szFolderName;
202
203 OldData.root.type = VMMDevHGCMParmType_32bit;
204 OldData.root.u.value32 = 0;
205
206 OldData.delimiter.type = VMMDevHGCMParmType_32bit;
207 OldData.delimiter.u.value32 = RTPATH_DELIMITER;
208
209 rc = VbglHGCMCall(pClient->handle, &OldData.callInfo, sizeof(OldData));
210 if (RT_SUCCESS(rc))
211 {
212 pMap->root = OldData.root.u.value32;
213 rc = OldData.callInfo.result;
214 }
215 }
216 return rc;
217}
218
219DECLVBGL(int) VbglR0SfUnmapFolder(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap)
220{
221 int rc;
222 VBoxSFUnmapFolder data;
223
224 VBOX_INIT_CALL(&data.callInfo, UNMAP_FOLDER, pClient);
225
226 data.root.type = VMMDevHGCMParmType_32bit;
227 data.root.u.value32 = pMap->root;
228
229 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
230/* Log(("VBOXSF: VbglR0SfUnmapFolder: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
231 if (RT_SUCCESS(rc))
232 rc = data.callInfo.result;
233 return rc;
234}
235
236DECLVBGL(int) VbglR0SfCreate(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, PSHFLSTRING pParsedPath, PSHFLCREATEPARMS pCreateParms)
237{
238 /** @todo copy buffers to physical or mapped memory. */
239 int rc;
240 VBoxSFCreate data;
241
242 VBOX_INIT_CALL(&data.callInfo, CREATE, pClient);
243
244 data.root.type = VMMDevHGCMParmType_32bit;
245 data.root.u.value32 = pMap->root;
246
247 data.path.type = VMMDevHGCMParmType_LinAddr;
248 data.path.u.Pointer.size = ShflStringSizeOfBuffer (pParsedPath);
249 data.path.u.Pointer.u.linearAddr = (uintptr_t)pParsedPath;
250
251 data.parms.type = VMMDevHGCMParmType_LinAddr;
252 data.parms.u.Pointer.size = sizeof(SHFLCREATEPARMS);
253 data.parms.u.Pointer.u.linearAddr = (uintptr_t)pCreateParms;
254
255 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
256/* Log(("VBOXSF: VbglR0SfCreate: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
257 if (RT_SUCCESS(rc))
258 rc = data.callInfo.result;
259 return rc;
260}
261
262DECLVBGL(int) VbglR0SfClose(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE Handle)
263{
264 int rc;
265 VBoxSFClose data;
266
267 VBOX_INIT_CALL(&data.callInfo, CLOSE, pClient);
268
269 data.root.type = VMMDevHGCMParmType_32bit;
270 data.root.u.value32 = pMap->root;
271
272 data.handle.type = VMMDevHGCMParmType_64bit;
273 data.handle.u.value64 = Handle;
274
275 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
276/* Log(("VBOXSF: VbglR0SfClose: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
277 if (RT_SUCCESS(rc))
278 rc = data.callInfo.result;
279 return rc;
280}
281
282DECLVBGL(int) VbglR0SfRemove(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, PSHFLSTRING pParsedPath, uint32_t flags)
283{
284 int rc = VINF_SUCCESS;
285
286 VBoxSFRemove data;
287
288 VBOX_INIT_CALL(&data.callInfo, REMOVE, pClient);
289
290 data.root.type = VMMDevHGCMParmType_32bit;
291 data.root.u.value32 = pMap->root;
292
293 data.path.type = VMMDevHGCMParmType_LinAddr_In;
294 data.path.u.Pointer.size = ShflStringSizeOfBuffer(pParsedPath);
295 data.path.u.Pointer.u.linearAddr = (uintptr_t)pParsedPath;
296
297 data.flags.type = VMMDevHGCMParmType_32bit;
298 data.flags.u.value32 = flags;
299
300 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
301/* Log(("VBOXSF: VbglR0SfRemove: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
302 if (RT_SUCCESS (rc))
303 rc = data.callInfo.result;
304 return rc;
305}
306
307DECLVBGL(int) VbglR0SfRename(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, PSHFLSTRING pSrcPath, PSHFLSTRING pDestPath, uint32_t flags)
308{
309 int rc;
310 VBoxSFRename data;
311
312 VBOX_INIT_CALL(&data.callInfo, RENAME, pClient);
313
314 data.root.type = VMMDevHGCMParmType_32bit;
315 data.root.u.value32 = pMap->root;
316
317 data.src.type = VMMDevHGCMParmType_LinAddr_In;
318 data.src.u.Pointer.size = ShflStringSizeOfBuffer(pSrcPath);
319 data.src.u.Pointer.u.linearAddr = (uintptr_t)pSrcPath;
320
321 data.dest.type = VMMDevHGCMParmType_LinAddr_In;
322 data.dest.u.Pointer.size = ShflStringSizeOfBuffer(pDestPath);
323 data.dest.u.Pointer.u.linearAddr = (uintptr_t)pDestPath;
324
325 data.flags.type = VMMDevHGCMParmType_32bit;
326 data.flags.u.value32 = flags;
327
328 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
329/* Log(("VBOXSF: VbglR0SfRename: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
330 if (RT_SUCCESS (rc))
331 rc = data.callInfo.result;
332 return rc;
333}
334
335DECLVBGL(int) VbglR0SfRead(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile,
336 uint64_t offset, uint32_t *pcbBuffer, uint8_t *pBuffer, bool fLocked)
337{
338 int rc;
339 VBoxSFRead data;
340
341 VBOX_INIT_CALL(&data.callInfo, READ, pClient);
342
343 data.root.type = VMMDevHGCMParmType_32bit;
344 data.root.u.value32 = pMap->root;
345
346 data.handle.type = VMMDevHGCMParmType_64bit;
347 data.handle.u.value64 = hFile;
348 data.offset.type = VMMDevHGCMParmType_64bit;
349 data.offset.u.value64 = offset;
350 data.cb.type = VMMDevHGCMParmType_32bit;
351 data.cb.u.value32 = *pcbBuffer;
352 data.buffer.type = (fLocked) ? VMMDevHGCMParmType_LinAddr_Locked_Out : VMMDevHGCMParmType_LinAddr_Out;
353 data.buffer.u.Pointer.size = *pcbBuffer;
354 data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
355
356 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
357/* Log(("VBOXSF: VbglR0SfRead: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
358 if (RT_SUCCESS(rc))
359 {
360 rc = data.callInfo.result;
361 *pcbBuffer = data.cb.u.value32;
362 }
363 return rc;
364}
365
366DECLVBGL(int) VbglR0SfReadPageList(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile, uint64_t offset, uint32_t *pcbBuffer,
367 uint16_t offFirstPage, uint16_t cPages, RTGCPHYS64 *paPages)
368{
369 uint32_t cbToRead = *pcbBuffer;
370 uint32_t cbData = (uint32_t)(sizeof(VBoxSFRead) + RT_UOFFSETOF(HGCMPageListInfo, aPages[cPages]));
371 VBoxSFRead *pData = (VBoxSFRead *)RTMemTmpAlloc(cbData);
372 HGCMPageListInfo *pPgLst = (HGCMPageListInfo *)(pData + 1);
373 uint16_t iPage;
374 int rc;
375
376 if (RT_UNLIKELY(!pData))
377 return VERR_NO_TMP_MEMORY;
378
379 VBOX_INIT_CALL(&pData->callInfo, READ, pClient);
380
381 pData->root.type = VMMDevHGCMParmType_32bit;
382 pData->root.u.value32 = pMap->root;
383
384 pData->handle.type = VMMDevHGCMParmType_64bit;
385 pData->handle.u.value64 = hFile;
386 pData->offset.type = VMMDevHGCMParmType_64bit;
387 pData->offset.u.value64 = offset;
388 pData->cb.type = VMMDevHGCMParmType_32bit;
389 pData->cb.u.value32 = cbToRead;
390 pData->buffer.type = VMMDevHGCMParmType_PageList;
391 pData->buffer.u.PageList.size = cbToRead;
392 pData->buffer.u.PageList.offset = sizeof(VBoxSFRead);
393
394 pPgLst->flags = VBOX_HGCM_F_PARM_DIRECTION_FROM_HOST;
395 pPgLst->offFirstPage = offFirstPage;
396 pPgLst->cPages = cPages;
397 for (iPage = 0; iPage < cPages; iPage++)
398 pPgLst->aPages[iPage] = paPages[iPage];
399
400 rc = VbglHGCMCall(pClient->handle, &pData->callInfo, cbData);
401/* Log(("VBOXSF: VbglR0SfReadPageList: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
402 if (RT_SUCCESS(rc))
403 {
404 rc = pData->callInfo.result;
405 *pcbBuffer = pData->cb.u.value32;
406 }
407
408 RTMemTmpFree(pData);
409 return rc;
410}
411
412DECLVBGL(int) VbglR0SfWrite(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile,
413 uint64_t offset, uint32_t *pcbBuffer, uint8_t *pBuffer, bool fLocked)
414{
415 int rc;
416 VBoxSFWrite data;
417
418 VBOX_INIT_CALL(&data.callInfo, WRITE, pClient);
419
420 data.root.type = VMMDevHGCMParmType_32bit;
421 data.root.u.value32 = pMap->root;
422
423 data.handle.type = VMMDevHGCMParmType_64bit;
424 data.handle.u.value64 = hFile;
425 data.offset.type = VMMDevHGCMParmType_64bit;
426 data.offset.u.value64 = offset;
427 data.cb.type = VMMDevHGCMParmType_32bit;
428 data.cb.u.value32 = *pcbBuffer;
429 data.buffer.type = fLocked ? VMMDevHGCMParmType_LinAddr_Locked_In : VMMDevHGCMParmType_LinAddr_In;
430 data.buffer.u.Pointer.size = *pcbBuffer;
431 data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
432
433 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
434/* Log(("VBOXSF: VbglR0SfWrite: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
435 if (RT_SUCCESS(rc))
436 {
437 rc = data.callInfo.result;
438 *pcbBuffer = data.cb.u.value32;
439 }
440 return rc;
441}
442
443DECLVBGL(int) VbglR0SfWritePhysCont(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile, uint64_t offset,
444 uint32_t *pcbBuffer, RTCCPHYS PhysBuffer)
445{
446 uint32_t cbToWrite = *pcbBuffer;
447 uint32_t cPages = RT_ALIGN_32((PhysBuffer & PAGE_OFFSET_MASK) + cbToWrite, PAGE_SIZE) >> PAGE_SHIFT;
448 uint32_t cbData = (uint32_t)(sizeof(VBoxSFWrite) + RT_UOFFSETOF(HGCMPageListInfo, aPages[cPages]));
449 VBoxSFWrite *pData = (VBoxSFWrite *)RTMemTmpAlloc(cbData);
450 HGCMPageListInfo *pPgLst = (HGCMPageListInfo *)(pData + 1);
451 uint32_t iPage;
452 int rc;
453
454 if (RT_UNLIKELY(!pData))
455 return VERR_NO_TMP_MEMORY;
456
457 VBOX_INIT_CALL(&pData->callInfo, WRITE, pClient);
458
459 pData->root.type = VMMDevHGCMParmType_32bit;
460 pData->root.u.value32 = pMap->root;
461
462 pData->handle.type = VMMDevHGCMParmType_64bit;
463 pData->handle.u.value64 = hFile;
464 pData->offset.type = VMMDevHGCMParmType_64bit;
465 pData->offset.u.value64 = offset;
466 pData->cb.type = VMMDevHGCMParmType_32bit;
467 pData->cb.u.value32 = cbToWrite;
468 pData->buffer.type = VMMDevHGCMParmType_PageList;
469 pData->buffer.u.PageList.size = cbToWrite;
470 pData->buffer.u.PageList.offset = sizeof(VBoxSFWrite);
471
472 pPgLst->flags = VBOX_HGCM_F_PARM_DIRECTION_TO_HOST;
473 pPgLst->offFirstPage = (uint16_t)(PhysBuffer & PAGE_OFFSET_MASK);
474 pPgLst->cPages = cPages;
475 PhysBuffer &= ~(RTCCPHYS)PAGE_OFFSET_MASK;
476 for (iPage = 0; iPage < cPages; iPage++, PhysBuffer += PAGE_SIZE)
477 pPgLst->aPages[iPage] = PhysBuffer;
478
479 rc = VbglHGCMCall(pClient->handle, &pData->callInfo, cbData);
480/* Log(("VBOXSF: VbglR0SfWritePhysCont: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
481 if (RT_SUCCESS(rc))
482 {
483 rc = pData->callInfo.result;
484 *pcbBuffer = pData->cb.u.value32;
485 }
486
487 RTMemTmpFree(pData);
488 return rc;
489
490}
491
492DECLVBGL(int) VbglR0SfWritePageList(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile, uint64_t offset, uint32_t *pcbBuffer,
493 uint16_t offFirstPage, uint16_t cPages, RTGCPHYS64 *paPages)
494{
495 uint32_t cbToWrite = *pcbBuffer;
496 uint32_t cbData = (uint32_t)(sizeof(VBoxSFWrite) + RT_UOFFSETOF(HGCMPageListInfo, aPages[cPages]));
497 VBoxSFWrite *pData = (VBoxSFWrite *)RTMemTmpAlloc(cbData);
498 HGCMPageListInfo *pPgLst = (HGCMPageListInfo *)(pData + 1);
499 uint16_t iPage;
500 int rc;
501
502 if (RT_UNLIKELY(!pData))
503 return VERR_NO_TMP_MEMORY;
504
505 VBOX_INIT_CALL(&pData->callInfo, WRITE, pClient);
506
507 pData->root.type = VMMDevHGCMParmType_32bit;
508 pData->root.u.value32 = pMap->root;
509
510 pData->handle.type = VMMDevHGCMParmType_64bit;
511 pData->handle.u.value64 = hFile;
512 pData->offset.type = VMMDevHGCMParmType_64bit;
513 pData->offset.u.value64 = offset;
514 pData->cb.type = VMMDevHGCMParmType_32bit;
515 pData->cb.u.value32 = cbToWrite;
516 pData->buffer.type = VMMDevHGCMParmType_PageList;
517 pData->buffer.u.PageList.size = cbToWrite;
518 pData->buffer.u.PageList.offset = sizeof(VBoxSFWrite);
519
520 pPgLst->flags = VBOX_HGCM_F_PARM_DIRECTION_TO_HOST;
521 pPgLst->offFirstPage = offFirstPage;
522 pPgLst->cPages = cPages;
523 for (iPage = 0; iPage < cPages; iPage++)
524 pPgLst->aPages[iPage] = paPages[iPage];
525
526 rc = VbglHGCMCall(pClient->handle, &pData->callInfo, cbData);
527/* Log(("VBOXSF: VbglR0SfWritePageList: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
528 if (RT_SUCCESS(rc))
529 {
530 rc = pData->callInfo.result;
531 *pcbBuffer = pData->cb.u.value32;
532 }
533
534 RTMemTmpFree(pData);
535 return rc;
536}
537
538DECLVBGL(int) VbglR0SfFlush(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile)
539{
540 int rc;
541 VBoxSFFlush data;
542
543 VBOX_INIT_CALL(&data.callInfo, FLUSH, pClient);
544
545 data.root.type = VMMDevHGCMParmType_32bit;
546 data.root.u.value32 = pMap->root;
547
548 data.handle.type = VMMDevHGCMParmType_64bit;
549 data.handle.u.value64 = hFile;
550
551 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
552/* Log(("VBOXSF: VbglR0SfFlush: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
553 if (RT_SUCCESS(rc))
554 rc = data.callInfo.result;
555 return rc;
556}
557
558DECLVBGL(int) VbglR0SfDirInfo(
559 PVBGLSFCLIENT pClient,
560 PVBGLSFMAP pMap,
561 SHFLHANDLE hFile,
562 PSHFLSTRING ParsedPath,
563 uint32_t flags,
564 uint32_t index,
565 uint32_t *pcbBuffer,
566 PSHFLDIRINFO pBuffer,
567 uint32_t *pcFiles)
568{
569 int rc;
570 VBoxSFList data;
571
572 VBOX_INIT_CALL(&data.callInfo, LIST, pClient);
573
574 data.root.type = VMMDevHGCMParmType_32bit;
575 data.root.u.value32 = pMap->root;
576
577 data.handle.type = VMMDevHGCMParmType_64bit;
578 data.handle.u.value64 = hFile;
579 data.flags.type = VMMDevHGCMParmType_32bit;
580 data.flags.u.value32 = flags;
581 data.cb.type = VMMDevHGCMParmType_32bit;
582 data.cb.u.value32 = *pcbBuffer;
583 data.path.type = VMMDevHGCMParmType_LinAddr_In;
584 data.path.u.Pointer.size = ParsedPath ? ShflStringSizeOfBuffer(ParsedPath) : 0;
585 data.path.u.Pointer.u.linearAddr = (uintptr_t) ParsedPath;
586
587 data.buffer.type = VMMDevHGCMParmType_LinAddr_Out;
588 data.buffer.u.Pointer.size = *pcbBuffer;
589 data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
590
591 data.resumePoint.type = VMMDevHGCMParmType_32bit;
592 data.resumePoint.u.value32 = index;
593 data.cFiles.type = VMMDevHGCMParmType_32bit;
594 data.cFiles.u.value32 = 0; /* out parameters only */
595
596 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
597/* Log(("VBOXSF: VbglR0SfDirInfo: rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
598 if (RT_SUCCESS(rc))
599 rc = data.callInfo.result;
600 *pcbBuffer = data.cb.u.value32;
601 *pcFiles = data.cFiles.u.value32;
602 return rc;
603}
604
605DECLVBGL(int) VbglR0SfFsInfo(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile,
606 uint32_t flags, uint32_t *pcbBuffer, PSHFLDIRINFO pBuffer)
607{
608 int rc;
609 VBoxSFInformation data;
610
611 VBOX_INIT_CALL(&data.callInfo, INFORMATION, pClient);
612
613 data.root.type = VMMDevHGCMParmType_32bit;
614 data.root.u.value32 = pMap->root;
615
616 data.handle.type = VMMDevHGCMParmType_64bit;
617 data.handle.u.value64 = hFile;
618 data.flags.type = VMMDevHGCMParmType_32bit;
619 data.flags.u.value32 = flags;
620 data.cb.type = VMMDevHGCMParmType_32bit;
621 data.cb.u.value32 = *pcbBuffer;
622 data.info.type = VMMDevHGCMParmType_LinAddr;
623 data.info.u.Pointer.size = *pcbBuffer;
624 data.info.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
625
626 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
627/* Log(("VBOXSF: VbglR0SfFsInfo: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
628 if (RT_SUCCESS(rc))
629 {
630 rc = data.callInfo.result;
631 *pcbBuffer = data.cb.u.value32;
632 }
633 return rc;
634}
635
636DECLVBGL(int) VbglR0SfLock(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile,
637 uint64_t offset, uint64_t cbSize, uint32_t fLock)
638{
639 int rc;
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/* Log(("VBOXSF: VbglR0SfLock: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
659 if (RT_SUCCESS (rc))
660 rc = data.callInfo.result;
661 return rc;
662}
663
664DECLVBGL(int) VbglR0SfSetUtf8(PVBGLSFCLIENT pClient)
665{
666 int rc;
667 VBoxGuestHGCMCallInfo callInfo;
668
669 VBOX_INIT_CALL(&callInfo, SET_UTF8, pClient);
670 rc = VbglHGCMCall(pClient->handle, &callInfo, sizeof(callInfo));
671/* Log(("VBOXSF: VbglR0SfSetUtf8: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
672 if (RT_SUCCESS(rc))
673 rc = callInfo.result;
674 return rc;
675}
676
677DECLVBGL(int) VbglR0SfReadLink(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, PSHFLSTRING pParsedPath, uint32_t cbBuffer, uint8_t *pBuffer)
678{
679 int rc;
680 VBoxSFReadLink data;
681
682 VBOX_INIT_CALL(&data.callInfo, READLINK, pClient);
683
684 data.root.type = VMMDevHGCMParmType_32bit;
685 data.root.u.value32 = pMap->root;
686
687 data.path.type = VMMDevHGCMParmType_LinAddr_In;
688 data.path.u.Pointer.size = ShflStringSizeOfBuffer (pParsedPath);
689 data.path.u.Pointer.u.linearAddr = (uintptr_t)pParsedPath;
690
691 data.buffer.type = VMMDevHGCMParmType_LinAddr_Out;
692 data.buffer.u.Pointer.size = cbBuffer;
693 data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
694
695 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
696/* Log(("VBOXSF: VbglR0SfReadLink: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
697 if (RT_SUCCESS (rc))
698 rc = data.callInfo.result;
699 return rc;
700}
701
702DECLVBGL(int) VbglR0SfSymlink(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, PSHFLSTRING pNewPath, PSHFLSTRING pOldPath,
703 PSHFLFSOBJINFO pBuffer)
704{
705 int rc;
706 VBoxSFSymlink data;
707
708 VBOX_INIT_CALL(&data.callInfo, SYMLINK, pClient);
709
710 data.root.type = VMMDevHGCMParmType_32bit;
711 data.root.u.value32 = pMap->root;
712
713 data.newPath.type = VMMDevHGCMParmType_LinAddr_In;
714 data.newPath.u.Pointer.size = ShflStringSizeOfBuffer (pNewPath);
715 data.newPath.u.Pointer.u.linearAddr = (uintptr_t)pNewPath;
716
717 data.oldPath.type = VMMDevHGCMParmType_LinAddr_In;
718 data.oldPath.u.Pointer.size = ShflStringSizeOfBuffer (pOldPath);
719 data.oldPath.u.Pointer.u.linearAddr = (uintptr_t)pOldPath;
720
721 data.info.type = VMMDevHGCMParmType_LinAddr_Out;
722 data.info.u.Pointer.size = sizeof(SHFLFSOBJINFO);
723 data.info.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
724
725 rc = VbglHGCMCall(pClient->handle, &data.callInfo, sizeof(data));
726/* Log(("VBOXSF: VbglR0SfSymlink: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
727 if (RT_SUCCESS (rc))
728 rc = data.callInfo.result;
729 return rc;
730}
731
732DECLVBGL(int) VbglR0SfSetSymlinks(PVBGLSFCLIENT pClient)
733{
734 int rc;
735 VBoxGuestHGCMCallInfo callInfo;
736
737 VBOX_INIT_CALL(&callInfo, SET_SYMLINKS, pClient);
738 rc = VbglHGCMCall(pClient->handle, &callInfo, sizeof(callInfo));
739/* Log(("VBOXSF: VbglR0SfSetSymlinks: VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result)); */
740 if (RT_SUCCESS(rc))
741 rc = callInfo.result;
742 return rc;
743}
744
745
746#endif /* !VBGL_VBOXGUEST */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use