MoreFilesX.h

/*
File:       MoreFilesX.h
 
Abstract:   A collection of useful high-level File Manager routines which use
            the HFS Plus APIs wherever possible.
 
Version:    1.0.2
 
Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple
Computer, Inc. ("Apple") in consideration of your agreement to the
following terms, and your use, installation, modification or
redistribution of this Apple software constitutes acceptance of these
terms.  If you do not agree with these terms, please do not use,
install, modify or redistribute this Apple software.
 
In consideration of your agreement to abide by the following terms, and
subject to these terms, Apple grants you a personal, non-exclusive
license, under Apple's copyrights in this original Apple software (the
"Apple Software"), to use, reproduce, modify and redistribute the Apple
Software, with or without modifications, in source and/or binary forms;
provided that if you redistribute the Apple Software in its entirety and
without modifications, you must retain this notice and the following
text and disclaimers in all such redistributions of the Apple Software. 
Neither the name, trademarks, service marks or logos of Apple Computer,
Inc. may be used to endorse or promote products derived from the Apple
Software without specific prior written permission from Apple.  Except
as expressly stated in this notice, no other rights or licenses, express
or implied, are granted by Apple herein, including but not limited to
any patent rights that may be infringed by your derivative works or by
other works in which the Apple Software may be incorporated.
 
The Apple Software is provided by Apple on an "AS IS" basis.  APPLE
MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
 
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
 
Copyright © 1992-2005 Apple Computer, Inc., All Rights Reserved
 
For bug reports, consult the following page on the World Wide Web:
    <http://developer.apple.com/bugreporter/>
 
Change History (most recent first):
 
    <4> 18 Dec 2004 <rdar://problem/3926695>
                    Replaced FSLockRange and FSUnlockRange with
                    FSLockRangeCompat and FSUnlockRangeCompat.
    <3> 19 Apr 2002 <rdar://problem/2853905>
                    Fixed #if test around header includes.
    <2> 19 Apr 2002 <rdar://problem/2853901>
                    Updated standard disclaimer.
    <1> 25 Jan 2002 MoreFilesX 1.0
    
Notes:
    What do those arrows in the documentation for each routine mean?
        
        --> The parameter is an input
        
        <-- The parameter is an output. The pointer to the variable
            where the output will be returned (must not be NULL).
        
        <** The parameter is an optional output. If it is not a
            NULL pointer, it points to the variable where the output
            will be returned. If it is a NULL pointer, the output will
            not be returned and will possibly let the routine and the
            File Manager do less work. If you don't need an optional output,
            don't ask for it.
        **> The parameter is an optional input. If it is not a
            NULL pointer, it points to the variable containing the
            input data. If it is a NULL pointer, the input is not used
            and will possibly let the routine and the File Manager
            do less work.
*/
 
#ifndef __MOREFILESX__
#define __MOREFILESX__
 
#ifndef __CARBON__
    #if defined(__MACH__)
        #include <Carbon/Carbon.h>
    #else
        #include <Carbon.h>
    #endif
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
    #pragma options align=mac68k
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
    #pragma pack(2)
#endif
 
/*****************************************************************************/
 
#pragma mark ----- FinderInfo and ExtendedFinderInfo -----
 
/*
 *  FSGetFinderInfo and FSSetFinderInfo use these unions for Finder information.
 */
 
union FinderInfo
{
  FileInfo              file;
  FolderInfo            folder;
};
typedef union FinderInfo FinderInfo;
 
union ExtendedFinderInfo
{
  ExtendedFileInfo      file;
  ExtendedFolderInfo    folder;
};
typedef union ExtendedFinderInfo ExtendedFinderInfo;
 
/*****************************************************************************/
 
#pragma mark ----- GetVolParmsInfoBuffer Macros -----
 
/*
 *  Macros to get information out of GetVolParmsInfoBuffer.
 */
 
/* version 1 field getters */
#define GetVolParmsInfoVersion(volParms) \
        ((volParms)->vMVersion)
#define GetVolParmsInfoAttrib(volParms) \
        ((volParms)->vMAttrib)
#define GetVolParmsInfoLocalHand(volParms) \
        ((volParms)->vMLocalHand)
#define GetVolParmsInfoServerAdr(volParms) \
        ((volParms)->vMServerAdr)
 
/* version 2 field getters (assume zero result if version < 2) */
#define GetVolParmsInfoVolumeGrade(volParms) \
        (((volParms)->vMVersion >= 2) ? (volParms)->vMVolumeGrade : 0)
#define GetVolParmsInfoForeignPrivID(volParms) \
        (((volParms)->vMVersion >= 2) ? (volParms)->vMForeignPrivID : 0)
 
/* version 3 field getters (assume zero result if version < 3) */
#define GetVolParmsInfoExtendedAttributes(volParms) \
        (((volParms)->vMVersion >= 3) ? (volParms)->vMExtendedAttributes : 0)
 
/* attribute bits supported by all versions of GetVolParmsInfoBuffer */
#define VolIsNetworkVolume(volParms) \
        ((volParms)->vMServerAdr != 0)
#define VolHasLimitFCBs(volParms) \
        (((volParms)->vMAttrib & (1L << bLimitFCBs)) != 0)
#define VolHasLocalWList(volParms) \
        (((volParms)->vMAttrib & (1L << bLocalWList)) != 0)
#define VolHasNoMiniFndr(volParms) \
        (((volParms)->vMAttrib & (1L << bNoMiniFndr)) != 0)
#define VolHasNoVNEdit(volParms) \
        (((volParms)->vMAttrib & (1L << bNoVNEdit)) != 0)
#define VolHasNoLclSync(volParms) \
        (((volParms)->vMAttrib & (1L << bNoLclSync)) != 0)
#define VolHasTrshOffLine(volParms) \
        (((volParms)->vMAttrib & (1L << bTrshOffLine)) != 0)
#define VolHasNoSwitchTo(volParms) \
        (((volParms)->vMAttrib & (1L << bNoSwitchTo)) != 0)
#define VolHasNoDeskItems(volParms) \
        (((volParms)->vMAttrib & (1L << bNoDeskItems)) != 0)
#define VolHasNoBootBlks(volParms) \
        (((volParms)->vMAttrib & (1L << bNoBootBlks)) != 0)
#define VolHasAccessCntl(volParms) \
        (((volParms)->vMAttrib & (1L << bAccessCntl)) != 0)
#define VolHasNoSysDir(volParms) \
        (((volParms)->vMAttrib & (1L << bNoSysDir)) != 0)
#define VolHasExtFSVol(volParms) \
        (((volParms)->vMAttrib & (1L << bHasExtFSVol)) != 0)
#define VolHasOpenDeny(volParms) \
        (((volParms)->vMAttrib & (1L << bHasOpenDeny)) != 0)
#define VolHasCopyFile(volParms) \
        (((volParms)->vMAttrib & (1L << bHasCopyFile)) != 0)
#define VolHasMoveRename(volParms) \
        (((volParms)->vMAttrib & (1L << bHasMoveRename)) != 0)
#define VolHasDesktopMgr(volParms) \
        (((volParms)->vMAttrib & (1L << bHasDesktopMgr)) != 0)
#define VolHasShortName(volParms) \
        (((volParms)->vMAttrib & (1L << bHasShortName)) != 0)
#define VolHasFolderLock(volParms) \
        (((volParms)->vMAttrib & (1L << bHasFolderLock)) != 0)
#define VolHasPersonalAccessPrivileges(volParms) \
        (((volParms)->vMAttrib & (1L << bHasPersonalAccessPrivileges)) != 0)
#define VolHasUserGroupList(volParms) \
        (((volParms)->vMAttrib & (1L << bHasUserGroupList)) != 0)
#define VolHasCatSearch(volParms) \
        (((volParms)->vMAttrib & (1L << bHasCatSearch)) != 0)
#define VolHasFileIDs(volParms) \
        (((volParms)->vMAttrib & (1L << bHasFileIDs)) != 0)
#define VolHasBTreeMgr(volParms) \
        (((volParms)->vMAttrib & (1L << bHasBTreeMgr)) != 0)
#define VolHasBlankAccessPrivileges(volParms) \
        (((volParms)->vMAttrib & (1L << bHasBlankAccessPrivileges)) != 0)
#define VolSupportsAsyncRequests(volParms) \
        (((volParms)->vMAttrib & (1L << bSupportsAsyncRequests)) != 0)
#define VolSupportsTrashVolumeCache(volParms) \
        (((volParms)->vMAttrib & (1L << bSupportsTrashVolumeCache)) != 0)
 
/* attribute bits supported by version 3 and greater versions of GetVolParmsInfoBuffer */
#define VolIsEjectable(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bIsEjectable)) != 0)
#define VolSupportsHFSPlusAPIs(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bSupportsHFSPlusAPIs)) != 0)
#define VolSupportsFSCatalogSearch(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bSupportsFSCatalogSearch)) != 0)
#define VolSupportsFSExchangeObjects(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bSupportsFSExchangeObjects)) != 0)
#define VolSupports2TBFiles(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bSupports2TBFiles)) != 0)
#define VolSupportsLongNames(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bSupportsLongNames)) != 0)
#define VolSupportsMultiScriptNames(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bSupportsMultiScriptNames)) != 0)
#define VolSupportsNamedForks(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bSupportsNamedForks)) != 0)
#define VolSupportsSubtreeIterators(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bSupportsSubtreeIterators)) != 0)
#define VolL2PCanMapFileBlocks(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bL2PCanMapFileBlocks)) != 0)
#define VolParentModDateChanges(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bParentModDateChanges)) != 0)
#define VolAncestorModDateChanges(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bAncestorModDateChanges)) != 0)
#define VolSupportsSymbolicLinks(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bSupportsSymbolicLinks)) != 0)
#define VolIsAutoMounted(volParms) \
        ((GetVolParmsInfoExtendedAttributes(volParms) & (1L << bIsAutoMounted)) != 0)
 
/*****************************************************************************/
 
#pragma mark ----- userPrivileges Bit Masks and Macros -----
 
/*
 *  Bit masks and macros to get common information out of userPrivileges byte
 *  returned by FSGetCatalogInfo.
 *
 *  Note:   The userPrivileges byte is the same as the ioACUser byte returned
 *          by PBGetCatInfo, and is the 1's complement of the user's privileges
 *          byte returned in ioACAccess by PBHGetDirAccess. That's where the
 *          ioACUser names came from.
 *
 *          The userPrivileges are user's effective privileges based on the
 *          user ID and the groups that user belongs to, and the owner, group,
 *          and everyone privileges for the given directory.
 */
 
enum
{
    /* mask for just the access restriction bits */
    kioACUserAccessMask     = (kioACUserNoSeeFolderMask +
                               kioACUserNoSeeFilesMask +
                               kioACUserNoMakeChangesMask),
    /* common access privilege settings */
    kioACUserFull           = 0x00, /* no access restiction bits on */
    kioACUserNone           = kioACUserAccessMask, /* all access restiction bits on */
    kioACUserDropBox        = (kioACUserNoSeeFolderMask +
                               kioACUserNoSeeFilesMask), /* make changes, but not see files or folders */
    kioACUserBulletinBoard  = kioACUserNoMakeChangesMask /* see files and folders, but not make changes */
};
 
 
/* Macros for testing ioACUser bits. */
 
#define UserIsOwner(userPrivileges) \
        (((userPrivileges) & kioACUserNotOwnerMask) == 0)
#define UserHasFullAccess(userPrivileges)   \
        (((userPrivileges) & (kioACUserAccessMask)) == kioACUserFull)
#define UserHasDropBoxAccess(userPrivileges)    \
        (((userPrivileges) & kioACUserAccessMask) == kioACUserDropBox)
#define UserHasBulletinBoard(userPrivileges)    \
        (((userPrivileges) & kioACUserAccessMask) == kioACUserBulletinBoard)
#define UserHasNoAccess(userPrivileges)     \
        (((userPrivileges) & kioACUserAccessMask) == kioACUserNone)
 
/*****************************************************************************/
 
#pragma mark ----- File Access Routines -----
 
/*****************************************************************************/
 
#pragma mark FSCopyFork
 
OSErr
FSCopyFork(
    SInt16 srcRefNum,
    SInt16 dstRefNum,
    void *copyBufferPtr,
    ByteCount copyBufferSize);
 
/*
    The FSCopyFork function copies all data from the source fork to the
    destination fork of open file forks and makes sure the destination EOF
    is equal to the source EOF.
 
    srcRefNum           --> The source file reference number.
    dstRefNum           --> The destination file reference number.
    copyBufferPtr       --> Pointer to buffer to use during copy. The
                            buffer should be at least 4K-bytes minimum.
                            The larger the buffer, the faster the copy
                            (up to a point).
    copyBufferSize      --> The size of the copy buffer.
*/
 
/*****************************************************************************/
 
#pragma mark ----- Volume Access Routines -----
 
/*****************************************************************************/
 
#pragma mark FSGetVolParms
 
OSErr
FSGetVolParms(
    FSVolumeRefNum volRefNum,
    UInt32 bufferSize,
    GetVolParmsInfoBuffer *volParmsInfo,
    UInt32 *actualInfoSize);
 
/*
    The FSGetVolParms function returns information about the characteristics
    of a volume. A result of paramErr usually just means the volume doesn't
    support GetVolParms and the feature you were going to check
    for isn't available.
    
    volRefNum           --> Volume specification.
    bufferSize          --> Size of buffer pointed to by volParmsInfo.
    volParmsInfo        <-- A GetVolParmsInfoBuffer record where the volume
                            attributes information is returned.
    actualInfoSize      <-- The number of bytes actually returned
                            in volParmsInfo.
    
    __________
    
    Also see:   The GetVolParmsInfoBuffer Macros for checking attribute bits
                in this file
*/
 
/*****************************************************************************/
 
#pragma mark FSGetVRefNum
 
OSErr
FSGetVRefNum(
    const FSRef *ref,
    FSVolumeRefNum *vRefNum);
 
/*
    The FSGetVRefNum function determines the volume reference
    number of a volume from a FSRef.
 
    ref                 --> The FSRef.
    vRefNum             <-- The volume reference number.
*/
 
/*****************************************************************************/
 
#pragma mark FSGetVInfo
 
OSErr
FSGetVInfo(
    FSVolumeRefNum volume,
    HFSUniStr255 *volumeName,   /* can be NULL */
    UInt64 *freeBytes,          /* can be NULL */
    UInt64 *totalBytes);        /* can be NULL */
 
/*
    The FSGetVInfo function returns the name, available space (in bytes),
    and total space (in bytes) for the specified volume.
 
    volume              --> The volume reference number.
    volumeName          <** An optional pointer to a HFSUniStr255.
                            If not NULL, the volume name will be returned in
                            the HFSUniStr255.
    freeBytes           <** An optional pointer to a UInt64.
                            If not NULL, the number of free bytes on the
                            volume will be returned in the UInt64.
    totalBytes          <** An optional pointer to a UInt64.
                            If not NULL, the total number of bytes on the
                            volume will be returned in the UInt64.
*/
 
/*****************************************************************************/
 
#pragma mark FSGetVolFileSystemID
 
OSErr
FSGetVolFileSystemID(
    FSVolumeRefNum volume,
    UInt16 *fileSystemID,   /* can be NULL */
    UInt16 *signature);     /* can be NULL */
 
/*
    The FSGetVolFileSystemID function returns the file system ID and signature
    of a mounted volume. The file system ID identifies the file system
    that handles requests to a particular volume. The signature identifies the
    volume type of the volume (for example, FSID 0 is Macintosh HFS Plus, HFS
    or MFS, where a signature of 0x4244 identifies the volume as HFS).
    Here's a partial list of file system ID numbers (only Apple's file systems
    are listed):
        FSID    File System
        -----   -----------------------------------------------------
        $0000   Macintosh HFS Plus, HFS or MFS
        $0100   ProDOS File System
        $0101   PowerTalk Mail Enclosures
        $4147   ISO 9660 File Access (through Foreign File Access)
        $4242   High Sierra File Access (through Foreign File Access)
        $464D   QuickTake File System (through Foreign File Access)
        $4953   Macintosh PC Exchange (MS-DOS)
        $4A48   Audio CD Access (through Foreign File Access)
        $4D4B   Apple Photo Access (through Foreign File Access)
        $6173   AppleShare (later versions of AppleShare only)
    
    See the Technical Note "FL 35 - Determining Which File System
    Is Active" and the "Guide to the File System Manager" for more
    information.
    
    volume              --> The volume reference number.
    fileSystemID        <** An optional pointer to a UInt16.
                            If not NULL, the volume's file system ID will
                            be returned in the UInt16.
    signature           <** An optional pointer to a UInt16.
                            If not NULL, the volume's signature will
                            be returned in the UInt16.
*/
 
/*****************************************************************************/
 
#pragma mark FSGetMountedVolumes
 
OSErr
FSGetMountedVolumes(
    FSRef ***volumeRefsHandle,  /* pointer to handle of FSRefs */
    ItemCount *numVolumes);
 
/*
    The FSGetMountedVolumes function returns the list of volumes currently
    mounted in an array of FSRef records. The array of FSRef records is
    returned in a Handle, volumeRefsHandle, which is allocated by
    FSGetMountedVolumes. The caller is responsible for disposing of
    volumeRefsHandle if the FSGetMountedVolumes returns noErr.
        
    volumeRefsHandle    <-- Pointer to an FSRef Handle where the array of
                            FSRefs is to be returned.
    numVolumes          <-- The number of volumes returned in the array.
*/
 
/*****************************************************************************/
 
#pragma mark ----- FSRef/FSpec/Path/Name Conversion Routines -----
 
/*****************************************************************************/
 
#pragma mark FSRefMakeFSSpec
 
OSErr
FSRefMakeFSSpec(
    const FSRef *ref,
    FSSpec *spec);
 
/*
    The FSRefMakeFSSpec function returns an FSSpec for the file or
    directory specified by the ref parameter.
 
    ref                 --> An FSRef specifying the file or directory.
    spec                <-- The FSSpec.
*/
 
/*****************************************************************************/
 
#pragma mark FSMakeFSRef
 
OSErr
FSMakeFSRef(
    FSVolumeRefNum volRefNum,
    SInt32 dirID,
    ConstStr255Param name,
    FSRef *ref);
 
/*
    The FSMakeFSRef function creates an FSRef from the traditional
    volume reference number, directory ID and pathname inputs. It is
    functionally equivalent to FSMakeFSSpec followed by FSpMakeFSRef.
    
    volRefNum           --> Volume specification.
    dirID               --> Directory specification.
    name                --> The file or directory name, or NULL.
    ref                 <-- The FSRef.
*/
 
/*****************************************************************************/
 
#pragma mark FSMakePath
 
OSStatus
FSMakePath(
    SInt16 vRefNum,
    SInt32 dirID,
    ConstStr255Param name,
    UInt8 *path,
    UInt32 maxPathSize);
 
/*
    The FSMakePath function creates a pathname from the traditional volume reference
    number, directory ID, and pathname inputs. It is functionally equivalent to
    FSMakeFSSpec, FSpMakeFSRef, FSRefMakePath.
    
    volRefNum           --> Volume specification.
    dirID               --> Directory specification.
    name                --> The file or directory name, or NULL.
    path                <-- A pointer to a buffer which FSMakePath will
                            fill with a C string representing the pathname
                            to the file or directory specified. The format of
                            the pathname returned can be determined with the
                            Gestalt selector gestaltFSAttr's
                            gestaltFSUsesPOSIXPathsForConversion bit.
                            If the gestaltFSUsesPOSIXPathsForConversion bit is
                            clear, the pathname is a Mac OS File Manager full
                            pathname in a C string, and file or directory names
                            in the pathname may be mangled as returned by
                            the File Manager. If the
                            gestaltFSUsesPOSIXPathsForConversion bit is set,
                            the pathname is a UTF8 encoded POSIX absolute
                            pathname in a C string. In either case, the
                            pathname returned can be passed back to
                            FSPathMakeRef to create an FSRef to the file or
                            directory, or FSPathMakeFSSpec to craete an FSSpec
                            to the file or directory.
    maxPathSize         --> The size of the path buffer in bytes. If the path
                            buffer is too small for the pathname string,
                            FSMakePath returns pathTooLongErr or
                            buffersTooSmall.
*/
 
/*****************************************************************************/
 
#pragma mark FSPathMakeFSSpec
 
OSStatus
FSPathMakeFSSpec(
    const UInt8 *path,
    FSSpec *spec,
    Boolean *isDirectory);  /* can be NULL */
 
/*
    The FSPathMakeFSSpec function converts a pathname to an FSSpec.
    
    path                --> A pointer to a C String that is the pathname. The
                            format of the pathname you must supply can be
                            determined with the Gestalt selector gestaltFSAttr's
                            gestaltFSUsesPOSIXPathsForConversion bit.
                            If the gestaltFSUsesPOSIXPathsForConversion bit is
                            clear, the pathname must be a Mac OS File Manager
                            full pathname in a C string. If the
                            gestaltFSUsesPOSIXPathsForConversion bit is set,
                            the pathname must be a UTF8 encoded POSIX absolute
                            pathname in a C string.
    spec                <-- The FSSpec.
    isDirectory         <** An optional pointer to a Boolean.
                            If not NULL, true will be returned in the Boolean
                            if the specified path is a directory, or false will
                            be returned in the Boolean if the specified path is
                            a file.
*/
 
/*****************************************************************************/
 
#pragma mark UnicodeNameGetHFSName
 
OSErr
UnicodeNameGetHFSName(
    UniCharCount nameLength,
    const UniChar *name,
    TextEncoding textEncodingHint,
    Boolean isVolumeName,
    Str31 hfsName);
 
/*
    The UnicodeNameGetHFSName function converts a Unicode string
    to a Pascal Str31 (or Str27) string using an algorithm similar to that used
    by the File Manager. Note that if the name is too long or cannot be converted
    using the given text encoding hint, you will get an error instead of the
    mangled name that the File Manager would return.
    
    nameLength          --> Number of UniChar in name parameter.
    name                --> The Unicode string to convert.
    textEncodingHint    --> The text encoding hint used for the conversion.
                            You can pass kTextEncodingUnknown to use the
                            "default" textEncodingHint.
    isVolumeName        --> If true, the output name will be limited to
                            27 characters (kHFSMaxVolumeNameChars). If false,
                            the output name will be limited to 31 characters
                            (kHFSMaxFileNameChars).
    hfsName             <-- The hfsName as a Pascal string.
    
    __________
    
    Also see:   HFSNameGetUnicodeName
*/
 
/*****************************************************************************/
 
#pragma mark HFSNameGetUnicodeName
 
OSErr
HFSNameGetUnicodeName(
    ConstStr31Param hfsName,
    TextEncoding textEncodingHint,
    HFSUniStr255 *unicodeName);
 
/*
    The HFSNameGetUnicodeName function converts a Pascal Str31 string to an
    Unicode HFSUniStr255 string using the same routines as the File Manager.
    
    hfsName             --> The Pascal string to convert.
    textEncodingHint    --> The text encoding hint used for the conversion.
                            You can pass kTextEncodingUnknown to use the
                            "default" textEncodingHint.
    unicodeName         <-- The Unicode string.
    
    __________
    
    Also see:   UnicodeNameGetHFSName
*/
 
/*****************************************************************************/
 
#pragma mark ----- File/Directory Manipulation Routines -----
 
/*****************************************************************************/
 
#pragma mark FSRefValid
 
Boolean FSRefValid(const FSRef *ref);
 
/*
    The FSRefValid function determines if an FSRef is valid. If the result is
    true, then the FSRef refers to an existing file or directory.
    
    ref                 --> FSRef to a file or directory.
*/
 
/*****************************************************************************/
 
#pragma mark FSGetParentRef
 
OSErr
FSGetParentRef(
    const FSRef *ref,
    FSRef *parentRef);
 
/*
    The FSGetParentRef function gets the parent directory FSRef of the
    specified object.
    
    Note: FSRefs always point to real file system objects. So, there cannot
    be a FSRef to the parent of volume root directories. If you call
    FSGetParentRef with a ref to the root directory of a volume, the
    function result will be noErr and the parentRef will be invalid (using it
    for other file system requests will fail).
 
    ref                 --> FSRef to a file or directory.
    parentRef           <-- The parent directory's FSRef.
*/
 
/*****************************************************************************/
 
#pragma mark FSGetFileDirName
 
OSErr
FSGetFileDirName(
    const FSRef *ref,
    HFSUniStr255 *outName);
 
/*
    The FSGetFileDirName function gets the name of the file or directory
    specified.
 
    ref                 --> FSRef to a file or directory.
    outName             <-- The file or directory name.
*/
 
/*****************************************************************************/
 
#pragma mark FSGetNodeID
 
OSErr
FSGetNodeID(
    const FSRef *ref,
    long *nodeID,           /* can be NULL */
    Boolean *isDirectory);  /* can be NULL */
 
/*
    The GetNodeIDFromFSRef function gets the node ID number of the
    file or directory specified (note: the node ID is the directory ID
    for directories).
 
    ref                 --> FSRef to a file or directory.
    nodeID              <** An optional pointer to a long.
                            If not NULL, the node ID will be returned in
                            the long.
    isDirectory         <** An optional pointer to a Boolean.
                            If not NULL, true will be returned in the Boolean
                            if the object is a directory, or false will be
                            returned in the Boolean if object is a file.
*/
 
/*****************************************************************************/
 
#pragma mark FSGetUserPrivilegesPermissions
 
OSErr
FSGetUserPrivilegesPermissions(
    const FSRef *ref,
    UInt8 *userPrivileges,      /* can be NULL */
    UInt32 permissions[4]);     /* can be NULL */
 
/*
    The FSGetUserPrivilegesPermissions function gets the userPrivileges and/or
    permissions of the file or directory specified.
 
    ref                 --> FSRef to a file or directory.
    userPrivileges      <** An optional pointer to a UInt8.
                            If not NULL, the userPrivileges will be returned
                            in the UInt8.
    permissions         <** An optional pointer to an UInt32[4] array.
                            If not NULL, the permissions will be returned
                            in the UInt32[4] array.
*/
 
/*****************************************************************************/
 
#pragma mark FSCheckLock
 
OSErr
FSCheckLock(
    const FSRef *ref);
 
/*
    The FSCheckLock function determines if a file or directory is locked.
    If FSCheckLock returns noErr, then the file or directory is not locked
    and the volume it is on is not locked either. If FSCheckLock returns
    fLckdErr, then the file or directory is locked. If FSCheckLock returns
    wPrErr, then the volume is locked by hardware (i.e., locked tab on
    removable media). If FSCheckLock returns vLckdErr, then the volume is
    locked by software.
    
    ref                 --> FSRef to a file or directory.
*/
 
/*****************************************************************************/
 
#pragma mark FSGetForkSizes
 
OSErr
FSGetForkSizes(
    const FSRef *ref,
    UInt64 *dataLogicalSize,    /* can be NULL */
    UInt64 *rsrcLogicalSize);   /* can be NULL */
 
/*
    The FSGetForkSizes returns the size of the data and/or resource fork for
    the specified file.
    
    ref                 --> FSRef to a file or directory.
    dataLogicalSize     <** An optional pointer to a UInt64.
                            If not NULL, the data fork's size will be
                            returned in the UInt64.
    rsrcLogicalSize     <** An optional pointer to a UInt64.
                            If not NULL, the resource fork's size will be
                            returned in the UInt64.
    
    __________
    
    Also see:   FSGetTotalForkSizes
*/
 
/*****************************************************************************/
 
#pragma mark FSGetTotalForkSizes
 
OSErr
FSGetTotalForkSizes(
    const FSRef *ref,
    UInt64 *totalLogicalSize,   /* can be NULL */
    UInt64 *totalPhysicalSize,  /* can be NULL */
    ItemCount *forkCount);      /* can be NULL */
 
/*
    The FSGetTotalForkSizes returns the total logical size and/or the total
    physical size of the specified file (i.e., it adds the sizes of all file
    forks). It optionally returns the number of file forks.
    
    ref                 --> FSRef to a file or directory.
    totalLogicalSize    <** An optional pointer to a UInt64.
                            If not NULL, the sum of all fork logical sizes
                            will be returned in the UInt64.
    totalPhysicalSize   <** An optional pointer to a UInt64.
                            If not NULL, the sum of all fork physical sizes
                            will be returned in the UInt64.
    forkCount           <** An optional pointer to a ItemCount.
                            If not NULL, the number of file forks
                            will be returned in the ItemCount.
    
    __________
    
    Also see:   FSGetForkSizes
*/
 
/*****************************************************************************/
 
#pragma mark FSBumpDate
 
OSErr
FSBumpDate(
    const FSRef *ref);
 
/*
    The FSBumpDate function changes the content modification date of a file
    or directory to the current date/time. If the content modification date
    is already equal to the current date/time, then add one second to the
    content modification date.
 
    ref                 --> FSRef to a file or directory.
*/
 
/*****************************************************************************/
 
#pragma mark FSGetFinderInfo
 
OSErr
FSGetFinderInfo(
    const FSRef *ref,
    FinderInfo *info,                   /* can be NULL */
    ExtendedFinderInfo *extendedInfo,   /* can be NULL */
    Boolean *isDirectory);              /* can be NULL */
 
/*
    The FSGetFinderInfo function gets the finder information for a file or
    directory.
 
    ref                 --> FSRef to a file or directory.
    info                <** An optional pointer to a FinderInfo.
                            If not NULL, the FileInfo (if ref is a file) or
                            the FolderInfo (if ref is a folder) will be
                            returned in the FinderInfo.
    extendedInfo        <** An optional pointer to a ExtendedFinderInfo.
                            If not NULL, the ExtendedFileInfo (if ref is a file)
                            or the ExtendedFolderInfo (if ref is a folder) will
                            be returned in the ExtendedFinderInfo.
    isDirectory         <** An optional pointer to a Boolean.
                            If not NULL, true will be returned in the Boolean
                            if the object is a directory, or false will be
                            returned in the Boolean if object is a file.
 
    __________
 
    Also see:   FSSetFinderInfo
*/
 
/*****************************************************************************/
 
#pragma mark FSSetFinderInfo
 
OSErr
FSSetFinderInfo(
    const FSRef *ref,
    const FinderInfo *info,                     /* can be NULL */
    const ExtendedFinderInfo *extendedInfo);    /* can be NULL */
 
/*
    The FSSetFinderInfo function sets the finder information for a file or
    directory.
 
    ref                 --> FSRef to a file or directory.
    info                **> A pointer to a FinderInfo record with the new
                            FileInfo (if ref is a file) or new FolderInfo
                            (if ref is a folder), or NULL if the FinderInfo
                            is not to be changed.
    extendedInfo        **> A pointer to a FinderInfo record with the new
                            ExtendedFileInfo (if ref is a file) or new
                            ExtendedFolderInfo (if ref is a folder), or NULL
                            if the ExtendedFinderInfo is not to be changed.
        
    __________
 
    Also see:   FSGetFinderInfo
*/
 
/*****************************************************************************/
 
#pragma mark FSChangeCreatorType
 
OSErr
FSChangeCreatorType(
    const FSRef *ref,
    OSType fileCreator,
    OSType fileType);
 
/*
    The FSChangeCreatorType function changes the creator and/or file type of a file.
 
    ref                 --> FSRef to a file.
    creator             --> The new creator type or 0x00000000 to leave
                            the creator type alone.
    fileType            --> The new file type or 0x00000000 to leave the
                            file type alone.
*/
 
/*****************************************************************************/
 
#pragma mark FSChangeFinderFlags
 
OSErr
FSChangeFinderFlags(
    const FSRef *ref,
    Boolean setBits,
    UInt16 flagBits);
 
/*
    The FSChangeFinderFlags function sets or clears flag bits in
    the finderFlags field of a file's FileInfo record or a
    directory's FolderInfo record.
 
    ref                 --> FSRef to a file or directory.
    setBits             --> If true, then set the bits specified in flagBits.
                            If false, then clear the bits specified in flagBits.
    flagBits            --> The flagBits parameter specifies which Finder Flag
                            bits to set or clear. If a bit in flagBits is set,
                            then the same bit in fdFlags is either set or
                            cleared depending on the state of the setBits
                            parameter.
*/
 
/*****************************************************************************/
 
#pragma mark FSSetInvisible
 
OSErr
FSSetInvisible(
    const FSRef *ref);
 
#pragma mark FSClearInvisible
 
OSErr
FSClearInvisible(
    const FSRef *ref);
 
/*
    The FSSetInvisible and FSClearInvisible functions set or clear the
    kIsInvisible bit in the finderFlags field of the specified file or
    directory's finder information.
 
    ref                 --> FSRef to a file or directory.
*/
 
/*****************************************************************************/
 
#pragma mark FSSetNameLocked
 
OSErr
FSSetNameLocked(
    const FSRef *ref);
 
#pragma mark FSClearNameLocked
 
OSErr
FSClearNameLocked(
    const FSRef *ref);
 
/*
    The FSSetNameLocked and FSClearNameLocked functions set or clear the
    kNameLocked bit bit in the finderFlags field of the specified file or
    directory's finder information.
 
    ref                 --> FSRef to a file or directory.
*/
 
/*****************************************************************************/
 
#pragma mark FSSetIsStationery
 
OSErr
FSSetIsStationery(
    const FSRef *ref);
 
#pragma mark FSClearIsStationery
 
OSErr
FSClearIsStationery(
    const FSRef *ref);
 
/*
    The FSSetIsStationery and FSClearIsStationery functions set or clear the
    kIsStationery bit bit in the finderFlags field of the specified file or
    directory's finder information.
 
    ref                 --> FSRef to a file or directory.
*/
 
/*****************************************************************************/
 
#pragma mark FSSetHasCustomIcon
 
OSErr
FSSetHasCustomIcon(
    const FSRef *ref);
 
#pragma mark FSClearHasCustomIcon
 
OSErr
FSClearHasCustomIcon(
    const FSRef *ref);
 
/*
    The FSSetHasCustomIcon and FSClearHasCustomIcon functions set or clear the
    kHasCustomIcon bit bit in the finderFlags field of the specified file or
    directory's finder information.
 
    ref                 --> FSRef to a file or directory.
*/
 
/*****************************************************************************/
 
#pragma mark FSClearHasBeenInited
 
OSErr
FSClearHasBeenInited(
    const FSRef *ref);
 
/*
    The FSClearHasBeenInited function clears the kHasBeenInited bit in the
    finderFlags field of the specified file or directory's finder information.
    
    Note:   There is no FSSetHasBeenInited function because ONLY the Finder
            should set the kHasBeenInited bit.
 
    ref                 --> FSRef to a file or directory.
*/
 
/*****************************************************************************/
 
#pragma mark FSCopyFileMgrAttributes
 
OSErr
FSCopyFileMgrAttributes(
    const FSRef *sourceRef,
    const FSRef *destinationRef,
    Boolean copyLockBit);
 
/*
    The CopyFileMgrAttributes function copies all File Manager attributes
    from the source file or directory to the destination file or directory.
    If copyLockBit is true, then set the locked state of the destination
    to match the source.
 
    sourceRef           --> FSRef to a file or directory.
    destinationRef      --> FSRef to a file or directory.
    copyLockBit         --> If true, set the locked state of the destination
                            to match the source.
*/
 
/*****************************************************************************/
 
#pragma mark FSMoveRenameObjectUnicode
 
OSErr
FSMoveRenameObjectUnicode(
    const FSRef *ref,
    const FSRef *destDirectory,
    UniCharCount nameLength,
    const UniChar *name,            /* can be NULL (no rename during move) */
    TextEncoding textEncodingHint,
    FSRef *newRef);                 /* if function fails along the way, newRef is final location of file */
 
/*
    The FSMoveRenameObjectUnicode function moves a file or directory and
    optionally renames it.  The source and destination locations must be on
    the same volume.
    
    Note:   If the input ref parameter is invalid, this call will fail and
            newRef, like ref, will be invalid.
 
    ref                 --> FSRef to a file or directory.
    destDirectory       --> FSRef to the destination directory.
    nameLength          --> Number of UniChar in name parameter.
    name                --> An Unicode string with the new name for the
                            moved object, or NULL if no rename is wanted.
    textEncodingHint    --> The text encoding hint used for the rename.
                            You can pass kTextEncodingUnknown to use the
                            "default" textEncodingHint.
    newRef              <-- The new FSRef of the object moved. Note that if
                            this function fails at any step along the way,
                            newRef is still then final location of the object.
*/
 
/*****************************************************************************/
 
#pragma mark FSDeleteContainerContents
 
OSErr
FSDeleteContainerContents(
    const FSRef *container);
 
/*
    The FSDeleteContainerContents function deletes the contents of a container
    directory. All files and subdirectories in the specified container are
    deleted. If a locked file or directory is encountered, it is unlocked and
    then deleted. If any unexpected errors are encountered,
    FSDeleteContainerContents quits and returns to the caller.
    
    container           --> FSRef to a directory.
    
    __________
    
    Also see:   FSDeleteContainer
*/
 
/*****************************************************************************/
 
#pragma mark FSDeleteContainer
 
OSErr
FSDeleteContainer(
    const FSRef *container);
 
/*
    The FSDeleteContainer function deletes a container directory and its contents.
    All files and subdirectories in the specified container are deleted.
    If a locked file or directory is encountered, it is unlocked and then
    deleted.  After deleting the container's contents, the container is
    deleted. If any unexpected errors are encountered, FSDeleteContainer
    quits and returns to the caller.
    
    container           --> FSRef to a directory.
    
    __________
    
    Also see:   FSDeleteContainerContents
*/
 
/*****************************************************************************/
 
#pragma mark IterateContainerFilterProcPtr
 
typedef CALLBACK_API( Boolean , IterateContainerFilterProcPtr ) (
    Boolean containerChanged,
    ItemCount currentLevel,
    const FSCatalogInfo *catalogInfo,
    const FSRef *ref,
    const FSSpec *spec,
    const HFSUniStr255 *name,
    void *yourDataPtr);
 
/*
    This is the prototype for the IterateContainerFilterProc function which
    is called once for each file and directory found by FSIterateContainer.
    The IterateContainerFilterProc can use the read-only data it receives for
    whatever it wants.
 
    The result of the IterateContainerFilterProc function indicates if
    iteration should be stopped. To stop iteration, return true; to continue
    iteration, return false.
 
    The yourDataPtr parameter can point to whatever data structure you might
    want to access from within the IterateContainerFilterProc.
 
    containerChanged    --> Set to true if the container's contents changed
                            during iteration.
    currentLevel        --> The current recursion level into the container.
                            1 = the container, 2 = the container's immediate
                            subdirectories, etc.
    catalogInfo         --> The catalog information for the current object.
                            Only the fields requested by the whichInfo
                            parameter passed to FSIterateContainer are valid.
    ref                 --> The FSRef to the current object.
    spec                --> The FSSpec to the current object if the wantFSSpec
                            parameter passed to FSIterateContainer is true.
    name                --> The name of the current object if the wantName
                            parameter passed to FSIterateContainer is true.
    yourDataPtr         --> An optional pointer to whatever data structure you
                            might want to access from within the
                            IterateFilterProc.
    result              <-- To stop iteration, return true; to continue
                            iteration, return false.
 
    __________
 
    Also see:   FSIterateContainer
*/
 
/*****************************************************************************/
 
#pragma mark CallIterateContainerFilterProc
 
#define CallIterateContainerFilterProc(userRoutine, containerChanged, currentLevel, catalogInfo, ref, spec, name, yourDataPtr) \
    (*(userRoutine))((containerChanged), (currentLevel), (catalogInfo), (ref), (spec), (name), (yourDataPtr))
 
/*****************************************************************************/
 
#pragma mark FSIterateContainer
 
OSErr
FSIterateContainer(
    const FSRef *container,
    ItemCount maxLevels,
    FSCatalogInfoBitmap whichInfo,
    Boolean wantFSSpec,
    Boolean wantName,
    IterateContainerFilterProcPtr iterateFilter,
    void *yourDataPtr);
 
/*
    The FSIterateContainer function performs a recursive iteration (scan) of the
    specified container directory and calls your IterateContainerFilterProc
    function once for each file and directory found.
 
    The maxLevels parameter lets you control how deep the recursion goes.
    If maxLevels is 1, FSIterateContainer only scans the specified directory;
    if maxLevels is 2, FSIterateContainer scans the specified directory and
    one subdirectory below the specified directory; etc. Set maxLevels to
    zero to scan all levels.
 
    The yourDataPtr parameter can point to whatever data structure you might
    want to access from within your IterateContainerFilterProc.
 
    container           --> The FSRef to the container directory to iterate.
    maxLevels           --> Maximum number of directory levels to scan or
                            zero to scan all directory levels.
    whichInfo           --> The fields of the FSCatalogInfo you wish to get.
    wantFSSpec          --> Set to true if you want the FSSpec to each
                            object passed to your IterateContainerFilterProc.
    wantName            --> Set to true if you want the name of each
                            object passed to your IterateContainerFilterProc.
    iterateFilter       --> A pointer to the IterateContainerFilterProc you
                            want called once for each file and directory found
                            by FSIterateContainer.
    yourDataPtr         --> An optional pointer to whatever data structure you
                            might want to access from within the
                            IterateFilterProc.
*/
 
/*****************************************************************************/
 
#pragma mark FSGetDirectoryItems
 
OSErr
FSGetDirectoryItems(
    const FSRef *container,
    FSRef ***refsHandle,    /* pointer to handle of FSRefs */
    ItemCount *numRefs,
    Boolean *containerChanged);
 
/*
    The FSGetDirectoryItems function returns the list of items in the specified
    container. The array of FSRef records is returned in a Handle, refsHandle,
    which is allocated by FSGetDirectoryItems. The caller is responsible for
    disposing of refsHandle if the FSGetDirectoryItems returns noErr.
        
    container           --> FSRef to a directory.
    refsHandle          <-- Pointer to an FSRef Handle where the array of
                            FSRefs is to be returned.
    numRefs             <-- The number of FSRefs returned in the array.
    containerChanged    <-- Set to true if the container changes while the
                            list of items is being obtained.
*/
 
/*****************************************************************************/
 
#pragma mark FSExchangeObjectsCompat
 
OSErr
FSExchangeObjectsCompat(
    const FSRef *sourceRef,
    const FSRef *destRef,
    FSRef *newSourceRef,
    FSRef *newDestRef);
 
/*
    The FSExchangeObjectsCompat function exchanges the data between two files.
    
    The FSExchangeObjectsCompat function is an enhanced version of
    FSExchangeObjects function. The two enhancements FSExchangeObjectsCompat
    provides are:
    
    1,  FSExchangeObjectsCompat will work on volumes which do not support
        FSExchangeObjects. FSExchangeObjectsCompat does this by emulating
        FSExchangeObjects through a series of File Manager operations. If
        there is a failure at any step along the way, FSExchangeObjectsCompat
        attempts to undo any steps already taken to leave the files in their
        original state in their original locations.
        
    2.  FSExchangeObjectsCompat returns new FSRefs to the source and
        destination files. Note that if this function fails at any step along
        the way, newSourceRef and newDestRef still give you access to the final
        locations of the files being exchanged -- even if they are renamed or
        not in their original locations.
 
    sourceRef           --> FSRef to the source file.
    destRef             --> FSRef to the destination file.
    newSourceRef        <-- The new FSRef to the source file.
    newDestRef          <-- The new FSRef to the destination file.
*/
 
/*****************************************************************************/
 
#pragma mark ----- Shared Environment Routines -----
 
/*****************************************************************************/
 
#pragma mark FSLockRange
#pragma mark FSUnlockRange
 
/*
    Mac OS X version 10.4 added FSLockRange and FSUnlockRange as APIs to
    CoreServices.framework which causes a name conflict with MoreFilesX.
    In addition, PBLockRangeSync and PBUnlockRangeSync are considered
    deprecated in Mac OS X version 10.4. Overall, this is a good because
    PBLockRangeSync and PBUnlockRangeSync are limited to working with
    2 GB files. However, it means that developers get to change their sources
    if they are using FSLockRange or FSUnlockRange from MoreFilesX 1.0 or 1.0.1.
    
    Because one of the goals of MoreFilesX is to encourage developers to use
    APIs that work best with Mac OS X, our recommendation is that developers
    change their code to use the FSLockRange and FSUnlockRange APIs. However,
    that presents a problem because the FSLockRange and FSUnlockRange APIs are
    not available prior to version 10.4. So, we've left the old routines in
    MoreFilesX but renamed them to FSLockRangeCompat and FSUnlockRangeCompat.
    
    If you want to switch to the new APIs, it's easy. Here's an example. Note
    that the new APIs *can* work with files larger than 2 GB, so make sure
    the rest of your code is using APIs that work with large files.
    
    Old MoreFilesX:
        result = FSLockRange(refNum, rangeLength, rangeStart);
        result = FSUnlockRange(refNum, rangeLength, rangeStart);
    
    New:
        UInt64 out_rangeStart;
        result = FSLockRange(refNum, fsFromStart, rangeStart, rangeLength, &out_rangeStart);
        result = FSUnlockRange(refNum, fsFromStart, rangeStart, rangeLength, &out_rangeStart);
 */
 
#pragma mark FSLockRangeCompat
 
OSErr
FSLockRangeCompat(
    SInt16 refNum,
    SInt32 rangeLength,
    SInt32 rangeStart);
 
/*
    The LockRange function locks (denies access to) a portion of a file
    that was opened with shared read/write permission.
 
    refNum              --> The file reference number of an open file.
    rangeLength         --> The number of bytes in the range.
    rangeStart          --> The starting byte in the range to lock.
 
    __________
 
    This function is deprecated in Mac OS X 10.4. Use the FSLockRange API instead.
    Also see:   UnlockRange
*/
 
/*****************************************************************************/
 
#pragma mark FSUnlockRangeCompat
 
OSErr
FSUnlockRangeCompat(
    SInt16 refNum,
    SInt32 rangeLength,
    SInt32 rangeStart);
 
/*
    The UnlockRange function unlocks (allows access to) a previously locked
    portion of a file that was opened with shared read/write permission.
 
    refNum              --> The file reference number of an open file.
    rangeLength         --> The number of bytes in the range.
    rangeStart          --> The starting byte in the range to unlock.
 
    __________
 
    This function is deprecated in Mac OS X 10.4. Use the FSUnlockRange API instead.
    Also see:   LockRange
*/
 
/*****************************************************************************/
 
#pragma mark FSGetDirAccess
 
OSErr
FSGetDirAccess(
    const FSRef *ref,
    SInt32 *ownerID,        /* can be NULL */
    SInt32 *groupID,        /* can be NULL */
    SInt32 *accessRights);  /* can be NULL */
 
/*
    The FSGetDirAccess function retrieves the directory access control
    information for a directory on a shared volume.
 
    ref                 --> An FSRef specifying the directory.
    ownerID             <** An optional pointer to a SInt32.
                            If not NULL, the directory's owner ID
                            will be returned in the SInt32.
    groupID             <** An optional pointer to a SInt32.
                            If not NULL, the directory's group ID, or 0
                            if no group affiliation, will be returned in
                            the SInt32.
    accessRights        <** An optional pointer to a SInt32.
                            If not NULL, the directory's access rights
                            will be returned in the SInt32.
 
    __________
 
    Also see:   FSSetDirAccess, FSMapID, FSMapName
*/
 
/*****************************************************************************/
 
#pragma mark FSSetDirAccess
 
OSErr
FSSetDirAccess(
    const FSRef *ref,
    SInt32 ownerID,
    SInt32 groupID,
    SInt32 accessRights);
 
/*
    The FSpSetDirAccess function changes the directory access control
    information for a directory on a shared volume. You must be the owner of
    a directory to change its access control information.
    
    ref                 --> An FSRef specifying the directory.
    ownerID             --> The directory's owner ID.
    groupID             --> The directory's group ID or 0 if no group affiliation.
    accessRights        --> The directory's access rights.
    
    __________
    
    Also see:   FSGetDirAccess, FSMapID, FSMapName
*/
 
/*****************************************************************************/
 
#pragma mark FSGetVolMountInfoSize
 
OSErr
FSGetVolMountInfoSize(
    FSVolumeRefNum volRefNum,
    SInt16 *size);
 
/*
    The FSGetVolMountInfoSize function determines the how much space the
    program needs to allocate for a volume mounting information record.
 
    volRefNum           --> Volume specification.
    size                <-- The space needed (in bytes) of the volume
                            mounting information record.
 
    __________
 
    Also see:   FSGetVolMountInfo, VolumeMount
*/
 
/*****************************************************************************/
 
#pragma mark FSGetVolMountInfo
 
OSErr
FSGetVolMountInfo(
    FSVolumeRefNum volRefNum,
    void *volMountInfo);
 
/*
    The FSGetVolMountInfo function retrieves a volume mounting information
    record containing all the information needed to mount the volume,
    except for passwords.
 
    volRefNum           --> Volume specification.
    volMountInfo        <-- The volume mounting information.
 
    __________
 
    Also see:   FSGetVolMountInfoSize, VolumeMount
*/
 
/*****************************************************************************/
 
#pragma mark FSVolumeMount
 
OSErr
FSVolumeMount(
    const void *volMountInfo,
    FSVolumeRefNum *volRefNum);
 
/*
    The VolumeMount function mounts a volume using a volume mounting
    information record.
 
    volMountInfo        --> A volume mounting information record.
    volRefNum           <-- The volume reference number.
 
    __________
 
    Also see:   FSGetVolMountInfoSize, FSGetVolMountInfo
*/
 
/*****************************************************************************/
 
#pragma mark FSMapID
 
OSErr
FSMapID(
    FSVolumeRefNum volRefNum,
    SInt32 ugID,
    SInt16 objType,
    Str31 name);
 
/*
    The FSMapID function determines the name of a user or group if you know
    the user or group ID.
 
    volRefNum           --> Volume specification.
    objType             --> The mapping function code:
                            kOwnerID2Name to map a user ID to a user name
                            kGroupID2Name to map a group ID to a group name
    name                <** An optional pointer to a buffer (minimum Str31).
                            If not NULL, the user or group name
                            will be returned in the buffer.
 
    __________
 
    Also see:   FSGetDirAccess, FSSetDirAccess, FSMapName
*/
 
/*****************************************************************************/
 
#pragma mark FSMapName
 
OSErr
FSMapName(
    FSVolumeRefNum volRefNum,
    ConstStr255Param name,
    SInt16 objType,
    SInt32 *ugID);
 
/*
    The FSMapName function determines the user or group ID if you know the
    user or group name.
    
    volRefNum           --> Volume specification.
    name                --> The user or group name.
    objType             --> The mapping function code:
                            kOwnerName2ID to map a user name to a user ID
                            kGroupName2ID to map a user name to a group ID
    ugID                <-- The user or group ID.
 
    __________
    
    Also see:   FSGetDirAccess, FSSetDirAccess, FSMapID
*/
 
/*****************************************************************************/
 
#pragma mark FSCopyFile
 
OSErr
FSCopyFile(
    const FSRef *srcFileRef,
    const FSRef *dstDirectoryRef,
    UniCharCount nameLength,
    const UniChar *copyName,    /* can be NULL (no rename during copy) */
    TextEncoding textEncodingHint,
    FSRef *newRef);             /* can be NULL */
 
/*
    The FSCopyFile function duplicates a file and optionally renames it.
    The source and destination volumes must be on the same file server.
    This function instructs the server to copy the file.
    
    srcFileRef          --> An FSRef specifying the source file.
    dstDirectoryRef     --> An FSRef specifying the destination directory.
    nameLength          --> Number of UniChar in copyName parameter (ignored
                            if copyName is NULL).
    copyName            --> Points to the new file name if the file is to be
                            renamed, or NULL if the file isn't to be renamed.
    textEncodingHint    --> The text encoding hint used for the rename.
                            You can pass kTextEncodingUnknown to use the
                            "default" textEncodingHint.
    newRef              <** An optional pointer to a FSRef.
                            If not NULL, the FSRef of the duplicated file
                            will be returned in the FSRef.
*/
 
/*****************************************************************************/
 
#pragma mark FSMoveRename
 
OSErr
FSMoveRename(
    const FSRef *srcFileRef,
    const FSRef *dstDirectoryRef,
    UniCharCount nameLength,
    const UniChar *moveName,    /* can be NULL (no rename during move) */
    TextEncoding textEncodingHint,
    FSRef *newRef);             /* can be NULL */
 
/*
    The FSMoveRename function moves a file or directory (object), and
    optionally renames it. The source and destination locations must be on
    the same shared volume.
    
    srcFileRef          --> An FSRef specifying the source file.
    dstDirectoryRef     --> An FSRef specifying the destination directory.
    nameLength          --> Number of UniChar in moveName parameter (ignored
                            if copyName is NULL)
    moveName            --> Points to the new object name if the object is to be
                            renamed, or NULL if the object isn't to be renamed.
    textEncodingHint    --> The text encoding hint used for the rename.
                            You can pass kTextEncodingUnknown to use the
                            "default" textEncodingHint.
    newRef              <** An optional pointer to a FSRef.
                            If not NULL, the FSRef of the moved object
                            will be returned in the FSRef.
*/
 
/*****************************************************************************/
 
#pragma mark ----- File ID Routines -----
 
/*****************************************************************************/
 
#pragma mark FSResolveFileIDRef
 
OSErr
FSResolveFileIDRef(
    FSVolumeRefNum volRefNum,
    SInt32 fileID,
    FSRef *ref);
 
/*
    The FSResolveFileIDRef function returns an FSRef for the file with the
    specified file ID reference.
 
    volRefNum           --> Volume specification.
    fileID              --> The file ID reference.
    ref                 <-- The FSRef for the file ID reference.
 
    __________
 
    Also see:   FSCreateFileIDRef, FSDeleteFileIDRef
*/
 
/*****************************************************************************/
 
#pragma mark FSCreateFileIDRef
 
OSErr
FSCreateFileIDRef(
    const FSRef *ref,
    SInt32 *fileID);
 
/*
    The FSCreateFileIDRef function creates a file ID reference for the
    specified file, or if a file ID reference already exists, supplies
    the file ID reference and returns the result code fidExists or afpIDExists.
 
    ref                 --> The FSRef for the file.
    fileID              <-- The file ID reference (if result is noErr,
                            fidExists, or afpIDExists).
 
    __________
 
    Also see:   GetFSRefFromFileIDRef, FSDeleteFileIDRef
*/
 
/*****************************************************************************/
 
#pragma mark FSDeleteFileIDRef
 
/*
    Why is there no FSDeleteFileIDRef routine? There are two reasons:
    
    1.  Since Mac OS 8.1, PBDeleteFileIDRef hasn't deleted file ID references.
        On HFS volumes, deleting a file ID reference breaks aliases (which
        use file ID references to track files as they are moved around on a
        volume) and file ID references are automatically deleted when the file
        they refer to is deleted. On HFS Plus volumes, file ID references are
        always created when a file is created, deleted when the file is deleted,
        and cannot be deleted at any other time.
        
    2.  PBDeleteFileIDRef causes a memory access fault under Mac OS X 10.0
        through 10.1.x. While this will be fixed in a future release, the
        implementation, like the Mac OS 8/9 implementation, does not delete
        file ID references.
        
    __________
 
    Also see:   GetFSRefFromFileIDRef, FSCreateFileIDRef
*/
 
/*****************************************************************************/
 
#pragma mark ----- Utility Routines -----
 
/*****************************************************************************/
 
#pragma mark GetTempBuffer
 
Ptr
GetTempBuffer(
    ByteCount buffReqSize,
    ByteCount *buffActSize);
 
/*
    The GetTempBuffer function allocates a temporary buffer for file system
    operations which is at least 4K bytes and a multiple of 4K bytes.
    
    buffReqSize         --> Size you'd like the buffer to be.
    buffActSize         <-- The size of the buffer allocated.
    function result     <-- Pointer to memory allocated, or NULL if no memory
                            was available. The caller is responsible for
                            disposing of this buffer with DisposePtr.
*/
 
/*****************************************************************************/
 
#pragma mark FileRefNumGetFSRef
 
OSErr
FileRefNumGetFSRef(
    short refNum,
    FSRef *ref);
 
/*
    The FileRefNumGetFSRef function gets the FSRef of an open file.
 
    refNum              --> The file reference number of an open file.
    ref                 <-- The FSRef to the open file.
*/
 
/*****************************************************************************/
 
#pragma mark FSSetDefault
 
OSErr
FSSetDefault(
    const FSRef *newDefault,
    FSRef *oldDefault);
 
/*
    The FSSetDefault function sets the current working directory to the
    directory specified by newDefault. The previous current working directory
    is returned in oldDefault and must be used to restore the current working
    directory to its previous state with the FSRestoreDefault function.
    These two functions are designed to be used as a wrapper around
    Standard I/O routines where the location of the file is implied to be the
    current working directory. This is how you should use these functions:
    
        result = FSSetDefault(&newDefault, &oldDefault);
        if ( noErr == result )
        {
            // call the Stdio functions like remove, rename,
            // fopen, freopen, etc here!
 
            result = FSRestoreDefault(&oldDefault);
        }
    
    newDefault          --> An FSRef that specifies the new current working
                            directory.
    oldDefault          <-- The previous current working directory's FSRef.
    
    __________
    
    Also see:   FSRestoreDefault
*/
 
/*****************************************************************************/
 
#pragma mark FSRestoreDefault
 
OSErr
FSRestoreDefault(
    const FSRef *oldDefault);
 
/*
    The FSRestoreDefault function restores the current working directory
    to the directory specified by oldDefault. The oldDefault parameter was
    previously obtained from the FSSetDefault function.
    These two functions are designed to be used as a wrapper around
    Standard I/O routines where the location of the file is implied to be the
    current working directory. This is how you should use these functions:
    
        result = FSSetDefault(&newDefault, &oldDefault);
        if ( noErr == result )
        {
            // call the Stdio functions like remove, rename,
            // fopen, freopen, etc here!
 
            result = FSRestoreDefault(&oldDefault);
        }
        
    oldDefault          --> The FSRef of the location to restore.
    
    __________
    
    Also see:   FSSetDefault
*/
 
/*****************************************************************************/
 
#if PRAGMA_STRUCT_ALIGN
    #pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
    #pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __MOREFILESX__ */


Copyright © 2005 Apple Computer, Inc. All Rights Reserved. Terms of Use | Privacy Policy | Updated: 2005-05-13