VirtualBox

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

Last change on this file since 3192 was 3192, checked in by vboxsync, 18 years ago

Make it build on OS/2.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.2 KB
Line 
1/** @file
2 *
3 * VBoxGuestLib - A support library for VirtualBox guest additions:
4 * Central calls
5 */
6
7/*
8 * Copyright (C) 2006-2007 innotek GmbH
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License as published by the Free Software Foundation,
14 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
15 * distribution. VirtualBox OSE is distributed in the hope that it will
16 * be useful, but WITHOUT ANY WARRANTY of any kind.
17 *
18 * If you received this file as part of a commercial VirtualBox
19 * distribution, then only the terms of your commercial VirtualBox
20 * license agreement apply instead of the previous paragraph.
21 */
22
23/* Entire file is ifdef'ed with !VBGL_VBOXGUEST */
24#ifndef VBGL_VBOXGUEST
25
26#ifdef __linux__ /** @todo r=bird: Why isn't this __LINUX__ like everywhere else? */
27# include "VBoxCalls.h"
28# define DbgPrint AssertMsg2
29#else
30# include "VBoxCalls.h"
31#endif
32#include <iprt/time.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 __WIN__
45# define RtlZeroMemory(a, b) memset (a, 0, b)
46#endif
47
48
49DECLVBGL(int) vboxInit (void)
50{
51 int rc = VINF_SUCCESS;
52
53 rc = VbglInit ();
54 return rc;
55}
56
57DECLVBGL(void) vboxUninit (void)
58{
59 VbglTerminate ();
60}
61
62DECLVBGL(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 (VBOX_SUCCESS (rc))
82 {
83 rc = data.result;
84 }
85
86 if (VBOX_SUCCESS (rc))
87 {
88 pClient->ulClientID = data.u32ClientID;
89 }
90 return rc;
91}
92
93DECLVBGL(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
114DECLVBGL(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 = (VBOXGCPTR)&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 (VBOX_SUCCESS (rc))
143 {
144 rc = data.callInfo.result;
145 }
146
147 if (VBOX_SUCCESS (rc))
148 {
149 *pcMappings = data.numberOfMappings.u.value32;
150 }
151
152 return rc;
153}
154
155DECLVBGL(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 = (VBOXGCPTR)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 (VBOX_SUCCESS (rc))
176 {
177 rc = data.callInfo.result;
178 }
179
180 return rc;
181}
182
183DECLVBGL(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 = (VBOXGCPTR)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 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
203
204/* Log(("VBOXSF: VBoxSF::vboxCallMapFolder: "
205 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
206*/
207 if (VBOX_SUCCESS (rc))
208 {
209 pMap->root = data.root.u.value32;
210 rc = data.callInfo.result;
211 }
212 return rc;
213}
214
215DECLVBGL(int) vboxCallUnmapFolder(PVBSFCLIENT pClient, PVBSFMAP pMap)
216{
217 int rc = VINF_SUCCESS;
218
219 VBoxSFUnmapFolder data;
220
221 VBOX_INIT_CALL(&data.callInfo, UNMAP_FOLDER, pClient);
222
223 data.root.type = VMMDevHGCMParmType_32bit;
224 data.root.u.value32 = pMap->root;
225
226 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
227
228/* Log(("VBOXSF: VBoxSF::vboxCallUnmapFolder: "
229 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
230*/
231 if (VBOX_SUCCESS (rc))
232 {
233 rc = data.callInfo.result;
234 }
235 return rc;
236}
237
238DECLVBGL(int) vboxCallCreate (PVBSFCLIENT pClient, PVBSFMAP pMap,
239 PSHFLSTRING pParsedPath, PSHFLCREATEPARMS pCreateParms)
240{
241 /** @todo copy buffers to physical or mapped memory. */
242 int rc = VINF_SUCCESS;
243
244 VBoxSFCreate data;
245
246 VBOX_INIT_CALL(&data.callInfo, CREATE, pClient);
247
248 data.root.type = VMMDevHGCMParmType_32bit;
249 data.root.u.value32 = pMap->root;
250
251 data.path.type = VMMDevHGCMParmType_LinAddr;
252 data.path.u.Pointer.size = ShflStringSizeOfBuffer (pParsedPath);
253 data.path.u.Pointer.u.linearAddr = (VBOXGCPTR)pParsedPath;
254
255 data.parms.type = VMMDevHGCMParmType_LinAddr;
256 data.parms.u.Pointer.size = sizeof (SHFLCREATEPARMS);
257 data.parms.u.Pointer.u.linearAddr = (VBOXGCPTR)pCreateParms;
258
259 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
260
261/* Log(("VBOXSF: VBoxSF::vboxCallCreate: "
262 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
263*/
264 if (VBOX_SUCCESS (rc))
265 {
266 rc = data.callInfo.result;
267 }
268 return rc;
269}
270
271DECLVBGL(int) vboxCallClose (PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE Handle)
272{
273 int rc = VINF_SUCCESS;
274
275 VBoxSFClose data;
276
277 VBOX_INIT_CALL(&data.callInfo, CLOSE, pClient);
278
279 data.root.type = VMMDevHGCMParmType_32bit;
280 data.root.u.value32 = pMap->root;
281
282 data.handle.type = VMMDevHGCMParmType_64bit;
283 data.handle.u.value64 = Handle;
284
285 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
286
287/* Log(("VBOXSF: VBoxSF::vboxCallClose: "
288 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
289*/
290 if (VBOX_SUCCESS (rc))
291 {
292 rc = data.callInfo.result;
293 }
294
295 return rc;
296}
297
298DECLVBGL(int) vboxCallRemove (PVBSFCLIENT pClient, PVBSFMAP pMap,
299 PSHFLSTRING pParsedPath, uint32_t flags)
300{
301 int rc = VINF_SUCCESS;
302
303 VBoxSFRemove data;
304
305 VBOX_INIT_CALL(&data.callInfo, REMOVE, pClient);
306
307 data.root.type = VMMDevHGCMParmType_32bit;
308 data.root.u.value32 = pMap->root;
309
310 data.path.type = VMMDevHGCMParmType_LinAddr_In;
311 data.path.u.Pointer.size = ShflStringSizeOfBuffer (pParsedPath);
312 data.path.u.Pointer.u.linearAddr = (VBOXGCPTR)pParsedPath;
313
314 data.flags.type = VMMDevHGCMParmType_32bit;
315 data.flags.u.value32 = flags;
316
317 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
318
319/* Log(("VBOXSF: VBoxSF::vboxCallRemove: "
320 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
321*/
322 if (VBOX_SUCCESS (rc))
323 {
324 rc = data.callInfo.result;
325 }
326
327 return rc;
328}
329
330DECLVBGL(int) vboxCallRename (PVBSFCLIENT pClient, PVBSFMAP pMap,
331 PSHFLSTRING pSrcPath, PSHFLSTRING pDestPath, uint32_t flags)
332{
333 int rc = VINF_SUCCESS;
334
335 VBoxSFRename data;
336
337 VBOX_INIT_CALL(&data.callInfo, RENAME, pClient);
338
339 data.root.type = VMMDevHGCMParmType_32bit;
340 data.root.u.value32 = pMap->root;
341
342 data.src.type = VMMDevHGCMParmType_LinAddr_In;
343 data.src.u.Pointer.size = ShflStringSizeOfBuffer (pSrcPath);
344 data.src.u.Pointer.u.linearAddr = (VBOXGCPTR)pSrcPath;
345
346 data.dest.type = VMMDevHGCMParmType_LinAddr_In;
347 data.dest.u.Pointer.size = ShflStringSizeOfBuffer (pDestPath);
348 data.dest.u.Pointer.u.linearAddr = (VBOXGCPTR)pDestPath;
349
350 data.flags.type = VMMDevHGCMParmType_32bit;
351 data.flags.u.value32 = flags;
352
353 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
354
355/* Log(("VBOXSF: VBoxSF::vboxCallRename: "
356 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
357*/
358 if (VBOX_SUCCESS (rc))
359 {
360 rc = data.callInfo.result;
361 }
362 return rc;
363}
364
365DECLVBGL(int) vboxCallRead(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
366 uint64_t offset, uint32_t *pcbBuffer, uint8_t *pBuffer)
367{
368 int rc = VINF_SUCCESS;
369
370 VBoxSFRead data;
371
372 VBOX_INIT_CALL(&data.callInfo, READ, pClient);
373
374 data.root.type = VMMDevHGCMParmType_32bit;
375 data.root.u.value32 = pMap->root;
376
377 data.handle.type = VMMDevHGCMParmType_64bit;
378 data.handle.u.value64 = hFile;
379 data.offset.type = VMMDevHGCMParmType_64bit;
380 data.offset.u.value64 = offset;
381 data.cb.type = VMMDevHGCMParmType_32bit;
382 data.cb.u.value32 = *pcbBuffer;
383 data.buffer.type = VMMDevHGCMParmType_LinAddr_Out;
384 data.buffer.u.Pointer.size = *pcbBuffer;
385 data.buffer.u.Pointer.u.linearAddr = (VBOXGCPTR)pBuffer;
386
387 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
388
389/* Log(("VBOXSF: VBoxSF::vboxCallRead: "
390 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
391*/
392 if (VBOX_SUCCESS (rc))
393 {
394 rc = data.callInfo.result;
395 *pcbBuffer = data.cb.u.value32;
396 }
397 return rc;
398}
399
400DECLVBGL(int) vboxCallWrite(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
401 uint64_t offset, uint32_t *pcbBuffer, uint8_t *pBuffer)
402{
403 int rc = VINF_SUCCESS;
404
405 VBoxSFWrite data;
406
407 VBOX_INIT_CALL(&data.callInfo, WRITE, pClient);
408
409 data.root.type = VMMDevHGCMParmType_32bit;
410 data.root.u.value32 = pMap->root;
411
412 data.handle.type = VMMDevHGCMParmType_64bit;
413 data.handle.u.value64 = hFile;
414 data.offset.type = VMMDevHGCMParmType_64bit;
415 data.offset.u.value64 = offset;
416 data.cb.type = VMMDevHGCMParmType_32bit;
417 data.cb.u.value32 = *pcbBuffer;
418 data.buffer.type = VMMDevHGCMParmType_LinAddr_In;
419 data.buffer.u.Pointer.size = *pcbBuffer;
420 data.buffer.u.Pointer.u.linearAddr = (VBOXGCPTR)pBuffer;
421
422 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
423
424/* Log(("VBOXSF: VBoxSF::vboxCallWrite: "
425 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
426*/
427 if (VBOX_SUCCESS (rc))
428 {
429 rc = data.callInfo.result;
430 *pcbBuffer = data.cb.u.value32;
431 }
432 return rc;
433}
434
435DECLVBGL(int) vboxCallFlush(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile)
436{
437 int rc = VINF_SUCCESS;
438
439 VBoxSFFlush data;
440
441 VBOX_INIT_CALL(&data.callInfo, FLUSH, pClient);
442
443 data.root.type = VMMDevHGCMParmType_32bit;
444 data.root.u.value32 = pMap->root;
445
446 data.handle.type = VMMDevHGCMParmType_64bit;
447 data.handle.u.value64 = hFile;
448
449 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
450
451/* Log(("VBOXSF: VBoxSF::vboxCallFlush: "
452 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
453*/
454 if (VBOX_SUCCESS (rc))
455 {
456 rc = data.callInfo.result;
457 }
458 return rc;
459}
460
461DECLVBGL(int) vboxCallDirInfo (
462 PVBSFCLIENT pClient,
463 PVBSFMAP pMap,
464 SHFLHANDLE hFile,
465 PSHFLSTRING ParsedPath,
466 uint32_t flags,
467 uint32_t index,
468 uint32_t *pcbBuffer,
469 PSHFLDIRINFO pBuffer,
470 uint32_t *pcFiles)
471{
472 int rc = VINF_SUCCESS;
473
474 VBoxSFList data;
475
476 VBOX_INIT_CALL(&data.callInfo, LIST, pClient);
477
478 data.root.type = VMMDevHGCMParmType_32bit;
479 data.root.u.value32 = pMap->root;
480
481 data.handle.type = VMMDevHGCMParmType_64bit;
482 data.handle.u.value64 = hFile;
483 data.flags.type = VMMDevHGCMParmType_32bit;
484 data.flags.u.value32 = flags;
485 data.cb.type = VMMDevHGCMParmType_32bit;
486 data.cb.u.value32 = *pcbBuffer;
487 data.path.type = VMMDevHGCMParmType_LinAddr_In;
488 data.path.u.Pointer.size =
489 (ParsedPath) ? ShflStringSizeOfBuffer(ParsedPath) : 0;
490 data.path.u.Pointer.u.linearAddr = (VBOXGCPTR) ParsedPath;
491
492 data.buffer.type = VMMDevHGCMParmType_LinAddr_Out;
493 data.buffer.u.Pointer.size = *pcbBuffer;
494 data.buffer.u.Pointer.u.linearAddr = (VBOXGCPTR)pBuffer;
495
496 data.resumePoint.type = VMMDevHGCMParmType_32bit;
497 data.resumePoint.u.value32 = index;
498 data.cFiles.type = VMMDevHGCMParmType_32bit;
499 data.cFiles.u.value32 = 0; /* out parameters only */
500
501 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
502
503/* Log(("VBOXSF: VBoxSF::vboxCallDirInfo: "
504 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
505*/
506 if (VBOX_SUCCESS (rc))
507 {
508 rc = data.callInfo.result;
509 }
510 *pcbBuffer = data.cb.u.value32;
511 *pcFiles = data.cFiles.u.value32;
512 return rc;
513}
514
515DECLVBGL(int) vboxCallFSInfo(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
516 uint32_t flags, uint32_t *pcbBuffer, PSHFLDIRINFO pBuffer)
517{
518 int rc = VINF_SUCCESS;
519
520 VBoxSFInformation data;
521
522 VBOX_INIT_CALL(&data.callInfo, INFORMATION, pClient);
523
524 data.root.type = VMMDevHGCMParmType_32bit;
525 data.root.u.value32 = pMap->root;
526
527 data.handle.type = VMMDevHGCMParmType_64bit;
528 data.handle.u.value64 = hFile;
529 data.flags.type = VMMDevHGCMParmType_32bit;
530 data.flags.u.value32 = flags;
531 data.cb.type = VMMDevHGCMParmType_32bit;
532 data.cb.u.value32 = *pcbBuffer;
533 data.info.type = VMMDevHGCMParmType_LinAddr;
534 data.info.u.Pointer.size = *pcbBuffer;
535 data.info.u.Pointer.u.linearAddr = (VBOXGCPTR)pBuffer;
536
537 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
538
539/* Log(("VBOXSF: VBoxSF::vboxCallFileInfo: "
540 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
541*/
542 if (VBOX_SUCCESS (rc))
543 {
544 rc = data.callInfo.result;
545 *pcbBuffer = data.cb.u.value32;
546 }
547 return rc;
548}
549
550DECLVBGL(int) vboxCallLock(PVBSFCLIENT pClient, PVBSFMAP pMap, SHFLHANDLE hFile,
551 uint64_t offset, uint64_t cbSize, uint32_t fLock)
552{
553 int rc = VINF_SUCCESS;
554
555 VBoxSFLock data;
556
557 VBOX_INIT_CALL(&data.callInfo, LOCK, pClient);
558
559 data.root.type = VMMDevHGCMParmType_32bit;
560 data.root.u.value32 = pMap->root;
561
562 data.handle.type = VMMDevHGCMParmType_64bit;
563 data.handle.u.value64 = hFile;
564 data.offset.type = VMMDevHGCMParmType_64bit;
565 data.offset.u.value64 = offset;
566 data.length.type = VMMDevHGCMParmType_64bit;
567 data.length.u.value64 = cbSize;
568
569 data.flags.type = VMMDevHGCMParmType_32bit;
570 data.flags.u.value32 = fLock;
571
572 rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
573
574/* Log(("VBOXSF: VBoxSF::vboxCallLock: "
575 "VbglHGCMCall rc = %#x, result = %#x\n", rc, data.callInfo.result));
576*/
577 if (VBOX_SUCCESS (rc))
578 {
579 rc = data.callInfo.result;
580 }
581 return rc;
582}
583
584DECLVBGL(int) vboxCallSetUtf8 (PVBSFCLIENT pClient)
585{
586 int rc = VINF_SUCCESS;
587
588 VBoxGuestHGCMCallInfo callInfo;
589
590 VBOX_INIT_CALL (&callInfo, SET_UTF8, pClient);
591 rc = VbglHGCMCall (pClient->handle, &callInfo, sizeof (callInfo));
592 if (VBOX_SUCCESS (rc))
593 {
594 rc = callInfo.result;
595 }
596 return rc;
597}
598
599#endif /* !VBGL_VBOXGUEST */
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette