]>
Commit | Line | Data |
---|---|---|
056a1eb7 SF |
1 | /** @file |
2 | * Shared Folders: Common header for host service and guest clients. | |
3 | */ | |
4 | ||
5 | /* | |
6 | * Copyright (C) 2006-2016 Oracle Corporation | |
7 | * | |
8 | * This file is part of VirtualBox Open Source Edition (OSE), as | |
9 | * available from http://www.virtualbox.org. This file is free software; | |
10 | * you can redistribute it and/or modify it under the terms of the GNU | |
11 | * General Public License (GPL) as published by the Free Software | |
12 | * Foundation, in version 2 as it comes in the "COPYING" file of the | |
13 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the | |
14 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. | |
15 | * | |
16 | * The contents of this file may alternatively be used under the terms | |
17 | * of the Common Development and Distribution License Version 1.0 | |
18 | * (CDDL) only, as it comes in the "COPYING.CDDL" file of the | |
19 | * VirtualBox OSE distribution, in which case the provisions of the | |
20 | * CDDL are applicable instead of those of the GPL. | |
21 | * | |
22 | * You may elect to license modified versions of this file under the | |
23 | * terms and conditions of either the GPL or the CDDL or both. | |
24 | */ | |
25 | ||
26 | #ifndef ___VBox_shflsvc_h | |
27 | #define ___VBox_shflsvc_h | |
28 | ||
29 | #include <VBox/types.h> | |
30 | #include <VBox/VBoxGuest2.h> | |
31 | #include <VBox/VMMDev.h> | |
32 | #include <VBox/hgcmsvc.h> | |
33 | #include <iprt/fs.h> | |
34 | ||
35 | ||
36 | /** @name Some bit flag manipulation macros. | |
37 | * @{ */ | |
38 | #ifndef BIT_FLAG | |
39 | #define BIT_FLAG(__Field,__Flag) ((__Field) & (__Flag)) | |
40 | #endif | |
41 | ||
42 | #ifndef BIT_FLAG_SET | |
43 | #define BIT_FLAG_SET(__Field,__Flag) ((__Field) |= (__Flag)) | |
44 | #endif | |
45 | ||
46 | #ifndef BIT_FLAG_CLEAR | |
47 | #define BIT_FLAG_CLEAR(__Field,__Flag) ((__Field) &= ~(__Flag)) | |
48 | #endif | |
49 | /** @} */ | |
50 | ||
51 | ||
52 | /** | |
53 | * Structures shared between guest and the service | |
54 | * can be relocated and use offsets to point to variable | |
55 | * length parts. | |
56 | */ | |
57 | ||
58 | /** | |
59 | * Shared folders protocol works with handles. | |
60 | * Before doing any action on a file system object, | |
61 | * one have to obtain the object handle via a SHFL_FN_CREATE | |
62 | * request. A handle must be closed with SHFL_FN_CLOSE. | |
63 | */ | |
64 | ||
65 | /** Shared Folders service functions. (guest) | |
66 | * @{ | |
67 | */ | |
68 | ||
69 | /** Query mappings changes. */ | |
70 | #define SHFL_FN_QUERY_MAPPINGS (1) | |
71 | /** Query mappings changes. */ | |
72 | #define SHFL_FN_QUERY_MAP_NAME (2) | |
73 | /** Open/create object. */ | |
74 | #define SHFL_FN_CREATE (3) | |
75 | /** Close object handle. */ | |
76 | #define SHFL_FN_CLOSE (4) | |
77 | /** Read object content. */ | |
78 | #define SHFL_FN_READ (5) | |
79 | /** Write new object content. */ | |
80 | #define SHFL_FN_WRITE (6) | |
81 | /** Lock/unlock a range in the object. */ | |
82 | #define SHFL_FN_LOCK (7) | |
83 | /** List object content. */ | |
84 | #define SHFL_FN_LIST (8) | |
85 | /** Query/set object information. */ | |
86 | #define SHFL_FN_INFORMATION (9) | |
87 | /** Remove object */ | |
88 | #define SHFL_FN_REMOVE (11) | |
89 | /** Map folder (legacy) */ | |
90 | #define SHFL_FN_MAP_FOLDER_OLD (12) | |
91 | /** Unmap folder */ | |
92 | #define SHFL_FN_UNMAP_FOLDER (13) | |
93 | /** Rename object (possibly moving it to another directory) */ | |
94 | #define SHFL_FN_RENAME (14) | |
95 | /** Flush file */ | |
96 | #define SHFL_FN_FLUSH (15) | |
97 | /** @todo macl, a description, please. */ | |
98 | #define SHFL_FN_SET_UTF8 (16) | |
99 | /** Map folder */ | |
100 | #define SHFL_FN_MAP_FOLDER (17) | |
101 | /** Read symlink destination (as of VBox 4.0) */ | |
102 | #define SHFL_FN_READLINK (18) | |
103 | /** Create symlink (as of VBox 4.0) */ | |
104 | #define SHFL_FN_SYMLINK (19) | |
105 | /** Ask host to show symlinks (as of VBox 4.0) */ | |
106 | #define SHFL_FN_SET_SYMLINKS (20) | |
107 | ||
108 | /** @} */ | |
109 | ||
110 | /** Shared Folders service functions. (host) | |
111 | * @{ | |
112 | */ | |
113 | ||
114 | /** Add shared folder mapping. */ | |
115 | #define SHFL_FN_ADD_MAPPING (1) | |
116 | /** Remove shared folder mapping. */ | |
117 | #define SHFL_FN_REMOVE_MAPPING (2) | |
118 | /** Set the led status light address. */ | |
119 | #define SHFL_FN_SET_STATUS_LED (3) | |
120 | /** Allow the guest to create symbolic links (as of VBox 4.0) */ | |
121 | #define SHFL_FN_ALLOW_SYMLINKS_CREATE (4) | |
122 | /** @} */ | |
123 | ||
124 | /** Root handle for a mapping. Root handles are unique. | |
125 | * @note | |
126 | * Function parameters structures consider | |
127 | * the root handle as 32 bit value. If the typedef | |
128 | * will be changed, then function parameters must be | |
129 | * changed accordingly. All those parameters are marked | |
130 | * with SHFLROOT in comments. | |
131 | */ | |
132 | typedef uint32_t SHFLROOT; | |
133 | ||
134 | #define SHFL_ROOT_NIL ((SHFLROOT)~0) | |
135 | ||
136 | ||
137 | /** A shared folders handle for an opened object. */ | |
138 | typedef uint64_t SHFLHANDLE; | |
139 | ||
140 | #define SHFL_HANDLE_NIL ((SHFLHANDLE)~0LL) | |
141 | #define SHFL_HANDLE_ROOT ((SHFLHANDLE)0LL) | |
142 | ||
143 | /** Hardcoded maximum length (in chars) of a shared folder name. */ | |
144 | #define SHFL_MAX_LEN (256) | |
145 | /** Hardcoded maximum number of shared folder mapping available to the guest. */ | |
146 | #define SHFL_MAX_MAPPINGS (64) | |
147 | ||
148 | /** @name Shared Folders strings. They can be either UTF-8 or UTF-16. | |
149 | * @{ | |
150 | */ | |
151 | ||
152 | /** | |
153 | * Shared folder string buffer structure. | |
154 | */ | |
155 | #pragma pack(1) | |
156 | typedef struct _SHFLSTRING | |
157 | { | |
158 | /** Allocated size of the String member in bytes. */ | |
159 | uint16_t u16Size; | |
160 | ||
161 | /** Length of string without trailing nul in bytes. */ | |
162 | uint16_t u16Length; | |
163 | ||
164 | /** UTF-8 or UTF-16 string. Nul terminated. */ | |
165 | union | |
166 | { | |
167 | uint8_t utf8[1]; | |
168 | uint16_t ucs2[1]; | |
169 | } String; | |
170 | } SHFLSTRING; | |
171 | #pragma pack() | |
172 | ||
173 | #define SHFLSTRING_HEADER_SIZE RT_UOFFSETOF(SHFLSTRING, String) | |
174 | ||
175 | /** Pointer to a shared folder string buffer. */ | |
176 | typedef SHFLSTRING *PSHFLSTRING; | |
177 | /** Pointer to a const shared folder string buffer. */ | |
178 | typedef const SHFLSTRING *PCSHFLSTRING; | |
179 | ||
180 | /** Calculate size of the string. */ | |
181 | DECLINLINE(uint32_t) ShflStringSizeOfBuffer(PCSHFLSTRING pString) | |
182 | { | |
183 | return pString ? (uint32_t)(sizeof(SHFLSTRING) - sizeof(pString->String) + pString->u16Size) : 0; | |
184 | } | |
185 | ||
186 | DECLINLINE(uint32_t) ShflStringLength(PCSHFLSTRING pString) | |
187 | { | |
188 | return pString ? pString->u16Length : 0; | |
189 | } | |
190 | ||
191 | DECLINLINE(PSHFLSTRING) ShflStringInitBuffer(void *pvBuffer, uint32_t u32Size) | |
192 | { | |
193 | PSHFLSTRING pString = NULL; | |
194 | const uint32_t u32HeaderSize = SHFLSTRING_HEADER_SIZE; | |
195 | ||
196 | /* | |
197 | * Check that the buffer size is big enough to hold a zero sized string | |
198 | * and is not too big to fit into 16 bit variables. | |
199 | */ | |
200 | if (u32Size >= u32HeaderSize && u32Size - u32HeaderSize <= 0xFFFF) | |
201 | { | |
202 | pString = (PSHFLSTRING)pvBuffer; | |
203 | pString->u16Size = (uint16_t)(u32Size - u32HeaderSize); | |
204 | pString->u16Length = 0; | |
205 | if (pString->u16Size >= sizeof(pString->String.ucs2[0])) | |
206 | pString->String.ucs2[0] = 0; | |
207 | else if (pString->u16Size >= sizeof(pString->String.utf8[0])) | |
208 | pString->String.utf8[0] = 0; | |
209 | } | |
210 | ||
211 | return pString; | |
212 | } | |
213 | ||
214 | /** | |
215 | * Validates a HGCM string output parameter. | |
216 | * | |
217 | * @returns true if valid, false if not. | |
218 | * | |
219 | * @param pString The string buffer pointer. | |
220 | * @param cbBuf The buffer size from the parameter. | |
221 | */ | |
222 | DECLINLINE(bool) ShflStringIsValidOut(PCSHFLSTRING pString, uint32_t cbBuf) | |
223 | { | |
224 | if (RT_LIKELY(cbBuf > RT_UOFFSETOF(SHFLSTRING, String))) | |
225 | if (RT_LIKELY((uint32_t)pString->u16Size + RT_UOFFSETOF(SHFLSTRING, String) <= cbBuf)) | |
226 | if (RT_LIKELY(pString->u16Length < pString->u16Size)) | |
227 | return true; | |
228 | return false; | |
229 | } | |
230 | ||
231 | /** | |
232 | * Validates a HGCM string input parameter. | |
233 | * | |
234 | * @returns true if valid, false if not. | |
235 | * | |
236 | * @param pString The string buffer pointer. | |
237 | * @param cbBuf The buffer size from the parameter. | |
238 | * @param fUtf8Not16 Set if UTF-8 encoding, clear if UTF-16 encoding. | |
239 | */ | |
240 | DECLINLINE(bool) ShflStringIsValidIn(PCSHFLSTRING pString, uint32_t cbBuf, bool fUtf8Not16) | |
241 | { | |
242 | int rc; | |
243 | if (RT_LIKELY(cbBuf > RT_UOFFSETOF(SHFLSTRING, String))) | |
244 | { | |
245 | if (RT_LIKELY((uint32_t)pString->u16Size + RT_UOFFSETOF(SHFLSTRING, String) <= cbBuf)) | |
246 | { | |
247 | if (fUtf8Not16) | |
248 | { | |
249 | /* UTF-8: */ | |
250 | if (RT_LIKELY(pString->u16Length < pString->u16Size)) | |
251 | { | |
252 | rc = RTStrValidateEncodingEx((const char *)&pString->String.utf8[0], pString->u16Length + 1, | |
253 | RTSTR_VALIDATE_ENCODING_EXACT_LENGTH | RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED); | |
254 | if (RT_SUCCESS(rc)) | |
255 | return true; | |
256 | } | |
257 | } | |
258 | else | |
259 | { | |
260 | /* UTF-16: */ | |
261 | if (RT_LIKELY(!(pString->u16Length & 1))) | |
262 | { | |
263 | if (RT_LIKELY((uint32_t)sizeof(RTUTF16) + pString->u16Length <= pString->u16Size)) | |
264 | { | |
265 | rc = RTUtf16ValidateEncodingEx(&pString->String.ucs2[0], pString->u16Length / 2 + 1, | |
266 | RTSTR_VALIDATE_ENCODING_EXACT_LENGTH | |
267 | | RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED); | |
268 | if (RT_SUCCESS(rc)) | |
269 | return true; | |
270 | } | |
271 | } | |
272 | } | |
273 | } | |
274 | } | |
275 | return false; | |
276 | } | |
277 | ||
278 | /** | |
279 | * Validates an optional HGCM string input parameter. | |
280 | * | |
281 | * @returns true if valid, false if not. | |
282 | * | |
283 | * @param pString The string buffer pointer. Can be NULL. | |
284 | * @param cbBuf The buffer size from the parameter. | |
285 | * @param fUtf8Not16 Set if UTF-8 encoding, clear if UTF-16 encoding. | |
286 | */ | |
287 | DECLINLINE(bool) ShflStringIsValidOrNullIn(PCSHFLSTRING pString, uint32_t cbBuf, bool fUtf8Not16) | |
288 | { | |
289 | if (pString) | |
290 | return ShflStringIsValidIn(pString, cbBuf, fUtf8Not16); | |
291 | if (RT_LIKELY(cbBuf == 0)) | |
292 | return true; | |
293 | return false; | |
294 | } | |
295 | ||
296 | /** @} */ | |
297 | ||
298 | ||
299 | /** | |
300 | * The available additional information in a SHFLFSOBJATTR object. | |
301 | */ | |
302 | typedef enum SHFLFSOBJATTRADD | |
303 | { | |
304 | /** No additional information is available / requested. */ | |
305 | SHFLFSOBJATTRADD_NOTHING = 1, | |
306 | /** The additional unix attributes (SHFLFSOBJATTR::u::Unix) are | |
307 | * available / requested. */ | |
308 | SHFLFSOBJATTRADD_UNIX, | |
309 | /** The additional extended attribute size (SHFLFSOBJATTR::u::EASize) is | |
310 | * available / requested. */ | |
311 | SHFLFSOBJATTRADD_EASIZE, | |
312 | /** The last valid item (inclusive). | |
313 | * The valid range is SHFLFSOBJATTRADD_NOTHING thru | |
314 | * SHFLFSOBJATTRADD_LAST. */ | |
315 | SHFLFSOBJATTRADD_LAST = SHFLFSOBJATTRADD_EASIZE, | |
316 | ||
317 | /** The usual 32-bit hack. */ | |
318 | SHFLFSOBJATTRADD_32BIT_SIZE_HACK = 0x7fffffff | |
319 | } SHFLFSOBJATTRADD; | |
320 | ||
321 | ||
322 | /* Assert sizes of the IRPT types we're using below. */ | |
323 | AssertCompileSize(RTFMODE, 4); | |
324 | AssertCompileSize(RTFOFF, 8); | |
325 | AssertCompileSize(RTINODE, 8); | |
326 | AssertCompileSize(RTTIMESPEC, 8); | |
327 | AssertCompileSize(RTDEV, 4); | |
328 | AssertCompileSize(RTUID, 4); | |
329 | ||
330 | /** | |
331 | * Shared folder filesystem object attributes. | |
332 | */ | |
333 | #pragma pack(1) | |
334 | typedef struct SHFLFSOBJATTR | |
335 | { | |
336 | /** Mode flags (st_mode). RTFS_UNIX_*, RTFS_TYPE_*, and RTFS_DOS_*. | |
337 | * @remarks We depend on a number of RTFS_ defines to remain unchanged. | |
338 | * Fortuntately, these are depending on windows, dos and unix | |
339 | * standard values, so this shouldn't be much of a pain. */ | |
340 | RTFMODE fMode; | |
341 | ||
342 | /** The additional attributes available. */ | |
343 | SHFLFSOBJATTRADD enmAdditional; | |
344 | ||
345 | /** | |
346 | * Additional attributes. | |
347 | * | |
348 | * Unless explicitly specified to an API, the API can provide additional | |
349 | * data as it is provided by the underlying OS. | |
350 | */ | |
351 | union SHFLFSOBJATTRUNION | |
352 | { | |
353 | /** Additional Unix Attributes | |
354 | * These are available when SHFLFSOBJATTRADD is set in fUnix. | |
355 | */ | |
356 | struct SHFLFSOBJATTRUNIX | |
357 | { | |
358 | /** The user owning the filesystem object (st_uid). | |
359 | * This field is ~0U if not supported. */ | |
360 | RTUID uid; | |
361 | ||
362 | /** The group the filesystem object is assigned (st_gid). | |
363 | * This field is ~0U if not supported. */ | |
364 | RTGID gid; | |
365 | ||
366 | /** Number of hard links to this filesystem object (st_nlink). | |
367 | * This field is 1 if the filesystem doesn't support hardlinking or | |
368 | * the information isn't available. | |
369 | */ | |
370 | uint32_t cHardlinks; | |
371 | ||
372 | /** The device number of the device which this filesystem object resides on (st_dev). | |
373 | * This field is 0 if this information is not available. */ | |
374 | RTDEV INodeIdDevice; | |
375 | ||
376 | /** The unique identifier (within the filesystem) of this filesystem object (st_ino). | |
377 | * Together with INodeIdDevice, this field can be used as a OS wide unique id | |
378 | * when both their values are not 0. | |
379 | * This field is 0 if the information is not available. */ | |
380 | RTINODE INodeId; | |
381 | ||
382 | /** User flags (st_flags). | |
383 | * This field is 0 if this information is not available. */ | |
384 | uint32_t fFlags; | |
385 | ||
386 | /** The current generation number (st_gen). | |
387 | * This field is 0 if this information is not available. */ | |
388 | uint32_t GenerationId; | |
389 | ||
390 | /** The device number of a character or block device type object (st_rdev). | |
391 | * This field is 0 if the file isn't of a character or block device type and | |
392 | * when the OS doesn't subscribe to the major+minor device idenfication scheme. */ | |
393 | RTDEV Device; | |
394 | } Unix; | |
395 | ||
396 | /** | |
397 | * Extended attribute size. | |
398 | */ | |
399 | struct SHFLFSOBJATTREASIZE | |
400 | { | |
401 | /** Size of EAs. */ | |
402 | RTFOFF cb; | |
403 | } EASize; | |
404 | } u; | |
405 | } SHFLFSOBJATTR; | |
406 | #pragma pack() | |
407 | AssertCompileSize(SHFLFSOBJATTR, 44); | |
408 | /** Pointer to a shared folder filesystem object attributes structure. */ | |
409 | typedef SHFLFSOBJATTR *PSHFLFSOBJATTR; | |
410 | /** Pointer to a const shared folder filesystem object attributes structure. */ | |
411 | typedef const SHFLFSOBJATTR *PCSHFLFSOBJATTR; | |
412 | ||
413 | ||
414 | /** | |
415 | * Filesystem object information structure. | |
416 | */ | |
417 | #pragma pack(1) | |
418 | typedef struct SHFLFSOBJINFO | |
419 | { | |
420 | /** Logical size (st_size). | |
421 | * For normal files this is the size of the file. | |
422 | * For symbolic links, this is the length of the path name contained | |
423 | * in the symbolic link. | |
424 | * For other objects this fields needs to be specified. | |
425 | */ | |
426 | RTFOFF cbObject; | |
427 | ||
428 | /** Disk allocation size (st_blocks * DEV_BSIZE). */ | |
429 | RTFOFF cbAllocated; | |
430 | ||
431 | /** Time of last access (st_atime). | |
432 | * @remarks Here (and other places) we depend on the IPRT timespec to | |
433 | * remain unchanged. */ | |
434 | RTTIMESPEC AccessTime; | |
435 | ||
436 | /** Time of last data modification (st_mtime). */ | |
437 | RTTIMESPEC ModificationTime; | |
438 | ||
439 | /** Time of last status change (st_ctime). | |
440 | * If not available this is set to ModificationTime. | |
441 | */ | |
442 | RTTIMESPEC ChangeTime; | |
443 | ||
444 | /** Time of file birth (st_birthtime). | |
445 | * If not available this is set to ChangeTime. | |
446 | */ | |
447 | RTTIMESPEC BirthTime; | |
448 | ||
449 | /** Attributes. */ | |
450 | SHFLFSOBJATTR Attr; | |
451 | ||
452 | } SHFLFSOBJINFO; | |
453 | #pragma pack() | |
454 | AssertCompileSize(SHFLFSOBJINFO, 92); | |
455 | /** Pointer to a shared folder filesystem object information structure. */ | |
456 | typedef SHFLFSOBJINFO *PSHFLFSOBJINFO; | |
457 | /** Pointer to a const shared folder filesystem object information | |
458 | * structure. */ | |
459 | typedef const SHFLFSOBJINFO *PCSHFLFSOBJINFO; | |
460 | ||
461 | ||
462 | /** | |
463 | * Copy file system objinfo from IPRT to shared folder format. | |
464 | * | |
465 | * @param pDst The shared folder structure. | |
466 | * @param pSrc The IPRT structure. | |
467 | */ | |
468 | DECLINLINE(void) vbfsCopyFsObjInfoFromIprt(PSHFLFSOBJINFO pDst, PCRTFSOBJINFO pSrc) | |
469 | { | |
470 | pDst->cbObject = pSrc->cbObject; | |
471 | pDst->cbAllocated = pSrc->cbAllocated; | |
472 | pDst->AccessTime = pSrc->AccessTime; | |
473 | pDst->ModificationTime = pSrc->ModificationTime; | |
474 | pDst->ChangeTime = pSrc->ChangeTime; | |
475 | pDst->BirthTime = pSrc->BirthTime; | |
476 | pDst->Attr.fMode = pSrc->Attr.fMode; | |
477 | RT_ZERO(pDst->Attr.u); | |
478 | switch (pSrc->Attr.enmAdditional) | |
479 | { | |
480 | default: | |
481 | case RTFSOBJATTRADD_NOTHING: | |
482 | pDst->Attr.enmAdditional = SHFLFSOBJATTRADD_NOTHING; | |
483 | break; | |
484 | ||
485 | case RTFSOBJATTRADD_UNIX: | |
486 | pDst->Attr.enmAdditional = SHFLFSOBJATTRADD_UNIX; | |
487 | pDst->Attr.u.Unix.uid = pSrc->Attr.u.Unix.uid; | |
488 | pDst->Attr.u.Unix.gid = pSrc->Attr.u.Unix.gid; | |
489 | pDst->Attr.u.Unix.cHardlinks = pSrc->Attr.u.Unix.cHardlinks; | |
490 | pDst->Attr.u.Unix.INodeIdDevice = pSrc->Attr.u.Unix.INodeIdDevice; | |
491 | pDst->Attr.u.Unix.INodeId = pSrc->Attr.u.Unix.INodeId; | |
492 | pDst->Attr.u.Unix.fFlags = pSrc->Attr.u.Unix.fFlags; | |
493 | pDst->Attr.u.Unix.GenerationId = pSrc->Attr.u.Unix.GenerationId; | |
494 | pDst->Attr.u.Unix.Device = pSrc->Attr.u.Unix.Device; | |
495 | break; | |
496 | ||
497 | case RTFSOBJATTRADD_EASIZE: | |
498 | pDst->Attr.enmAdditional = SHFLFSOBJATTRADD_EASIZE; | |
499 | pDst->Attr.u.EASize.cb = pSrc->Attr.u.EASize.cb; | |
500 | break; | |
501 | } | |
502 | } | |
503 | ||
504 | ||
505 | /** Result of an open/create request. | |
506 | * Along with handle value the result code | |
507 | * identifies what has happened while | |
508 | * trying to open the object. | |
509 | */ | |
510 | typedef enum _SHFLCREATERESULT | |
511 | { | |
512 | SHFL_NO_RESULT, | |
513 | /** Specified path does not exist. */ | |
514 | SHFL_PATH_NOT_FOUND, | |
515 | /** Path to file exists, but the last component does not. */ | |
516 | SHFL_FILE_NOT_FOUND, | |
517 | /** File already exists and either has been opened or not. */ | |
518 | SHFL_FILE_EXISTS, | |
519 | /** New file was created. */ | |
520 | SHFL_FILE_CREATED, | |
521 | /** Existing file was replaced or overwritten. */ | |
522 | SHFL_FILE_REPLACED | |
523 | } SHFLCREATERESULT; | |
524 | ||
525 | ||
526 | /** Open/create flags. | |
527 | * @{ | |
528 | */ | |
529 | ||
530 | /** No flags. Initialization value. */ | |
531 | #define SHFL_CF_NONE (0x00000000) | |
532 | ||
533 | /** Lookup only the object, do not return a handle. All other flags are ignored. */ | |
534 | #define SHFL_CF_LOOKUP (0x00000001) | |
535 | ||
536 | /** Open parent directory of specified object. | |
537 | * Useful for the corresponding Windows FSD flag | |
538 | * and for opening paths like \\dir\\*.* to search the 'dir'. | |
539 | * @todo possibly not needed??? | |
540 | */ | |
541 | #define SHFL_CF_OPEN_TARGET_DIRECTORY (0x00000002) | |
542 | ||
543 | /** Create/open a directory. */ | |
544 | #define SHFL_CF_DIRECTORY (0x00000004) | |
545 | ||
546 | /** Open/create action to do if object exists | |
547 | * and if the object does not exists. | |
548 | * REPLACE file means atomically DELETE and CREATE. | |
549 | * OVERWRITE file means truncating the file to 0 and | |
550 | * setting new size. | |
551 | * When opening an existing directory REPLACE and OVERWRITE | |
552 | * actions are considered invalid, and cause returning | |
553 | * FILE_EXISTS with NIL handle. | |
554 | */ | |
555 | #define SHFL_CF_ACT_MASK_IF_EXISTS (0x000000F0) | |
556 | #define SHFL_CF_ACT_MASK_IF_NEW (0x00000F00) | |
557 | ||
558 | /** What to do if object exists. */ | |
559 | #define SHFL_CF_ACT_OPEN_IF_EXISTS (0x00000000) | |
560 | #define SHFL_CF_ACT_FAIL_IF_EXISTS (0x00000010) | |
561 | #define SHFL_CF_ACT_REPLACE_IF_EXISTS (0x00000020) | |
562 | #define SHFL_CF_ACT_OVERWRITE_IF_EXISTS (0x00000030) | |
563 | ||
564 | /** What to do if object does not exist. */ | |
565 | #define SHFL_CF_ACT_CREATE_IF_NEW (0x00000000) | |
566 | #define SHFL_CF_ACT_FAIL_IF_NEW (0x00000100) | |
567 | ||
568 | /** Read/write requested access for the object. */ | |
569 | #define SHFL_CF_ACCESS_MASK_RW (0x00003000) | |
570 | ||
571 | /** No access requested. */ | |
572 | #define SHFL_CF_ACCESS_NONE (0x00000000) | |
573 | /** Read access requested. */ | |
574 | #define SHFL_CF_ACCESS_READ (0x00001000) | |
575 | /** Write access requested. */ | |
576 | #define SHFL_CF_ACCESS_WRITE (0x00002000) | |
577 | /** Read/Write access requested. */ | |
578 | #define SHFL_CF_ACCESS_READWRITE (SHFL_CF_ACCESS_READ | SHFL_CF_ACCESS_WRITE) | |
579 | ||
580 | /** Requested share access for the object. */ | |
581 | #define SHFL_CF_ACCESS_MASK_DENY (0x0000C000) | |
582 | ||
583 | /** Allow any access. */ | |
584 | #define SHFL_CF_ACCESS_DENYNONE (0x00000000) | |
585 | /** Do not allow read. */ | |
586 | #define SHFL_CF_ACCESS_DENYREAD (0x00004000) | |
587 | /** Do not allow write. */ | |
588 | #define SHFL_CF_ACCESS_DENYWRITE (0x00008000) | |
589 | /** Do not allow access. */ | |
590 | #define SHFL_CF_ACCESS_DENYALL (SHFL_CF_ACCESS_DENYREAD | SHFL_CF_ACCESS_DENYWRITE) | |
591 | ||
592 | /** Requested access to attributes of the object. */ | |
593 | #define SHFL_CF_ACCESS_MASK_ATTR (0x00030000) | |
594 | ||
595 | /** No access requested. */ | |
596 | #define SHFL_CF_ACCESS_ATTR_NONE (0x00000000) | |
597 | /** Read access requested. */ | |
598 | #define SHFL_CF_ACCESS_ATTR_READ (0x00010000) | |
599 | /** Write access requested. */ | |
600 | #define SHFL_CF_ACCESS_ATTR_WRITE (0x00020000) | |
601 | /** Read/Write access requested. */ | |
602 | #define SHFL_CF_ACCESS_ATTR_READWRITE (SHFL_CF_ACCESS_ATTR_READ | SHFL_CF_ACCESS_ATTR_WRITE) | |
603 | ||
604 | /** The file is opened in append mode. Ignored if SHFL_CF_ACCESS_WRITE is not set. */ | |
605 | #define SHFL_CF_ACCESS_APPEND (0x00040000) | |
606 | ||
607 | /** @} */ | |
608 | ||
609 | #pragma pack(1) | |
610 | typedef struct _SHFLCREATEPARMS | |
611 | { | |
612 | /* Returned handle of opened object. */ | |
613 | SHFLHANDLE Handle; | |
614 | ||
615 | /* Returned result of the operation */ | |
616 | SHFLCREATERESULT Result; | |
617 | ||
618 | /* SHFL_CF_* */ | |
619 | uint32_t CreateFlags; | |
620 | ||
621 | /* Attributes of object to create and | |
622 | * returned actual attributes of opened/created object. | |
623 | */ | |
624 | SHFLFSOBJINFO Info; | |
625 | ||
626 | } SHFLCREATEPARMS; | |
627 | #pragma pack() | |
628 | ||
629 | typedef SHFLCREATEPARMS *PSHFLCREATEPARMS; | |
630 | ||
631 | ||
632 | /** Shared Folders mappings. | |
633 | * @{ | |
634 | */ | |
635 | ||
636 | /** The mapping has been added since last query. */ | |
637 | #define SHFL_MS_NEW (1) | |
638 | /** The mapping has been deleted since last query. */ | |
639 | #define SHFL_MS_DELETED (2) | |
640 | ||
641 | typedef struct _SHFLMAPPING | |
642 | { | |
643 | /** Mapping status. */ | |
644 | uint32_t u32Status; | |
645 | /** Root handle. */ | |
646 | SHFLROOT root; | |
647 | } SHFLMAPPING; | |
648 | /** Pointer to a SHFLMAPPING structure. */ | |
649 | typedef SHFLMAPPING *PSHFLMAPPING; | |
650 | ||
651 | /** @} */ | |
652 | ||
653 | /** Shared Folder directory information | |
654 | * @{ | |
655 | */ | |
656 | ||
657 | typedef struct _SHFLDIRINFO | |
658 | { | |
659 | /** Full information about the object. */ | |
660 | SHFLFSOBJINFO Info; | |
661 | /** The length of the short field (number of RTUTF16 chars). | |
662 | * It is 16-bit for reasons of alignment. */ | |
663 | uint16_t cucShortName; | |
664 | /** The short name for 8.3 compatibility. | |
665 | * Empty string if not available. | |
666 | */ | |
667 | RTUTF16 uszShortName[14]; | |
668 | /** @todo malc, a description, please. */ | |
669 | SHFLSTRING name; | |
670 | } SHFLDIRINFO, *PSHFLDIRINFO; | |
671 | ||
672 | ||
673 | /** | |
674 | * Shared folder filesystem properties. | |
675 | */ | |
676 | typedef struct SHFLFSPROPERTIES | |
677 | { | |
678 | /** The maximum size of a filesystem object name. | |
679 | * This does not include the '\\0'. */ | |
680 | uint32_t cbMaxComponent; | |
681 | ||
682 | /** True if the filesystem is remote. | |
683 | * False if the filesystem is local. */ | |
684 | bool fRemote; | |
685 | ||
686 | /** True if the filesystem is case sensitive. | |
687 | * False if the filesystem is case insensitive. */ | |
688 | bool fCaseSensitive; | |
689 | ||
690 | /** True if the filesystem is mounted read only. | |
691 | * False if the filesystem is mounted read write. */ | |
692 | bool fReadOnly; | |
693 | ||
694 | /** True if the filesystem can encode unicode object names. | |
695 | * False if it can't. */ | |
696 | bool fSupportsUnicode; | |
697 | ||
698 | /** True if the filesystem is compresses. | |
699 | * False if it isn't or we don't know. */ | |
700 | bool fCompressed; | |
701 | ||
702 | /** True if the filesystem compresses of individual files. | |
703 | * False if it doesn't or we don't know. */ | |
704 | bool fFileCompression; | |
705 | ||
706 | /** @todo more? */ | |
707 | } SHFLFSPROPERTIES; | |
708 | AssertCompileSize(SHFLFSPROPERTIES, 12); | |
709 | /** Pointer to a shared folder filesystem properties structure. */ | |
710 | typedef SHFLFSPROPERTIES *PSHFLFSPROPERTIES; | |
711 | /** Pointer to a const shared folder filesystem properties structure. */ | |
712 | typedef SHFLFSPROPERTIES const *PCSHFLFSPROPERTIES; | |
713 | ||
714 | ||
715 | /** | |
716 | * Copy file system properties from IPRT to shared folder format. | |
717 | * | |
718 | * @param pDst The shared folder structure. | |
719 | * @param pSrc The IPRT structure. | |
720 | */ | |
721 | DECLINLINE(void) vbfsCopyFsPropertiesFromIprt(PSHFLFSPROPERTIES pDst, PCRTFSPROPERTIES pSrc) | |
722 | { | |
723 | RT_ZERO(*pDst); /* zap the implicit padding. */ | |
724 | pDst->cbMaxComponent = pSrc->cbMaxComponent; | |
725 | pDst->fRemote = pSrc->fRemote; | |
726 | pDst->fCaseSensitive = pSrc->fCaseSensitive; | |
727 | pDst->fReadOnly = pSrc->fReadOnly; | |
728 | pDst->fSupportsUnicode = pSrc->fSupportsUnicode; | |
729 | pDst->fCompressed = pSrc->fCompressed; | |
730 | pDst->fFileCompression = pSrc->fFileCompression; | |
731 | } | |
732 | ||
733 | ||
734 | typedef struct _SHFLVOLINFO | |
735 | { | |
736 | RTFOFF ullTotalAllocationBytes; | |
737 | RTFOFF ullAvailableAllocationBytes; | |
738 | uint32_t ulBytesPerAllocationUnit; | |
739 | uint32_t ulBytesPerSector; | |
740 | uint32_t ulSerial; | |
741 | SHFLFSPROPERTIES fsProperties; | |
742 | } SHFLVOLINFO, *PSHFLVOLINFO; | |
743 | ||
744 | /** @} */ | |
745 | ||
746 | /** Function parameter structures. | |
747 | * @{ | |
748 | */ | |
749 | ||
750 | /** | |
751 | * SHFL_FN_QUERY_MAPPINGS | |
752 | */ | |
753 | /** Validation mask. Needs to be adjusted | |
754 | * whenever a new SHFL_MF_ flag is added. */ | |
755 | #define SHFL_MF_MASK (0x00000011) | |
756 | /** UC2 enconded strings. */ | |
757 | #define SHFL_MF_UCS2 (0x00000000) | |
758 | /** Guest uses UTF8 strings, if not set then the strings are unicode (UCS2). */ | |
759 | #define SHFL_MF_UTF8 (0x00000001) | |
760 | /** Just handle the auto-mounted folders. */ | |
761 | #define SHFL_MF_AUTOMOUNT (0x00000010) | |
762 | ||
763 | /** Type of guest system. For future system dependent features. */ | |
764 | #define SHFL_MF_SYSTEM_MASK (0x0000FF00) | |
765 | #define SHFL_MF_SYSTEM_NONE (0x00000000) | |
766 | #define SHFL_MF_SYSTEM_WINDOWS (0x00000100) | |
767 | #define SHFL_MF_SYSTEM_LINUX (0x00000200) | |
768 | ||
769 | /** Parameters structure. */ | |
770 | typedef struct _VBoxSFQueryMappings | |
771 | { | |
772 | VBoxGuestHGCMCallInfo callInfo; | |
773 | ||
774 | /** 32bit, in: | |
775 | * Flags describing various client needs. | |
776 | */ | |
777 | HGCMFunctionParameter flags; | |
778 | ||
779 | /** 32bit, in/out: | |
780 | * Number of mappings the client expects. | |
781 | * This is the number of elements in the | |
782 | * mappings array. | |
783 | */ | |
784 | HGCMFunctionParameter numberOfMappings; | |
785 | ||
786 | /** pointer, in/out: | |
787 | * Points to array of SHFLMAPPING structures. | |
788 | */ | |
789 | HGCMFunctionParameter mappings; | |
790 | ||
791 | } VBoxSFQueryMappings; | |
792 | ||
793 | /** Number of parameters */ | |
794 | #define SHFL_CPARMS_QUERY_MAPPINGS (3) | |
795 | ||
796 | ||
797 | ||
798 | /** | |
799 | * SHFL_FN_QUERY_MAP_NAME | |
800 | */ | |
801 | ||
802 | /** Parameters structure. */ | |
803 | typedef struct _VBoxSFQueryMapName | |
804 | { | |
805 | VBoxGuestHGCMCallInfo callInfo; | |
806 | ||
807 | /** 32bit, in: SHFLROOT | |
808 | * Root handle of the mapping which name is queried. | |
809 | */ | |
810 | HGCMFunctionParameter root; | |
811 | ||
812 | /** pointer, in/out: | |
813 | * Points to SHFLSTRING buffer. | |
814 | */ | |
815 | HGCMFunctionParameter name; | |
816 | ||
817 | } VBoxSFQueryMapName; | |
818 | ||
819 | /** Number of parameters */ | |
820 | #define SHFL_CPARMS_QUERY_MAP_NAME (2) | |
821 | ||
822 | /** | |
823 | * SHFL_FN_MAP_FOLDER_OLD | |
824 | */ | |
825 | ||
826 | /** Parameters structure. */ | |
827 | typedef struct _VBoxSFMapFolder_Old | |
828 | { | |
829 | VBoxGuestHGCMCallInfo callInfo; | |
830 | ||
831 | /** pointer, in: | |
832 | * Points to SHFLSTRING buffer. | |
833 | */ | |
834 | HGCMFunctionParameter path; | |
835 | ||
836 | /** pointer, out: SHFLROOT | |
837 | * Root handle of the mapping which name is queried. | |
838 | */ | |
839 | HGCMFunctionParameter root; | |
840 | ||
841 | /** pointer, in: RTUTF16 | |
842 | * Path delimiter | |
843 | */ | |
844 | HGCMFunctionParameter delimiter; | |
845 | ||
846 | } VBoxSFMapFolder_Old; | |
847 | ||
848 | /** Number of parameters */ | |
849 | #define SHFL_CPARMS_MAP_FOLDER_OLD (3) | |
850 | ||
851 | /** | |
852 | * SHFL_FN_MAP_FOLDER | |
853 | */ | |
854 | ||
855 | /** Parameters structure. */ | |
856 | typedef struct _VBoxSFMapFolder | |
857 | { | |
858 | VBoxGuestHGCMCallInfo callInfo; | |
859 | ||
860 | /** pointer, in: | |
861 | * Points to SHFLSTRING buffer. | |
862 | */ | |
863 | HGCMFunctionParameter path; | |
864 | ||
865 | /** pointer, out: SHFLROOT | |
866 | * Root handle of the mapping which name is queried. | |
867 | */ | |
868 | HGCMFunctionParameter root; | |
869 | ||
870 | /** pointer, in: RTUTF16 | |
871 | * Path delimiter | |
872 | */ | |
873 | HGCMFunctionParameter delimiter; | |
874 | ||
875 | /** pointer, in: SHFLROOT | |
876 | * Case senstive flag | |
877 | */ | |
878 | HGCMFunctionParameter fCaseSensitive; | |
879 | ||
880 | } VBoxSFMapFolder; | |
881 | ||
882 | /** Number of parameters */ | |
883 | #define SHFL_CPARMS_MAP_FOLDER (4) | |
884 | ||
885 | /** | |
886 | * SHFL_FN_UNMAP_FOLDER | |
887 | */ | |
888 | ||
889 | /** Parameters structure. */ | |
890 | typedef struct _VBoxSFUnmapFolder | |
891 | { | |
892 | VBoxGuestHGCMCallInfo callInfo; | |
893 | ||
894 | /** pointer, in: SHFLROOT | |
895 | * Root handle of the mapping which name is queried. | |
896 | */ | |
897 | HGCMFunctionParameter root; | |
898 | ||
899 | } VBoxSFUnmapFolder; | |
900 | ||
901 | /** Number of parameters */ | |
902 | #define SHFL_CPARMS_UNMAP_FOLDER (1) | |
903 | ||
904 | ||
905 | /** | |
906 | * SHFL_FN_CREATE | |
907 | */ | |
908 | ||
909 | /** Parameters structure. */ | |
910 | typedef struct _VBoxSFCreate | |
911 | { | |
912 | VBoxGuestHGCMCallInfo callInfo; | |
913 | ||
914 | /** pointer, in: SHFLROOT | |
915 | * Root handle of the mapping which name is queried. | |
916 | */ | |
917 | HGCMFunctionParameter root; | |
918 | ||
919 | /** pointer, in: | |
920 | * Points to SHFLSTRING buffer. | |
921 | */ | |
922 | HGCMFunctionParameter path; | |
923 | ||
924 | /** pointer, in/out: | |
925 | * Points to SHFLCREATEPARMS buffer. | |
926 | */ | |
927 | HGCMFunctionParameter parms; | |
928 | ||
929 | } VBoxSFCreate; | |
930 | ||
931 | /** Number of parameters */ | |
932 | #define SHFL_CPARMS_CREATE (3) | |
933 | ||
934 | ||
935 | /** | |
936 | * SHFL_FN_CLOSE | |
937 | */ | |
938 | ||
939 | /** Parameters structure. */ | |
940 | typedef struct _VBoxSFClose | |
941 | { | |
942 | VBoxGuestHGCMCallInfo callInfo; | |
943 | ||
944 | /** pointer, in: SHFLROOT | |
945 | * Root handle of the mapping which name is queried. | |
946 | */ | |
947 | HGCMFunctionParameter root; | |
948 | ||
949 | ||
950 | /** value64, in: | |
951 | * SHFLHANDLE of object to close. | |
952 | */ | |
953 | HGCMFunctionParameter handle; | |
954 | ||
955 | } VBoxSFClose; | |
956 | ||
957 | /** Number of parameters */ | |
958 | #define SHFL_CPARMS_CLOSE (2) | |
959 | ||
960 | ||
961 | /** | |
962 | * SHFL_FN_READ | |
963 | */ | |
964 | ||
965 | /** Parameters structure. */ | |
966 | typedef struct _VBoxSFRead | |
967 | { | |
968 | VBoxGuestHGCMCallInfo callInfo; | |
969 | ||
970 | /** pointer, in: SHFLROOT | |
971 | * Root handle of the mapping which name is queried. | |
972 | */ | |
973 | HGCMFunctionParameter root; | |
974 | ||
975 | /** value64, in: | |
976 | * SHFLHANDLE of object to read from. | |
977 | */ | |
978 | HGCMFunctionParameter handle; | |
979 | ||
980 | /** value64, in: | |
981 | * Offset to read from. | |
982 | */ | |
983 | HGCMFunctionParameter offset; | |
984 | ||
985 | /** value64, in/out: | |
986 | * Bytes to read/How many were read. | |
987 | */ | |
988 | HGCMFunctionParameter cb; | |
989 | ||
990 | /** pointer, out: | |
991 | * Buffer to place data to. | |
992 | */ | |
993 | HGCMFunctionParameter buffer; | |
994 | ||
995 | } VBoxSFRead; | |
996 | ||
997 | /** Number of parameters */ | |
998 | #define SHFL_CPARMS_READ (5) | |
999 | ||
1000 | ||
1001 | ||
1002 | /** | |
1003 | * SHFL_FN_WRITE | |
1004 | */ | |
1005 | ||
1006 | /** Parameters structure. */ | |
1007 | typedef struct _VBoxSFWrite | |
1008 | { | |
1009 | VBoxGuestHGCMCallInfo callInfo; | |
1010 | ||
1011 | /** pointer, in: SHFLROOT | |
1012 | * Root handle of the mapping which name is queried. | |
1013 | */ | |
1014 | HGCMFunctionParameter root; | |
1015 | ||
1016 | /** value64, in: | |
1017 | * SHFLHANDLE of object to write to. | |
1018 | */ | |
1019 | HGCMFunctionParameter handle; | |
1020 | ||
1021 | /** value64, in: | |
1022 | * Offset to write to. | |
1023 | */ | |
1024 | HGCMFunctionParameter offset; | |
1025 | ||
1026 | /** value64, in/out: | |
1027 | * Bytes to write/How many were written. | |
1028 | */ | |
1029 | HGCMFunctionParameter cb; | |
1030 | ||
1031 | /** pointer, in: | |
1032 | * Data to write. | |
1033 | */ | |
1034 | HGCMFunctionParameter buffer; | |
1035 | ||
1036 | } VBoxSFWrite; | |
1037 | ||
1038 | /** Number of parameters */ | |
1039 | #define SHFL_CPARMS_WRITE (5) | |
1040 | ||
1041 | ||
1042 | ||
1043 | /** | |
1044 | * SHFL_FN_LOCK | |
1045 | */ | |
1046 | ||
1047 | /** Lock owner is the HGCM client. */ | |
1048 | ||
1049 | /** Lock mode bit mask. */ | |
1050 | #define SHFL_LOCK_MODE_MASK (0x3) | |
1051 | /** Cancel lock on the given range. */ | |
1052 | #define SHFL_LOCK_CANCEL (0x0) | |
1053 | /** Acquire read only lock. Prevent write to the range. */ | |
1054 | #define SHFL_LOCK_SHARED (0x1) | |
1055 | /** Acquire write lock. Prevent both write and read to the range. */ | |
1056 | #define SHFL_LOCK_EXCLUSIVE (0x2) | |
1057 | ||
1058 | /** Do not wait for lock if it can not be acquired at the time. */ | |
1059 | #define SHFL_LOCK_NOWAIT (0x0) | |
1060 | /** Wait and acquire lock. */ | |
1061 | #define SHFL_LOCK_WAIT (0x4) | |
1062 | ||
1063 | /** Lock the specified range. */ | |
1064 | #define SHFL_LOCK_PARTIAL (0x0) | |
1065 | /** Lock entire object. */ | |
1066 | #define SHFL_LOCK_ENTIRE (0x8) | |
1067 | ||
1068 | /** Parameters structure. */ | |
1069 | typedef struct _VBoxSFLock | |
1070 | { | |
1071 | VBoxGuestHGCMCallInfo callInfo; | |
1072 | ||
1073 | /** pointer, in: SHFLROOT | |
1074 | * Root handle of the mapping which name is queried. | |
1075 | */ | |
1076 | HGCMFunctionParameter root; | |
1077 | ||
1078 | /** value64, in: | |
1079 | * SHFLHANDLE of object to be locked. | |
1080 | */ | |
1081 | HGCMFunctionParameter handle; | |
1082 | ||
1083 | /** value64, in: | |
1084 | * Starting offset of lock range. | |
1085 | */ | |
1086 | HGCMFunctionParameter offset; | |
1087 | ||
1088 | /** value64, in: | |
1089 | * Length of range. | |
1090 | */ | |
1091 | HGCMFunctionParameter length; | |
1092 | ||
1093 | /** value32, in: | |
1094 | * Lock flags SHFL_LOCK_*. | |
1095 | */ | |
1096 | HGCMFunctionParameter flags; | |
1097 | ||
1098 | } VBoxSFLock; | |
1099 | ||
1100 | /** Number of parameters */ | |
1101 | #define SHFL_CPARMS_LOCK (5) | |
1102 | ||
1103 | ||
1104 | ||
1105 | /** | |
1106 | * SHFL_FN_FLUSH | |
1107 | */ | |
1108 | ||
1109 | /** Parameters structure. */ | |
1110 | typedef struct _VBoxSFFlush | |
1111 | { | |
1112 | VBoxGuestHGCMCallInfo callInfo; | |
1113 | ||
1114 | /** pointer, in: SHFLROOT | |
1115 | * Root handle of the mapping which name is queried. | |
1116 | */ | |
1117 | HGCMFunctionParameter root; | |
1118 | ||
1119 | /** value64, in: | |
1120 | * SHFLHANDLE of object to be locked. | |
1121 | */ | |
1122 | HGCMFunctionParameter handle; | |
1123 | ||
1124 | } VBoxSFFlush; | |
1125 | ||
1126 | /** Number of parameters */ | |
1127 | #define SHFL_CPARMS_FLUSH (2) | |
1128 | ||
1129 | /** | |
1130 | * SHFL_FN_LIST | |
1131 | */ | |
1132 | ||
1133 | /** Listing information includes variable length RTDIRENTRY[EX] structures. */ | |
1134 | ||
1135 | /** @todo might be necessary for future. */ | |
1136 | #define SHFL_LIST_NONE 0 | |
1137 | #define SHFL_LIST_RETURN_ONE 1 | |
1138 | ||
1139 | /** Parameters structure. */ | |
1140 | typedef struct _VBoxSFList | |
1141 | { | |
1142 | VBoxGuestHGCMCallInfo callInfo; | |
1143 | ||
1144 | /** pointer, in: SHFLROOT | |
1145 | * Root handle of the mapping which name is queried. | |
1146 | */ | |
1147 | HGCMFunctionParameter root; | |
1148 | ||
1149 | /** value64, in: | |
1150 | * SHFLHANDLE of object to be listed. | |
1151 | */ | |
1152 | HGCMFunctionParameter handle; | |
1153 | ||
1154 | /** value32, in: | |
1155 | * List flags SHFL_LIST_*. | |
1156 | */ | |
1157 | HGCMFunctionParameter flags; | |
1158 | ||
1159 | /** value32, in/out: | |
1160 | * Bytes to be used for listing information/How many bytes were used. | |
1161 | */ | |
1162 | HGCMFunctionParameter cb; | |
1163 | ||
1164 | /** pointer, in/optional | |
1165 | * Points to SHFLSTRING buffer that specifies a search path. | |
1166 | */ | |
1167 | HGCMFunctionParameter path; | |
1168 | ||
1169 | /** pointer, out: | |
1170 | * Buffer to place listing information to. (SHFLDIRINFO) | |
1171 | */ | |
1172 | HGCMFunctionParameter buffer; | |
1173 | ||
1174 | /** value32, in/out: | |
1175 | * Indicates a key where the listing must be resumed. | |
1176 | * in: 0 means start from begin of object. | |
1177 | * out: 0 means listing completed. | |
1178 | */ | |
1179 | HGCMFunctionParameter resumePoint; | |
1180 | ||
1181 | /** pointer, out: | |
1182 | * Number of files returned | |
1183 | */ | |
1184 | HGCMFunctionParameter cFiles; | |
1185 | ||
1186 | } VBoxSFList; | |
1187 | ||
1188 | /** Number of parameters */ | |
1189 | #define SHFL_CPARMS_LIST (8) | |
1190 | ||
1191 | ||
1192 | ||
1193 | /** | |
1194 | * SHFL_FN_READLINK | |
1195 | */ | |
1196 | ||
1197 | /** Parameters structure. */ | |
1198 | typedef struct _VBoxSFReadLink | |
1199 | { | |
1200 | VBoxGuestHGCMCallInfo callInfo; | |
1201 | ||
1202 | /** pointer, in: SHFLROOT | |
1203 | * Root handle of the mapping which name is queried. | |
1204 | */ | |
1205 | HGCMFunctionParameter root; | |
1206 | ||
1207 | /** pointer, in: | |
1208 | * Points to SHFLSTRING buffer. | |
1209 | */ | |
1210 | HGCMFunctionParameter path; | |
1211 | ||
1212 | /** pointer, out: | |
1213 | * Buffer to place data to. | |
1214 | */ | |
1215 | HGCMFunctionParameter buffer; | |
1216 | ||
1217 | } VBoxSFReadLink; | |
1218 | ||
1219 | /** Number of parameters */ | |
1220 | #define SHFL_CPARMS_READLINK (3) | |
1221 | ||
1222 | ||
1223 | ||
1224 | /** | |
1225 | * SHFL_FN_INFORMATION | |
1226 | */ | |
1227 | ||
1228 | /** Mask of Set/Get bit. */ | |
1229 | #define SHFL_INFO_MODE_MASK (0x1) | |
1230 | /** Get information */ | |
1231 | #define SHFL_INFO_GET (0x0) | |
1232 | /** Set information */ | |
1233 | #define SHFL_INFO_SET (0x1) | |
1234 | ||
1235 | /** Get name of the object. */ | |
1236 | #define SHFL_INFO_NAME (0x2) | |
1237 | /** Set size of object (extend/trucate); only applies to file objects */ | |
1238 | #define SHFL_INFO_SIZE (0x4) | |
1239 | /** Get/Set file object info. */ | |
1240 | #define SHFL_INFO_FILE (0x8) | |
1241 | /** Get volume information. */ | |
1242 | #define SHFL_INFO_VOLUME (0x10) | |
1243 | ||
1244 | /** @todo different file info structures */ | |
1245 | ||
1246 | ||
1247 | /** Parameters structure. */ | |
1248 | typedef struct _VBoxSFInformation | |
1249 | { | |
1250 | VBoxGuestHGCMCallInfo callInfo; | |
1251 | ||
1252 | /** pointer, in: SHFLROOT | |
1253 | * Root handle of the mapping which name is queried. | |
1254 | */ | |
1255 | HGCMFunctionParameter root; | |
1256 | ||
1257 | /** value64, in: | |
1258 | * SHFLHANDLE of object to be listed. | |
1259 | */ | |
1260 | HGCMFunctionParameter handle; | |
1261 | ||
1262 | /** value32, in: | |
1263 | * SHFL_INFO_* | |
1264 | */ | |
1265 | HGCMFunctionParameter flags; | |
1266 | ||
1267 | /** value32, in/out: | |
1268 | * Bytes to be used for information/How many bytes were used. | |
1269 | */ | |
1270 | HGCMFunctionParameter cb; | |
1271 | ||
1272 | /** pointer, in/out: | |
1273 | * Information to be set/get (SHFLFSOBJINFO or SHFLSTRING). Do not forget | |
1274 | * to set the SHFLFSOBJINFO::Attr::enmAdditional for Get operation as well. | |
1275 | */ | |
1276 | HGCMFunctionParameter info; | |
1277 | ||
1278 | } VBoxSFInformation; | |
1279 | ||
1280 | /** Number of parameters */ | |
1281 | #define SHFL_CPARMS_INFORMATION (5) | |
1282 | ||
1283 | ||
1284 | /** | |
1285 | * SHFL_FN_REMOVE | |
1286 | */ | |
1287 | ||
1288 | #define SHFL_REMOVE_FILE (0x1) | |
1289 | #define SHFL_REMOVE_DIR (0x2) | |
1290 | #define SHFL_REMOVE_SYMLINK (0x4) | |
1291 | ||
1292 | /** Parameters structure. */ | |
1293 | typedef struct _VBoxSFRemove | |
1294 | { | |
1295 | VBoxGuestHGCMCallInfo callInfo; | |
1296 | ||
1297 | /** pointer, in: SHFLROOT | |
1298 | * Root handle of the mapping which name is queried. | |
1299 | */ | |
1300 | HGCMFunctionParameter root; | |
1301 | ||
1302 | /** pointer, in: | |
1303 | * Points to SHFLSTRING buffer. | |
1304 | */ | |
1305 | HGCMFunctionParameter path; | |
1306 | ||
1307 | /** value32, in: | |
1308 | * remove flags (file/directory) | |
1309 | */ | |
1310 | HGCMFunctionParameter flags; | |
1311 | ||
1312 | } VBoxSFRemove; | |
1313 | ||
1314 | #define SHFL_CPARMS_REMOVE (3) | |
1315 | ||
1316 | ||
1317 | /** | |
1318 | * SHFL_FN_RENAME | |
1319 | */ | |
1320 | ||
1321 | #define SHFL_RENAME_FILE (0x1) | |
1322 | #define SHFL_RENAME_DIR (0x2) | |
1323 | #define SHFL_RENAME_REPLACE_IF_EXISTS (0x4) | |
1324 | ||
1325 | /** Parameters structure. */ | |
1326 | typedef struct _VBoxSFRename | |
1327 | { | |
1328 | VBoxGuestHGCMCallInfo callInfo; | |
1329 | ||
1330 | /** pointer, in: SHFLROOT | |
1331 | * Root handle of the mapping which name is queried. | |
1332 | */ | |
1333 | HGCMFunctionParameter root; | |
1334 | ||
1335 | /** pointer, in: | |
1336 | * Points to SHFLSTRING src. | |
1337 | */ | |
1338 | HGCMFunctionParameter src; | |
1339 | ||
1340 | /** pointer, in: | |
1341 | * Points to SHFLSTRING dest. | |
1342 | */ | |
1343 | HGCMFunctionParameter dest; | |
1344 | ||
1345 | /** value32, in: | |
1346 | * rename flags (file/directory) | |
1347 | */ | |
1348 | HGCMFunctionParameter flags; | |
1349 | ||
1350 | } VBoxSFRename; | |
1351 | ||
1352 | #define SHFL_CPARMS_RENAME (4) | |
1353 | ||
1354 | ||
1355 | /** | |
1356 | * SHFL_FN_SYMLINK | |
1357 | */ | |
1358 | ||
1359 | /** Parameters structure. */ | |
1360 | typedef struct _VBoxSFSymlink | |
1361 | { | |
1362 | VBoxGuestHGCMCallInfo callInfo; | |
1363 | ||
1364 | /** pointer, in: SHFLROOT | |
1365 | * Root handle of the mapping which name is queried. | |
1366 | */ | |
1367 | HGCMFunctionParameter root; | |
1368 | ||
1369 | /** pointer, in: | |
1370 | * Points to SHFLSTRING of path for the new symlink. | |
1371 | */ | |
1372 | HGCMFunctionParameter newPath; | |
1373 | ||
1374 | /** pointer, in: | |
1375 | * Points to SHFLSTRING of destination for symlink. | |
1376 | */ | |
1377 | HGCMFunctionParameter oldPath; | |
1378 | ||
1379 | /** pointer, out: | |
1380 | * Information about created symlink. | |
1381 | */ | |
1382 | HGCMFunctionParameter info; | |
1383 | ||
1384 | } VBoxSFSymlink; | |
1385 | ||
1386 | #define SHFL_CPARMS_SYMLINK (4) | |
1387 | ||
1388 | ||
1389 | ||
1390 | /** | |
1391 | * SHFL_FN_ADD_MAPPING | |
1392 | * Host call, no guest structure is used. | |
1393 | */ | |
1394 | ||
1395 | /** mapping is writable */ | |
1396 | #define SHFL_ADD_MAPPING_F_WRITABLE (RT_BIT_32(0)) | |
1397 | /** mapping is automounted by the guest */ | |
1398 | #define SHFL_ADD_MAPPING_F_AUTOMOUNT (RT_BIT_32(1)) | |
1399 | /** allow the guest to create symlinks */ | |
1400 | #define SHFL_ADD_MAPPING_F_CREATE_SYMLINKS (RT_BIT_32(2)) | |
1401 | /** mapping is actually missing on the host */ | |
1402 | #define SHFL_ADD_MAPPING_F_MISSING (RT_BIT_32(3)) | |
1403 | ||
1404 | #define SHFL_CPARMS_ADD_MAPPING (3) | |
1405 | ||
1406 | /** | |
1407 | * SHFL_FN_REMOVE_MAPPING | |
1408 | * Host call, no guest structure is used. | |
1409 | */ | |
1410 | ||
1411 | #define SHFL_CPARMS_REMOVE_MAPPING (1) | |
1412 | ||
1413 | ||
1414 | /** | |
1415 | * SHFL_FN_SET_STATUS_LED | |
1416 | * Host call, no guest structure is used. | |
1417 | */ | |
1418 | ||
1419 | #define SHFL_CPARMS_SET_STATUS_LED (1) | |
1420 | ||
1421 | /** @} */ | |
1422 | ||
1423 | #endif |