VBoxCalls.c@ 26131

Last change on this file since 26131 was 25528, checked in by vboxsync, 15 years ago
IPRT,SUPDrv,++: AssertMsg[12] -> AssertMsg1Weak, AssertMsg1, AssertMsg2Weak, AssertMsg2, AssertMsg2WeakV and AssertMsg2V. Doing more of the assertion machinery in common/misc/assert.cpp to avoid code duplication (ring-0). Major SUPDrv version bump.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.2 KB

Line
1	/* $Revision: 25528 $ */
2	/** @file
3	* VBoxGuestLibR0 - Central calls.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22	/* Entire file is ifdef'ed with !VBGL_VBOXGUEST */
23	#ifndef VBGL_VBOXGUEST
24
25	#ifdef RT_OS_LINUX
26	# include "VBoxCalls.h"
27	# define DbgPrint RTAssertMsg2Weak
28	#else
29	# include "VBoxCalls.h"
30	#endif
31	#include <iprt/time.h>
32	#include <iprt/mem.h>
33	#include <iprt/path.h>
34	#include <iprt/string.h>
35
36	#define SHFL_CPARMS_SET_UTF8 0
37
38	#define VBOX_INIT_CALL(a, b, c) \
39	(a)->result = VINF_SUCCESS; \
40	(a)->u32ClientID = (c)->ulClientID; \
41	(a)->u32Function = SHFL_FN_##b; \
42	(a)->cParms = SHFL_CPARMS_##b
43
44	#ifndef RT_OS_WINDOWS
45	# define RtlZeroMemory(a, b) memset (a, 0, b)
46	#endif
47
48
49	DECLVBGL(int) vboxInit (void)
50	{
51	int rc = VINF_SUCCESS;
52
53	rc = VbglInit ();
54	return rc;
55	}
56
57	DECLVBGL(void) vboxUninit (void)
58	{
59	VbglTerminate ();
60	}
61
62	DECLVBGL(int) vboxConnect (PVBSFCLIENT pClient)
63	{
64	int rc = VINF_SUCCESS;
65
66	VBoxGuestHGCMConnectInfo data;
67
68	RtlZeroMemory (&data, sizeof (VBoxGuestHGCMConnectInfo));
69
70	pClient->handle = NULL;
71
72	data.result = VINF_SUCCESS;
73	data.Loc.type = VMMDevHGCMLoc_LocalHost_Existing;
74	strcpy (data.Loc.u.host.achName, "VBoxSharedFolders");
75
76	rc = VbglHGCMConnect (&pClient->handle, &data);
77
78	/* Log(("VBOXSF: VBoxSF::vboxConnect: VbglHGCMConnect rc = %#x, result = %#x\n",
79	rc, data.result));
80	*/
81	if (RT_SUCCESS (rc))
82	{
83	rc = data.result;
84	}
85
86	if (RT_SUCCESS (rc))
87	{
88	pClient->ulClientID = data.u32ClientID;
89	}
90	return rc;
91	}
92
93	DECLVBGL(void) vboxDisconnect (PVBSFCLIENT pClient)
94	{
95	int rc;
96
97	VBoxGuestHGCMDisconnectInfo data;
98
99	if (pClient->handle == NULL)
100	return; /* not connected */
101
102	RtlZeroMemory (&data, sizeof (VBoxGuestHGCMDisconnectInfo));
103
104	data.result = VINF_SUCCESS;
105	data.u32ClientID = pClient->ulClientID;
106
107	rc = VbglHGCMDisconnect (pClient->handle, &data);
108	/* Log(("VBOXSF: VBoxSF::vboxDisconnect: "
109	"VbglHGCMDisconnect rc = %#x, result = %#x\n", rc, data.result));
110	*/
111	return;
112	}
113
114	DECLVBGL(int) vboxCallQueryMappings (PVBSFCLIENT pClient, SHFLMAPPING paMappings[],
115	uint32_t *pcMappings)
116	{
117	int rc = VINF_SUCCESS;
118
119	VBoxSFQueryMappings data;
120
121	VBOX_INIT_CALL(&data.callInfo, QUERY_MAPPINGS, pClient);
122
123	data.flags.type = VMMDevHGCMParmType_32bit;
124	data.flags.u.value32 = SHFL_MF_UCS2;
125
126	data.numberOfMappings.type = VMMDevHGCMParmType_32bit;
127	data.numberOfMappings.u.value32 = *pcMappings;
128
129	data.mappings.type = VMMDevHGCMParmType_LinAddr;
130	data.mappings.u.Pointer.size = sizeof (SHFLMAPPING) * *pcMappings;
131	data.mappings.u.Pointer.u.linearAddr = (uintptr_t)&paMappings[0];
132
133	/* Log(("VBOXSF: in ifs difference %d\n",
134	(char )&data.flags.type - (char )&data.callInfo.cParms));
135	*/
136	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
137
138	/*
139	Log(("VBOXSF: VBoxSF::vboxCallQueryMappings: "
140	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
141	*/
142	if (RT_SUCCESS (rc))
143	{
144	rc = data.callInfo.result;
145	}
146
147	if (RT_SUCCESS (rc))
148	{
149	*pcMappings = data.numberOfMappings.u.value32;
150	}
151
152	return rc;
153	}
154
155	DECLVBGL(int) vboxCallQueryMapName (PVBSFCLIENT pClient, SHFLROOT root, SHFLSTRING *pString, uint32_t size)
156	{
157	int rc = VINF_SUCCESS;
158
159	VBoxSFQueryMapName data;
160
161	VBOX_INIT_CALL(&data.callInfo, QUERY_MAP_NAME, pClient);
162
163	data.root.type = VMMDevHGCMParmType_32bit;
164	data.root.u.value32 = root;
165
166	data.name.type = VMMDevHGCMParmType_LinAddr;
167	data.name.u.Pointer.size = size;
168	data.name.u.Pointer.u.linearAddr = (uintptr_t)pString;
169
170	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
171
172	/* Log(("VBOXSF: VBoxSF::vboxCallQueryMapName: "
173	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
174	*/
175	if (RT_SUCCESS (rc))
176	{
177	rc = data.callInfo.result;
178	}
179
180	return rc;
181	}
182
183	DECLVBGL(int) vboxCallMapFolder(PVBSFCLIENT pClient, PSHFLSTRING szFolderName,
184	PVBSFMAP pMap)
185	{
186	int rc = VINF_SUCCESS;
187
188	VBoxSFMapFolder data;
189
190	VBOX_INIT_CALL(&data.callInfo, MAP_FOLDER, pClient);
191
192	data.path.type = VMMDevHGCMParmType_LinAddr;
193	data.path.u.Pointer.size = ShflStringSizeOfBuffer (szFolderName);
194	data.path.u.Pointer.u.linearAddr = (uintptr_t)szFolderName;
195
196	data.root.type = VMMDevHGCMParmType_32bit;
197	data.root.u.value32 = 0;
198
199	data.delimiter.type = VMMDevHGCMParmType_32bit;
200	data.delimiter.u.value32 = RTPATH_DELIMITER;
201
202	data.fCaseSensitive.type = VMMDevHGCMParmType_32bit;
203	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
204	data.fCaseSensitive.u.value32 = 0;
205	#else
206	data.fCaseSensitive.u.value32 = 1;
207	#endif
208
209	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
210
211	/* Log(("VBOXSF: VBoxSF::vboxCallMapFolder: "
212	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
213	*/
214	if (RT_SUCCESS (rc))
215	{
216	pMap->root = data.root.u.value32;
217	rc = data.callInfo.result;
218	}
219	else
220	if (rc == VERR_NOT_IMPLEMENTED)
221	{
222	/* try the legacy interface too; temporary to assure backwards compatibility */
223	VBoxSFMapFolder_Old data;
224
225	VBOX_INIT_CALL(&data.callInfo, MAP_FOLDER_OLD, pClient);
226
227	data.path.type = VMMDevHGCMParmType_LinAddr;
228	data.path.u.Pointer.size = ShflStringSizeOfBuffer (szFolderName);
229	data.path.u.Pointer.u.linearAddr = (uintptr_t)szFolderName;
230
231	data.root.type = VMMDevHGCMParmType_32bit;
232	data.root.u.value32 = 0;
233
234	data.delimiter.type = VMMDevHGCMParmType_32bit;
235	data.delimiter.u.value32 = RTPATH_DELIMITER;
236
237	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
238
239	if (RT_SUCCESS (rc))
240	{
241	pMap->root = data.root.u.value32;
242	rc = data.callInfo.result;
243	}
244	}
245	return rc;
246	}
247
248	DECLVBGL(int) vboxCallUnmapFolder(PVBSFCLIENT pClient, PVBSFMAP pMap)
249	{
250	int rc = VINF_SUCCESS;
251
252	VBoxSFUnmapFolder data;
253
254	VBOX_INIT_CALL(&data.callInfo, UNMAP_FOLDER, pClient);
255
256	data.root.type = VMMDevHGCMParmType_32bit;
257	data.root.u.value32 = pMap->root;
258
259	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
260
261	/* Log(("VBOXSF: VBoxSF::vboxCallUnmapFolder: "
262	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
263	*/
264	if (RT_SUCCESS (rc))
265	{
266	rc = data.callInfo.result;
267	}
268	return rc;
269	}
270
271	DECLVBGL(int) vboxCallCreate (PVBSFCLIENT pClient, PVBSFMAP pMap,
272	PSHFLSTRING pParsedPath, PSHFLCREATEPARMS pCreateParms)
273	{
274	/** @todo copy buffers to physical or mapped memory. */
275	int rc = VINF_SUCCESS;
276
277	VBoxSFCreate data;
278
279	VBOX_INIT_CALL(&data.callInfo, CREATE, pClient);
280
281	data.root.type = VMMDevHGCMParmType_32bit;
282	data.root.u.value32 = pMap->root;
283
284	data.path.type = VMMDevHGCMParmType_LinAddr;
285	data.path.u.Pointer.size = ShflStringSizeOfBuffer (pParsedPath);
286	data.path.u.Pointer.u.linearAddr = (uintptr_t)pParsedPath;
287
288	data.parms.type = VMMDevHGCMParmType_LinAddr;
289	data.parms.u.Pointer.size = sizeof (SHFLCREATEPARMS);
290	data.parms.u.Pointer.u.linearAddr = (uintptr_t)pCreateParms;
291
292	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
293
294	/* Log(("VBOXSF: VBoxSF::vboxCallCreate: "
295	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
296	*/
297	if (RT_SUCCESS (rc))
298	{
299	rc = data.callInfo.result;
300	}
301	return rc;
302	}
303
304	DECLVBGL(int) vboxCallClose (PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE Handle)
305	{
306	int rc = VINF_SUCCESS;
307
308	VBoxSFClose data;
309
310	VBOX_INIT_CALL(&data.callInfo, CLOSE, pClient);
311
312	data.root.type = VMMDevHGCMParmType_32bit;
313	data.root.u.value32 = pMap->root;
314
315	data.handle.type = VMMDevHGCMParmType_64bit;
316	data.handle.u.value64 = Handle;
317
318	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
319
320	/* Log(("VBOXSF: VBoxSF::vboxCallClose: "
321	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
322	*/
323	if (RT_SUCCESS (rc))
324	{
325	rc = data.callInfo.result;
326	}
327
328	return rc;
329	}
330
331	DECLVBGL(int) vboxCallRemove (PVBSFCLIENT pClient, PVBSFMAP pMap,
332	PSHFLSTRING pParsedPath, uint32_t flags)
333	{
334	int rc = VINF_SUCCESS;
335
336	VBoxSFRemove data;
337
338	VBOX_INIT_CALL(&data.callInfo, REMOVE, pClient);
339
340	data.root.type = VMMDevHGCMParmType_32bit;
341	data.root.u.value32 = pMap->root;
342
343	data.path.type = VMMDevHGCMParmType_LinAddr_In;
344	data.path.u.Pointer.size = ShflStringSizeOfBuffer (pParsedPath);
345	data.path.u.Pointer.u.linearAddr = (uintptr_t)pParsedPath;
346
347	data.flags.type = VMMDevHGCMParmType_32bit;
348	data.flags.u.value32 = flags;
349
350	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
351
352	/* Log(("VBOXSF: VBoxSF::vboxCallRemove: "
353	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
354	*/
355	if (RT_SUCCESS (rc))
356	{
357	rc = data.callInfo.result;
358	}
359
360	return rc;
361	}
362
363	DECLVBGL(int) vboxCallRename (PVBSFCLIENT pClient, PVBSFMAP pMap,
364	PSHFLSTRING pSrcPath, PSHFLSTRING pDestPath, uint32_t flags)
365	{
366	int rc = VINF_SUCCESS;
367
368	VBoxSFRename data;
369
370	VBOX_INIT_CALL(&data.callInfo, RENAME, pClient);
371
372	data.root.type = VMMDevHGCMParmType_32bit;
373	data.root.u.value32 = pMap->root;
374
375	data.src.type = VMMDevHGCMParmType_LinAddr_In;
376	data.src.u.Pointer.size = ShflStringSizeOfBuffer (pSrcPath);
377	data.src.u.Pointer.u.linearAddr = (uintptr_t)pSrcPath;
378
379	data.dest.type = VMMDevHGCMParmType_LinAddr_In;
380	data.dest.u.Pointer.size = ShflStringSizeOfBuffer (pDestPath);
381	data.dest.u.Pointer.u.linearAddr = (uintptr_t)pDestPath;
382
383	data.flags.type = VMMDevHGCMParmType_32bit;
384	data.flags.u.value32 = flags;
385
386	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
387
388	/* Log(("VBOXSF: VBoxSF::vboxCallRename: "
389	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
390	*/
391	if (RT_SUCCESS (rc))
392	{
393	rc = data.callInfo.result;
394	}
395	return rc;
396	}
397
398	DECLVBGL(int) vboxCallRead(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
399	uint64_t offset, uint32_t pcbBuffer, uint8_t pBuffer, bool fLocked)
400	{
401	int rc = VINF_SUCCESS;
402
403	VBoxSFRead data;
404
405	VBOX_INIT_CALL(&data.callInfo, READ, pClient);
406
407	data.root.type = VMMDevHGCMParmType_32bit;
408	data.root.u.value32 = pMap->root;
409
410	data.handle.type = VMMDevHGCMParmType_64bit;
411	data.handle.u.value64 = hFile;
412	data.offset.type = VMMDevHGCMParmType_64bit;
413	data.offset.u.value64 = offset;
414	data.cb.type = VMMDevHGCMParmType_32bit;
415	data.cb.u.value32 = *pcbBuffer;
416	data.buffer.type = (fLocked) ? VMMDevHGCMParmType_LinAddr_Locked_Out : VMMDevHGCMParmType_LinAddr_Out;
417	data.buffer.u.Pointer.size = *pcbBuffer;
418	data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
419
420	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
421
422	/* Log(("VBOXSF: VBoxSF::vboxCallRead: "
423	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
424	*/
425	if (RT_SUCCESS (rc))
426	{
427	rc = data.callInfo.result;
428	*pcbBuffer = data.cb.u.value32;
429	}
430	return rc;
431	}
432
433	DECLVBGL(int) vboxCallWrite(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
434	uint64_t offset, uint32_t pcbBuffer, uint8_t pBuffer, bool fLocked)
435	{
436	int rc = VINF_SUCCESS;
437
438	VBoxSFWrite data;
439
440	VBOX_INIT_CALL(&data.callInfo, WRITE, pClient);
441
442	data.root.type = VMMDevHGCMParmType_32bit;
443	data.root.u.value32 = pMap->root;
444
445	data.handle.type = VMMDevHGCMParmType_64bit;
446	data.handle.u.value64 = hFile;
447	data.offset.type = VMMDevHGCMParmType_64bit;
448	data.offset.u.value64 = offset;
449	data.cb.type = VMMDevHGCMParmType_32bit;
450	data.cb.u.value32 = *pcbBuffer;
451	data.buffer.type = (fLocked) ? VMMDevHGCMParmType_LinAddr_Locked_In : VMMDevHGCMParmType_LinAddr_In;
452	data.buffer.u.Pointer.size = *pcbBuffer;
453	data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
454
455	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
456
457	/* Log(("VBOXSF: VBoxSF::vboxCallWrite: "
458	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
459	*/
460	if (RT_SUCCESS (rc))
461	{
462	rc = data.callInfo.result;
463	*pcbBuffer = data.cb.u.value32;
464	}
465	return rc;
466	}
467
468	DECLVBGL(int) VbglR0SfWritePhysCont(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile, uint64_t offset, uint32_t *pcbBuffer, RTCCPHYS PhysBuffer)
469	{
470	uint32_t cbToWrite = *pcbBuffer;
471	uint32_t cPages = RT_ALIGN_32((PhysBuffer & PAGE_OFFSET_MASK) + cbToWrite, PAGE_SIZE) >> PAGE_SHIFT;
472	uint32_t cbData = sizeof(VBoxSFWrite) + RT_UOFFSETOF(HGCMPageListInfo, aPages[cPages]);
473	VBoxSFWrite pData = (VBoxSFWrite )RTMemTmpAlloc(cbData);
474	HGCMPageListInfo pPgLst = (HGCMPageListInfo )(pData + 1);
475	uint32_t iPage;
476	int rc;
477
478	if (RT_UNLIKELY(!pData))
479	return VERR_NO_TMP_MEMORY;
480
481	VBOX_INIT_CALL(&pData->callInfo, WRITE, pClient);
482
483	pData->root.type = VMMDevHGCMParmType_32bit;
484	pData->root.u.value32 = pMap->root;
485
486	pData->handle.type = VMMDevHGCMParmType_64bit;
487	pData->handle.u.value64 = hFile;
488	pData->offset.type = VMMDevHGCMParmType_64bit;
489	pData->offset.u.value64 = offset;
490	pData->cb.type = VMMDevHGCMParmType_32bit;
491	pData->cb.u.value32 = cbToWrite;
492	pData->buffer.type = VMMDevHGCMParmType_PageList;
493	pData->buffer.u.PageList.size = cbToWrite;
494	pData->buffer.u.PageList.offset = sizeof(VBoxSFWrite);
495
496	pPgLst->flags = VBOX_HGCM_F_PARM_DIRECTION_TO_HOST;
497	pPgLst->offFirstPage = PhysBuffer & PAGE_OFFSET_MASK;
498	pPgLst->cPages = cPages;
499	PhysBuffer &= ~(RTCCPHYS)PAGE_OFFSET_MASK;
500	for (iPage = 0; iPage < cPages; iPage++, PhysBuffer += PAGE_SIZE)
501	pPgLst->aPages[iPage] = PhysBuffer;
502
503	rc = VbglHGCMCall (pClient->handle, &pData->callInfo, cbData);
504	if (RT_SUCCESS (rc))
505	{
506	rc = pData->callInfo.result;
507	*pcbBuffer = pData->cb.u.value32;
508	}
509
510	RTMemTmpFree(pData);
511	return rc;
512
513	}
514
515	DECLVBGL(int) vboxCallFlush(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile)
516	{
517	int rc = VINF_SUCCESS;
518
519	VBoxSFFlush data;
520
521	VBOX_INIT_CALL(&data.callInfo, FLUSH, pClient);
522
523	data.root.type = VMMDevHGCMParmType_32bit;
524	data.root.u.value32 = pMap->root;
525
526	data.handle.type = VMMDevHGCMParmType_64bit;
527	data.handle.u.value64 = hFile;
528
529	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
530
531	/* Log(("VBOXSF: VBoxSF::vboxCallFlush: "
532	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
533	*/
534	if (RT_SUCCESS (rc))
535	{
536	rc = data.callInfo.result;
537	}
538	return rc;
539	}
540
541	DECLVBGL(int) vboxCallDirInfo (
542	PVBSFCLIENT pClient,
543	PVBSFMAP pMap,
544	SHFLHANDLE hFile,
545	PSHFLSTRING ParsedPath,
546	uint32_t flags,
547	uint32_t index,
548	uint32_t *pcbBuffer,
549	PSHFLDIRINFO pBuffer,
550	uint32_t *pcFiles)
551	{
552	int rc = VINF_SUCCESS;
553
554	VBoxSFList data;
555
556	VBOX_INIT_CALL(&data.callInfo, LIST, pClient);
557
558	data.root.type = VMMDevHGCMParmType_32bit;
559	data.root.u.value32 = pMap->root;
560
561	data.handle.type = VMMDevHGCMParmType_64bit;
562	data.handle.u.value64 = hFile;
563	data.flags.type = VMMDevHGCMParmType_32bit;
564	data.flags.u.value32 = flags;
565	data.cb.type = VMMDevHGCMParmType_32bit;
566	data.cb.u.value32 = *pcbBuffer;
567	data.path.type = VMMDevHGCMParmType_LinAddr_In;
568	data.path.u.Pointer.size =
569	(ParsedPath) ? ShflStringSizeOfBuffer(ParsedPath) : 0;
570	data.path.u.Pointer.u.linearAddr = (uintptr_t) ParsedPath;
571
572	data.buffer.type = VMMDevHGCMParmType_LinAddr_Out;
573	data.buffer.u.Pointer.size = *pcbBuffer;
574	data.buffer.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
575
576	data.resumePoint.type = VMMDevHGCMParmType_32bit;
577	data.resumePoint.u.value32 = index;
578	data.cFiles.type = VMMDevHGCMParmType_32bit;
579	data.cFiles.u.value32 = 0; /* out parameters only */
580
581	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
582
583	/* Log(("VBOXSF: VBoxSF::vboxCallDirInfo: "
584	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
585	*/
586	if (RT_SUCCESS (rc))
587	{
588	rc = data.callInfo.result;
589	}
590	*pcbBuffer = data.cb.u.value32;
591	*pcFiles = data.cFiles.u.value32;
592	return rc;
593	}
594
595	DECLVBGL(int) vboxCallFSInfo(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
596	uint32_t flags, uint32_t *pcbBuffer, PSHFLDIRINFO pBuffer)
597	{
598	int rc = VINF_SUCCESS;
599
600	VBoxSFInformation data;
601
602	VBOX_INIT_CALL(&data.callInfo, INFORMATION, pClient);
603
604	data.root.type = VMMDevHGCMParmType_32bit;
605	data.root.u.value32 = pMap->root;
606
607	data.handle.type = VMMDevHGCMParmType_64bit;
608	data.handle.u.value64 = hFile;
609	data.flags.type = VMMDevHGCMParmType_32bit;
610	data.flags.u.value32 = flags;
611	data.cb.type = VMMDevHGCMParmType_32bit;
612	data.cb.u.value32 = *pcbBuffer;
613	data.info.type = VMMDevHGCMParmType_LinAddr;
614	data.info.u.Pointer.size = *pcbBuffer;
615	data.info.u.Pointer.u.linearAddr = (uintptr_t)pBuffer;
616
617	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
618
619	/* Log(("VBOXSF: VBoxSF::vboxCallFileInfo: "
620	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
621	*/
622	if (RT_SUCCESS (rc))
623	{
624	rc = data.callInfo.result;
625	*pcbBuffer = data.cb.u.value32;
626	}
627	return rc;
628	}
629
630	DECLVBGL(int) vboxCallLock(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
631	uint64_t offset, uint64_t cbSize, uint32_t fLock)
632	{
633	int rc = VINF_SUCCESS;
634
635	VBoxSFLock data;
636
637	VBOX_INIT_CALL(&data.callInfo, LOCK, pClient);
638
639	data.root.type = VMMDevHGCMParmType_32bit;
640	data.root.u.value32 = pMap->root;
641
642	data.handle.type = VMMDevHGCMParmType_64bit;
643	data.handle.u.value64 = hFile;
644	data.offset.type = VMMDevHGCMParmType_64bit;
645	data.offset.u.value64 = offset;
646	data.length.type = VMMDevHGCMParmType_64bit;
647	data.length.u.value64 = cbSize;
648
649	data.flags.type = VMMDevHGCMParmType_32bit;
650	data.flags.u.value32 = fLock;
651
652	rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
653
654	/* Log(("VBOXSF: VBoxSF::vboxCallLock: "
655	"VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
656	*/
657	if (RT_SUCCESS (rc))
658	{
659	rc = data.callInfo.result;
660	}
661	return rc;
662	}
663
664	DECLVBGL(int) vboxCallSetUtf8 (PVBSFCLIENT pClient)
665	{
666	int rc = VINF_SUCCESS;
667
668	VBoxGuestHGCMCallInfo callInfo;
669
670	VBOX_INIT_CALL (&callInfo, SET_UTF8, pClient);
671	rc = VbglHGCMCall (pClient->handle, &callInfo, sizeof (callInfo));
672	if (RT_SUCCESS (rc))
673	{
674	rc = callInfo.result;
675	}
676	return rc;
677	}
678
679	#endif /* !VBGL_VBOXGUEST */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxCalls.c@ 26131

Download in other formats: