VirtualBox

source: vbox/trunk/include/iprt/vfs.h@ 62476

Last change on this file since 62476 was 62473, 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: 42.6 KB
Line 
1/** @file
2 * IPRT - Virtual Filesystem.
3 */
4
5/*
6 * Copyright (C) 2010-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 ___iprt_vfs_h
27#define ___iprt_vfs_h
28
29#include <iprt/cdefs.h>
30#include <iprt/types.h>
31#include <iprt/dir.h>
32#include <iprt/fs.h>
33#include <iprt/handle.h>
34#include <iprt/symlink.h>
35#include <iprt/sg.h>
36#include <iprt/time.h>
37
38
39RT_C_DECLS_BEGIN
40
41/** @defgroup grp_rt_vfs RTVfs - Virtual Filesystem
42 * @ingroup grp_rt
43 *
44 * The virtual filesystem APIs are intended to make it possible to work on
45 * container files, file system sub-trees, file system overlays and other custom
46 * filesystem configurations. It also makes it possible to create filters, like
47 * automatically gunzipping a tar.gz file before feeding it to the RTTar API for
48 * unpacking - or wise versa.
49 *
50 * The virtual filesystem APIs are intended to mirror the RTDir, RTFile, RTPath
51 * and RTFs APIs pretty closely so that rewriting a piece of code to work with
52 * it should be easy. However there are some differences to the way the APIs
53 * works and the user should heed the documentation. The differences are
54 * usually motivated by simplification and in some case to make the VFS more
55 * flexible.
56 *
57 * @{
58 */
59
60/**
61 * The object type.
62 */
63typedef enum RTVFSOBJTYPE
64{
65 /** Invalid type. */
66 RTVFSOBJTYPE_INVALID = 0,
67 /** Pure base object.
68 * This is returned by the filesystem stream to represent directories,
69 * devices, fifos and similar that needs to be created. */
70 RTVFSOBJTYPE_BASE,
71 /** Virtual filesystem. */
72 RTVFSOBJTYPE_VFS,
73 /** Filesystem stream. */
74 RTVFSOBJTYPE_FS_STREAM,
75 /** Pure I/O stream. */
76 RTVFSOBJTYPE_IO_STREAM,
77 /** Directory. */
78 RTVFSOBJTYPE_DIR,
79 /** File. */
80 RTVFSOBJTYPE_FILE,
81 /** Symbolic link. */
82 RTVFSOBJTYPE_SYMLINK,
83 /** End of valid object types. */
84 RTVFSOBJTYPE_END,
85 /** Pure I/O stream. */
86 RTVFSOBJTYPE_32BIT_HACK = 0x7fffffff
87} RTVFSOBJTYPE;
88/** Pointer to a VFS object type. */
89typedef RTVFSOBJTYPE *PRTVFSOBJTYPE;
90
91
92
93/** @name RTVfsCreate flags
94 * @{ */
95/** Whether the file system is read-only. */
96#define RTVFS_C_READONLY RT_BIT(0)
97/** Whether we the VFS should be thread safe (i.e. automaticaly employ
98 * locks). */
99#define RTVFS_C_THREAD_SAFE RT_BIT(1)
100/** @} */
101
102/**
103 * Creates an empty virtual filesystem.
104 *
105 * @returns IPRT status code.
106 * @param pszName Name, for logging and such.
107 * @param fFlags Flags, MBZ.
108 * @param phVfs Where to return the VFS handle. Release the returned
109 * reference by calling RTVfsRelease.
110 */
111RTDECL(int) RTVfsCreate(const char *pszName, uint32_t fFlags, PRTVFS phVfs);
112RTDECL(uint32_t) RTVfsRetain(RTVFS phVfs);
113RTDECL(uint32_t) RTVfsRelease(RTVFS phVfs);
114RTDECL(int) RTVfsAttach(RTVFS hVfs, const char *pszMountPoint, uint32_t fFlags, RTVFS hVfsAttach);
115RTDECL(int) RTVfsDetach(RTVFS hVfs, const char *pszMountPoint, RTVFS hVfsToDetach, PRTVFS *phVfsDetached);
116RTDECL(uint32_t) RTVfsGetAttachmentCount(RTVFS hVfs);
117RTDECL(int) RTVfsGetAttachment(RTVFS hVfs, uint32_t iOrdinal, PRTVFS *phVfsAttached, uint32_t *pfFlags,
118 char *pszMountPoint, size_t cbMountPoint);
119
120/**
121 * Checks whether a given range is in use by the virtual filesystem.
122 *
123 * @returns IPRT status code.
124 * @param hVfs VFS handle.
125 * @param off Start offset to check.
126 * @param cb Number of bytes to check.
127 * @param pfUsed Where to store the result.
128 */
129RTDECL(int) RTVfsIsRangeInUse(RTVFS hVfs, uint64_t off, size_t cb,
130 bool *pfUsed);
131
132/** @defgroup grp_vfs_obj VFS Base Object API
133 * @{
134 */
135
136/**
137 * Retains a reference to the VFS base object handle.
138 *
139 * @returns New reference count on success, UINT32_MAX on failure.
140 * @param hVfsObj The VFS base object handle.
141 */
142RTDECL(uint32_t) RTVfsObjRetain(RTVFSOBJ hVfsObj);
143
144/**
145 * Releases a reference to the VFS base handle.
146 *
147 * @returns New reference count on success (0 if closed), UINT32_MAX on failure.
148 * @param hVfsObj The VFS base object handle.
149 */
150RTDECL(uint32_t) RTVfsObjRelease(RTVFSOBJ hVfsObj);
151
152/**
153 * Query information about the object.
154 *
155 * @returns IPRT status code.
156 * @retval VERR_NOT_SUPPORTED if the @a enmAddAttr value is not handled by the
157 * implementation.
158 *
159 * @param hVfsObj The VFS object handle.
160 * @param pObjInfo Where to return the info.
161 * @param enmAddAttr Which additional attributes should be retrieved.
162 * @sa RTVfsIoStrmQueryInfo, RTVfsFileQueryInfo, RTFileQueryInfo,
163 * RTPathQueryInfo
164 */
165RTDECL(int) RTVfsObjQueryInfo(RTVFSOBJ hVfsObj, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr);
166
167
168/**
169 * Converts a VFS base object handle to a VFS handle.
170 *
171 * @returns Referenced handle on success, NIL on failure.
172 * @param hVfsObj The VFS base object handle.
173 */
174RTDECL(RTVFS) RTVfsObjToVfs(RTVFSOBJ hVfsObj);
175
176/**
177 * Converts a VFS base object handle to a VFS filesystem stream handle.
178 *
179 * @returns Referenced handle on success, NIL on failure.
180 * @param hVfsObj The VFS base object handle.
181 */
182RTDECL(RTVFSFSSTREAM) RTVfsObjToFsStream(RTVFSOBJ hVfsObj);
183
184/**
185 * Converts a VFS base object handle to a VFS directory handle.
186 *
187 * @returns Referenced handle on success, NIL on failure.
188 * @param hVfsObj The VFS base object handle.
189 */
190RTDECL(RTVFSDIR) RTVfsObjToDir(RTVFSOBJ hVfsObj);
191
192/**
193 * Converts a VFS base object handle to a VFS I/O stream handle.
194 *
195 * @returns Referenced handle on success, NIL on failure.
196 * @param hVfsObj The VFS base object handle.
197 */
198RTDECL(RTVFSIOSTREAM) RTVfsObjToIoStream(RTVFSOBJ hVfsObj);
199
200/**
201 * Converts a VFS base object handle to a VFS file handle.
202 *
203 * @returns Referenced handle on success, NIL on failure.
204 * @param hVfsObj The VFS base object handle.
205 */
206RTDECL(RTVFSFILE) RTVfsObjToFile(RTVFSOBJ hVfsObj);
207
208/**
209 * Converts a VFS base object handle to a VFS symbolic link handle.
210 *
211 * @returns Referenced handle on success, NIL on failure.
212 * @param hVfsObj The VFS base object handle.
213 */
214RTDECL(RTVFSSYMLINK) RTVfsObjToSymlink(RTVFSOBJ hVfsObj);
215
216
217/**
218 * Converts a VFS handle to a VFS base object handle.
219 *
220 * @returns Referenced handle on success, NIL if the input handle was invalid.
221 * @param hVfs The VFS handle.
222 */
223RTDECL(RTVFSOBJ) RTVfsObjFromVfs(RTVFS hVfs);
224
225/**
226 * Converts a VFS filesystem stream handle to a VFS base object handle.
227 *
228 * @returns Referenced handle on success, NIL if the input handle was invalid.
229 * @param hVfsFss The VFS filesystem stream handle.
230 */
231RTDECL(RTVFSOBJ) RTVfsObjFromFsStream(RTVFSFSSTREAM hVfsFss);
232
233/**
234 * Converts a VFS directory handle to a VFS base object handle.
235 *
236 * @returns Referenced handle on success, NIL if the input handle was invalid.
237 * @param hVfsDir The VFS directory handle.
238 */
239RTDECL(RTVFSOBJ) RTVfsObjFromDir(RTVFSDIR hVfsDir);
240
241/**
242 * Converts a VFS I/O stream handle to a VFS base object handle.
243 *
244 * @returns Referenced handle on success, NIL if the input handle was invalid.
245 * @param hVfsIos The VFS I/O stream handle.
246 */
247RTDECL(RTVFSOBJ) RTVfsObjFromIoStream(RTVFSIOSTREAM hVfsIos);
248
249/**
250 * Converts a VFS file handle to a VFS base object handle.
251 *
252 * @returns Referenced handle on success, NIL if the input handle was invalid.
253 * @param hVfsFile The VFS file handle.
254 */
255RTDECL(RTVFSOBJ) RTVfsObjFromFile(RTVFSFILE hVfsFile);
256
257/**
258 * Converts a VFS symbolic link handle to a VFS base object handle.
259 *
260 * @returns Referenced handle on success, NIL if the input handle was invalid.
261 * @param hVfsSym The VFS symbolic link handle.
262 */
263RTDECL(RTVFSOBJ) RTVfsObjFromSymlink(RTVFSSYMLINK hVfsSym);
264
265/** @} */
266
267
268/** @defgroup grp_vfs_fsstream VFS Filesystem Stream API
269 *
270 * Filesystem streams are for tar, cpio and similar. Any virtual filesystem can
271 * be turned into a filesystem stream using RTVfsFsStrmFromVfs.
272 *
273 * @{
274 */
275
276RTDECL(uint32_t) RTVfsFsStrmRetain(RTVFSFSSTREAM hVfsFss);
277RTDECL(uint32_t) RTVfsFsStrmRelease(RTVFSFSSTREAM hVfsFss);
278RTDECL(int) RTVfsFsStrmQueryInfo(RTVFSFSSTREAM hVfsFss, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr);
279
280/**
281 * Gets the next object in the stream.
282 *
283 * This call may affect the stream posision of a previously returned object.
284 *
285 * The type of object returned here typically boils down to three types:
286 * - I/O streams (representing files),
287 * - symbolic links
288 * - base object
289 * The base objects represent anything not convered by the two other, i.e.
290 * directories, device nodes, fifos, sockets and whatnot. The details can be
291 * queried using RTVfsObjQueryInfo.
292 *
293 * That said, absolutely any object except for filesystem stream objects can be
294 * returned by this call. Any generic code is adviced to just deal with it all.
295 *
296 * @returns IPRT status code.
297 * @retval VINF_SUCCESS if a new object was retrieved.
298 * @retval VERR_EOF when there are no more objects.
299 *
300 * @param hVfsFss The file system stream handle.
301 * @param ppszName Where to return the object name. Must be freed by
302 * calling RTStrFree.
303 * @param penmType Where to return the object type.
304 * @param phVfsObj Where to return the object handle (referenced). This
305 * must be cast to the desired type before use.
306 */
307RTDECL(int) RTVfsFsStrmNext(RTVFSFSSTREAM hVfsFss, char **ppszName, RTVFSOBJTYPE *penmType, PRTVFSOBJ phVfsObj);
308
309/** @} */
310
311
312/** @defgroup grp_vfs_dir VFS Directory API
313 * @{
314 */
315
316/**
317 * Retains a reference to the VFS directory handle.
318 *
319 * @returns New reference count on success, UINT32_MAX on failure.
320 * @param hVfsDir The VFS directory handle.
321 */
322RTDECL(uint32_t) RTVfsDirRetain(RTVFSDIR hVfsDir);
323
324/**
325 * Releases a reference to the VFS directory handle.
326 *
327 * @returns New reference count on success (0 if closed), UINT32_MAX on failure.
328 * @param hVfsDir The VFS directory handle.
329 */
330RTDECL(uint32_t) RTVfsDirRelease(RTVFSDIR hVfsDir);
331
332/** @} */
333
334
335/** @defgroup grp_vfs_symlink VFS Symbolic Link API
336 *
337 * @remarks The TAR VFS and filesystem stream uses symbolic links for
338 * describing hard links as well. The users must use RTFS_IS_SYMLINK
339 * to check if it is a real symlink in those cases.
340 *
341 * @remarks Any VFS which is backed by a real file system may be subject to
342 * races with other processes or threads, so the user may get
343 * unexpected errors when this happends. This is a bit host specific,
344 * i.e. it might be prevent on windows if we care.
345 *
346 * @{
347 */
348
349
350/**
351 * Retains a reference to the VFS symbolic link handle.
352 *
353 * @returns New reference count on success, UINT32_MAX on failure.
354 * @param hVfsSym The VFS symbolic link handle.
355 */
356RTDECL(uint32_t) RTVfsSymlinkRetain(RTVFSSYMLINK hVfsSym);
357
358/**
359 * Releases a reference to the VFS symbolic link handle.
360 *
361 * @returns New reference count on success (0 if closed), UINT32_MAX on failure.
362 * @param hVfsSym The VFS symbolic link handle.
363 */
364RTDECL(uint32_t) RTVfsSymlinkRelease(RTVFSSYMLINK hVfsSym);
365
366/**
367 * Query information about the symbolic link.
368 *
369 * @returns IPRT status code.
370 * @param hVfsSym The VFS symbolic link handle.
371 * @param pObjInfo Where to return the info.
372 * @param enmAddAttr Which additional attributes should be retrieved.
373 *
374 * @sa RTFileQueryInfo, RTPathQueryInfo, RTPathQueryInfoEx
375 */
376RTDECL(int) RTVfsSymlinkQueryInfo(RTVFSSYMLINK hVfsSym, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr);
377
378/**
379 * Set the unix style owner and group.
380 *
381 * @returns IPRT status code.
382 * @param hVfsSym The VFS symbolic link handle.
383 * @param fMode The new mode bits.
384 * @param fMask The mask indicating which bits we are changing.
385 * @sa RTFileSetMode, RTPathSetMode
386 */
387RTDECL(int) RTVfsSymlinkSetMode(RTVFSSYMLINK hVfsSym, RTFMODE fMode, RTFMODE fMask);
388
389/**
390 * Set the timestamps associated with the object.
391 *
392 * @returns IPRT status code.
393 * @param hVfsSym The VFS symbolic link handle.
394 * @param pAccessTime Pointer to the new access time. NULL if not
395 * to be changed.
396 * @param pModificationTime Pointer to the new modifcation time. NULL if
397 * not to be changed.
398 * @param pChangeTime Pointer to the new change time. NULL if not to be
399 * changed.
400 * @param pBirthTime Pointer to the new time of birth. NULL if not to be
401 * changed.
402 * @remarks See RTFileSetTimes for restrictions and behavior imposed by the
403 * host OS or underlying VFS provider.
404 * @sa RTFileSetTimes, RTPathSetTimes
405 */
406RTDECL(int) RTVfsSymlinkSetTimes(RTVFSSYMLINK hVfsSym, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
407 PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime);
408
409/**
410 * Set the unix style owner and group.
411 *
412 * @returns IPRT status code.
413 * @param hVfsSym The VFS symbolic link handle.
414 * @param uid The user ID of the new owner. NIL_RTUID if
415 * unchanged.
416 * @param gid The group ID of the new owner group. NIL_RTGID if
417 * unchanged.
418 * @sa RTFileSetOwner, RTPathSetOwner.
419 */
420RTDECL(int) RTVfsSymlinkSetOwner(RTVFSSYMLINK hVfsSym, RTUID uid, RTGID gid);
421
422/**
423 * Read the symbolic link target.
424 *
425 * @returns IPRT status code.
426 * @param hVfsSym The VFS symbolic link handle.
427 * @param pszTarget The target buffer.
428 * @param cbTarget The size of the target buffer.
429 * @sa RTSymlinkRead
430 */
431RTDECL(int) RTVfsSymlinkRead(RTVFSSYMLINK hVfsSym, char *pszTarget, size_t cbTarget);
432
433/** @} */
434
435
436
437/** @defgroup grp_vfs_iostream VFS I/O Stream API
438 * @{
439 */
440
441/**
442 * Creates a VFS file from a memory buffer.
443 *
444 * @returns IPRT status code.
445 *
446 * @param fFlags A combination of RTFILE_O_READ and RTFILE_O_WRITE.
447 * @param pvBuf The buffer. This will be copied and not referenced
448 * after this function returns.
449 * @param cbBuf The buffer size.
450 * @param phVfsIos Where to return the VFS I/O stream handle.
451 */
452RTDECL(int) RTVfsIoStrmFromBuffer(uint32_t fFlags, void const *pvBuf, size_t cbBuf, PRTVFSIOSTREAM phVfsIos);
453
454/**
455 * Creates a VFS I/O stream handle from a standard IPRT file handle (RTFILE).
456 *
457 * @returns IPRT status code.
458 * @param hFile The standard IPRT file handle.
459 * @param fOpen The flags the handle was opened with. Pass 0 to
460 * have these detected.
461 * @param fLeaveOpen Whether to leave the handle open when the VFS file
462 * is released, or to close it (@c false).
463 * @param phVfsIos Where to return the VFS I/O stream handle.
464 */
465RTDECL(int) RTVfsIoStrmFromRTFile(RTFILE hFile, uint64_t fOpen, bool fLeaveOpen, PRTVFSIOSTREAM phVfsIos);
466
467/**
468 * Creates a VFS I/O stream handle from a standard IPRT pipe handle (RTPIPE).
469 *
470 * @returns IPRT status code.
471 * @param hPipe The standard IPRT pipe handle.
472 * @param fLeaveOpen Whether to leave the handle open when the VFS file
473 * is released, or to close it (@c false).
474 * @param phVfsIos Where to return the VFS I/O stream handle.
475 */
476RTDECL(int) RTVfsIoStrmFromRTPipe(RTPIPE hPipe, bool fLeaveOpen, PRTVFSIOSTREAM phVfsIos);
477
478/**
479 * Convenience function combining RTFileOpen with RTVfsIoStrmFromRTFile.
480 *
481 * @returns IPRT status code.
482 * @param pszFilename The path to the file in the normal file system.
483 * @param fOpen The flags to pass to RTFileOpen when opening the
484 * file, i.e. RTFILE_O_XXX.
485 * @param phVfsIos Where to return the VFS I/O stream handle.
486 */
487RTDECL(int) RTVfsIoStrmOpenNormal(const char *pszFilename, uint64_t fOpen, PRTVFSIOSTREAM phVfsIos);
488
489/**
490 * Create a VFS I/O stream handle from one of the standard handles.
491 *
492 * @returns IPRT status code.
493 * @param enmStdHandle The standard IPRT file handle.
494 * @param fOpen The flags the handle was opened with. Pass 0 to
495 * have these detected.
496 * @param fLeaveOpen Whether to leave the handle open when the VFS file
497 * is released, or to close it (@c false).
498 * @param phVfsIos Where to return the VFS I/O stream handle.
499 */
500RTDECL(int) RTVfsIoStrmFromStdHandle(RTHANDLESTD enmStdHandle, uint64_t fOpen, bool fLeaveOpen,
501 PRTVFSIOSTREAM phVfsIos);
502
503/**
504 * Retains a reference to the VFS I/O stream handle.
505 *
506 * @returns New reference count on success, UINT32_MAX on failure.
507 * @param hVfsIos The VFS I/O stream handle.
508 */
509RTDECL(uint32_t) RTVfsIoStrmRetain(RTVFSIOSTREAM hVfsIos);
510
511/**
512 * Releases a reference to the VFS I/O stream handle.
513 *
514 * @returns New reference count on success (0 if closed), UINT32_MAX on failure.
515 * @param hVfsIos The VFS I/O stream handle.
516 */
517RTDECL(uint32_t) RTVfsIoStrmRelease(RTVFSIOSTREAM hVfsIos);
518
519/**
520 * Convert the VFS I/O stream handle to a VFS file handle.
521 *
522 * @returns The VFS file handle on success, this must be released.
523 * NIL_RTVFSFILE if the I/O stream handle is invalid.
524 * @param hVfsIos The VFS I/O stream handle.
525 * @sa RTVfsFileToIoStream
526 */
527RTDECL(RTVFSFILE) RTVfsIoStrmToFile(RTVFSIOSTREAM hVfsIos);
528
529/**
530 * Query information about the I/O stream.
531 *
532 * @returns IPRT status code.
533 * @param hVfsIos The VFS I/O stream handle.
534 * @param pObjInfo Where to return the info.
535 * @param enmAddAttr Which additional attributes should be retrieved.
536 * @sa RTFileQueryInfo
537 */
538RTDECL(int) RTVfsIoStrmQueryInfo(RTVFSIOSTREAM hVfsIos, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr);
539
540/**
541 * Read bytes from the I/O stream.
542 *
543 * @returns IPRT status code.
544 * @retval VINF_SUCCESS and the number of bytes read written to @a pcbRead.
545 * @retval VINF_TRY_AGAIN if @a fBlocking is @c false, @a pcbRead is not NULL,
546 * and no data was available. @a *pcbRead will be set to 0.
547 * @retval VINF_EOF when trying to read __beyond__ the end of the stream and
548 * @a pcbRead is not NULL (it will be set to the number of bytes read,
549 * or 0 if the end of the stream was reached before this call).
550 * When the last byte of the read request is the last byte in the
551 * stream, this status code will not be used. However, VINF_EOF is
552 * returned when attempting to read 0 bytes while standing at the end
553 * of the stream.
554 * @retval VERR_EOF when trying to read __beyond__ the end of the stream and
555 * @a pcbRead is NULL.
556 * @retval VERR_ACCESS_DENIED if the stream is not readable.
557 *
558 * @param hVfsIos The VFS I/O stream handle.
559 * @param pvBuf Where to store the read bytes.
560 * @param cbToRead The number of bytes to read.
561 * @param fBlocking Whether the call is blocking (@c true) or not. If
562 * not, the @a pcbRead parameter must not be NULL.
563 * @param pcbRead Where to always store the number of bytes actually
564 * read. This can be NULL if @a fBlocking is true.
565 * @sa RTVfsFileRead, RTFileRead, RTPipeRead, RTPipeReadBlocking,
566 * RTSocketRead
567 */
568RTDECL(int) RTVfsIoStrmRead(RTVFSIOSTREAM hVfsIos, void *pvBuf, size_t cbToRead, bool fBlocking, size_t *pcbRead);
569
570/**
571 * Read bytes from the I/O stream, optionally with offset.
572 *
573 * @returns IPRT status code.
574 * @retval VINF_SUCCESS and the number of bytes read written to @a pcbRead.
575 * @retval VINF_TRY_AGAIN if @a fBlocking is @c false, @a pcbRead is not NULL,
576 * and no data was available. @a *pcbRead will be set to 0.
577 * @retval VINF_EOF when trying to read __beyond__ the end of the stream and
578 * @a pcbRead is not NULL (it will be set to the number of bytes read,
579 * or 0 if the end of the stream was reached before this call).
580 * When the last byte of the read request is the last byte in the
581 * stream, this status code will not be used. However, VINF_EOF is
582 * returned when attempting to read 0 bytes while standing at the end
583 * of the stream.
584 * @retval VERR_EOF when trying to read __beyond__ the end of the stream and
585 * @a pcbRead is NULL.
586 * @retval VERR_ACCESS_DENIED if the stream is not readable.
587 *
588 * @param hVfsIos The VFS I/O stream handle.
589 * @param off Where to read at, -1 for the current position.
590 * @param pvBuf Where to store the read bytes.
591 * @param cbToRead The number of bytes to read.
592 * @param fBlocking Whether the call is blocking (@c true) or not. If
593 * not, the @a pcbRead parameter must not be NULL.
594 * @param pcbRead Where to always store the number of bytes actually
595 * read. This can be NULL if @a fBlocking is true.
596 * @sa RTVfsFileRead, RTFileRead, RTPipeRead, RTPipeReadBlocking,
597 * RTSocketRead
598 */
599RTDECL(int) RTVfsIoStrmReadAt(RTVFSIOSTREAM hVfsIos, RTFOFF off, void *pvBuf, size_t cbToRead, bool fBlocking, size_t *pcbRead);
600
601/**
602 * Reads the remainder of the stream into a memory buffer.
603 *
604 * For simplifying string-style processing, the is a zero byte after the
605 * returned buffer, making sure it can be used as a zero terminated string.
606 *
607 * @returns IPRT status code.
608 * @param hVfsIos The VFS I/O stream handle.
609 * @param ppvBuf Where to return the buffer. Must pass to
610 * RTVfsIoStrmReadAllFree for freeing, not RTMemFree!
611 * @param pcbBuf Where to return the buffer size.
612 */
613RTDECL(int) RTVfsIoStrmReadAll(RTVFSIOSTREAM hVfsIos, void **ppvBuf, size_t *pcbBuf);
614
615/**
616 * Free memory buffer returned by RTVfsIoStrmReadAll.
617 *
618 * @param pvBuf What RTVfsIoStrmReadAll returned.
619 * @param cbBuf What RTVfsIoStrmReadAll returned.
620 */
621RTDECL(void) RTVfsIoStrmReadAllFree(void *pvBuf, size_t cbBuf);
622
623/**
624 * Write bytes to the I/O stream.
625 *
626 * @returns IPRT status code.
627 * @retval VERR_ACCESS_DENIED if the stream is not writable.
628 *
629 * @param hVfsIos The VFS I/O stream handle.
630 * @param pvBuf The bytes to write.
631 * @param cbToWrite The number of bytes to write.
632 * @param fBlocking Whether the call is blocking (@c true) or not. If
633 * not, the @a pcbWritten parameter must not be NULL.
634 * @param pcbWritten Where to always store the number of bytes actually
635 * written. This can be NULL if @a fBlocking is true.
636 * @sa RTVfsFileWrite, RTFileWrite, RTPipeWrite, RTPipeWriteBlocking,
637 * RTSocketWrite
638 */
639RTDECL(int) RTVfsIoStrmWrite(RTVFSIOSTREAM hVfsIos, const void *pvBuf, size_t cbToWrite, bool fBlocking, size_t *pcbWritten);
640RTDECL(int) RTVfsIoStrmWriteAt(RTVFSIOSTREAM hVfsIos, RTFOFF off, const void *pvBuf, size_t cbToWrite, bool fBlocking, size_t *pcbWritten);
641
642/**
643 * Reads bytes from the I/O stream into a scatter buffer.
644 *
645 * @returns IPRT status code.
646 * @retval VINF_SUCCESS and the number of bytes read written to @a pcbRead.
647 * @retval VINF_TRY_AGAIN if @a fBlocking is @c false, @a pcbRead is not NULL,
648 * and no data was available. @a *pcbRead will be set to 0.
649 * @retval VINF_EOF when trying to read __beyond__ the end of the stream and
650 * @a pcbRead is not NULL (it will be set to the number of bytes read,
651 * or 0 if the end of the stream was reached before this call).
652 * When the last byte of the read request is the last byte in the
653 * stream, this status code will not be used. However, VINF_EOF is
654 * returned when attempting to read 0 bytes while standing at the end
655 * of the stream.
656 * @retval VERR_EOF when trying to read __beyond__ the end of the stream and
657 * @a pcbRead is NULL.
658 * @retval VERR_ACCESS_DENIED if the stream is not readable.
659 *
660 * @param hVfsIos The VFS I/O stream handle.
661 * @param off Where to read at, -1 for the current position.
662 * @param pSgBuf Pointer to a scatter buffer descriptor. The number
663 * of bytes described by the segments is what will be
664 * attemted read.
665 * @param fBlocking Whether the call is blocking (@c true) or not. If
666 * not, the @a pcbRead parameter must not be NULL.
667 * @param pcbRead Where to always store the number of bytes actually
668 * read. This can be NULL if @a fBlocking is true.
669 * @sa RTFileSgRead, RTSocketSgRead, RTPipeRead, RTPipeReadBlocking
670 */
671RTDECL(int) RTVfsIoStrmSgRead(RTVFSIOSTREAM hVfsIos, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead);
672
673/**
674 * Write bytes to the I/O stream from a gather buffer.
675 *
676 * @returns IPRT status code.
677 * @retval VERR_ACCESS_DENIED if the stream is not writable.
678 *
679 * @param hVfsIos The VFS I/O stream handle.
680 * @param off Where to write at, -1 for the current position.
681 * @param pSgBuf Pointer to a gather buffer descriptor. The number
682 * of bytes described by the segments is what will be
683 * attemted written.
684 * @param fBlocking Whether the call is blocking (@c true) or not. If
685 * not, the @a pcbWritten parameter must not be NULL.
686 * @param pcbWritten Where to always store the number of bytes actually
687 * written. This can be NULL if @a fBlocking is true.
688 * @sa RTFileSgWrite, RTSocketSgWrite
689 */
690RTDECL(int) RTVfsIoStrmSgWrite(RTVFSIOSTREAM hVfsIos, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten);
691
692/**
693 * Flush any buffered data to the I/O stream.
694 *
695 * @returns IPRT status code.
696 * @param hVfsIos The VFS I/O stream handle.
697 * @sa RTVfsFileFlush, RTFileFlush, RTPipeFlush
698 */
699RTDECL(int) RTVfsIoStrmFlush(RTVFSIOSTREAM hVfsIos);
700
701/**
702 * Poll for events.
703 *
704 * @returns IPRT status code.
705 * @param hVfsIos The VFS I/O stream handle.
706 * @param fEvents The events to poll for (RTPOLL_EVT_XXX).
707 * @param cMillies How long to wait for event to eventuate.
708 * @param fIntr Whether the wait is interruptible and can return
709 * VERR_INTERRUPTED (@c true) or if this condition
710 * should be hidden from the caller (@c false).
711 * @param pfRetEvents Where to return the event mask.
712 * @sa RTVfsFilePoll, RTPollSetAdd, RTPoll, RTPollNoResume.
713 */
714RTDECL(int) RTVfsIoStrmPoll(RTVFSIOSTREAM hVfsIos, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
715 uint32_t *pfRetEvents);
716/**
717 * Tells the current I/O stream position.
718 *
719 * @returns Zero or higher - where to return the I/O stream offset. Values
720 * below zero are IPRT status codes (VERR_XXX).
721 * @param hVfsIos The VFS I/O stream handle.
722 * @sa RTFileTell
723 */
724RTDECL(RTFOFF) RTVfsIoStrmTell(RTVFSIOSTREAM hVfsIos);
725
726/**
727 * Skips @a cb ahead in the stream.
728 *
729 * @returns IPRT status code.
730 * @param hVfsIos The VFS I/O stream handle.
731 * @param cb The number bytes to skip.
732 */
733RTDECL(int) RTVfsIoStrmSkip(RTVFSIOSTREAM hVfsIos, RTFOFF cb);
734
735/**
736 * Fills the stream with @a cb zeros.
737 *
738 * @returns IPRT status code.
739 * @param hVfsIos The VFS I/O stream handle.
740 * @param cb The number of zero bytes to insert.
741 */
742RTDECL(int) RTVfsIoStrmZeroFill(RTVFSIOSTREAM hVfsIos, RTFOFF cb);
743
744/**
745 * Checks if we're at the end of the I/O stream.
746 *
747 * @returns true if at EOS, otherwise false.
748 * @param hVfsIos The VFS I/O stream handle.
749 */
750RTDECL(bool) RTVfsIoStrmIsAtEnd(RTVFSIOSTREAM hVfsIos);
751
752/**
753 * Process the rest of the stream, checking if it's all valid UTF-8 encoding.
754 *
755 * @returns IPRT status code.
756 *
757 * @param hVfsIos The VFS I/O stream handle.
758 * @param fFlags Flags governing the validation, see
759 * RTVFS_VALIDATE_UTF8_XXX.
760 * @param poffError Where to return the error offset. Optional.
761 */
762RTDECL(int) RTVfsIoStrmValidateUtf8Encoding(RTVFSIOSTREAM hVfsIos, uint32_t fFlags, PRTFOFF poffError);
763
764/** @defgroup RTVFS_VALIDATE_UTF8_XXX RTVfsIoStrmValidateUtf8Encoding flags.
765 * @{ */
766/** The text must not contain any null terminator codepoints. */
767#define RTVFS_VALIDATE_UTF8_NO_NULL RT_BIT_32(0)
768/** The codepoints must be in the range covered by RTC-3629. */
769#define RTVFS_VALIDATE_UTF8_BY_RTC_3629 RT_BIT_32(1)
770/** Mask of valid flags. */
771#define RTVFS_VALIDATE_UTF8_VALID_MASK UINT32_C(0x00000003)
772/** @} */
773
774/** @} */
775
776
777/** @defgroup grp_vfs_file VFS File API
778 * @{
779 */
780RTDECL(int) RTVfsFileOpen(RTVFS hVfs, const char *pszFilename, uint64_t fOpen, PRTVFSFILE phVfsFile);
781
782/**
783 * Create a VFS file handle from a standard IPRT file handle (RTFILE).
784 *
785 * @returns IPRT status code.
786 * @param hFile The standard IPRT file handle.
787 * @param fOpen The flags the handle was opened with. Pass 0 to
788 * have these detected.
789 * @param fLeaveOpen Whether to leave the handle open when the VFS file
790 * is released, or to close it (@c false).
791 * @param phVfsFile Where to return the VFS file handle.
792 */
793RTDECL(int) RTVfsFileFromRTFile(RTFILE hFile, uint64_t fOpen, bool fLeaveOpen, PRTVFSFILE phVfsFile);
794RTDECL(RTHCUINTPTR) RTVfsFileToNative(RTFILE hVfsFile);
795
796/**
797 * Convenience function combining RTFileOpen with RTVfsFileFromRTFile.
798 *
799 * @returns IPRT status code.
800 * @param pszFilename The path to the file in the normal file system.
801 * @param fOpen The flags to pass to RTFileOpen when opening the
802 * file, i.e. RTFILE_O_XXX.
803 * @param phVfsFile Where to return the VFS file handle.
804 */
805RTDECL(int) RTVfsFileOpenNormal(const char *pszFilename, uint64_t fOpen, PRTVFSFILE phVfsFile);
806
807/**
808 * Convert the VFS file handle to a VFS I/O stream handle.
809 *
810 * @returns The VFS I/O stream handle on success, this must be released.
811 * NIL_RTVFSIOSTREAM if the file handle is invalid.
812 * @param hVfsFile The VFS file handle.
813 * @sa RTVfsIoStrmToFile
814 */
815RTDECL(RTVFSIOSTREAM) RTVfsFileToIoStream(RTVFSFILE hVfsFile);
816
817/**
818 * Retains a reference to the VFS file handle.
819 *
820 * @returns New reference count on success, UINT32_MAX on failure.
821 * @param hVfsFile The VFS file handle.
822 */
823RTDECL(uint32_t) RTVfsFileRetain(RTVFSFILE hVfsFile);
824
825/**
826 * Releases a reference to the VFS file handle.
827 *
828 * @returns New reference count on success (0 if closed), UINT32_MAX on failure.
829 * @param hVfsFile The VFS file handle.
830 */
831RTDECL(uint32_t) RTVfsFileRelease(RTVFSFILE hVfsFile);
832
833/**
834 * Query information about the object.
835 *
836 * @returns IPRT status code.
837 * @retval VERR_NOT_SUPPORTED if the @a enmAddAttr value is not handled by the
838 * implementation.
839 *
840 * @param hVfsFile The VFS file handle.
841 * @param pObjInfo Where to return the info.
842 * @param enmAddAttr Which additional attributes should be retrieved.
843 * @sa RTVfsObjQueryInfo, RTVfsFsStrmQueryInfo, RTVfsDirQueryInfo,
844 * RTVfsIoStrmQueryInfo, RTVfsFileQueryInfo, RTFileQueryInfo,
845 * RTPathQueryInfo.
846 */
847RTDECL(int) RTVfsFileQueryInfo(RTVFSFILE hVfsFile, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr);
848
849/**
850 * Read bytes from the file at the current position.
851 *
852 * @returns IPRT status code.
853 * @retval VINF_SUCCESS and the number of bytes read written to @a pcbRead.
854 * @retval VINF_EOF when trying to read __beyond__ the end of the file and
855 * @a pcbRead is not NULL (it will be set to the number of bytes read,
856 * or 0 if the end of the file was reached before this call).
857 * When the last byte of the read request is the last byte in the
858 * file, this status code will not be used. However, VINF_EOF is
859 * returned when attempting to read 0 bytes while standing at the end
860 * of the file.
861 * @retval VERR_EOF when trying to read __beyond__ the end of the file and
862 * @a pcbRead is NULL.
863 * @retval VERR_ACCESS_DENIED if the file is not readable.
864 *
865 * @param hVfsFile The VFS file handle.
866 * @param pvBuf Where to store the read bytes.
867 * @param cbToRead The number of bytes to read.
868 * @param pcbRead Where to always store the number of bytes actually
869 * read. Optional.
870 * @sa RTVfsIoStrmRead, RTFileRead, RTPipeRead, RTPipeReadBlocking,
871 * RTSocketRead
872 */
873RTDECL(int) RTVfsFileRead(RTVFSFILE hVfsFile, void *pvBuf, size_t cbToRead, size_t *pcbRead);
874RTDECL(int) RTVfsFileReadAt(RTVFSFILE hVfsFile, RTFOFF off, void *pvBuf, size_t cbToRead, size_t *pcbRead);
875
876/**
877 * Write bytes to the file at the current position.
878 *
879 * @returns IPRT status code.
880 * @retval VERR_ACCESS_DENIED if the file is not writable.
881 *
882 * @param hVfsFile The VFS file handle.
883 * @param pvBuf The bytes to write.
884 * @param cbToWrite The number of bytes to write.
885 * @param pcbWritten Where to always store the number of bytes actually
886 * written. This can be NULL.
887 * @sa RTVfsIoStrmRead, RTFileWrite, RTPipeWrite, RTPipeWriteBlocking,
888 * RTSocketWrite
889 */
890RTDECL(int) RTVfsFileWrite(RTVFSFILE hVfsFile, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten);
891RTDECL(int) RTVfsFileWriteAt(RTVFSFILE hVfsFile, RTFOFF off, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten);
892
893/**
894 * Flush any buffered data to the file.
895 *
896 * @returns IPRT status code.
897 * @param hVfsFile The VFS file handle.
898 * @sa RTVfsIoStrmFlush, RTFileFlush, RTPipeFlush
899 */
900RTDECL(int) RTVfsFileFlush(RTVFSFILE hVfsFile);
901
902/**
903 * Poll for events.
904 *
905 * @returns IPRT status code.
906 * @param hVfsFile The VFS file handle.
907 * @param fEvents The events to poll for (RTPOLL_EVT_XXX).
908 * @param cMillies How long to wait for event to eventuate.
909 * @param fIntr Whether the wait is interruptible and can return
910 * VERR_INTERRUPTED (@c true) or if this condition
911 * should be hidden from the caller (@c false).
912 * @param pfRetEvents Where to return the event mask.
913 * @sa RTVfsIoStrmPoll, RTPollSetAdd, RTPoll, RTPollNoResume.
914 */
915RTDECL(RTFOFF) RTVfsFilePoll(RTVFSFILE hVfsFile, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
916 uint32_t *pfRetEvents);
917
918/**
919 * Tells the current file position.
920 *
921 * @returns Zero or higher - where to return the file offset. Values
922 * below zero are IPRT status codes (VERR_XXX).
923 * @param hVfsFile The VFS file handle.
924 * @sa RTFileTell, RTVfsIoStrmTell.
925 */
926RTDECL(RTFOFF) RTVfsFileTell(RTVFSFILE hVfsFile);
927
928/**
929 * Changes the current read/write position of a file.
930 *
931 * @returns IPRT status code.
932 *
933 * @param hVfsFile The VFS file handle.
934 * @param offSeek The seek offset.
935 * @param uMethod The seek emthod.
936 * @param poffActual Where to optionally return the new file offset.
937 *
938 * @sa RTFileSeek
939 */
940RTDECL(int) RTVfsFileSeek(RTVFSFILE hVfsFile, RTFOFF offSeek, uint32_t uMethod, uint64_t *poffActual);
941
942RTDECL(int) RTVfsFileSetSize(RTVFSFILE hVfsFile, uint64_t cbSize);
943RTDECL(int) RTVfsFileGetSize(RTVFSFILE hVfsFile, uint64_t *pcbSize);
944RTDECL(RTFOFF) RTVfsFileGetMaxSize(RTVFSFILE hVfsFile);
945RTDECL(int) RTVfsFileGetMaxSizeEx(RTVFSFILE hVfsFile, PRTFOFF pcbMax);
946
947/** @} */
948
949
950/** @defgroup grp_vfs_misc VFS Miscellaneous
951 * @{
952 */
953
954/**
955 * Memorizes the I/O stream as a file backed by memory.
956 *
957 * @returns IPRT status code.
958 *
959 * @param hVfsIos The VFS I/O stream to memorize. This will be read
960 * to the end on success, on failure its position is
961 * undefined.
962 * @param fFlags A combination of RTFILE_O_READ and RTFILE_O_WRITE.
963 * @param phVfsFile Where to return the handle to the memory file on
964 * success.
965 */
966RTDECL(int) RTVfsMemorizeIoStreamAsFile(RTVFSIOSTREAM hVfsIos, uint32_t fFlags, PRTVFSFILE phVfsFile);
967
968
969/**
970 * Creates a VFS file from a memory buffer.
971 *
972 * @returns IPRT status code.
973 *
974 * @param fFlags A combination of RTFILE_O_READ and RTFILE_O_WRITE.
975 * @param pvBuf The buffer. This will be copied and not referenced
976 * after this function returns.
977 * @param cbBuf The buffer size.
978 * @param phVfsFile Where to return the handle to the memory file on
979 * success.
980 */
981RTDECL(int) RTVfsFileFromBuffer(uint32_t fFlags, void const *pvBuf, size_t cbBuf, PRTVFSFILE phVfsFile);
982
983/**
984 * Creates a memory backed VFS file object for read and write.
985 *
986 * @returns IPRT status code.
987 *
988 * @param hVfsIos The VFS I/O stream to memorize. This will be read
989 * to the end on success, on failure its position is
990 * undefined.
991 * @param cbEstimate The estimated file size.
992 * @param phVfsFile Where to return the handle to the memory file on
993 * success.
994 */
995RTDECL(int) RTVfsMemFileCreate(RTVFSIOSTREAM hVfsIos, size_t cbEstimate, PRTVFSFILE phVfsFile);
996
997/**
998 * Pumps data from one I/O stream to another.
999 *
1000 * The data is read in chunks from @a hVfsIosSrc and written to @a hVfsIosDst
1001 * until @a hVfsIosSrc indicates end of stream.
1002 *
1003 * @returns IPRT status code
1004 *
1005 * @param hVfsIosSrc The input stream.
1006 * @param hVfsIosDst The output stream.
1007 * @param cbBufHint Hints at a good temporary buffer size, pass 0 if
1008 * clueless.
1009 */
1010RTDECL(int) RTVfsUtilPumpIoStreams(RTVFSIOSTREAM hVfsIosSrc, RTVFSIOSTREAM hVfsIosDst, size_t cbBufHint);
1011
1012/**
1013 * Create an I/O stream instance performing simple sequential read-ahead.
1014 *
1015 * @returns IPRT status code.
1016 * @param hVfsIos The input stream to perform read ahead on. If this is
1017 * actually for a file object, the returned I/O stream
1018 * handle can also be cast to a file handle.
1019 * @param fFlags Flags reserved for future use, MBZ.
1020 * @param cBuffers How many read ahead buffers to use. Specify 0 for
1021 * default value.
1022 * @param cbBuffer The size of each read ahead buffer. Specify 0 for
1023 * default value.
1024 * @param phVfsIos Where to return the read ahead I/O stream handle.
1025 *
1026 * @remarks Careful using this on a message pipe or socket. The reads are
1027 * performed in blocked mode and it may be host and/or implementation
1028 * dependent whether they will return ready data immediate or wait
1029 * until there's a whole @a cbBuffer (or default) worth ready.
1030 *
1031 * @sa RTVfsCreateReadAheadForFile
1032 */
1033RTDECL(int) RTVfsCreateReadAheadForIoStream(RTVFSIOSTREAM hVfsIos, uint32_t fFlags, uint32_t cBuffers, uint32_t cbBuffer,
1034 PRTVFSIOSTREAM phVfsIos);
1035
1036/**
1037 * Create an I/O stream instance performing simple sequential read-ahead.
1038 *
1039 * @returns IPRT status code.
1040 * @param hVfsFile The input file to perform read ahead on.
1041 * @param fFlags Flags reserved for future use, MBZ.
1042 * @param cBuffers How many read ahead buffers to use. Specify 0 for
1043 * default value.
1044 * @param cbBuffer The size of each read ahead buffer. Specify 0 for
1045 * default value.
1046 * @param phVfsFile Where to return the read ahead file handle.
1047 * @sa RTVfsCreateReadAheadForIoStream
1048 */
1049RTDECL(int) RTVfsCreateReadAheadForFile(RTVFSFILE hVfsFile, uint32_t fFlags, uint32_t cBuffers, uint32_t cbBuffer,
1050 PRTVFSFILE phVfsFile);
1051
1052/** @} */
1053
1054
1055/** @defgroup grp_rt_vfs_chain VFS Chains
1056 *
1057 * VFS chains is for doing pipe like things with VFS objects from the command
1058 * line. Imagine you want to cat the readme.gz of an ISO you could do
1059 * something like:
1060 * RTCat :iprtvfs:vfs(isofs,./mycd.iso)|ios(open,readme.gz)|ios(gunzip)
1061 * or
1062 * RTCat :iprtvfs:ios(isofs,./mycd.iso,/readme.gz)|ios(gunzip)
1063 *
1064 * The "isofs", "open" and "gunzip" bits in the above examples are chain
1065 * element providers registered with IPRT. See RTVFSCHAINELEMENTREG for how
1066 * these works.
1067 *
1068 * @{ */
1069
1070/** The path prefix used to identify an VFS chain specification. */
1071#define RTVFSCHAIN_SPEC_PREFIX ":iprtvfs:"
1072
1073RTDECL(int) RTVfsChainOpenVfs( const char *pszSpec, PRTVFS phVfs, const char **ppszError);
1074RTDECL(int) RTVfsChainOpenFsStream( const char *pszSpec, PRTVFSFSSTREAM phVfsFss, const char **ppszError);
1075RTDECL(int) RTVfsChainOpenDir( const char *pszSpec, uint64_t fOpen, PRTVFSDIR phVfsDir, const char **ppszError);
1076RTDECL(int) RTVfsChainOpenFile( const char *pszSpec, uint64_t fOpen, PRTVFSFILE phVfsFile, const char **ppszError);
1077RTDECL(int) RTVfsChainOpenSymlink( const char *pszSpec, PRTVFSSYMLINK phVfsSym, const char **ppszError);
1078RTDECL(int) RTVfsChainOpenIoStream( const char *pszSpec, uint64_t fOpen, PRTVFSIOSTREAM phVfsIos, const char **ppszError);
1079
1080/**
1081 * Tests if the given string is a chain specification or not.
1082 *
1083 * @returns true if it is, false if it isn't.
1084 * @param pszSpec The alleged chain spec.
1085 */
1086RTDECL(bool) RTVfsChainIsSpec(const char *pszSpec);
1087
1088/** @} */
1089
1090
1091/** @} */
1092
1093RT_C_DECLS_END
1094
1095#endif /* !___iprt_vfs_h */
1096
Note: See TracBrowser for help on using the repository browser.

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