← Back to branch summary

~ubuntu-branches/ubuntu/precise/kompozer/precise

« back to all changes in this revision

Viewing changes to mozilla/xpcom/MoreFiles/MoreFilesX.c.orig

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Yarusso
  • Date: 2007-08-27 01:11:03 UTC
  • Revision ID: james.westby@ubuntu.com-20070827011103-2jgf4s6532gqu2ka
Tags: upstream-0.7.10
Import upstream version 0.7.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/xpcom/MoreFiles/MoreFilesX.c.orig
 
1
/*
 
2
        File:           MoreFilesX.c
 
3
 
 
4
        Contains:       A collection of useful high-level File Manager routines
 
5
                                which use the HFS Plus APIs wherever possible.
 
6
 
 
7
        Version:        MoreFilesX 1.0.1
 
8
 
 
9
        Copyright:      � 1992-2002 by Apple Computer, Inc., all rights reserved.
 
10
 
 
11
        Disclaimer:     IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.
 
12
                                ("Apple") in consideration of your agreement to the following terms, and your
 
13
                                use, installation, modification or redistribution of this Apple software
 
14
                                constitutes acceptance of these terms.  If you do not agree with these terms,
 
15
                                please do not use, install, modify or redistribute this Apple software.
 
16
 
 
17
                                In consideration of your agreement to abide by the following terms, and subject
 
18
                                to these terms, Apple grants you a personal, non-exclusive license, under Apple�s
 
19
                                copyrights in this original Apple software (the "Apple Software"), to use,
 
20
                                reproduce, modify and redistribute the Apple Software, with or without
 
21
                                modifications, in source and/or binary forms; provided that if you redistribute
 
22
                                the Apple Software in its entirety and without modifications, you must retain
 
23
                                this notice and the following text and disclaimers in all such redistributions of
 
24
                                the Apple Software.  Neither the name, trademarks, service marks or logos of
 
25
                                Apple Computer, Inc. may be used to endorse or promote products derived from the
 
26
                                Apple Software without specific prior written permission from Apple.  Except as
 
27
                                expressly stated in this notice, no other rights or licenses, express or implied,
 
28
                                are granted by Apple herein, including but not limited to any patent rights that
 
29
                                may be infringed by your derivative works or by other works in which the Apple
 
30
                                Software may be incorporated.
 
31
 
 
32
                                The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
 
33
                                WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
 
34
                                WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
35
                                PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
 
36
                                COMBINATION WITH YOUR PRODUCTS.
 
37
 
 
38
                                IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
 
39
                                CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 
40
                                GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
41
                                ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
 
42
                                OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
 
43
                                (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
 
44
                                ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
45
 
 
46
        File Ownership:
 
47
 
 
48
                DRI:                            Apple Macintosh Developer Technical Support
 
49
 
 
50
                Other Contact:          For bug reports, consult the following page on
 
51
                                                        the World Wide Web:
 
52
                                                                http://developer.apple.com/bugreporter/
 
53
 
 
54
                Technology:                     DTS Sample Code
 
55
 
 
56
        Writers:
 
57
 
 
58
                (JL)    Jim Luther
 
59
 
 
60
        Change History (most recent first):
 
61
 
 
62
                 <4>     8/22/02        JL              [3016251]  Changed FSMoveRenameObjectUnicode to not use
 
63
                                                                        the Temporary folder because it isn't available on
 
64
                                                                        NFS volumes.
 
65
                 <3>     4/19/02        JL              [2853905]  Fixed #if test around header includes.
 
66
                 <2>     4/19/02        JL              [2850624]  Fixed C++ compile errors and Project Builder
 
67
                                                                        warnings.
 
68
                 <2>     4/19/02        JL              [2853901]  Updated standard disclaimer.
 
69
                 <1>     1/25/02        JL              MoreFilesX 1.0
 
70
*/
 
71
 
 
72
#if defined(__MACH__)
 
73
        #include <Carbon/Carbon.h>
 
74
        #include <string.h>
 
75
#else
 
76
        #include <Carbon.h>
 
77
        #include <string.h>
 
78
#endif
 
79
 
 
80
#include "MoreFilesX.h"
 
81
 
 
82
/* Set BuildingMoreFilesXForMacOS9 to 1 if building for Mac OS 9 */
 
83
#ifndef BuildingMoreFilesXForMacOS9
 
84
        #define BuildingMoreFilesXForMacOS9 0
 
85
#endif
 
86
 
 
87
/*****************************************************************************/
 
88
 
 
89
#pragma mark ----- Local type definitions -----
 
90
 
 
91
struct FSIterateContainerGlobals
 
92
{
 
93
        IterateContainerFilterProcPtr   iterateFilter;  /* pointer to IterateFilterProc */
 
94
        FSCatalogInfoBitmap                             whichInfo;              /* fields of the CatalogInfo to get */
 
95
        FSCatalogInfo                                   catalogInfo;    /* FSCatalogInfo */
 
96
        FSRef                                                   ref;                    /* FSRef */
 
97
        FSSpec                                                  spec;                   /* FSSpec */
 
98
        FSSpec                                                  *specPtr;               /* pointer to spec field, or NULL */
 
99
        HFSUniStr255                                    name;                   /* HFSUniStr255 */
 
100
        HFSUniStr255                                    *namePtr;               /* pointer to name field, or NULL */
 
101
        void                                                    *yourDataPtr;   /* a pointer to caller supplied data the filter may need to access */
 
102
        ItemCount                                               maxLevels;              /* maximum levels to iterate through */
 
103
        ItemCount                                               currentLevel;   /* the current level FSIterateContainerLevel is on */
 
104
        Boolean                                                 quitFlag;               /* set to true if filter wants to kill interation */
 
105
        Boolean                                                 containerChanged; /* temporary - set to true if the current container changed during iteration */
 
106
        OSErr                                                   result;                 /* result */
 
107
        ItemCount                                               actualObjects;  /* number of objects returned */
 
108
};
 
109
typedef struct FSIterateContainerGlobals FSIterateContainerGlobals;
 
110
 
 
111
struct FSDeleteContainerGlobals
 
112
{
 
113
        OSErr                                                   result;                 /* result */
 
114
        ItemCount                                               actualObjects;  /* number of objects returned */
 
115
        FSCatalogInfo                                   catalogInfo;    /* FSCatalogInfo */
 
116
};
 
117
typedef struct FSDeleteContainerGlobals FSDeleteContainerGlobals;
 
118
 
 
119
/*****************************************************************************/
 
120
 
 
121
#pragma mark ----- Local prototypes -----
 
122
 
 
123
static
 
124
void
 
125
FSDeleteContainerLevel(
 
126
        const FSRef *container,
 
127
        FSDeleteContainerGlobals *theGlobals);
 
128
 
 
129
static
 
130
void
 
131
FSIterateContainerLevel(
 
132
        FSIterateContainerGlobals *theGlobals);
 
133
 
 
134
static
 
135
OSErr
 
136
GenerateUniqueHFSUniStr(
 
137
        long *startSeed,
 
138
        const FSRef *dir1,
 
139
        const FSRef *dir2,
 
140
        HFSUniStr255 *uniqueName);
 
141
 
 
142
/*****************************************************************************/
 
143
 
 
144
#pragma mark ----- File Access Routines -----
 
145
 
 
146
/*****************************************************************************/
 
147
 
 
148
OSErr
 
149
FSCopyFork(
 
150
        SInt16 srcRefNum,
 
151
        SInt16 dstRefNum,
 
152
        void *copyBufferPtr,
 
153
        ByteCount copyBufferSize)
 
154
{
 
155
        OSErr           srcResult;
 
156
        OSErr           dstResult;
 
157
        OSErr           result;
 
158
        SInt64          forkSize;
 
159
        ByteCount       readActualCount;
 
160
        
 
161
        /* check input parameters */
 
162
        require_action((NULL != copyBufferPtr) && (0 != copyBufferSize), BadParameter, result = paramErr);
 
163
        
 
164
        /* get source fork size */
 
165
        result = FSGetForkSize(srcRefNum, &forkSize);
 
166
        require_noerr(result, SourceFSGetForkSizeFailed);
 
167
        
 
168
        /* allocate disk space for destination fork */
 
169
        result = FSSetForkSize(dstRefNum, fsFromStart, forkSize);
 
170
        require_noerr(result, DestinationFSSetForkSizeFailed);
 
171
        
 
172
        /* reset source fork's position to 0 */
 
173
        result = FSSetForkPosition(srcRefNum, fsFromStart, 0);
 
174
        require_noerr(result, SourceFSSetForkPositionFailed);
 
175
        
 
176
        /* reset destination fork's position to 0 */
 
177
        result = FSSetForkPosition(dstRefNum, fsFromStart, 0);
 
178
        require_noerr(result, DestinationFSSetForkPositionFailed);
 
179
 
 
180
        /* If copyBufferSize is greater than 4K bytes, make it a multiple of 4k bytes */
 
181
        /* This will make writes on local volumes faster */
 
182
        if ( (copyBufferSize >= 0x00001000) && ((copyBufferSize & 0x00000fff) != 0) )
 
183
        {
 
184
                copyBufferSize &= ~(0x00001000 - 1);
 
185
        }
 
186
        
 
187
        /* copy source to destination */
 
188
        srcResult = dstResult = noErr;
 
189
        while ( (noErr == srcResult) && (noErr == dstResult) )
 
190
        {
 
191
                srcResult = FSReadFork(srcRefNum, fsAtMark + noCacheMask, 0, copyBufferSize, copyBufferPtr, &readActualCount);
 
192
                dstResult = FSWriteFork(dstRefNum, fsAtMark + noCacheMask, 0, readActualCount, copyBufferPtr, NULL);
 
193
        }
 
194
        
 
195
        /* make sure there were no errors at the destination */
 
196
        require_noerr_action(dstResult, DestinationFSWriteForkFailed, result = dstResult);
 
197
        
 
198
        /* make sure the error at the source was eofErr */
 
199
        require_action(eofErr == srcResult, SourceResultNotEofErr, result = srcResult);
 
200
        
 
201
        /* everything went as expected */
 
202
        result = noErr;
 
203
 
 
204
SourceResultNotEofErr:
 
205
DestinationFSWriteForkFailed:
 
206
DestinationFSSetForkPositionFailed:
 
207
SourceFSSetForkPositionFailed:
 
208
DestinationFSSetForkSizeFailed:
 
209
SourceFSGetForkSizeFailed:
 
210
BadParameter:
 
211
 
 
212
        return ( result );
 
213
}
 
214
 
 
215
/*****************************************************************************/
 
216
 
 
217
#pragma mark ----- Volume Access Routines -----
 
218
 
 
219
/*****************************************************************************/ 
 
220
 
 
221
OSErr
 
222
FSGetVolParms(
 
223
        FSVolumeRefNum volRefNum,
 
224
        UInt32 bufferSize,
 
225
        GetVolParmsInfoBuffer *volParmsInfo,
 
226
        UInt32 *actualInfoSize)
 
227
{
 
228
        OSErr                   result;
 
229
        HParamBlockRec  pb;
 
230
        
 
231
        /* check parameters */
 
232
        require_action((NULL != volParmsInfo) && (NULL != actualInfoSize),
 
233
                BadParameter, result = paramErr);
 
234
        
 
235
        pb.ioParam.ioNamePtr = NULL;
 
236
        pb.ioParam.ioVRefNum = volRefNum;
 
237
        pb.ioParam.ioBuffer = (Ptr)volParmsInfo;
 
238
        pb.ioParam.ioReqCount = (SInt32)bufferSize;
 
239
        result = PBHGetVolParmsSync(&pb);
 
240
        require_noerr(result, PBHGetVolParmsSync);
 
241
        
 
242
        /* return number of bytes the file system returned in volParmsInfo buffer */
 
243
        *actualInfoSize = (UInt32)pb.ioParam.ioActCount;
 
244
        
 
245
PBHGetVolParmsSync:
 
246
BadParameter:
 
247
 
 
248
        return ( result );
 
249
}
 
250
 
 
251
/*****************************************************************************/
 
252
 
 
253
OSErr
 
254
FSGetVRefNum(
 
255
        const FSRef *ref,
 
256
        FSVolumeRefNum *vRefNum)
 
257
{
 
258
        OSErr                   result;
 
259
        FSCatalogInfo   catalogInfo;
 
260
        
 
261
        /* check parameters */
 
262
        require_action(NULL != vRefNum, BadParameter, result = paramErr);
 
263
        
 
264
        /* get the volume refNum from the FSRef */
 
265
        result = FSGetCatalogInfo(ref, kFSCatInfoVolume, &catalogInfo, NULL, NULL, NULL);
 
266
        require_noerr(result, FSGetCatalogInfo);
 
267
        
 
268
        /* return volume refNum from catalogInfo */
 
269
        *vRefNum = catalogInfo.volume;
 
270
        
 
271
FSGetCatalogInfo:
 
272
BadParameter:
 
273
 
 
274
        return ( result );
 
275
}
 
276
 
 
277
/*****************************************************************************/
 
278
 
 
279
OSErr
 
280
FSGetVInfo(
 
281
        FSVolumeRefNum volume,
 
282
        HFSUniStr255 *volumeName,       /* can be NULL */
 
283
        UInt64 *freeBytes,                      /* can be NULL */
 
284
        UInt64 *totalBytes)                     /* can be NULL */
 
285
{
 
286
        OSErr                           result;
 
287
        FSVolumeInfo            info;
 
288
        
 
289
        /* ask for the volume's sizes only if needed */
 
290
        result = FSGetVolumeInfo(volume, 0, NULL,
 
291
                (((NULL != freeBytes) || (NULL != totalBytes)) ? kFSVolInfoSizes : kFSVolInfoNone),
 
292
                &info, volumeName, NULL);
 
293
        require_noerr(result, FSGetVolumeInfo);
 
294
        
 
295
        if ( NULL != freeBytes )
 
296
        {
 
297
                *freeBytes = info.freeBytes;
 
298
        }
 
299
        if ( NULL != totalBytes )
 
300
        {
 
301
                *totalBytes = info.totalBytes;
 
302
        }
 
303
        
 
304
FSGetVolumeInfo:
 
305
 
 
306
        return ( result );
 
307
}
 
308
 
 
309
/*****************************************************************************/
 
310
 
 
311
OSErr
 
312
FSGetVolFileSystemID(
 
313
        FSVolumeRefNum volume,
 
314
        UInt16 *fileSystemID,   /* can be NULL */
 
315
        UInt16 *signature)              /* can be NULL */
 
316
{
 
317
        OSErr                   result;
 
318
        FSVolumeInfo    info;
 
319
        
 
320
        result = FSGetVolumeInfo(volume, 0, NULL, kFSVolInfoFSInfo, &info, NULL, NULL);
 
321
        require_noerr(result, FSGetVolumeInfo);
 
322
        
 
323
        if ( NULL != fileSystemID )
 
324
        {
 
325
                *fileSystemID = info.filesystemID;
 
326
        }
 
327
        if ( NULL != signature )
 
328
        {
 
329
                *signature = info.signature;
 
330
        }
 
331
        
 
332
FSGetVolumeInfo:
 
333
 
 
334
        return ( result );
 
335
}
 
336
 
 
337
/*****************************************************************************/
 
338
 
 
339
OSErr
 
340
FSGetMountedVolumes(
 
341
        FSRef ***volumeRefsHandle,      /* pointer to handle of FSRefs */
 
342
        ItemCount *numVolumes)
 
343
{
 
344
        OSErr           result;
 
345
        OSErr           memResult;
 
346
        ItemCount       volumeIndex;
 
347
        FSRef           ref;
 
348
        
 
349
        /* check parameters */
 
350
        require_action((NULL != volumeRefsHandle) && (NULL != numVolumes),
 
351
                BadParameter, result = paramErr);
 
352
        
 
353
        /* No volumes yet */
 
354
        *numVolumes = 0;
 
355
        
 
356
        /* Allocate a handle for the results */
 
357
        *volumeRefsHandle = (FSRef **)NewHandle(0);
 
358
        require_action(NULL != *volumeRefsHandle, NewHandle, result = memFullErr);
 
359
        
 
360
        /* Call FSGetVolumeInfo in loop to get all volumes starting with the first */
 
361
        volumeIndex = 1;
 
362
        do
 
363
        {
 
364
                result = FSGetVolumeInfo(0, volumeIndex, NULL, kFSVolInfoNone, NULL, NULL, &ref);
 
365
                if ( noErr == result )
 
366
                {
 
367
                        /* concatenate the FSRef to the end of the handle */
 
368
                        PtrAndHand(&ref, (Handle)*volumeRefsHandle, sizeof(FSRef));
 
369
                        memResult = MemError();
 
370
                        require_noerr_action(memResult, MemoryAllocationFailed, result = memResult);
 
371
                        
 
372
                        ++(*numVolumes);        /* increment the volume count */
 
373
                        ++volumeIndex;          /* and the volumeIndex to get the next volume*/
 
374
                }
 
375
        } while ( noErr == result );
 
376
        
 
377
        /* nsvErr is OK -- it just means there are no more volumes */
 
378
        require(nsvErr == result, FSGetVolumeInfo);
 
379
                
 
380
        return ( noErr );
 
381
        
 
382
        /**********************/
 
383
        
 
384
MemoryAllocationFailed:
 
385
FSGetVolumeInfo:
 
386
 
 
387
        /* dispose of handle if already allocated and clear the outputs */
 
388
        if ( NULL != *volumeRefsHandle )
 
389
        {
 
390
                DisposeHandle((Handle)*volumeRefsHandle);
 
391
                *volumeRefsHandle = NULL;
 
392
        }
 
393
        *numVolumes = 0;
 
394
        
 
395
NewHandle:
 
396
BadParameter:
 
397
 
 
398
        return ( result );
 
399
}
 
400
 
 
401
/*****************************************************************************/
 
402
 
 
403
#pragma mark ----- FSRef/FSpec/Path/Name Conversion Routines -----
 
404
 
 
405
/*****************************************************************************/
 
406
 
 
407
OSErr
 
408
FSRefMakeFSSpec(
 
409
        const FSRef *ref,
 
410
        FSSpec *spec)
 
411
{
 
412
        OSErr   result;
 
413
        
 
414
        /* check parameters */
 
415
        require_action(NULL != spec, BadParameter, result = paramErr);
 
416
        
 
417
        result = FSGetCatalogInfo(ref, kFSCatInfoNone, NULL, NULL, spec, NULL);
 
418
        require_noerr(result, FSGetCatalogInfo);
 
419
        
 
420
FSGetCatalogInfo:
 
421
BadParameter:
 
422
 
 
423
        return ( result );
 
424
}
 
425
 
 
426
/*****************************************************************************/
 
427
 
 
428
OSErr
 
429
FSMakeFSRef(
 
430
        FSVolumeRefNum volRefNum,
 
431
        SInt32 dirID,
 
432
        ConstStr255Param name,
 
433
        FSRef *ref)
 
434
{
 
435
        OSErr           result;
 
436
        FSRefParam      pb;
 
437
        
 
438
        /* check parameters */
 
439
        require_action(NULL != ref, BadParameter, result = paramErr);
 
440
        
 
441
        pb.ioVRefNum = volRefNum;
 
442
        pb.ioDirID = dirID;
 
443
        pb.ioNamePtr = (StringPtr)name;
 
444
        pb.newRef = ref;
 
445
        result = PBMakeFSRefSync(&pb);
 
446
        require_noerr(result, PBMakeFSRefSync);
 
447
        
 
448
PBMakeFSRefSync:
 
449
BadParameter:
 
450
 
 
451
        return ( result );
 
452
}
 
453
 
 
454
/*****************************************************************************/
 
455
 
 
456
OSStatus
 
457
FSMakePath(
 
458
        SInt16 volRefNum,
 
459
        SInt32 dirID,
 
460
        ConstStr255Param name,
 
461
        UInt8 *path,
 
462
        UInt32 maxPathSize)
 
463
{
 
464
        OSStatus        result;
 
465
        FSRef           ref;
 
466
        
 
467
        /* check parameters */
 
468
        require_action(NULL != path, BadParameter, result = paramErr);
 
469
        
 
470
        /* convert the inputs to an FSRef */
 
471
        result = FSMakeFSRef(volRefNum, dirID, name, &ref);
 
472
        require_noerr(result, FSMakeFSRef);
 
473
        
 
474
        /* and then convert the FSRef to a path */
 
475
        result = FSRefMakePath(&ref, path, maxPathSize);
 
476
        require_noerr(result, FSRefMakePath);
 
477
        
 
478
FSRefMakePath:
 
479
FSMakeFSRef:
 
480
BadParameter:
 
481
 
 
482
        return ( result );
 
483
}
 
484
 
 
485
/*****************************************************************************/
 
486
 
 
487
OSStatus
 
488
FSPathMakeFSSpec(
 
489
        const UInt8 *path,
 
490
        FSSpec *spec,
 
491
        Boolean *isDirectory)   /* can be NULL */
 
492
{
 
493
        OSStatus        result;
 
494
        FSRef           ref;
 
495
        
 
496
        /* check parameters */
 
497
        require_action(NULL != spec, BadParameter, result = paramErr);
 
498
        
 
499
        /* convert the POSIX path to an FSRef */
 
500
        result = FSPathMakeRef(path, &ref, isDirectory);
 
501
        require_noerr(result, FSPathMakeRef);
 
502
        
 
503
        /* and then convert the FSRef to an FSSpec */
 
504
        result = FSGetCatalogInfo(&ref, kFSCatInfoNone, NULL, NULL, spec, NULL);
 
505
        require_noerr(result, FSGetCatalogInfo);
 
506
        
 
507
FSGetCatalogInfo:
 
508
FSPathMakeRef:
 
509
BadParameter:
 
510
 
 
511
        return ( result );
 
512
}
 
513
 
 
514
/*****************************************************************************/
 
515
 
 
516
OSErr
 
517
UnicodeNameGetHFSName(
 
518
        UniCharCount nameLength,
 
519
        const UniChar *name,
 
520
        TextEncoding textEncodingHint,
 
521
        Boolean isVolumeName,
 
522
        Str31 hfsName)
 
523
{
 
524
        OSStatus                        result;
 
525
        ByteCount                       unicodeByteLength;
 
526
        ByteCount                       unicodeBytesConverted;
 
527
        ByteCount                       actualPascalBytes;
 
528
        UnicodeMapping          uMapping;
 
529
        UnicodeToTextInfo       utInfo;
 
530
        
 
531
        /* check parameters */
 
532
        require_action(NULL != hfsName, BadParameter, result = paramErr);
 
533
        
 
534
        /* make sure output is valid in case we get errors or there's nothing to convert */
 
535
        hfsName[0] = 0;
 
536
        
 
537
        unicodeByteLength = nameLength * sizeof(UniChar);
 
538
        if ( 0 == unicodeByteLength )
 
539
        {
 
540
                /* do nothing */
 
541
                result = noErr;
 
542
        }
 
543
        else
 
544
        {
 
545
                /* if textEncodingHint is kTextEncodingUnknown, get a "default" textEncodingHint */
 
546
                if ( kTextEncodingUnknown == textEncodingHint )
 
547
                {
 
548
                        ScriptCode                      script;
 
549
                        RegionCode                      region;
 
550
                        
 
551
                        script = (ScriptCode)GetScriptManagerVariable(smSysScript);
 
552
                        region = (RegionCode)GetScriptManagerVariable(smRegionCode);
 
553
                        result = UpgradeScriptInfoToTextEncoding(script, kTextLanguageDontCare, region,
 
554
                                NULL, &textEncodingHint );
 
555
                        if ( paramErr == result )
 
556
                        {
 
557
                                /* ok, ignore the region and try again */
 
558
                                result = UpgradeScriptInfoToTextEncoding(script, kTextLanguageDontCare,
 
559
                                        kTextRegionDontCare, NULL, &textEncodingHint );
 
560
                        }
 
561
                        if ( noErr != result )
 
562
                        {
 
563
                                /* ok... try something */
 
564
                                textEncodingHint = kTextEncodingMacRoman;
 
565
                        }
 
566
                }
 
567
                
 
568
                uMapping.unicodeEncoding = CreateTextEncoding(kTextEncodingUnicodeV2_0,
 
569
                        kUnicodeCanonicalDecompVariant, kUnicode16BitFormat);
 
570
                uMapping.otherEncoding = GetTextEncodingBase(textEncodingHint);
 
571
                uMapping.mappingVersion = kUnicodeUseHFSPlusMapping;
 
572
        
 
573
                result = CreateUnicodeToTextInfo(&uMapping, &utInfo);
 
574
                require_noerr(result, CreateUnicodeToTextInfo);
 
575
                
 
576
                result = ConvertFromUnicodeToText(utInfo, unicodeByteLength, name, kUnicodeLooseMappingsMask,
 
577
                        0, NULL, 0, NULL,       /* offsetCounts & offsetArrays */
 
578
                        isVolumeName ? kHFSMaxVolumeNameChars : kHFSMaxFileNameChars,
 
579
                        &unicodeBytesConverted, &actualPascalBytes, &hfsName[1]);
 
580
                require_noerr(result, ConvertFromUnicodeToText);
 
581
                
 
582
                hfsName[0] = (unsigned char)actualPascalBytes;  /* fill in length byte */
 
583
 
 
584
ConvertFromUnicodeToText:
 
585
                
 
586
                /* verify the result in debug builds -- there's really not anything you can do if it fails */
 
587
                verify_noerr(DisposeUnicodeToTextInfo(&utInfo));
 
588
        }
 
589
        
 
590
CreateUnicodeToTextInfo:        
 
591
BadParameter:
 
592
 
 
593
        return ( result );
 
594
}
 
595
 
 
596
/*****************************************************************************/
 
597
 
 
598
OSErr
 
599
HFSNameGetUnicodeName(
 
600
        ConstStr31Param hfsName,
 
601
        TextEncoding textEncodingHint,
 
602
        HFSUniStr255 *unicodeName)
 
603
{
 
604
        ByteCount                       unicodeByteLength;
 
605
        OSStatus                        result;
 
606
        UnicodeMapping          uMapping;
 
607
        TextToUnicodeInfo       tuInfo;
 
608
        ByteCount                       pascalCharsRead;
 
609
        
 
610
        /* check parameters */
 
611
        require_action(NULL != unicodeName, BadParameter, result = paramErr);
 
612
        
 
613
        /* make sure output is valid in case we get errors or there's nothing to convert */
 
614
        unicodeName->length = 0;
 
615
        
 
616
        if ( 0 == StrLength(hfsName) )
 
617
        {
 
618
                result = noErr;
 
619
        }
 
620
        else
 
621
        {
 
622
                /* if textEncodingHint is kTextEncodingUnknown, get a "default" textEncodingHint */
 
623
                if ( kTextEncodingUnknown == textEncodingHint )
 
624
                {
 
625
                        ScriptCode                      script;
 
626
                        RegionCode                      region;
 
627
                        
 
628
                        script = GetScriptManagerVariable(smSysScript);
 
629
                        region = GetScriptManagerVariable(smRegionCode);
 
630
                        result = UpgradeScriptInfoToTextEncoding(script, kTextLanguageDontCare, region,
 
631
                                NULL, &textEncodingHint);
 
632
                        if ( paramErr == result )
 
633
                        {
 
634
                                /* ok, ignore the region and try again */
 
635
                                result = UpgradeScriptInfoToTextEncoding(script, kTextLanguageDontCare,
 
636
                                        kTextRegionDontCare, NULL, &textEncodingHint);
 
637
                        }
 
638
                        if ( noErr != result )
 
639
                        {
 
640
                                /* ok... try something */
 
641
                                textEncodingHint = kTextEncodingMacRoman;
 
642
                        }
 
643
                }
 
644
                
 
645
                uMapping.unicodeEncoding = CreateTextEncoding(kTextEncodingUnicodeV2_0,
 
646
                        kUnicodeCanonicalDecompVariant, kUnicode16BitFormat);
 
647
                uMapping.otherEncoding = GetTextEncodingBase(textEncodingHint);
 
648
                uMapping.mappingVersion = kUnicodeUseHFSPlusMapping;
 
649
        
 
650
                result = CreateTextToUnicodeInfo(&uMapping, &tuInfo);
 
651
                require_noerr(result, CreateTextToUnicodeInfo);
 
652
                        
 
653
                result = ConvertFromTextToUnicode(tuInfo, hfsName[0], &hfsName[1],
 
654
                        0,                                                              /* no control flag bits */
 
655
                        0, NULL, 0, NULL,                               /* offsetCounts & offsetArrays */
 
656
                        sizeof(unicodeName->unicode),   /* output buffer size in bytes */
 
657
                        &pascalCharsRead, &unicodeByteLength, unicodeName->unicode);
 
658
                require_noerr(result, ConvertFromTextToUnicode);
 
659
                
 
660
                /* convert from byte count to char count */
 
661
                unicodeName->length = unicodeByteLength / sizeof(UniChar);
 
662
 
 
663
ConvertFromTextToUnicode:
 
664
 
 
665
                /* verify the result in debug builds -- there's really not anything you can do if it fails */
 
666
                verify_noerr(DisposeTextToUnicodeInfo(&tuInfo));
 
667
        }
 
668
        
 
669
CreateTextToUnicodeInfo:
 
670
BadParameter:
 
671
 
 
672
        return ( result );
 
673
}
 
674
 
 
675
/*****************************************************************************/
 
676
 
 
677
#pragma mark ----- File/Directory Manipulation Routines -----
 
678
 
 
679
/*****************************************************************************/
 
680
 
 
681
Boolean FSRefValid(const FSRef *ref)
 
682
{
 
683
        return ( noErr == FSGetCatalogInfo(ref, kFSCatInfoNone, NULL, NULL, NULL, NULL) );
 
684
}
 
685
 
 
686
/*****************************************************************************/
 
687
 
 
688
OSErr
 
689
FSGetParentRef(
 
690
        const FSRef *ref,
 
691
        FSRef *parentRef)
 
692
{
 
693
        OSErr   result;
 
694
        FSCatalogInfo   catalogInfo;
 
695
        
 
696
        /* check parameters */
 
697
        require_action(NULL != parentRef, BadParameter, result = paramErr);
 
698
        
 
699
        result = FSGetCatalogInfo(ref, kFSCatInfoNodeID, &catalogInfo, NULL, NULL, parentRef);
 
700
        require_noerr(result, FSGetCatalogInfo);
 
701
        
 
702
        /*
 
703
         * Note: FSRefs always point to real file system objects. So, there cannot
 
704
         * be a FSRef to the parent of volume root directories. Early versions of
 
705
         * Mac OS X do not handle this case correctly and incorrectly return a
 
706
         * FSRef for the parent of volume root directories instead of returning an
 
707
         * invalid FSRef (a cleared FSRef is invalid). The next three lines of code
 
708
         * ensure that you won't run into this bug. WW9D!
 
709
         */
 
710
        if ( fsRtDirID == catalogInfo.nodeID )
 
711
        {
 
712
                /* clear parentRef and return noErr which is the proper behavior */
 
713
                memset(parentRef, 0, sizeof(FSRef));
 
714
        }
 
715
 
 
716
FSGetCatalogInfo:
 
717
BadParameter:
 
718
 
 
719
        return ( result );
 
720
}
 
721
 
 
722
/*****************************************************************************/
 
723
 
 
724
OSErr
 
725
FSGetFileDirName(
 
726
        const FSRef *ref,
 
727
        HFSUniStr255 *outName)
 
728
{
 
729
        OSErr   result;
 
730
        
 
731
        /* check parameters */
 
732
        require_action(NULL != outName, BadParameter, result = paramErr);
 
733
        
 
734
        result = FSGetCatalogInfo(ref, kFSCatInfoNone, NULL, outName, NULL, NULL);
 
735
        require_noerr(result, FSGetCatalogInfo);
 
736
        
 
737
FSGetCatalogInfo:
 
738
BadParameter:
 
739
 
 
740
        return ( result );
 
741
}
 
742
 
 
743
/*****************************************************************************/
 
744
 
 
745
OSErr
 
746
FSGetNodeID(
 
747
        const FSRef *ref,
 
748
        long *nodeID,                   /* can be NULL */
 
749
        Boolean *isDirectory)   /* can be NULL */
 
750
{
 
751
        OSErr                           result;
 
752
        FSCatalogInfo           catalogInfo;
 
753
        FSCatalogInfoBitmap whichInfo;
 
754
        
 
755
        /* determine what catalog information to get */
 
756
        whichInfo = kFSCatInfoNone; /* start with none */
 
757
        if ( NULL != nodeID )
 
758
        {
 
759
                whichInfo |= kFSCatInfoNodeID;
 
760
        }
 
761
        if ( NULL != isDirectory )
 
762
        {
 
763
                whichInfo |= kFSCatInfoNodeFlags;
 
764
        }
 
765
        
 
766
        result = FSGetCatalogInfo(ref, whichInfo, &catalogInfo, NULL, NULL, NULL);
 
767
        require_noerr(result, FSGetCatalogInfo);
 
768
        
 
769
        if ( NULL != nodeID )
 
770
        {
 
771
                *nodeID = catalogInfo.nodeID;
 
772
        }
 
773
        if ( NULL != isDirectory )
 
774
        {
 
775
                *isDirectory = (0 != (kFSNodeIsDirectoryMask & catalogInfo.nodeFlags));
 
776
        }
 
777
        
 
778
FSGetCatalogInfo:
 
779
 
 
780
        return ( result );
 
781
}
 
782
 
 
783
/*****************************************************************************/
 
784
 
 
785
OSErr
 
786
FSGetUserPrivilegesPermissions(
 
787
        const FSRef *ref,
 
788
        UInt8 *userPrivileges,          /* can be NULL */
 
789
        UInt32 permissions[4])          /* can be NULL */
 
790
{
 
791
        OSErr                   result;
 
792
        FSCatalogInfo   catalogInfo;
 
793
        FSCatalogInfoBitmap whichInfo;
 
794
        
 
795
        /* determine what catalog information to get */
 
796
        whichInfo = kFSCatInfoNone; /* start with none */
 
797
        if ( NULL != userPrivileges )
 
798
        {
 
799
                whichInfo |= kFSCatInfoUserPrivs;
 
800
        }
 
801
        if ( NULL != permissions )
 
802
        {
 
803
                whichInfo |= kFSCatInfoPermissions;
 
804
        }
 
805
        
 
806
        result = FSGetCatalogInfo(ref, whichInfo, &catalogInfo, NULL, NULL, NULL);
 
807
        require_noerr(result, FSGetCatalogInfo);
 
808
        
 
809
        if ( NULL != userPrivileges )
 
810
        {
 
811
                *userPrivileges = catalogInfo.userPrivileges;
 
812
        }
 
813
        if ( NULL != permissions )
 
814
        {
 
815
                BlockMoveData(&catalogInfo.permissions, permissions, sizeof(UInt32) * 4);
 
816
        }
 
817
        
 
818
FSGetCatalogInfo:
 
819
 
 
820
        return ( result );
 
821
}
 
822
 
 
823
/*****************************************************************************/
 
824
 
 
825
OSErr
 
826
FSCheckLock(
 
827
        const FSRef *ref)
 
828
{
 
829
        OSErr                   result;
 
830
        FSCatalogInfo   catalogInfo;
 
831
        FSVolumeInfo    volumeInfo;
 
832
        
 
833
        /* get nodeFlags and vRefNum for container */
 
834
        result = FSGetCatalogInfo(ref, kFSCatInfoNodeFlags + kFSCatInfoVolume, &catalogInfo, NULL, NULL,NULL);
 
835
        require_noerr(result, FSGetCatalogInfo);
 
836
        
 
837
        /* is file locked? */
 
838
        if ( 0 != (catalogInfo.nodeFlags & kFSNodeLockedMask) )
 
839
        {
 
840
                result = fLckdErr;      /* file is locked */
 
841
        }
 
842
        else
 
843
        {
 
844
                /* file isn't locked, but is volume locked? */
 
845
                
 
846
                /* get volume flags */
 
847
                result = FSGetVolumeInfo(catalogInfo.volume, 0, NULL, kFSVolInfoFlags, &volumeInfo, NULL, NULL);
 
848
                require_noerr(result, FSGetVolumeInfo);
 
849
                
 
850
                if ( 0 != (volumeInfo.flags & kFSVolFlagHardwareLockedMask) )
 
851
                {
 
852
                        result = wPrErr;        /* volume locked by hardware */
 
853
                }
 
854
                else if ( 0 != (volumeInfo.flags & kFSVolFlagSoftwareLockedMask) )
 
855
                {
 
856
                        result = vLckdErr;      /* volume locked by software */
 
857
                }
 
858
        }
 
859
        
 
860
FSGetVolumeInfo:
 
861
FSGetCatalogInfo:
 
862
 
 
863
        return ( result );
 
864
}
 
865
 
 
866
/*****************************************************************************/
 
867
 
 
868
OSErr
 
869
FSGetForkSizes(
 
870
        const FSRef *ref,
 
871
        UInt64 *dataLogicalSize,        /* can be NULL */
 
872
        UInt64 *rsrcLogicalSize)        /* can be NULL */
 
873
{
 
874
        OSErr                           result;
 
875
        FSCatalogInfoBitmap whichInfo;
 
876
        FSCatalogInfo           catalogInfo;
 
877
        
 
878
        whichInfo = kFSCatInfoNodeFlags;
 
879
        if ( NULL != dataLogicalSize )
 
880
        {
 
881
                /* get data fork size */
 
882
                whichInfo |= kFSCatInfoDataSizes;
 
883
        }
 
884
        if ( NULL != rsrcLogicalSize )
 
885
        {
 
886
                /* get resource fork size */
 
887
                whichInfo |= kFSCatInfoRsrcSizes;
 
888
        }
 
889
 
 
890
        /* get nodeFlags and catalog info */
 
891
        result = FSGetCatalogInfo(ref, whichInfo, &catalogInfo, NULL, NULL,NULL);
 
892
        require_noerr(result, FSGetCatalogInfo);
 
893
        
 
894
        /* make sure FSRef was to a file */
 
895
        require_action(0 == (catalogInfo.nodeFlags & kFSNodeIsDirectoryMask), FSRefNotFile, result = notAFileErr);
 
896
        
 
897
        if ( NULL != dataLogicalSize )
 
898
        {
 
899
                /* return data fork size */
 
900
                *dataLogicalSize = catalogInfo.dataLogicalSize;
 
901
        }
 
902
        if ( NULL != rsrcLogicalSize )
 
903
        {
 
904
                /* return resource fork size */
 
905
                *rsrcLogicalSize = catalogInfo.rsrcLogicalSize;
 
906
        }
 
907
        
 
908
FSRefNotFile:
 
909
FSGetCatalogInfo:
 
910
 
 
911
        return ( result );
 
912
}
 
913
 
 
914
/*****************************************************************************/
 
915
 
 
916
OSErr
 
917
FSGetTotalForkSizes(
 
918
        const FSRef *ref,
 
919
        UInt64 *totalLogicalSize,       /* can be NULL */
 
920
        UInt64 *totalPhysicalSize,      /* can be NULL */
 
921
        ItemCount *forkCount)           /* can be NULL */
 
922
{
 
923
        OSErr                   result;
 
924
        CatPositionRec  forkIterator;
 
925
        SInt64                  forkSize;
 
926
        SInt64                  *forkSizePtr;
 
927
        UInt64                  forkPhysicalSize;
 
928
        UInt64                  *forkPhysicalSizePtr;
 
929
        
 
930
        /* Determine if forkSize needed */
 
931
        if ( NULL != totalLogicalSize)
 
932
        {
 
933
                *totalLogicalSize = 0;
 
934
                forkSizePtr = &forkSize;
 
935
        }
 
936
        else
 
937
        {
 
938
                forkSizePtr = NULL;
 
939
        }
 
940
        
 
941
        /* Determine if forkPhysicalSize is needed */
 
942
        if ( NULL != totalPhysicalSize )
 
943
        {
 
944
                *totalPhysicalSize = 0;
 
945
                forkPhysicalSizePtr = &forkPhysicalSize;
 
946
        }
 
947
        else
 
948
        {
 
949
                forkPhysicalSizePtr = NULL;
 
950
        }
 
951
        
 
952
        /* zero fork count if returning it */
 
953
        if ( NULL != forkCount )
 
954
        {
 
955
                *forkCount = 0;
 
956
        }
 
957
        
 
958
        /* Iterate through the forks to get the sizes */
 
959
        forkIterator.initialize = 0;
 
960
        do
 
961
        {
 
962
                result = FSIterateForks(ref, &forkIterator, NULL, forkSizePtr, forkPhysicalSizePtr);
 
963
                if ( noErr == result )
 
964
                {
 
965
                        if ( NULL != totalLogicalSize )
 
966
                        {
 
967
                                *totalLogicalSize += forkSize;
 
968
                        }
 
969
                        
 
970
                        if ( NULL != totalPhysicalSize )
 
971
                        {
 
972
                                *totalPhysicalSize += forkPhysicalSize;
 
973
                        }
 
974
                        
 
975
                        if ( NULL != forkCount )
 
976
                        {
 
977
                                ++*forkCount;
 
978
                        }
 
979
                }
 
980
        } while ( noErr == result );
 
981
        
 
982
        /* any error result other than errFSNoMoreItems is serious */
 
983
        require(errFSNoMoreItems == result, FSIterateForks);
 
984
        
 
985
        /* Normal exit */
 
986
        result = noErr;
 
987
 
 
988
FSIterateForks:
 
989
        
 
990
        return ( result );
 
991
}
 
992
 
 
993
/*****************************************************************************/
 
994
 
 
995
OSErr
 
996
FSBumpDate(
 
997
        const FSRef *ref)
 
998
{
 
999
        OSStatus                result;
 
1000
        FSCatalogInfo   catalogInfo;
 
1001
        UTCDateTime             oldDateTime;
 
1002
#if !BuildingMoreFilesXForMacOS9
 
1003
        FSRef                   parentRef;
 
1004
        Boolean                 notifyParent;
 
1005
#endif
 
1006
 
 
1007
#if !BuildingMoreFilesXForMacOS9
 
1008
        /* Get the node flags, the content modification date and time, and the parent ref */
 
1009
        result = FSGetCatalogInfo(ref, kFSCatInfoNodeFlags + kFSCatInfoContentMod, &catalogInfo, NULL, NULL, &parentRef);
 
1010
        require_noerr(result, FSGetCatalogInfo);
 
1011
        
 
1012
        /* Notify the parent if this is a file */
 
1013
        notifyParent = (0 == (catalogInfo.nodeFlags & kFSNodeIsDirectoryMask));
 
1014
#else
 
1015
        /* Get the content modification date and time */
 
1016
        result = FSGetCatalogInfo(ref, kFSCatInfoContentMod, &catalogInfo, NULL, NULL, NULL);
 
1017
        require_noerr(result, FSGetCatalogInfo);
 
1018
#endif
 
1019
        
 
1020
        oldDateTime = catalogInfo.contentModDate;
 
1021
 
 
1022
        /* Get the current date and time */
 
1023
        result = GetUTCDateTime(&catalogInfo.contentModDate, kUTCDefaultOptions);
 
1024
        require_noerr(result, GetUTCDateTime);
 
1025
        
 
1026
        /* if the old date and time is the the same as the current, bump the seconds by one */
 
1027
        if ( (catalogInfo.contentModDate.fraction == oldDateTime.fraction) &&
 
1028
                 (catalogInfo.contentModDate.lowSeconds == oldDateTime.lowSeconds) &&
 
1029
                 (catalogInfo.contentModDate.highSeconds == oldDateTime.highSeconds) )
 
1030
        {
 
1031
                ++catalogInfo.contentModDate.lowSeconds;
 
1032
                if ( 0 == catalogInfo.contentModDate.lowSeconds )
 
1033
                {
 
1034
                        ++catalogInfo.contentModDate.highSeconds;
 
1035
                }
 
1036
        }
 
1037
        
 
1038
        /* Bump the content modification date and time */
 
1039
        result = FSSetCatalogInfo(ref, kFSCatInfoContentMod, &catalogInfo);
 
1040
        require_noerr(result, FSSetCatalogInfo);
 
1041
 
 
1042
#if !BuildingMoreFilesXForMacOS9
 
1043
        /*
 
1044
         * The problem with FNNotify is that it is not available under Mac OS 9
 
1045
         * and there's no way to test for that except for looking for the symbol
 
1046
         * or something. So, I'll just conditionalize this for those who care
 
1047
         * to send a notification.
 
1048
         */
 
1049
        
 
1050
        /* Send a notification for the parent of the file, or for the directory */
 
1051
        result = FNNotify(notifyParent ? &parentRef : ref, kFNDirectoryModifiedMessage, kNilOptions);
 
1052
        require_noerr(result, FNNotify);
 
1053
#endif
 
1054
 
 
1055
        /* ignore errors from FSSetCatalogInfo (volume might be write protected) and FNNotify */
 
1056
FNNotify:
 
1057
FSSetCatalogInfo:
 
1058
        
 
1059
        return ( noErr );
 
1060
        
 
1061
        /**********************/
 
1062
        
 
1063
GetUTCDateTime:
 
1064
FSGetCatalogInfo:
 
1065
 
 
1066
        return ( result );
 
1067
}
 
1068
 
 
1069
/*****************************************************************************/
 
1070
 
 
1071
OSErr
 
1072
FSGetFinderInfo(
 
1073
        const FSRef *ref,
 
1074
        FinderInfo *info,                                       /* can be NULL */
 
1075
        ExtendedFinderInfo *extendedInfo,       /* can be NULL */
 
1076
        Boolean *isDirectory)                           /* can be NULL */
 
1077
{
 
1078
        OSErr                           result;
 
1079
        FSCatalogInfo           catalogInfo;
 
1080
        FSCatalogInfoBitmap whichInfo;
 
1081
        
 
1082
        /* determine what catalog information is really needed */
 
1083
        whichInfo = kFSCatInfoNone;
 
1084
        
 
1085
        if ( NULL != info )
 
1086
        {
 
1087
                /* get FinderInfo */
 
1088
                whichInfo |= kFSCatInfoFinderInfo;
 
1089
        }
 
1090
        
 
1091
        if ( NULL != extendedInfo )
 
1092
        {
 
1093
                /* get ExtendedFinderInfo */
 
1094
                whichInfo |= kFSCatInfoFinderXInfo;
 
1095
        }
 
1096
        
 
1097
        if ( NULL != isDirectory )
 
1098
        {
 
1099
                whichInfo |= kFSCatInfoNodeFlags;
 
1100
        }
 
1101
        
 
1102
        result = FSGetCatalogInfo(ref, whichInfo, &catalogInfo, NULL, NULL, NULL);
 
1103
        require_noerr(result, FSGetCatalogInfo);
 
1104
        
 
1105
        /* return FinderInfo if requested */
 
1106
        if ( NULL != info )
 
1107
        {
 
1108
                BlockMoveData(catalogInfo.finderInfo, info, sizeof(FinderInfo));
 
1109
        }
 
1110
        
 
1111
        /* return ExtendedFinderInfo if requested */
 
1112
        if ( NULL != extendedInfo)
 
1113
        {
 
1114
                BlockMoveData(catalogInfo.extFinderInfo, extendedInfo, sizeof(ExtendedFinderInfo));
 
1115
        }
 
1116
        
 
1117
        /* set isDirectory Boolean if requested */
 
1118
        if ( NULL != isDirectory)
 
1119
        {
 
1120
                *isDirectory = (0 != (kFSNodeIsDirectoryMask & catalogInfo.nodeFlags));
 
1121
        }
 
1122
        
 
1123
FSGetCatalogInfo:
 
1124
 
 
1125
        return ( result );
 
1126
}
 
1127
 
 
1128
/*****************************************************************************/
 
1129
 
 
1130
OSErr
 
1131
FSSetFinderInfo(
 
1132
        const FSRef *ref,
 
1133
        const FinderInfo *info,
 
1134
        const ExtendedFinderInfo *extendedInfo)
 
1135
{
 
1136
        OSErr                           result;
 
1137
        FSCatalogInfo           catalogInfo;
 
1138
        FSCatalogInfoBitmap whichInfo;
 
1139
        
 
1140
        /* determine what catalog information will be set */
 
1141
        whichInfo = kFSCatInfoNone; /* start with none */
 
1142
        if ( NULL != info )
 
1143
        {
 
1144
                /* set FinderInfo */
 
1145
                whichInfo |= kFSCatInfoFinderInfo;
 
1146
                BlockMoveData(info, catalogInfo.finderInfo, sizeof(FinderInfo));
 
1147
        }
 
1148
        if ( NULL != extendedInfo )
 
1149
        {
 
1150
                /* set ExtendedFinderInfo */
 
1151
                whichInfo |= kFSCatInfoFinderXInfo;
 
1152
                BlockMoveData(extendedInfo, catalogInfo.extFinderInfo, sizeof(ExtendedFinderInfo));
 
1153
        }
 
1154
        
 
1155
        result = FSSetCatalogInfo(ref, whichInfo, &catalogInfo);
 
1156
        require_noerr(result, FSGetCatalogInfo);
 
1157
        
 
1158
FSGetCatalogInfo:
 
1159
 
 
1160
        return ( result );
 
1161
}
 
1162
 
 
1163
/*****************************************************************************/
 
1164
 
 
1165
OSErr
 
1166
FSChangeCreatorType(
 
1167
        const FSRef *ref,
 
1168
        OSType fileCreator,
 
1169
        OSType fileType)
 
1170
{
 
1171
        OSErr                   result;
 
1172
        FSCatalogInfo   catalogInfo;
 
1173
        FSRef                   parentRef;
 
1174
        
 
1175
        /* get nodeFlags, finder info, and parent FSRef */
 
1176
        result = FSGetCatalogInfo(ref, kFSCatInfoNodeFlags + kFSCatInfoFinderInfo, &catalogInfo , NULL, NULL, &parentRef);
 
1177
        require_noerr(result, FSGetCatalogInfo);
 
1178
        
 
1179
        /* make sure FSRef was to a file */
 
1180
        require_action(0 == (catalogInfo.nodeFlags & kFSNodeIsDirectoryMask), FSRefNotFile, result = notAFileErr);
 
1181
        
 
1182
        /* If fileType not 0x00000000, change fileType */
 
1183
        if ( fileType != (OSType)0x00000000 )
 
1184
        {
 
1185
                ((FileInfo *)&catalogInfo.finderInfo)->fileType = fileType;
 
1186
        }
 
1187
        
 
1188
        /* If creator not 0x00000000, change creator */
 
1189
        if ( fileCreator != (OSType)0x00000000 )
 
1190
        {
 
1191
                ((FileInfo *)&catalogInfo.finderInfo)->fileCreator = fileCreator;
 
1192
        }
 
1193
        
 
1194
        /* now, save the new information back to disk */
 
1195
        result = FSSetCatalogInfo(ref, kFSCatInfoFinderInfo, &catalogInfo);
 
1196
        require_noerr(result, FSSetCatalogInfo);
 
1197
        
 
1198
        /* and attempt to bump the parent directory's mod date to wake up */
 
1199
        /* the Finder to the change we just made (ignore errors from this) */
 
1200
        verify_noerr(FSBumpDate(&parentRef));
 
1201
        
 
1202
FSSetCatalogInfo:
 
1203
FSRefNotFile:
 
1204
FSGetCatalogInfo:
 
1205
 
 
1206
        return ( result );
 
1207
}
 
1208
 
 
1209
/*****************************************************************************/
 
1210
 
 
1211
OSErr
 
1212
FSChangeFinderFlags(
 
1213
        const FSRef *ref,
 
1214
        Boolean setBits,
 
1215
        UInt16 flagBits)
 
1216
{
 
1217
        OSErr                   result;
 
1218
        FSCatalogInfo   catalogInfo;
 
1219
        FSRef                   parentRef;
 
1220
        
 
1221
        /* get the current finderInfo */
 
1222
        result = FSGetCatalogInfo(ref, kFSCatInfoFinderInfo, &catalogInfo, NULL, NULL, &parentRef);
 
1223
        require_noerr(result, FSGetCatalogInfo);
 
1224
        
 
1225
        /* set or clear the appropriate bits in the finderInfo.finderFlags */
 
1226
        if ( setBits )
 
1227
        {
 
1228
                /* OR in the bits */
 
1229
                ((FileInfo *)&catalogInfo.finderInfo)->finderFlags |= flagBits;
 
1230
        }
 
1231
        else
 
1232
        {
 
1233
                /* AND out the bits */
 
1234
                ((FileInfo *)&catalogInfo.finderInfo)->finderFlags &= ~flagBits;
 
1235
        }
 
1236
        
 
1237
        /* save the modified finderInfo */
 
1238
        result = FSSetCatalogInfo(ref, kFSCatInfoFinderInfo, &catalogInfo);
 
1239
        require_noerr(result, FSSetCatalogInfo);
 
1240
        
 
1241
        /* and attempt to bump the parent directory's mod date to wake up the Finder */
 
1242
        /* to the change we just made (ignore errors from this) */
 
1243
        verify_noerr(FSBumpDate(&parentRef));
 
1244
        
 
1245
FSSetCatalogInfo:
 
1246
FSGetCatalogInfo:
 
1247
 
 
1248
        return ( result );
 
1249
}
 
1250
 
 
1251
/*****************************************************************************/
 
1252
 
 
1253
OSErr
 
1254
FSSetInvisible(
 
1255
        const FSRef *ref)
 
1256
{
 
1257
        return ( FSChangeFinderFlags(ref, true, kIsInvisible) );
 
1258
}
 
1259
 
 
1260
OSErr
 
1261
FSClearInvisible(
 
1262
        const FSRef *ref)
 
1263
{
 
1264
        return ( FSChangeFinderFlags(ref, false, kIsInvisible) );
 
1265
}
 
1266
 
 
1267
/*****************************************************************************/
 
1268
 
 
1269
OSErr
 
1270
FSSetNameLocked(
 
1271
        const FSRef *ref)
 
1272
{
 
1273
        return ( FSChangeFinderFlags(ref, true, kNameLocked) );
 
1274
}
 
1275
 
 
1276
OSErr
 
1277
FSClearNameLocked(
 
1278
        const FSRef *ref)
 
1279
{
 
1280
        return ( FSChangeFinderFlags(ref, false, kNameLocked) );
 
1281
}
 
1282
 
 
1283
/*****************************************************************************/
 
1284
 
 
1285
OSErr
 
1286
FSSetIsStationery(
 
1287
        const FSRef *ref)
 
1288
{
 
1289
        return ( FSChangeFinderFlags(ref, true, kIsStationery) );
 
1290
}
 
1291
 
 
1292
OSErr
 
1293
FSClearIsStationery(
 
1294
        const FSRef *ref)
 
1295
{
 
1296
        return ( FSChangeFinderFlags(ref, false, kIsStationery) );
 
1297
}
 
1298
 
 
1299
/*****************************************************************************/
 
1300
 
 
1301
OSErr
 
1302
FSSetHasCustomIcon(
 
1303
        const FSRef *ref)
 
1304
{
 
1305
        return ( FSChangeFinderFlags(ref, true, kHasCustomIcon) );
 
1306
}
 
1307
 
 
1308
OSErr
 
1309
FSClearHasCustomIcon(
 
1310
        const FSRef *ref)
 
1311
{
 
1312
        return ( FSChangeFinderFlags(ref, false, kHasCustomIcon) );
 
1313
}
 
1314
 
 
1315
/*****************************************************************************/
 
1316
 
 
1317
OSErr
 
1318
FSClearHasBeenInited(
 
1319
        const FSRef *ref)
 
1320
{
 
1321
        return ( FSChangeFinderFlags(ref, false, kHasBeenInited) );
 
1322
}
 
1323
 
 
1324
/*****************************************************************************/
 
1325
 
 
1326
OSErr
 
1327
FSCopyFileMgrAttributes(
 
1328
        const FSRef *sourceRef,
 
1329
        const FSRef *destinationRef,
 
1330
        Boolean copyLockBit)
 
1331
{
 
1332
        OSErr                   result;
 
1333
        FSCatalogInfo   catalogInfo;
 
1334
        
 
1335
        /* get the source information */
 
1336
        result = FSGetCatalogInfo(sourceRef, kFSCatInfoSettableInfo, &catalogInfo, NULL, NULL, NULL);
 
1337
        require_noerr(result, FSGetCatalogInfo);
 
1338
        
 
1339
        /* don't copy the hasBeenInited bit; clear it */
 
1340
        ((FileInfo *)&catalogInfo.finderInfo)->finderFlags &= ~kHasBeenInited;
 
1341
        
 
1342
        /* should the locked bit be copied? */
 
1343
        if ( !copyLockBit )
 
1344
        {
 
1345
                /* no, make sure the locked bit is clear */
 
1346
                catalogInfo.nodeFlags &= ~kFSNodeLockedMask;
 
1347
        }
 
1348
                
 
1349
        /* set the destination information */
 
1350
        result = FSSetCatalogInfo(destinationRef, kFSCatInfoSettableInfo, &catalogInfo);
 
1351
        require_noerr(result, FSSetCatalogInfo);
 
1352
        
 
1353
FSSetCatalogInfo:
 
1354
FSGetCatalogInfo:
 
1355
 
 
1356
        return ( result );
 
1357
}
 
1358
 
 
1359
/*****************************************************************************/
 
1360
 
 
1361
OSErr
 
1362
FSMoveRenameObjectUnicode(
 
1363
        const FSRef *ref,
 
1364
        const FSRef *destDirectory,
 
1365
        UniCharCount nameLength,
 
1366
        const UniChar *name,                    /* can be NULL (no rename during move) */
 
1367
        TextEncoding textEncodingHint,
 
1368
        FSRef *newRef)                                  /* if function fails along the way, newRef is final location of file */
 
1369
{
 
1370
        OSErr                   result;
 
1371
        FSVolumeRefNum  vRefNum;
 
1372
        FSCatalogInfo   catalogInfo;
 
1373
        FSRef                   originalDirectory;
 
1374
        TextEncoding    originalTextEncodingHint;
 
1375
        HFSUniStr255    originalName;
 
1376
        HFSUniStr255    uniqueName;             /* unique name given to object while moving it to destination */
 
1377
        long                    theSeed;                /* the seed for generating unique names */
 
1378
        
 
1379
        /* check parameters */
 
1380
        require_action(NULL != newRef, BadParameter, result = paramErr);
 
1381
        
 
1382
        /* newRef = input to start with */
 
1383
        BlockMoveData(ref, newRef, sizeof(FSRef));
 
1384
        
 
1385
        /* get destDirectory's vRefNum */
 
1386
        result = FSGetCatalogInfo(destDirectory, kFSCatInfoVolume, &catalogInfo, NULL, NULL, NULL);
 
1387
        require_noerr(result, DestinationBad);
 
1388
        
 
1389
        /* save vRefNum */
 
1390
        vRefNum = catalogInfo.volume;
 
1391
        
 
1392
        /* get ref's vRefNum, TextEncoding, name and parent directory*/
 
1393
        result = FSGetCatalogInfo(ref, kFSCatInfoTextEncoding + kFSCatInfoVolume, &catalogInfo, &originalName, NULL, &originalDirectory);
 
1394
        require_noerr(result, SourceBad);
 
1395
        
 
1396
        /* save TextEncoding */
 
1397
        originalTextEncodingHint = catalogInfo.textEncodingHint;
 
1398
        
 
1399
        /* make sure ref and destDirectory are on same volume */
 
1400
        require_action(vRefNum == catalogInfo.volume, NotSameVolume, result = diffVolErr);
 
1401
        
 
1402
        /* Skip a few steps if we're not renaming */
 
1403
        if ( NULL != name )
 
1404
        {
 
1405
                /* generate a name that is unique in both directories */
 
1406
                theSeed = 0x4a696d4c;   /* a fine unlikely filename */
 
1407
                
 
1408
                result = GenerateUniqueHFSUniStr(&theSeed, &originalDirectory, destDirectory, &uniqueName);
 
1409
                require_noerr(result, GenerateUniqueHFSUniStrFailed);
 
1410
                
 
1411
                /* Rename the object to uniqueName */
 
1412
                result = FSRenameUnicode(ref, uniqueName.length, uniqueName.unicode, kTextEncodingUnknown, newRef);
 
1413
                require_noerr(result, FSRenameUnicodeBeforeMoveFailed);
 
1414
                
 
1415
                if ( FSCompareFSRefs(destDirectory, &originalDirectory) != noErr )
 
1416
                {
 
1417
                  /* Move object to its new home */
 
1418
                  result = FSMoveObject(newRef, destDirectory, newRef);
 
1419
                  require_noerr(result, FSMoveObjectAfterRenameFailed);
 
1420
                }
 
1421
                
 
1422
                /* Rename the object to new name */
 
1423
                result = FSRenameUnicode(ref, nameLength, name, textEncodingHint, newRef);
 
1424
                require_noerr(result, FSRenameUnicodeAfterMoveFailed);
 
1425
        }
 
1426
        else
 
1427
        {
 
1428
                /* Move object to its new home */
 
1429
                result = FSMoveObject(newRef, destDirectory, newRef);
 
1430
                require_noerr(result, FSMoveObjectNoRenameFailed);
 
1431
        }
 
1432
        
 
1433
        return ( result );
 
1434
        
 
1435
        /*************/
 
1436
 
 
1437
/*
 
1438
 * failure handling code when renaming
 
1439
 */
 
1440
 
 
1441
FSRenameUnicodeAfterMoveFailed:
 
1442
 
 
1443
        /* Error handling: move object back to original location - ignore errors */
 
1444
        verify_noerr(FSMoveObject(newRef, &originalDirectory, newRef));
 
1445
        
 
1446
FSMoveObjectAfterRenameFailed:
 
1447
 
 
1448
        /* Error handling: rename object back to original name - ignore errors */
 
1449
        verify_noerr(FSRenameUnicode(newRef, originalName.length, originalName.unicode, originalTextEncodingHint, newRef));
 
1450
        
 
1451
FSRenameUnicodeBeforeMoveFailed:
 
1452
GenerateUniqueHFSUniStrFailed:
 
1453
 
 
1454
/*
 
1455
 * failure handling code for renaming or not
 
1456
 */
 
1457
FSMoveObjectNoRenameFailed:
 
1458
NotSameVolume:
 
1459
SourceBad:
 
1460
DestinationBad:
 
1461
BadParameter:
 
1462
 
 
1463
        return ( result );
 
1464
}
 
1465
 
 
1466
/*****************************************************************************/
 
1467
 
 
1468
/*
 
1469
        The FSDeleteContainerLevel function deletes the contents of a container
 
1470
        directory. All files and subdirectories in the specified container are
 
1471
        deleted. If a locked file or directory is encountered, it is unlocked
 
1472
        and then deleted. If any unexpected errors are encountered,
 
1473
        FSDeleteContainerLevel quits and returns to the caller.
 
1474
        
 
1475
        container                       --> FSRef to a directory.
 
1476
        theGlobals                      --> A pointer to a FSDeleteContainerGlobals struct
 
1477
                                                        which contains the variables that do not need to
 
1478
                                                        be allocated each time FSDeleteContainerLevel
 
1479
                                                        recurses. That lets FSDeleteContainerLevel use
 
1480
                                                        less stack space per recursion level.
 
1481
*/
 
1482
 
 
1483
static
 
1484
void
 
1485
FSDeleteContainerLevel(
 
1486
        const FSRef *container,
 
1487
        FSDeleteContainerGlobals *theGlobals)
 
1488
{
 
1489
        /* level locals */
 
1490
        FSIterator                                      iterator;
 
1491
        FSRef                                           itemToDelete;
 
1492
        UInt16                                          nodeFlags;
 
1493
        
 
1494
        /* Open FSIterator for flat access and give delete optimization hint */
 
1495
        theGlobals->result = FSOpenIterator(container, kFSIterateFlat + kFSIterateDelete, &iterator);
 
1496
        require_noerr(theGlobals->result, FSOpenIterator);
 
1497
        
 
1498
        /* delete the contents of the directory */
 
1499
        do
 
1500
        {
 
1501
                /* get 1 item to delete */
 
1502
                theGlobals->result = FSGetCatalogInfoBulk(iterator, 1, &theGlobals->actualObjects,
 
1503
                                                                NULL, kFSCatInfoNodeFlags, &theGlobals->catalogInfo,
 
1504
                                                                &itemToDelete, NULL, NULL);
 
1505
                if ( (noErr == theGlobals->result) && (1 == theGlobals->actualObjects) )
 
1506
                {
 
1507
                        /* save node flags in local in case we have to recurse */
 
1508
                        nodeFlags = theGlobals->catalogInfo.nodeFlags;
 
1509
                        
 
1510
                        /* is it a file or directory? */
 
1511
                        if ( 0 != (nodeFlags & kFSNodeIsDirectoryMask) )
 
1512
                        {
 
1513
                                /* it's a directory -- delete its contents before attempting to delete it */
 
1514
                                FSDeleteContainerLevel(&itemToDelete, theGlobals);
 
1515
                        }
 
1516
                        /* are we still OK to delete? */
 
1517
                        if ( noErr == theGlobals->result )
 
1518
                        {
 
1519
                                /* is item locked? */
 
1520
                                if ( 0 != (nodeFlags & kFSNodeLockedMask) )
 
1521
                                {
 
1522
                                        /* then attempt to unlock it (ignore result since FSDeleteObject will set it correctly) */
 
1523
                                        theGlobals->catalogInfo.nodeFlags = nodeFlags & ~kFSNodeLockedMask;
 
1524
                                        (void) FSSetCatalogInfo(&itemToDelete, kFSCatInfoNodeFlags, &theGlobals->catalogInfo);
 
1525
                                }
 
1526
                                /* delete the item */
 
1527
                                theGlobals->result = FSDeleteObject(&itemToDelete);
 
1528
                        }
 
1529
                }
 
1530
        } while ( noErr == theGlobals->result );
 
1531
        
 
1532
        /* we found the end of the items normally, so return noErr */
 
1533
        if ( errFSNoMoreItems == theGlobals->result )
 
1534
        {
 
1535
                theGlobals->result = noErr;
 
1536
        }
 
1537
        
 
1538
        /* close the FSIterator (closing an open iterator should never fail) */
 
1539
        verify_noerr(FSCloseIterator(iterator));
 
1540
 
 
1541
FSOpenIterator:
 
1542
 
 
1543
        return;
 
1544
}
 
1545
 
 
1546
/*****************************************************************************/
 
1547
 
 
1548
OSErr
 
1549
FSDeleteContainerContents(
 
1550
        const FSRef *container)
 
1551
{
 
1552
        FSDeleteContainerGlobals        theGlobals;
 
1553
        
 
1554
        /* delete container's contents */
 
1555
        FSDeleteContainerLevel(container, &theGlobals);
 
1556
        
 
1557
        return ( theGlobals.result );
 
1558
}
 
1559
 
 
1560
/*****************************************************************************/
 
1561
 
 
1562
OSErr
 
1563
FSDeleteContainer(
 
1564
        const FSRef *container)
 
1565
{
 
1566
        OSErr                   result;
 
1567
        FSCatalogInfo   catalogInfo;
 
1568
        
 
1569
        /* get nodeFlags for container */
 
1570
        result = FSGetCatalogInfo(container, kFSCatInfoNodeFlags, &catalogInfo, NULL, NULL,NULL);
 
1571
        require_noerr(result, FSGetCatalogInfo);
 
1572
        
 
1573
        /* make sure container is a directory */
 
1574
        require_action(0 != (catalogInfo.nodeFlags & kFSNodeIsDirectoryMask), ContainerNotDirectory, result = dirNFErr);
 
1575
        
 
1576
        /* delete container's contents */
 
1577
        result = FSDeleteContainerContents(container);
 
1578
        require_noerr(result, FSDeleteContainerContents);
 
1579
        
 
1580
        /* is container locked? */
 
1581
        if ( 0 != (catalogInfo.nodeFlags & kFSNodeLockedMask) )
 
1582
        {
 
1583
                /* then attempt to unlock container (ignore result since FSDeleteObject will set it correctly) */
 
1584
                catalogInfo.nodeFlags &= ~kFSNodeLockedMask;
 
1585
                (void) FSSetCatalogInfo(container, kFSCatInfoNodeFlags, &catalogInfo);
 
1586
        }
 
1587
        
 
1588
        /* delete the container */
 
1589
        result = FSDeleteObject(container);
 
1590
        
 
1591
FSDeleteContainerContents:
 
1592
ContainerNotDirectory:
 
1593
FSGetCatalogInfo:
 
1594
 
 
1595
        return ( result );
 
1596
}
 
1597
 
 
1598
/*****************************************************************************/
 
1599
 
 
1600
/*
 
1601
        The FSIterateContainerLevel function iterates the contents of a container
 
1602
        directory and calls a IterateContainerFilterProc function once for each
 
1603
        file and directory found.
 
1604
        
 
1605
        theGlobals                      --> A pointer to a FSIterateContainerGlobals struct
 
1606
                                                        which contains the variables needed globally by
 
1607
                                                        all recusion levels of FSIterateContainerLevel.
 
1608
                                                        That makes FSIterateContainer thread safe since
 
1609
                                                        each call to it uses its own global world.
 
1610
                                                        It also contains the variables that do not need
 
1611
                                                        to be allocated each time FSIterateContainerLevel
 
1612
                                                        recurses. That lets FSIterateContainerLevel use
 
1613
                                                        less stack space per recursion level.
 
1614
*/
 
1615
 
 
1616
static
 
1617
void
 
1618
FSIterateContainerLevel(
 
1619
        FSIterateContainerGlobals *theGlobals)
 
1620
{       
 
1621
        FSIterator      iterator;
 
1622
        
 
1623
        /* If maxLevels is zero, we aren't checking levels */
 
1624
        /* If currentLevel < maxLevels, look at this level */
 
1625
        if ( (theGlobals->maxLevels == 0) ||
 
1626
                 (theGlobals->currentLevel < theGlobals->maxLevels) )
 
1627
        {
 
1628
                /* Open FSIterator for flat access to theGlobals->ref */
 
1629
                theGlobals->result = FSOpenIterator(&theGlobals->ref, kFSIterateFlat, &iterator);
 
1630
                require_noerr(theGlobals->result, FSOpenIterator);
 
1631
                
 
1632
                ++theGlobals->currentLevel; /* Go to next level */
 
1633
                
 
1634
                /* Call FSGetCatalogInfoBulk in loop to get all items in the container */
 
1635
                do
 
1636
                {
 
1637
                        theGlobals->result = FSGetCatalogInfoBulk(iterator, 1, &theGlobals->actualObjects,
 
1638
                                &theGlobals->containerChanged, theGlobals->whichInfo, &theGlobals->catalogInfo,
 
1639
                                &theGlobals->ref, theGlobals->specPtr, theGlobals->namePtr);
 
1640
                        if ( (noErr == theGlobals->result || errFSNoMoreItems == theGlobals->result) &&
 
1641
                                (0 != theGlobals->actualObjects) )
 
1642
                        {
 
1643
                                /* Call the IterateFilterProc */
 
1644
                                theGlobals->quitFlag = CallIterateContainerFilterProc(theGlobals->iterateFilter,
 
1645
                                        theGlobals->containerChanged, theGlobals->currentLevel,
 
1646
                                        &theGlobals->catalogInfo, &theGlobals->ref,
 
1647
                                        theGlobals->specPtr, theGlobals->namePtr, theGlobals->yourDataPtr);
 
1648
                                /* Is it a directory? */
 
1649
                                if ( 0 != (theGlobals->catalogInfo.nodeFlags & kFSNodeIsDirectoryMask) )
 
1650
                                {
 
1651
                                        /* Keep going? */
 
1652
                                        if ( !theGlobals->quitFlag )
 
1653
                                        {
 
1654
                                                /* Dive again if the IterateFilterProc didn't say "quit" */
 
1655
                                                FSIterateContainerLevel(theGlobals);
 
1656
                                        }
 
1657
                                }
 
1658
                        }
 
1659
                        /* time to fall back a level? */
 
1660
                } while ( (noErr == theGlobals->result) && (!theGlobals->quitFlag) );
 
1661
                
 
1662
                /* errFSNoMoreItems is OK - it only means we hit the end of this level */
 
1663
                /* afpAccessDenied is OK, too - it only means we cannot see inside a directory */
 
1664
                if ( (errFSNoMoreItems == theGlobals->result) ||
 
1665
                         (afpAccessDenied == theGlobals->result) )
 
1666
                {
 
1667
                        theGlobals->result = noErr;
 
1668
                }
 
1669
                
 
1670
                --theGlobals->currentLevel; /* Return to previous level as we leave */
 
1671
                
 
1672
                /* Close the FSIterator (closing an open iterator should never fail) */
 
1673
                verify_noerr(FSCloseIterator(iterator));
 
1674
        }
 
1675
        
 
1676
FSOpenIterator:
 
1677
 
 
1678
        return;
 
1679
}
 
1680
 
 
1681
/*****************************************************************************/
 
1682
 
 
1683
OSErr
 
1684
FSIterateContainer(
 
1685
        const FSRef *container,
 
1686
        ItemCount maxLevels,
 
1687
        FSCatalogInfoBitmap whichInfo,
 
1688
        Boolean wantFSSpec,
 
1689
        Boolean wantName,
 
1690
        IterateContainerFilterProcPtr iterateFilter,
 
1691
        void *yourDataPtr)
 
1692
{
 
1693
        OSErr                                           result;
 
1694
        FSIterateContainerGlobals       theGlobals;
 
1695
        
 
1696
        /* make sure there is an iterateFilter */
 
1697
        require_action(iterateFilter != NULL, NoIterateFilter, result = paramErr);
 
1698
        
 
1699
        /*
 
1700
         * set up the globals we need to access from the recursive routine
 
1701
         */
 
1702
        theGlobals.iterateFilter = iterateFilter;
 
1703
        /* we need the node flags no matter what was requested so we can detect files vs. directories */
 
1704
        theGlobals.whichInfo = whichInfo | kFSCatInfoNodeFlags;
 
1705
        /* start with input container -- the first OpenIterator will ensure it is a directory */
 
1706
        theGlobals.ref = *container;
 
1707
        if ( wantFSSpec )
 
1708
        {
 
1709
                theGlobals.specPtr = &theGlobals.spec;
 
1710
        }
 
1711
        else
 
1712
        {
 
1713
                theGlobals.specPtr = NULL;
 
1714
        }
 
1715
        if ( wantName )
 
1716
        {
 
1717
                theGlobals.namePtr = &theGlobals.name;
 
1718
        }
 
1719
        else
 
1720
        {
 
1721
                theGlobals.namePtr = NULL;
 
1722
        }
 
1723
        theGlobals.yourDataPtr = yourDataPtr;
 
1724
        theGlobals.maxLevels = maxLevels;
 
1725
        theGlobals.currentLevel = 0;
 
1726
        theGlobals.quitFlag = false;
 
1727
        theGlobals.containerChanged = false;
 
1728
        theGlobals.result = noErr;
 
1729
        theGlobals.actualObjects = 0;
 
1730
        
 
1731
        /* here we go into recursion land... */
 
1732
        FSIterateContainerLevel(&theGlobals);
 
1733
        result = theGlobals.result;
 
1734
        require_noerr(result, FSIterateContainerLevel);
 
1735
        
 
1736
FSIterateContainerLevel:
 
1737
NoIterateFilter:
 
1738
 
 
1739
        return ( result );
 
1740
}
 
1741
 
 
1742
/*****************************************************************************/
 
1743
 
 
1744
OSErr
 
1745
FSGetDirectoryItems(
 
1746
        const FSRef *container,
 
1747
        FSRef ***refsHandle,    /* pointer to handle of FSRefs */
 
1748
        ItemCount *numRefs,
 
1749
        Boolean *containerChanged)
 
1750
{
 
1751
        /* Grab items 10 at a time. */
 
1752
        enum { kMaxItemsPerBulkCall = 10 };
 
1753
        
 
1754
        OSErr           result;
 
1755
        OSErr           memResult;
 
1756
        FSIterator      iterator;
 
1757
        FSRef           refs[kMaxItemsPerBulkCall];
 
1758
        ItemCount       actualObjects;
 
1759
        Boolean         changed;
 
1760
        
 
1761
        /* check parameters */
 
1762
        require_action((NULL != refsHandle) && (NULL != numRefs) && (NULL != containerChanged),
 
1763
                BadParameter, result = paramErr);
 
1764
        
 
1765
        *numRefs = 0;
 
1766
        *containerChanged = false;
 
1767
        *refsHandle = (FSRef **)NewHandle(0);
 
1768
        require_action(NULL != *refsHandle, NewHandle, result = memFullErr);
 
1769
        
 
1770
        /* open an FSIterator */
 
1771
        result = FSOpenIterator(container, kFSIterateFlat, &iterator);
 
1772
        require_noerr(result, FSOpenIterator);
 
1773
        
 
1774
        /* Call FSGetCatalogInfoBulk in loop to get all items in the container */
 
1775
        do
 
1776
        {
 
1777
                result = FSGetCatalogInfoBulk(iterator, kMaxItemsPerBulkCall, &actualObjects,
 
1778
                                        &changed, kFSCatInfoNone,  NULL,  refs, NULL, NULL);
 
1779
                
 
1780
                /* if the container changed, set containerChanged for output, but keep going */
 
1781
                if ( changed )
 
1782
                {
 
1783
                        *containerChanged = changed;
 
1784
                }
 
1785
                
 
1786
                /* any result other than noErr and errFSNoMoreItems is serious */
 
1787
                require((noErr == result) || (errFSNoMoreItems == result), FSGetCatalogInfoBulk);
 
1788
                
 
1789
                /* add objects to output array and count */
 
1790
                if ( 0 != actualObjects )
 
1791
                {
 
1792
                        /* concatenate the FSRefs to the end of the      handle */
 
1793
                        PtrAndHand(refs, (Handle)*refsHandle, actualObjects * sizeof(FSRef));
 
1794
                        memResult = MemError();
 
1795
                        require_noerr_action(memResult, MemoryAllocationFailed, result = memResult);
 
1796
                        
 
1797
                        *numRefs += actualObjects;
 
1798
                }
 
1799
        } while ( noErr == result );
 
1800
        
 
1801
        verify_noerr(FSCloseIterator(iterator)); /* closing an open iterator should never fail, but... */
 
1802
        
 
1803
        return ( noErr );
 
1804
        
 
1805
        /**********************/
 
1806
        
 
1807
MemoryAllocationFailed:
 
1808
FSGetCatalogInfoBulk:
 
1809
 
 
1810
        /* close the iterator */
 
1811
        verify_noerr(FSCloseIterator(iterator));
 
1812
 
 
1813
FSOpenIterator:
 
1814
        /* dispose of handle if already allocated and clear the outputs */
 
1815
        if ( NULL != *refsHandle )
 
1816
        {
 
1817
                DisposeHandle((Handle)*refsHandle);
 
1818
                *refsHandle = NULL;
 
1819
        }
 
1820
        *numRefs = 0;
 
1821
        
 
1822
NewHandle:
 
1823
BadParameter:
 
1824
 
 
1825
        return ( result );
 
1826
}
 
1827
 
 
1828
/*****************************************************************************/
 
1829
 
 
1830
/*
 
1831
        The GenerateUniqueName function generates a HFSUniStr255 name that is
 
1832
        unique in both dir1 and dir2.
 
1833
        
 
1834
        startSeed                       -->     A pointer to a long which is used to generate the
 
1835
                                                        unique name.
 
1836
                                                <--     It is modified on output to a value which should
 
1837
                                                        be used to generate the next unique name.
 
1838
        dir1                            -->     The first directory.
 
1839
        dir2                            -->     The second directory.
 
1840
        uniqueName                      <--     A pointer to a HFSUniStr255 where the unique name
 
1841
                                                        is to be returned.
 
1842
*/
 
1843
 
 
1844
static
 
1845
OSErr
 
1846
GenerateUniqueHFSUniStr(
 
1847
        long *startSeed,
 
1848
        const FSRef *dir1,
 
1849
        const FSRef *dir2,
 
1850
        HFSUniStr255 *uniqueName)
 
1851
{
 
1852
        OSErr                   result;
 
1853
        long                    i;
 
1854
        FSRefParam              pb;
 
1855
        FSRef                   newRef;
 
1856
        unsigned char   hexStr[17] = "0123456789ABCDEF";
 
1857
        
 
1858
        /* set up the parameter block */
 
1859
        pb.name = uniqueName->unicode;
 
1860
        pb.nameLength = 8;      /* always 8 characters */
 
1861
        pb.textEncodingHint = kTextEncodingUnknown;
 
1862
        pb.newRef = &newRef;
 
1863
 
 
1864
        /* loop until we get fnfErr with a filename in both directories */
 
1865
        result = noErr;
 
1866
        while ( fnfErr != result )
 
1867
        {
 
1868
                /* convert startSeed to 8 character Unicode string */
 
1869
                uniqueName->length = 8;
 
1870
                for ( i = 0; i < 8; ++i )
 
1871
                {
 
1872
                        uniqueName->unicode[i] = hexStr[((*startSeed >> ((7-i)*4)) & 0xf)];
 
1873
                }
 
1874
                
 
1875
                /* try in dir1 */
 
1876
                pb.ref = dir1;
 
1877
                result = PBMakeFSRefUnicodeSync(&pb);
 
1878
                if ( fnfErr == result )
 
1879
                {
 
1880
                        /* try in dir2 */
 
1881
                        pb.ref = dir2;
 
1882
                        result = PBMakeFSRefUnicodeSync(&pb);
 
1883
                        if ( fnfErr != result )
 
1884
                        {
 
1885
                                /* exit if anything other than noErr or fnfErr */
 
1886
                                require_noerr(result, Dir2PBMakeFSRefUnicodeSyncFailed);
 
1887
                        }
 
1888
                }
 
1889
                else
 
1890
                {
 
1891
                        /* exit if anything other than noErr or fnfErr */
 
1892
                        require_noerr(result, Dir1PBMakeFSRefUnicodeSyncFailed);
 
1893
                }
 
1894
                
 
1895
                /* increment seed for next pass through loop, */
 
1896
                /* or for next call to GenerateUniqueHFSUniStr */
 
1897
                ++(*startSeed);
 
1898
        }
 
1899
        
 
1900
        /* we have a unique file name which doesn't exist in dir1 or dir2 */
 
1901
        result = noErr;
 
1902
        
 
1903
Dir2PBMakeFSRefUnicodeSyncFailed:
 
1904
Dir1PBMakeFSRefUnicodeSyncFailed:
 
1905
 
 
1906
        return ( result );
 
1907
}
 
1908
 
 
1909
/*****************************************************************************/
 
1910
 
 
1911
OSErr
 
1912
FSExchangeObjectsCompat(
 
1913
        const FSRef *sourceRef,
 
1914
        const FSRef *destRef,
 
1915
        FSRef *newSourceRef,
 
1916
        FSRef *newDestRef)
 
1917
{
 
1918
        enum
 
1919
        {
 
1920
                /* get all settable info except for mod dates, plus the volume refNum and parent directory ID */
 
1921
                kGetCatInformationMask = (kFSCatInfoSettableInfo |
 
1922
                                                                  kFSCatInfoVolume |
 
1923
                                                                  kFSCatInfoParentDirID) &
 
1924
                                                                 ~(kFSCatInfoContentMod | kFSCatInfoAttrMod),
 
1925
                /* set everything possible except for mod dates */
 
1926
                kSetCatinformationMask = kFSCatInfoSettableInfo &
 
1927
                                                                 ~(kFSCatInfoContentMod | kFSCatInfoAttrMod)
 
1928
        };
 
1929
        
 
1930
        OSErr                                   result;
 
1931
        GetVolParmsInfoBuffer   volParmsInfo;
 
1932
        UInt32                                  infoSize;
 
1933
        FSCatalogInfo                   sourceCatalogInfo;      /* source file's catalog information */
 
1934
        FSCatalogInfo                   destCatalogInfo;        /* destination file's catalog information */
 
1935
        HFSUniStr255                    sourceName;                     /* source file's Unicode name */
 
1936
        HFSUniStr255                    destName;                       /* destination file's Unicode name */
 
1937
        FSRef                                   sourceCurrentRef;       /* FSRef to current location of source file throughout this function */
 
1938
        FSRef                                   destCurrentRef;         /* FSRef to current location of destination file throughout this function */
 
1939
        FSRef                                   sourceParentRef;        /* FSRef to parent directory of source file */
 
1940
        FSRef                                   destParentRef;          /* FSRef to parent directory of destination file */
 
1941
        HFSUniStr255                    sourceUniqueName;       /* unique name given to source file while exchanging it with destination */
 
1942
        HFSUniStr255                    destUniqueName;         /* unique name given to destination file while exchanging it with source */
 
1943
        long                                    theSeed;                        /* the seed for generating unique names */
 
1944
        Boolean                                 sameParentDirs;         /* true if source and destinatin parent directory is the same */
 
1945
        
 
1946
        /* check parameters */
 
1947
        require_action((NULL != newSourceRef) && (NULL != newDestRef), BadParameter, result = paramErr);
 
1948
        
 
1949
        /* output refs and current refs = input refs to start with */
 
1950
        BlockMoveData(sourceRef, newSourceRef, sizeof(FSRef));
 
1951
        BlockMoveData(sourceRef, &sourceCurrentRef, sizeof(FSRef));
 
1952
        
 
1953
        BlockMoveData(destRef, newDestRef, sizeof(FSRef));
 
1954
        BlockMoveData(destRef, &destCurrentRef, sizeof(FSRef));
 
1955
 
 
1956
        /* get source volume's vRefNum */
 
1957
        result = FSGetCatalogInfo(&sourceCurrentRef, kFSCatInfoVolume, &sourceCatalogInfo, NULL, NULL, NULL);
 
1958
        require_noerr(result, DetermineSourceVRefNumFailed);
 
1959
        
 
1960
        /* see if that volume supports FSExchangeObjects */
 
1961
        result = FSGetVolParms(sourceCatalogInfo.volume, sizeof(GetVolParmsInfoBuffer),
 
1962
                &volParmsInfo, &infoSize);
 
1963
        if ( (noErr == result) && VolSupportsFSExchangeObjects(&volParmsInfo) )
 
1964
        {
 
1965
                /* yes - use FSExchangeObjects */
 
1966
                result = FSExchangeObjects(sourceRef, destRef);
 
1967
        }
 
1968
        else
 
1969
        {
 
1970
                /* no - emulate FSExchangeObjects */
 
1971
                
 
1972
                /* Note: The compatibility case won't work for files with *Btree control blocks. */
 
1973
                /* Right now the only *Btree files are created by the system. */
 
1974
                
 
1975
                /* get all catalog information and Unicode names for each file */
 
1976
                result = FSGetCatalogInfo(&sourceCurrentRef, kGetCatInformationMask, &sourceCatalogInfo, &sourceName, NULL, &sourceParentRef);
 
1977
                require_noerr(result, SourceFSGetCatalogInfoFailed);
 
1978
                
 
1979
                result = FSGetCatalogInfo(&destCurrentRef, kGetCatInformationMask, &destCatalogInfo, &destName, NULL, &destParentRef);
 
1980
                require_noerr(result, DestFSGetCatalogInfoFailed);
 
1981
                
 
1982
                /* make sure source and destination are on same volume */
 
1983
                require_action(sourceCatalogInfo.volume == destCatalogInfo.volume, NotSameVolume, result = diffVolErr);
 
1984
                
 
1985
                /* make sure both files are *really* files */
 
1986
                require_action((0 == (sourceCatalogInfo.nodeFlags & kFSNodeIsDirectoryMask)) &&
 
1987
                                           (0 == (destCatalogInfo.nodeFlags & kFSNodeIsDirectoryMask)), NotAFile, result = notAFileErr);
 
1988
                
 
1989
                /* generate 2 names that are unique in both directories */
 
1990
                theSeed = 0x4a696d4c;   /* a fine unlikely filename */
 
1991
                
 
1992
                result = GenerateUniqueHFSUniStr(&theSeed, &sourceParentRef, &destParentRef, &sourceUniqueName);
 
1993
                require_noerr(result, GenerateUniqueHFSUniStr1Failed);
 
1994
                
 
1995
                result = GenerateUniqueHFSUniStr(&theSeed, &sourceParentRef, &destParentRef, &destUniqueName);
 
1996
                require_noerr(result, GenerateUniqueHFSUniStr2Failed);
 
1997
 
 
1998
                /* rename sourceCurrentRef to sourceUniqueName */
 
1999
                result = FSRenameUnicode(&sourceCurrentRef, sourceUniqueName.length, sourceUniqueName.unicode, kTextEncodingUnknown, newSourceRef);
 
2000
                require_noerr(result, FSRenameUnicode1Failed);
 
2001
                BlockMoveData(newSourceRef, &sourceCurrentRef, sizeof(FSRef));
 
2002
                
 
2003
                /* rename destCurrentRef to destUniqueName */
 
2004
                result = FSRenameUnicode(&destCurrentRef, destUniqueName.length, destUniqueName.unicode, kTextEncodingUnknown, newDestRef);
 
2005
                require_noerr(result, FSRenameUnicode2Failed);
 
2006
                BlockMoveData(newDestRef, &destCurrentRef, sizeof(FSRef));
 
2007
                
 
2008
                /* are the source and destination parent directories the same? */
 
2009
                sameParentDirs = ( sourceCatalogInfo.parentDirID == destCatalogInfo.parentDirID );
 
2010
                if ( !sameParentDirs )
 
2011
                {
 
2012
                        /* move source file to dest parent directory */
 
2013
                        result = FSMoveObject(&sourceCurrentRef, &destParentRef, newSourceRef);
 
2014
                        require_noerr(result, FSMoveObject1Failed);
 
2015
                        BlockMoveData(newSourceRef, &sourceCurrentRef, sizeof(FSRef));
 
2016
                        
 
2017
                        /* move dest file to source parent directory */
 
2018
                        result = FSMoveObject(&destCurrentRef, &sourceParentRef, newDestRef);
 
2019
                        require_noerr(result, FSMoveObject2Failed);
 
2020
                        BlockMoveData(newDestRef, &destCurrentRef, sizeof(FSRef));
 
2021
                }
 
2022
                
 
2023
                /* At this point, the files are in their new locations (if they were moved). */
 
2024
                /* The source file is named sourceUniqueName and is in the directory referred to */
 
2025
                /* by destParentRef. The destination file is named destUniqueName and is in the */
 
2026
                /* directory referred to by sourceParentRef. */
 
2027
                                
 
2028
                /* give source file the dest file's catalog information except for mod dates */
 
2029
                result = FSSetCatalogInfo(&sourceCurrentRef, kSetCatinformationMask, &destCatalogInfo);
 
2030
                require_noerr(result, FSSetCatalogInfo1Failed);
 
2031
                
 
2032
                /* give dest file the source file's catalog information except for mod dates */
 
2033
                result = FSSetCatalogInfo(&destCurrentRef, kSetCatinformationMask, &sourceCatalogInfo);
 
2034
                require_noerr(result, FSSetCatalogInfo2Failed);
 
2035
                
 
2036
                /* rename source file with dest file's name */
 
2037
                result = FSRenameUnicode(&sourceCurrentRef, destName.length, destName.unicode, destCatalogInfo.textEncodingHint, newSourceRef);
 
2038
                require_noerr(result, FSRenameUnicode3Failed);
 
2039
                BlockMoveData(newSourceRef, &sourceCurrentRef, sizeof(FSRef));
 
2040
                
 
2041
                /* rename dest file with source file's name */
 
2042
                result = FSRenameUnicode(&destCurrentRef, sourceName.length, sourceName.unicode, sourceCatalogInfo.textEncodingHint, newDestRef);
 
2043
                require_noerr(result, FSRenameUnicode4Failed);
 
2044
                
 
2045
                /* we're done with no errors, so swap newSourceRef and newDestRef */
 
2046
                BlockMoveData(newDestRef, newSourceRef, sizeof(FSRef));
 
2047
                BlockMoveData(&sourceCurrentRef, newDestRef, sizeof(FSRef));
 
2048
        }
 
2049
        
 
2050
        return ( result );
 
2051
        
 
2052
        /**********************/
 
2053
 
 
2054
/* If there are any failures while emulating FSExchangeObjects, attempt to reverse any steps */
 
2055
/* already taken. In any case, newSourceRef and newDestRef will refer to the files in whatever */
 
2056
/* state and location they ended up in so that both files can be found by the calling code. */
 
2057
        
 
2058
FSRenameUnicode4Failed:
 
2059
 
 
2060
        /* attempt to rename source file to sourceUniqueName */
 
2061
        if ( noErr == FSRenameUnicode(&sourceCurrentRef, sourceUniqueName.length, sourceUniqueName.unicode, kTextEncodingUnknown, newSourceRef) )
 
2062
        {
 
2063
                BlockMoveData(newSourceRef, &sourceCurrentRef, sizeof(FSRef));
 
2064
        }
 
2065
 
 
2066
FSRenameUnicode3Failed:
 
2067
 
 
2068
        /* attempt to restore dest file's catalog information */
 
2069
        verify_noerr(FSSetCatalogInfo(&destCurrentRef, kFSCatInfoSettableInfo, &destCatalogInfo));
 
2070
 
 
2071
FSSetCatalogInfo2Failed:
 
2072
 
 
2073
        /* attempt to restore source file's catalog information */
 
2074
        verify_noerr(FSSetCatalogInfo(&sourceCurrentRef, kFSCatInfoSettableInfo, &sourceCatalogInfo));
 
2075
 
 
2076
FSSetCatalogInfo1Failed:
 
2077
 
 
2078
        if ( !sameParentDirs )
 
2079
        {
 
2080
                /* attempt to move dest file back to dest directory */
 
2081
                if ( noErr == FSMoveObject(&destCurrentRef, &destParentRef, newDestRef) )
 
2082
                {
 
2083
                        BlockMoveData(newDestRef, &destCurrentRef, sizeof(FSRef));
 
2084
                }
 
2085
        }
 
2086
 
 
2087
FSMoveObject2Failed:
 
2088
 
 
2089
        if ( !sameParentDirs )
 
2090
        {
 
2091
                /* attempt to move source file back to source directory */
 
2092
                if ( noErr == FSMoveObject(&sourceCurrentRef, &sourceParentRef, newSourceRef) )
 
2093
                {
 
2094
                        BlockMoveData(newSourceRef, &sourceCurrentRef, sizeof(FSRef));
 
2095
                }
 
2096
        }
 
2097
 
 
2098
FSMoveObject1Failed:
 
2099
 
 
2100
        /* attempt to rename dest file to original name */
 
2101
        verify_noerr(FSRenameUnicode(&destCurrentRef, destName.length, destName.unicode, destCatalogInfo.textEncodingHint, newDestRef));
 
2102
 
 
2103
FSRenameUnicode2Failed:
 
2104
 
 
2105
        /* attempt to rename source file to original name */
 
2106
        verify_noerr(FSRenameUnicode(&sourceCurrentRef, sourceName.length, sourceName.unicode, sourceCatalogInfo.textEncodingHint, newSourceRef));
 
2107
 
 
2108
FSRenameUnicode1Failed:
 
2109
GenerateUniqueHFSUniStr2Failed:
 
2110
GenerateUniqueHFSUniStr1Failed:
 
2111
NotAFile:
 
2112
NotSameVolume:
 
2113
DestFSGetCatalogInfoFailed:
 
2114
SourceFSGetCatalogInfoFailed:
 
2115
DetermineSourceVRefNumFailed:   
 
2116
BadParameter:
 
2117
 
 
2118
        return ( result );
 
2119
}
 
2120
 
 
2121
/*****************************************************************************/
 
2122
 
 
2123
#pragma mark ----- Shared Environment Routines -----
 
2124
 
 
2125
/*****************************************************************************/
 
2126
 
 
2127
OSErr
 
2128
FSLockRange(
 
2129
        SInt16 refNum,
 
2130
        SInt32 rangeLength,
 
2131
        SInt32 rangeStart)
 
2132
{
 
2133
        OSErr                   result;
 
2134
        ParamBlockRec   pb;
 
2135
 
 
2136
        pb.ioParam.ioRefNum = refNum;
 
2137
        pb.ioParam.ioReqCount = rangeLength;
 
2138
        pb.ioParam.ioPosMode = fsFromStart;
 
2139
        pb.ioParam.ioPosOffset = rangeStart;
 
2140
        result = PBLockRangeSync(&pb);
 
2141
        require_noerr(result, PBLockRangeSync);
 
2142
        
 
2143
PBLockRangeSync:
 
2144
 
 
2145
        return ( result );
 
2146
}
 
2147
 
 
2148
/*****************************************************************************/
 
2149
 
 
2150
OSErr
 
2151
FSUnlockRange(
 
2152
        SInt16 refNum,
 
2153
        SInt32 rangeLength,
 
2154
        SInt32 rangeStart)
 
2155
{
 
2156
        OSErr                   result;
 
2157
        ParamBlockRec   pb;
 
2158
 
 
2159
        pb.ioParam.ioRefNum = refNum;
 
2160
        pb.ioParam.ioReqCount = rangeLength;
 
2161
        pb.ioParam.ioPosMode = fsFromStart;
 
2162
        pb.ioParam.ioPosOffset = rangeStart;
 
2163
        result = PBUnlockRangeSync(&pb);
 
2164
        require_noerr(result, PBUnlockRangeSync);
 
2165
        
 
2166
PBUnlockRangeSync:
 
2167
 
 
2168
        return ( result );
 
2169
}
 
2170
 
 
2171
/*****************************************************************************/
 
2172
 
 
2173
OSErr
 
2174
FSGetDirAccess(
 
2175
        const FSRef *ref,
 
2176
        SInt32 *ownerID,                /* can be NULL */
 
2177
        SInt32 *groupID,                /* can be NULL */
 
2178
        SInt32 *accessRights)   /* can be NULL */
 
2179
{
 
2180
        OSErr                   result;
 
2181
        FSSpec                  spec;
 
2182
        HParamBlockRec  pb;
 
2183
        
 
2184
        /* get FSSpec from FSRef */
 
2185
        result = FSGetCatalogInfo(ref, kFSCatInfoNone, NULL, NULL, &spec, NULL);
 
2186
        require_noerr(result, FSGetCatalogInfo);
 
2187
        
 
2188
        /* get directory access info for FSSpec */
 
2189
        pb.accessParam.ioNamePtr = (StringPtr)spec.name;
 
2190
        pb.accessParam.ioVRefNum = spec.vRefNum;
 
2191
        pb.fileParam.ioDirID = spec.parID;
 
2192
        result = PBHGetDirAccessSync(&pb);
 
2193
        require_noerr(result, PBHGetDirAccessSync);
 
2194
        
 
2195
        /* return the IDs and access rights */
 
2196
        if ( NULL != ownerID )
 
2197
        {
 
2198
                *ownerID = pb.accessParam.ioACOwnerID;
 
2199
        }
 
2200
        if ( NULL != groupID )
 
2201
        {
 
2202
                *groupID = pb.accessParam.ioACGroupID;
 
2203
        }
 
2204
        if ( NULL != accessRights )
 
2205
        {
 
2206
                *accessRights = pb.accessParam.ioACAccess;
 
2207
        }
 
2208
        
 
2209
PBHGetDirAccessSync:
 
2210
FSGetCatalogInfo:
 
2211
 
 
2212
        return ( result );
 
2213
}
 
2214
 
 
2215
/*****************************************************************************/
 
2216
 
 
2217
OSErr
 
2218
FSSetDirAccess(
 
2219
        const FSRef *ref,
 
2220
        SInt32 ownerID,
 
2221
        SInt32 groupID,
 
2222
        SInt32 accessRights)
 
2223
{
 
2224
        OSErr                   result;
 
2225
        FSSpec                  spec;
 
2226
        HParamBlockRec  pb;
 
2227
 
 
2228
        enum
 
2229
        {
 
2230
                /* Just the bits that can be set */
 
2231
                kSetDirAccessSettableMask = (kioACAccessBlankAccessMask +
 
2232
                        kioACAccessEveryoneWriteMask + kioACAccessEveryoneReadMask + kioACAccessEveryoneSearchMask +
 
2233
                        kioACAccessGroupWriteMask + kioACAccessGroupReadMask + kioACAccessGroupSearchMask +
 
2234
                        kioACAccessOwnerWriteMask + kioACAccessOwnerReadMask + kioACAccessOwnerSearchMask)
 
2235
        };
 
2236
        
 
2237
        /* get FSSpec from FSRef */
 
2238
        result = FSGetCatalogInfo(ref, kFSCatInfoNone, NULL, NULL, &spec, NULL);
 
2239
        require_noerr(result, FSGetCatalogInfo);
 
2240
        
 
2241
        /* set directory access info for FSSpec */
 
2242
        pb.accessParam.ioNamePtr = (StringPtr)spec.name;
 
2243
        pb.accessParam.ioVRefNum = spec.vRefNum;
 
2244
        pb.fileParam.ioDirID = spec.parID;
 
2245
        pb.accessParam.ioACOwnerID = ownerID;
 
2246
        pb.accessParam.ioACGroupID = groupID;
 
2247
        pb.accessParam.ioACAccess = accessRights & kSetDirAccessSettableMask;
 
2248
        result = PBHSetDirAccessSync(&pb);
 
2249
        require_noerr(result, PBHSetDirAccessSync);
 
2250
        
 
2251
PBHSetDirAccessSync:
 
2252
FSGetCatalogInfo:
 
2253
 
 
2254
        return ( result );
 
2255
}
 
2256
 
 
2257
/*****************************************************************************/
 
2258
 
 
2259
OSErr
 
2260
FSGetVolMountInfoSize(
 
2261
        FSVolumeRefNum volRefNum,
 
2262
        SInt16 *size)
 
2263
{
 
2264
        OSErr                   result;
 
2265
        ParamBlockRec   pb;
 
2266
 
 
2267
        /* check parameters */
 
2268
        require_action(NULL != size, BadParameter, result = paramErr);
 
2269
        
 
2270
        pb.ioParam.ioNamePtr = NULL;
 
2271
        pb.ioParam.ioVRefNum = volRefNum;
 
2272
        pb.ioParam.ioBuffer = (Ptr)size;
 
2273
        result = PBGetVolMountInfoSize(&pb);
 
2274
        require_noerr(result, PBGetVolMountInfoSize);
 
2275
        
 
2276
PBGetVolMountInfoSize:
 
2277
BadParameter:
 
2278
 
 
2279
        return ( result );
 
2280
}
 
2281
 
 
2282
/*****************************************************************************/
 
2283
 
 
2284
OSErr
 
2285
FSGetVolMountInfo(
 
2286
        FSVolumeRefNum volRefNum,
 
2287
        void *volMountInfo)
 
2288
{
 
2289
        OSErr                   result;
 
2290
        ParamBlockRec   pb;
 
2291
 
 
2292
        /* check parameters */
 
2293
        require_action(NULL != volMountInfo, BadParameter, result = paramErr);
 
2294
        
 
2295
        pb.ioParam.ioNamePtr = NULL;
 
2296
        pb.ioParam.ioVRefNum = volRefNum;
 
2297
        pb.ioParam.ioBuffer = (Ptr)volMountInfo;
 
2298
        result = PBGetVolMountInfo(&pb);
 
2299
        require_noerr(result, PBGetVolMountInfo);
 
2300
        
 
2301
PBGetVolMountInfo:
 
2302
BadParameter:
 
2303
 
 
2304
        return ( result );
 
2305
}
 
2306
 
 
2307
/*****************************************************************************/
 
2308
 
 
2309
OSErr
 
2310
FSVolumeMount(
 
2311
        const void *volMountInfo,
 
2312
        FSVolumeRefNum *volRefNum)
 
2313
{
 
2314
        OSErr                   result;
 
2315
        ParamBlockRec   pb;
 
2316
 
 
2317
        /* check parameters */
 
2318
        require_action(NULL != volRefNum, BadParameter, result = paramErr);
 
2319
        
 
2320
        pb.ioParam.ioBuffer = (Ptr)volMountInfo;
 
2321
        result = PBVolumeMount(&pb);
 
2322
        require_noerr(result, PBVolumeMount);
 
2323
        
 
2324
        /* return the volume reference number */
 
2325
        *volRefNum = pb.ioParam.ioVRefNum;
 
2326
 
 
2327
PBVolumeMount:
 
2328
BadParameter:
 
2329
 
 
2330
        return ( result );
 
2331
}
 
2332
 
 
2333
/*****************************************************************************/
 
2334
 
 
2335
OSErr
 
2336
FSMapID(
 
2337
        FSVolumeRefNum volRefNum,
 
2338
        SInt32 ugID,
 
2339
        SInt16 objType,
 
2340
        Str31 name)
 
2341
{
 
2342
        OSErr                   result;
 
2343
        HParamBlockRec  pb;
 
2344
 
 
2345
        /* check parameters */
 
2346
        require_action(NULL != name, BadParameter, result = paramErr);
 
2347
        
 
2348
        pb.objParam.ioNamePtr = NULL;
 
2349
        pb.objParam.ioVRefNum = volRefNum;
 
2350
        pb.objParam.ioObjType = objType;
 
2351
        pb.objParam.ioObjNamePtr = name;
 
2352
        pb.objParam.ioObjID = ugID;
 
2353
        result = PBHMapIDSync(&pb);
 
2354
        require_noerr(result, PBHMapIDSync);
 
2355
        
 
2356
PBHMapIDSync:
 
2357
BadParameter:
 
2358
 
 
2359
        return ( result );
 
2360
}
 
2361
 
 
2362
/*****************************************************************************/
 
2363
 
 
2364
OSErr
 
2365
FSMapName(
 
2366
        FSVolumeRefNum volRefNum,
 
2367
        ConstStr255Param name,
 
2368
        SInt16 objType,
 
2369
        SInt32 *ugID)
 
2370
{
 
2371
        OSErr                   result;
 
2372
        HParamBlockRec  pb;
 
2373
 
 
2374
        /* check parameters */
 
2375
        require_action(NULL != ugID, BadParameter, result = paramErr);
 
2376
        
 
2377
        pb.objParam.ioNamePtr = NULL;
 
2378
        pb.objParam.ioVRefNum = volRefNum;
 
2379
        pb.objParam.ioObjType = objType;
 
2380
        pb.objParam.ioObjNamePtr = (StringPtr)name;
 
2381
        result = PBHMapNameSync(&pb);
 
2382
        require_noerr(result, PBHMapNameSync);
 
2383
        
 
2384
        /* return the user or group ID */
 
2385
        *ugID = pb.objParam.ioObjID;
 
2386
        
 
2387
PBHMapNameSync:
 
2388
BadParameter:
 
2389
 
 
2390
        return ( result );
 
2391
}
 
2392
 
 
2393
/*****************************************************************************/
 
2394
 
 
2395
OSErr
 
2396
FSCopyFile(
 
2397
        const FSRef *srcFileRef,
 
2398
        const FSRef *dstDirectoryRef,
 
2399
        UniCharCount nameLength,
 
2400
        const UniChar *copyName,        /* can be NULL (no rename during copy) */
 
2401
        TextEncoding textEncodingHint,
 
2402
        FSRef *newRef)                          /* can be NULL */
 
2403
{
 
2404
        OSErr                                   result;
 
2405
        FSSpec                                  srcFileSpec;
 
2406
        FSCatalogInfo                   catalogInfo;
 
2407
        HParamBlockRec                  pb;
 
2408
        Str31                                   hfsName;
 
2409
        GetVolParmsInfoBuffer   volParmsInfo;
 
2410
        UInt32                                  infoSize;
 
2411
        
 
2412
        /* get source FSSpec from source FSRef */
 
2413
        result = FSGetCatalogInfo(srcFileRef, kFSCatInfoNone, NULL, NULL, &srcFileSpec, NULL);
 
2414
        require_noerr(result, FSGetCatalogInfo_srcFileRef);
 
2415
        
 
2416
        /* Make sure the volume supports CopyFile */
 
2417
        result = FSGetVolParms(srcFileSpec.vRefNum, sizeof(GetVolParmsInfoBuffer),
 
2418
                &volParmsInfo, &infoSize);
 
2419
        require_action((noErr == result) && VolHasCopyFile(&volParmsInfo),
 
2420
                NoCopyFileSupport, result = paramErr);
 
2421
 
 
2422
        /* get destination volume reference number and destination directory ID from destination FSRef */
 
2423
        result = FSGetCatalogInfo(dstDirectoryRef, kFSCatInfoVolume + kFSCatInfoNodeID,
 
2424
                &catalogInfo, NULL, NULL, NULL);
 
2425
        require_noerr(result, FSGetCatalogInfo_dstDirectoryRef);
 
2426
        
 
2427
        /* tell the server to copy the object */
 
2428
        pb.copyParam.ioVRefNum = srcFileSpec.vRefNum;
 
2429
        pb.copyParam.ioDirID = srcFileSpec.parID;
 
2430
        pb.copyParam.ioNamePtr = (StringPtr)srcFileSpec.name;
 
2431
        pb.copyParam.ioDstVRefNum = catalogInfo.volume;
 
2432
        pb.copyParam.ioNewDirID = (long)catalogInfo.nodeID;
 
2433
        pb.copyParam.ioNewName = NULL;
 
2434
        if ( NULL != copyName )
 
2435
        {
 
2436
                result = UnicodeNameGetHFSName(nameLength, copyName, textEncodingHint, false, hfsName);
 
2437
                require_noerr(result, UnicodeNameGetHFSName);
 
2438
                
 
2439
                pb.copyParam.ioCopyName = hfsName;
 
2440
        }
 
2441
        else
 
2442
        {
 
2443
                pb.copyParam.ioCopyName = NULL;
 
2444
        }
 
2445
        result = PBHCopyFileSync(&pb);
 
2446
        require_noerr(result, PBHCopyFileSync);
 
2447
        
 
2448
        if ( NULL != newRef )
 
2449
        {
 
2450
                verify_noerr(FSMakeFSRef(pb.copyParam.ioDstVRefNum, pb.copyParam.ioNewDirID,
 
2451
                        pb.copyParam.ioCopyName, newRef));
 
2452
        }
 
2453
                
 
2454
PBHCopyFileSync:
 
2455
UnicodeNameGetHFSName:
 
2456
FSGetCatalogInfo_dstDirectoryRef:
 
2457
NoCopyFileSupport:
 
2458
FSGetCatalogInfo_srcFileRef:
 
2459
 
 
2460
        return ( result );
 
2461
}
 
2462
 
 
2463
/*****************************************************************************/
 
2464
 
 
2465
OSErr
 
2466
FSMoveRename(
 
2467
        const FSRef *srcFileRef,
 
2468
        const FSRef *dstDirectoryRef,
 
2469
        UniCharCount nameLength,
 
2470
        const UniChar *moveName,        /* can be NULL (no rename during move) */
 
2471
        TextEncoding textEncodingHint,
 
2472
        FSRef *newRef)                          /* can be NULL */
 
2473
{
 
2474
        OSErr                                   result;
 
2475
        FSSpec                                  srcFileSpec;
 
2476
        FSCatalogInfo                   catalogInfo;
 
2477
        HParamBlockRec                  pb;
 
2478
        Str31                                   hfsName;
 
2479
        GetVolParmsInfoBuffer   volParmsInfo;
 
2480
        UInt32                                  infoSize;
 
2481
        
 
2482
        /* get source FSSpec from source FSRef */
 
2483
        result = FSGetCatalogInfo(srcFileRef, kFSCatInfoNone, NULL, NULL, &srcFileSpec, NULL);
 
2484
        require_noerr(result, FSGetCatalogInfo_srcFileRef);
 
2485
        
 
2486
        /* Make sure the volume supports MoveRename */
 
2487
        result = FSGetVolParms(srcFileSpec.vRefNum, sizeof(GetVolParmsInfoBuffer),
 
2488
                &volParmsInfo, &infoSize);
 
2489
        require_action((noErr == result) && VolHasMoveRename(&volParmsInfo),
 
2490
                NoMoveRenameSupport, result = paramErr);
 
2491
 
 
2492
        /* get destination volume reference number and destination directory ID from destination FSRef */
 
2493
        result = FSGetCatalogInfo(dstDirectoryRef, kFSCatInfoVolume + kFSCatInfoNodeID,
 
2494
                &catalogInfo, NULL, NULL, NULL);
 
2495
        require_noerr(result, FSGetCatalogInfo_dstDirectoryRef);
 
2496
        
 
2497
        /* make sure the source and destination are on the same volume */
 
2498
        require_action(srcFileSpec.vRefNum == catalogInfo.volume, NotSameVolume, result = diffVolErr);
 
2499
        
 
2500
        /* tell the server to move and rename the object */
 
2501
        pb.copyParam.ioVRefNum = srcFileSpec.vRefNum;
 
2502
        pb.copyParam.ioDirID = srcFileSpec.parID;
 
2503
        pb.copyParam.ioNamePtr = (StringPtr)srcFileSpec.name;
 
2504
        pb.copyParam.ioNewDirID = (long)catalogInfo.nodeID;
 
2505
        pb.copyParam.ioNewName = NULL;
 
2506
        if ( NULL != moveName )
 
2507
        {
 
2508
                result = UnicodeNameGetHFSName(nameLength, moveName, textEncodingHint, false, hfsName);
 
2509
                require_noerr(result, UnicodeNameGetHFSName);
 
2510
                
 
2511
                pb.copyParam.ioCopyName = hfsName;
 
2512
        }
 
2513
        else
 
2514
        {
 
2515
                pb.copyParam.ioCopyName = NULL;
 
2516
        }
 
2517
        result = PBHMoveRenameSync(&pb);
 
2518
        require_noerr(result, PBHMoveRenameSync);
 
2519
        
 
2520
        if ( NULL != newRef )
 
2521
        {
 
2522
                verify_noerr(FSMakeFSRef(pb.copyParam.ioVRefNum, pb.copyParam.ioNewDirID,
 
2523
                        pb.copyParam.ioCopyName, newRef));
 
2524
        }
 
2525
        
 
2526
PBHMoveRenameSync:
 
2527
UnicodeNameGetHFSName:
 
2528
NotSameVolume:
 
2529
FSGetCatalogInfo_dstDirectoryRef:
 
2530
NoMoveRenameSupport:
 
2531
FSGetCatalogInfo_srcFileRef:
 
2532
 
 
2533
        return ( result );
 
2534
}
 
2535
 
 
2536
/*****************************************************************************/
 
2537
 
 
2538
#pragma mark ----- File ID Routines -----
 
2539
 
 
2540
/*****************************************************************************/
 
2541
 
 
2542
OSErr
 
2543
FSResolveFileIDRef(
 
2544
        FSVolumeRefNum volRefNum,
 
2545
        SInt32 fileID,
 
2546
        FSRef *ref)
 
2547
{
 
2548
        OSErr           result;
 
2549
        FIDParam        pb;
 
2550
        Str255          tempStr;
 
2551
        
 
2552
        /* check parameters */
 
2553
        require_action(NULL != ref, BadParameter, result = paramErr);
 
2554
        
 
2555
        /* resolve the file ID reference */
 
2556
        tempStr[0] = 0;
 
2557
        pb.ioNamePtr = tempStr;
 
2558
        pb.ioVRefNum = volRefNum;
 
2559
        pb.ioFileID = fileID;
 
2560
        result = PBResolveFileIDRefSync((HParmBlkPtr)&pb);
 
2561
        require_noerr(result, PBResolveFileIDRefSync);
 
2562
        
 
2563
        /* and then make an FSRef to the file */
 
2564
        result = FSMakeFSRef(volRefNum, pb.ioSrcDirID, tempStr, ref);
 
2565
        require_noerr(result, FSMakeFSRef);
 
2566
        
 
2567
FSMakeFSRef:
 
2568
PBResolveFileIDRefSync:
 
2569
BadParameter:
 
2570
 
 
2571
        return ( result );
 
2572
}
 
2573
 
 
2574
/*****************************************************************************/
 
2575
 
 
2576
OSErr
 
2577
FSCreateFileIDRef(
 
2578
        const FSRef *ref,
 
2579
        SInt32 *fileID)
 
2580
{
 
2581
        OSErr           result;
 
2582
        FSSpec          spec;
 
2583
        FIDParam        pb;
 
2584
        
 
2585
        /* check parameters */
 
2586
        require_action(NULL != fileID, BadParameter, result = paramErr);
 
2587
        
 
2588
        /* Get an FSSpec from the FSRef */
 
2589
        result = FSGetCatalogInfo(ref, kFSCatInfoNone, NULL, NULL, &spec, NULL);
 
2590
        require_noerr(result, FSGetCatalogInfo);
 
2591
        
 
2592
        /* Create (or get) the file ID reference using the FSSpec */
 
2593
        pb.ioNamePtr = (StringPtr)spec.name;
 
2594
        pb.ioVRefNum = spec.vRefNum;
 
2595
        pb.ioSrcDirID = spec.parID;
 
2596
        result = PBCreateFileIDRefSync((HParmBlkPtr)&pb);
 
2597
        require((noErr == result) || (fidExists == result) || (afpIDExists == result),
 
2598
                PBCreateFileIDRefSync);
 
2599
        
 
2600
        /* return the file ID reference */
 
2601
        *fileID = pb.ioFileID;
 
2602
        
 
2603
PBCreateFileIDRefSync:
 
2604
FSGetCatalogInfo:
 
2605
BadParameter:
 
2606
 
 
2607
        return ( result );
 
2608
}
 
2609
 
 
2610
/*****************************************************************************/
 
2611
 
 
2612
#pragma mark ----- Utility Routines -----
 
2613
 
 
2614
/*****************************************************************************/
 
2615
 
 
2616
Ptr
 
2617
GetTempBuffer(
 
2618
        ByteCount buffReqSize,
 
2619
        ByteCount *buffActSize)
 
2620
{
 
2621
        enum
 
2622
        {
 
2623
                kSlopMemory = 0x00008000        /* 32K - Amount of free memory to leave when allocating buffers */
 
2624
        };
 
2625
        
 
2626
        Ptr tempPtr;
 
2627
        
 
2628
        /* check parameters */
 
2629
        require_action(NULL != buffActSize, BadParameter, tempPtr = NULL);
 
2630
        
 
2631
        /* Make request a multiple of 4K bytes */
 
2632
        buffReqSize = buffReqSize & 0xfffff000;
 
2633
        
 
2634
        if ( buffReqSize < 0x00001000 )
 
2635
        {
 
2636
                /* Request was smaller than 4K bytes - make it 4K */
 
2637
                buffReqSize = 0x00001000;
 
2638
        }
 
2639
        
 
2640
        /* Attempt to allocate the memory */
 
2641
        tempPtr = NewPtr(buffReqSize);
 
2642
        
 
2643
        /* If request failed, go to backup plan */
 
2644
        if ( (tempPtr == NULL) && (buffReqSize > 0x00001000) )
 
2645
        {
 
2646
                /*
 
2647
                **      Try to get largest 4K byte block available
 
2648
                **      leaving some slop for the toolbox if possible
 
2649
                */
 
2650
                long freeMemory = (FreeMem() - kSlopMemory) & 0xfffff000;
 
2651
                
 
2652
                buffReqSize = MaxBlock() & 0xfffff000;
 
2653
                
 
2654
                if ( buffReqSize > freeMemory )
 
2655
                {
 
2656
                        buffReqSize = freeMemory;
 
2657
                }
 
2658
                
 
2659
                if ( buffReqSize == 0 )
 
2660
                {
 
2661
                        buffReqSize = 0x00001000;
 
2662
                }
 
2663
                
 
2664
                tempPtr = NewPtr(buffReqSize);
 
2665
        }
 
2666
        
 
2667
        /* Return bytes allocated */
 
2668
        if ( tempPtr != NULL )
 
2669
        {
 
2670
                *buffActSize = buffReqSize;
 
2671
        }
 
2672
        else
 
2673
        {
 
2674
                *buffActSize = 0;
 
2675
        }
 
2676
        
 
2677
BadParameter:
 
2678
 
 
2679
        return ( tempPtr );
 
2680
}
 
2681
 
 
2682
/*****************************************************************************/
 
2683
 
 
2684
OSErr
 
2685
FileRefNumGetFSRef(
 
2686
        short refNum,
 
2687
        FSRef *ref)
 
2688
{
 
2689
        return ( FSGetForkCBInfo(refNum, 0, NULL, NULL, NULL, ref, NULL) );
 
2690
}
 
2691
 
 
2692
/*****************************************************************************/
 
2693
 
 
2694
OSErr
 
2695
FSSetDefault(
 
2696
        const FSRef *newDefault,
 
2697
        FSRef *oldDefault)
 
2698
{
 
2699
        OSErr                   result;
 
2700
        FSVolumeRefNum  vRefNum;
 
2701
        long                    dirID;
 
2702
        FSCatalogInfo   catalogInfo;
 
2703
        
 
2704
        /* check parameters */
 
2705
        require_action((NULL != newDefault) && (NULL != oldDefault), BadParameter, result = paramErr);
 
2706
        
 
2707
        /* Get nodeFlags, vRefNum and dirID (nodeID) of newDefault */
 
2708
        result = FSGetCatalogInfo(newDefault,
 
2709
                kFSCatInfoNodeFlags + kFSCatInfoVolume + kFSCatInfoNodeID,
 
2710
                &catalogInfo, NULL, NULL, NULL);
 
2711
        require_noerr(result, FSGetCatalogInfo);
 
2712
        
 
2713
        /* Make sure newDefault is a directory */
 
2714
        require_action(0 != (kFSNodeIsDirectoryMask & catalogInfo.nodeFlags), NewDefaultNotDirectory,
 
2715
                result = dirNFErr);
 
2716
        
 
2717
        /* Get the current working directory. */
 
2718
        result = HGetVol(NULL, &vRefNum, &dirID);
 
2719
        require_noerr(result, HGetVol);
 
2720
        
 
2721
        /* Return the oldDefault FSRef */
 
2722
        result = FSMakeFSRef(vRefNum, dirID, NULL, oldDefault);
 
2723
        require_noerr(result, FSMakeFSRef);
 
2724
        
 
2725
        /* Set the new current working directory */
 
2726
        result = HSetVol(NULL, catalogInfo.volume, catalogInfo.nodeID);
 
2727
        require_noerr(result, HSetVol);
 
2728
 
 
2729
HSetVol:
 
2730
FSMakeFSRef:
 
2731
HGetVol:
 
2732
NewDefaultNotDirectory:
 
2733
FSGetCatalogInfo:
 
2734
BadParameter:
 
2735
 
 
2736
        return ( result );
 
2737
}
 
2738
 
 
2739
/*****************************************************************************/
 
2740
 
 
2741
OSErr
 
2742
FSRestoreDefault(
 
2743
        const FSRef *oldDefault)
 
2744
{
 
2745
        OSErr                   result;
 
2746
        FSCatalogInfo   catalogInfo;
 
2747
        
 
2748
        /* check parameters */
 
2749
        require_action(NULL != oldDefault, BadParameter, result = paramErr);
 
2750
        
 
2751
        /* Get nodeFlags, vRefNum and dirID (nodeID) of oldDefault */
 
2752
        result = FSGetCatalogInfo(oldDefault,
 
2753
                kFSCatInfoNodeFlags + kFSCatInfoVolume + kFSCatInfoNodeID,
 
2754
                &catalogInfo, NULL, NULL, NULL);
 
2755
        require_noerr(result, FSGetCatalogInfo);
 
2756
        
 
2757
        /* Make sure oldDefault is a directory */
 
2758
        require_action(0 != (kFSNodeIsDirectoryMask & catalogInfo.nodeFlags), OldDefaultNotDirectory,
 
2759
                result = dirNFErr);
 
2760
        
 
2761
        /* Set the current working directory to oldDefault */
 
2762
        result = HSetVol(NULL, catalogInfo.volume, catalogInfo.nodeID);
 
2763
        require_noerr(result, HSetVol);
 
2764
 
 
2765
HSetVol:
 
2766
OldDefaultNotDirectory:
 
2767
FSGetCatalogInfo:
 
2768
BadParameter:
 
2769
 
 
2770
        return ( result );
 
2771
}
 
2772
 
 
2773
/*****************************************************************************/