]> git.saurik.com Git - wxWidgets.git/blob - src/mac/carbon/morefilex/MoreFilesX.c
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[ 1473731 ] 'wxColourBase and wxString <-> wxColour implementation' with minor modifi...
[wxWidgets.git] / src / mac / carbon / morefilex / MoreFilesX.c
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 /* Move object to its new home */
1416 result = FSMoveObject(newRef, destDirectory, newRef);
1417 require_noerr(result, FSMoveObjectAfterRenameFailed);
1418
1419 /* Rename the object to new name */
1420 result = FSRenameUnicode(ref, nameLength, name, textEncodingHint, newRef);
1421 require_noerr(result, FSRenameUnicodeAfterMoveFailed);
1422 }
1423 else
1424 {
1425 /* Move object to its new home */
1426 result = FSMoveObject(newRef, destDirectory, newRef);
1427 require_noerr(result, FSMoveObjectNoRenameFailed);
1428 }
1429
1430 return ( result );
1431
1432 /*************/
1433
1434 /*
1435 * failure handling code when renaming
1436 */
1437
1438 FSRenameUnicodeAfterMoveFailed:
1439
1440 /* Error handling: move object back to original location - ignore errors */
1441 verify_noerr(FSMoveObject(newRef, &originalDirectory, newRef));
1442
1443 FSMoveObjectAfterRenameFailed:
1444
1445 /* Error handling: rename object back to original name - ignore errors */
1446 verify_noerr(FSRenameUnicode(newRef, originalName.length, originalName.unicode, originalTextEncodingHint, newRef));
1447
1448 FSRenameUnicodeBeforeMoveFailed:
1449 GenerateUniqueHFSUniStrFailed:
1450
1451 /*
1452 * failure handling code for renaming or not
1453 */
1454 FSMoveObjectNoRenameFailed:
1455 NotSameVolume:
1456 SourceBad:
1457 DestinationBad:
1458 BadParameter:
1459
1460 return ( result );
1461 }
1462
1463 /*****************************************************************************/
1464
1465 /*
1466 The FSDeleteContainerLevel function deletes the contents of a container
1467 directory. All files and subdirectories in the specified container are
1468 deleted. If a locked file or directory is encountered, it is unlocked
1469 and then deleted. If any unexpected errors are encountered,
1470 FSDeleteContainerLevel quits and returns to the caller.
1471
1472 container --> FSRef to a directory.
1473 theGlobals --> A pointer to a FSDeleteContainerGlobals struct
1474 which contains the variables that do not need to
1475 be allocated each time FSDeleteContainerLevel
1476 recurses. That lets FSDeleteContainerLevel use
1477 less stack space per recursion level.
1478 */
1479
1480 static
1481 void
1482 FSDeleteContainerLevel(
1483 const FSRef *container,
1484 FSDeleteContainerGlobals *theGlobals)
1485 {
1486 /* level locals */
1487 FSIterator iterator;
1488 FSRef itemToDelete;
1489 UInt16 nodeFlags;
1490
1491 /* Open FSIterator for flat access and give delete optimization hint */
1492 theGlobals->result = FSOpenIterator(container, kFSIterateFlat + kFSIterateDelete, &iterator);
1493 require_noerr(theGlobals->result, FSOpenIterator);
1494
1495 /* delete the contents of the directory */
1496 do
1497 {
1498 /* get 1 item to delete */
1499 theGlobals->result = FSGetCatalogInfoBulk(iterator, 1, &theGlobals->actualObjects,
1500 NULL, kFSCatInfoNodeFlags, &theGlobals->catalogInfo,
1501 &itemToDelete, NULL, NULL);
1502 if ( (noErr == theGlobals->result) && (1 == theGlobals->actualObjects) )
1503 {
1504 /* save node flags in local in case we have to recurse */
1505 nodeFlags = theGlobals->catalogInfo.nodeFlags;
1506
1507 /* is it a file or directory? */
1508 if ( 0 != (nodeFlags & kFSNodeIsDirectoryMask) )
1509 {
1510 /* it's a directory -- delete its contents before attempting to delete it */
1511 FSDeleteContainerLevel(&itemToDelete, theGlobals);
1512 }
1513 /* are we still OK to delete? */
1514 if ( noErr == theGlobals->result )
1515 {
1516 /* is item locked? */
1517 if ( 0 != (nodeFlags & kFSNodeLockedMask) )
1518 {
1519 /* then attempt to unlock it (ignore result since FSDeleteObject will set it correctly) */
1520 theGlobals->catalogInfo.nodeFlags = nodeFlags & ~kFSNodeLockedMask;
1521 (void) FSSetCatalogInfo(&itemToDelete, kFSCatInfoNodeFlags, &theGlobals->catalogInfo);
1522 }
1523 /* delete the item */
1524 theGlobals->result = FSDeleteObject(&itemToDelete);
1525 }
1526 }
1527 } while ( noErr == theGlobals->result );
1528
1529 /* we found the end of the items normally, so return noErr */
1530 if ( errFSNoMoreItems == theGlobals->result )
1531 {
1532 theGlobals->result = noErr;
1533 }
1534
1535 /* close the FSIterator (closing an open iterator should never fail) */
1536 verify_noerr(FSCloseIterator(iterator));
1537
1538 FSOpenIterator:
1539
1540 return;
1541 }
1542
1543 /*****************************************************************************/
1544
1545 OSErr
1546 FSDeleteContainerContents(
1547 const FSRef *container)
1548 {
1549 FSDeleteContainerGlobals theGlobals;
1550
1551 /* delete container's contents */
1552 FSDeleteContainerLevel(container, &theGlobals);
1553
1554 return ( theGlobals.result );
1555 }
1556
1557 /*****************************************************************************/
1558
1559 OSErr
1560 FSDeleteContainer(
1561 const FSRef *container)
1562 {
1563 OSErr result;
1564 FSCatalogInfo catalogInfo;
1565
1566 /* get nodeFlags for container */
1567 result = FSGetCatalogInfo(container, kFSCatInfoNodeFlags, &catalogInfo, NULL, NULL,NULL);
1568 require_noerr(result, FSGetCatalogInfo);
1569
1570 /* make sure container is a directory */
1571 require_action(0 != (catalogInfo.nodeFlags & kFSNodeIsDirectoryMask), ContainerNotDirectory, result = dirNFErr);
1572
1573 /* delete container's contents */
1574 result = FSDeleteContainerContents(container);
1575 require_noerr(result, FSDeleteContainerContents);
1576
1577 /* is container locked? */
1578 if ( 0 != (catalogInfo.nodeFlags & kFSNodeLockedMask) )
1579 {
1580 /* then attempt to unlock container (ignore result since FSDeleteObject will set it correctly) */
1581 catalogInfo.nodeFlags &= ~kFSNodeLockedMask;
1582 (void) FSSetCatalogInfo(container, kFSCatInfoNodeFlags, &catalogInfo);
1583 }
1584
1585 /* delete the container */
1586 result = FSDeleteObject(container);
1587
1588 FSDeleteContainerContents:
1589 ContainerNotDirectory:
1590 FSGetCatalogInfo:
1591
1592 return ( result );
1593 }
1594
1595 /*****************************************************************************/
1596
1597 /*
1598 The FSIterateContainerLevel function iterates the contents of a container
1599 directory and calls a IterateContainerFilterProc function once for each
1600 file and directory found.
1601
1602 theGlobals --> A pointer to a FSIterateContainerGlobals struct
1603 which contains the variables needed globally by
1604 all recusion levels of FSIterateContainerLevel.
1605 That makes FSIterateContainer thread safe since
1606 each call to it uses its own global world.
1607 It also contains the variables that do not need
1608 to be allocated each time FSIterateContainerLevel
1609 recurses. That lets FSIterateContainerLevel use
1610 less stack space per recursion level.
1611 */
1612
1613 static
1614 void
1615 FSIterateContainerLevel(
1616 FSIterateContainerGlobals *theGlobals)
1617 {
1618 FSIterator iterator;
1619
1620 /* If maxLevels is zero, we aren't checking levels */
1621 /* If currentLevel < maxLevels, look at this level */
1622 if ( (theGlobals->maxLevels == 0) ||
1623 (theGlobals->currentLevel < theGlobals->maxLevels) )
1624 {
1625 /* Open FSIterator for flat access to theGlobals->ref */
1626 theGlobals->result = FSOpenIterator(&theGlobals->ref, kFSIterateFlat, &iterator);
1627 require_noerr(theGlobals->result, FSOpenIterator);
1628
1629 ++theGlobals->currentLevel; /* Go to next level */
1630
1631 /* Call FSGetCatalogInfoBulk in loop to get all items in the container */
1632 do
1633 {
1634 theGlobals->result = FSGetCatalogInfoBulk(iterator, 1, &theGlobals->actualObjects,
1635 &theGlobals->containerChanged, theGlobals->whichInfo, &theGlobals->catalogInfo,
1636 &theGlobals->ref, theGlobals->specPtr, theGlobals->namePtr);
1637 if ( (noErr == theGlobals->result || errFSNoMoreItems == theGlobals->result) &&
1638 (0 != theGlobals->actualObjects) )
1639 {
1640 /* Call the IterateFilterProc */
1641 theGlobals->quitFlag = CallIterateContainerFilterProc(theGlobals->iterateFilter,
1642 theGlobals->containerChanged, theGlobals->currentLevel,
1643 &theGlobals->catalogInfo, &theGlobals->ref,
1644 theGlobals->specPtr, theGlobals->namePtr, theGlobals->yourDataPtr);
1645 /* Is it a directory? */
1646 if ( 0 != (theGlobals->catalogInfo.nodeFlags & kFSNodeIsDirectoryMask) )
1647 {
1648 /* Keep going? */
1649 if ( !theGlobals->quitFlag )
1650 {
1651 /* Dive again if the IterateFilterProc didn't say "quit" */
1652 FSIterateContainerLevel(theGlobals);
1653 }
1654 }
1655 }
1656 /* time to fall back a level? */
1657 } while ( (noErr == theGlobals->result) && (!theGlobals->quitFlag) );
1658
1659 /* errFSNoMoreItems is OK - it only means we hit the end of this level */
1660 /* afpAccessDenied is OK, too - it only means we cannot see inside a directory */
1661 if ( (errFSNoMoreItems == theGlobals->result) ||
1662 (afpAccessDenied == theGlobals->result) )
1663 {
1664 theGlobals->result = noErr;
1665 }
1666
1667 --theGlobals->currentLevel; /* Return to previous level as we leave */
1668
1669 /* Close the FSIterator (closing an open iterator should never fail) */
1670 verify_noerr(FSCloseIterator(iterator));
1671 }
1672
1673 FSOpenIterator:
1674
1675 return;
1676 }
1677
1678 /*****************************************************************************/
1679
1680 OSErr
1681 FSIterateContainer(
1682 const FSRef *container,
1683 ItemCount maxLevels,
1684 FSCatalogInfoBitmap whichInfo,
1685 Boolean wantFSSpec,
1686 Boolean wantName,
1687 IterateContainerFilterProcPtr iterateFilter,
1688 void *yourDataPtr)
1689 {
1690 OSErr result;
1691 FSIterateContainerGlobals theGlobals;
1692
1693 /* make sure there is an iterateFilter */
1694 require_action(iterateFilter != NULL, NoIterateFilter, result = paramErr);
1695
1696 /*
1697 * set up the globals we need to access from the recursive routine
1698 */
1699 theGlobals.iterateFilter = iterateFilter;
1700 /* we need the node flags no matter what was requested so we can detect files vs. directories */
1701 theGlobals.whichInfo = whichInfo | kFSCatInfoNodeFlags;
1702 /* start with input container -- the first OpenIterator will ensure it is a directory */
1703 theGlobals.ref = *container;
1704 if ( wantFSSpec )
1705 {
1706 theGlobals.specPtr = &theGlobals.spec;
1707 }
1708 else
1709 {
1710 theGlobals.specPtr = NULL;
1711 }
1712 if ( wantName )
1713 {
1714 theGlobals.namePtr = &theGlobals.name;
1715 }
1716 else
1717 {
1718 theGlobals.namePtr = NULL;
1719 }
1720 theGlobals.yourDataPtr = yourDataPtr;
1721 theGlobals.maxLevels = maxLevels;
1722 theGlobals.currentLevel = 0;
1723 theGlobals.quitFlag = false;
1724 theGlobals.containerChanged = false;
1725 theGlobals.result = noErr;
1726 theGlobals.actualObjects = 0;
1727
1728 /* here we go into recursion land... */
1729 FSIterateContainerLevel(&theGlobals);
1730 result = theGlobals.result;
1731 require_noerr(result, FSIterateContainerLevel);
1732
1733 FSIterateContainerLevel:
1734 NoIterateFilter:
1735
1736 return ( result );
1737 }
1738
1739 /*****************************************************************************/
1740
1741 OSErr
1742 FSGetDirectoryItems(
1743 const FSRef *container,
1744 FSRef ***refsHandle, /* pointer to handle of FSRefs */
1745 ItemCount *numRefs,
1746 Boolean *containerChanged)
1747 {
1748 /* Grab items 10 at a time. */
1749 enum { kMaxItemsPerBulkCall = 10 };
1750
1751 OSErr result;
1752 OSErr memResult;
1753 FSIterator iterator;
1754 FSRef refs[kMaxItemsPerBulkCall];
1755 ItemCount actualObjects;
1756 Boolean changed;
1757
1758 /* check parameters */
1759 require_action((NULL != refsHandle) && (NULL != numRefs) && (NULL != containerChanged),
1760 BadParameter, result = paramErr);
1761
1762 *numRefs = 0;
1763 *containerChanged = false;
1764 *refsHandle = (FSRef **)NewHandle(0);
1765 require_action(NULL != *refsHandle, NewHandle, result = memFullErr);
1766
1767 /* open an FSIterator */
1768 result = FSOpenIterator(container, kFSIterateFlat, &iterator);
1769 require_noerr(result, FSOpenIterator);
1770
1771 /* Call FSGetCatalogInfoBulk in loop to get all items in the container */
1772 do
1773 {
1774 result = FSGetCatalogInfoBulk(iterator, kMaxItemsPerBulkCall, &actualObjects,
1775 &changed, kFSCatInfoNone, NULL, refs, NULL, NULL);
1776
1777 /* if the container changed, set containerChanged for output, but keep going */
1778 if ( changed )
1779 {
1780 *containerChanged = changed;
1781 }
1782
1783 /* any result other than noErr and errFSNoMoreItems is serious */
1784 require((noErr == result) || (errFSNoMoreItems == result), FSGetCatalogInfoBulk);
1785
1786 /* add objects to output array and count */
1787 if ( 0 != actualObjects )
1788 {
1789 /* concatenate the FSRefs to the end of the handle */
1790 PtrAndHand(refs, (Handle)*refsHandle, actualObjects * sizeof(FSRef));
1791 memResult = MemError();
1792 require_noerr_action(memResult, MemoryAllocationFailed, result = memResult);
1793
1794 *numRefs += actualObjects;
1795 }
1796 } while ( noErr == result );
1797
1798 verify_noerr(FSCloseIterator(iterator)); /* closing an open iterator should never fail, but... */
1799
1800 return ( noErr );
1801
1802 /**********************/
1803
1804 MemoryAllocationFailed:
1805 FSGetCatalogInfoBulk:
1806
1807 /* close the iterator */
1808 verify_noerr(FSCloseIterator(iterator));
1809
1810 FSOpenIterator:
1811 /* dispose of handle if already allocated and clear the outputs */
1812 if ( NULL != *refsHandle )
1813 {
1814 DisposeHandle((Handle)*refsHandle);
1815 *refsHandle = NULL;
1816 }
1817 *numRefs = 0;
1818
1819 NewHandle:
1820 BadParameter:
1821
1822 return ( result );
1823 }
1824
1825 /*****************************************************************************/
1826
1827 /*
1828 The GenerateUniqueName function generates a HFSUniStr255 name that is
1829 unique in both dir1 and dir2.
1830
1831 startSeed --> A pointer to a long which is used to generate the
1832 unique name.
1833 <-- It is modified on output to a value which should
1834 be used to generate the next unique name.
1835 dir1 --> The first directory.
1836 dir2 --> The second directory.
1837 uniqueName <-- A pointer to a HFSUniStr255 where the unique name
1838 is to be returned.
1839 */
1840
1841 static
1842 OSErr
1843 GenerateUniqueHFSUniStr(
1844 long *startSeed,
1845 const FSRef *dir1,
1846 const FSRef *dir2,
1847 HFSUniStr255 *uniqueName)
1848 {
1849 OSErr result;
1850 long i;
1851 FSRefParam pb;
1852 FSRef newRef;
1853 unsigned char hexStr[17] = "0123456789ABCDEF";
1854
1855 /* set up the parameter block */
1856 pb.name = uniqueName->unicode;
1857 pb.nameLength = 8; /* always 8 characters */
1858 pb.textEncodingHint = kTextEncodingUnknown;
1859 pb.newRef = &newRef;
1860
1861 /* loop until we get fnfErr with a filename in both directories */
1862 result = noErr;
1863 while ( fnfErr != result )
1864 {
1865 /* convert startSeed to 8 character Unicode string */
1866 uniqueName->length = 8;
1867 for ( i = 0; i < 8; ++i )
1868 {
1869 uniqueName->unicode[i] = hexStr[((*startSeed >> ((7-i)*4)) & 0xf)];
1870 }
1871
1872 /* try in dir1 */
1873 pb.ref = dir1;
1874 result = PBMakeFSRefUnicodeSync(&pb);
1875 if ( fnfErr == result )
1876 {
1877 /* try in dir2 */
1878 pb.ref = dir2;
1879 result = PBMakeFSRefUnicodeSync(&pb);
1880 if ( fnfErr != result )
1881 {
1882 /* exit if anything other than noErr or fnfErr */
1883 require_noerr(result, Dir2PBMakeFSRefUnicodeSyncFailed);
1884 }
1885 }
1886 else
1887 {
1888 /* exit if anything other than noErr or fnfErr */
1889 require_noerr(result, Dir1PBMakeFSRefUnicodeSyncFailed);
1890 }
1891
1892 /* increment seed for next pass through loop, */
1893 /* or for next call to GenerateUniqueHFSUniStr */
1894 ++(*startSeed);
1895 }
1896
1897 /* we have a unique file name which doesn't exist in dir1 or dir2 */
1898 result = noErr;
1899
1900 Dir2PBMakeFSRefUnicodeSyncFailed:
1901 Dir1PBMakeFSRefUnicodeSyncFailed:
1902
1903 return ( result );
1904 }
1905
1906 /*****************************************************************************/
1907
1908 OSErr
1909 FSExchangeObjectsCompat(
1910 const FSRef *sourceRef,
1911 const FSRef *destRef,
1912 FSRef *newSourceRef,
1913 FSRef *newDestRef)
1914 {
1915 enum
1916 {
1917 /* get all settable info except for mod dates, plus the volume refNum and parent directory ID */
1918 kGetCatInformationMask = (kFSCatInfoSettableInfo |
1919 kFSCatInfoVolume |
1920 kFSCatInfoParentDirID) &
1921 ~(kFSCatInfoContentMod | kFSCatInfoAttrMod),
1922 /* set everything possible except for mod dates */
1923 kSetCatinformationMask = kFSCatInfoSettableInfo &
1924 ~(kFSCatInfoContentMod | kFSCatInfoAttrMod)
1925 };
1926
1927 OSErr result;
1928 GetVolParmsInfoBuffer volParmsInfo;
1929 UInt32 infoSize;
1930 FSCatalogInfo sourceCatalogInfo; /* source file's catalog information */
1931 FSCatalogInfo destCatalogInfo; /* destination file's catalog information */
1932 HFSUniStr255 sourceName; /* source file's Unicode name */
1933 HFSUniStr255 destName; /* destination file's Unicode name */
1934 FSRef sourceCurrentRef; /* FSRef to current location of source file throughout this function */
1935 FSRef destCurrentRef; /* FSRef to current location of destination file throughout this function */
1936 FSRef sourceParentRef; /* FSRef to parent directory of source file */
1937 FSRef destParentRef; /* FSRef to parent directory of destination file */
1938 HFSUniStr255 sourceUniqueName; /* unique name given to source file while exchanging it with destination */
1939 HFSUniStr255 destUniqueName; /* unique name given to destination file while exchanging it with source */
1940 long theSeed; /* the seed for generating unique names */
1941 Boolean sameParentDirs; /* true if source and destinatin parent directory is the same */
1942
1943 /* check parameters */
1944 require_action((NULL != newSourceRef) && (NULL != newDestRef), BadParameter, result = paramErr);
1945
1946 /* output refs and current refs = input refs to start with */
1947 BlockMoveData(sourceRef, newSourceRef, sizeof(FSRef));
1948 BlockMoveData(sourceRef, &sourceCurrentRef, sizeof(FSRef));
1949
1950 BlockMoveData(destRef, newDestRef, sizeof(FSRef));
1951 BlockMoveData(destRef, &destCurrentRef, sizeof(FSRef));
1952
1953 /* get source volume's vRefNum */
1954 result = FSGetCatalogInfo(&sourceCurrentRef, kFSCatInfoVolume, &sourceCatalogInfo, NULL, NULL, NULL);
1955 require_noerr(result, DetermineSourceVRefNumFailed);
1956
1957 /* see if that volume supports FSExchangeObjects */
1958 result = FSGetVolParms(sourceCatalogInfo.volume, sizeof(GetVolParmsInfoBuffer),
1959 &volParmsInfo, &infoSize);
1960 if ( (noErr == result) && VolSupportsFSExchangeObjects(&volParmsInfo) )
1961 {
1962 /* yes - use FSExchangeObjects */
1963 result = FSExchangeObjects(sourceRef, destRef);
1964 }
1965 else
1966 {
1967 /* no - emulate FSExchangeObjects */
1968
1969 /* Note: The compatibility case won't work for files with *Btree control blocks. */
1970 /* Right now the only *Btree files are created by the system. */
1971
1972 /* get all catalog information and Unicode names for each file */
1973 result = FSGetCatalogInfo(&sourceCurrentRef, kGetCatInformationMask, &sourceCatalogInfo, &sourceName, NULL, &sourceParentRef);
1974 require_noerr(result, SourceFSGetCatalogInfoFailed);
1975
1976 result = FSGetCatalogInfo(&destCurrentRef, kGetCatInformationMask, &destCatalogInfo, &destName, NULL, &destParentRef);
1977 require_noerr(result, DestFSGetCatalogInfoFailed);
1978
1979 /* make sure source and destination are on same volume */
1980 require_action(sourceCatalogInfo.volume == destCatalogInfo.volume, NotSameVolume, result = diffVolErr);
1981
1982 /* make sure both files are *really* files */
1983 require_action((0 == (sourceCatalogInfo.nodeFlags & kFSNodeIsDirectoryMask)) &&
1984 (0 == (destCatalogInfo.nodeFlags & kFSNodeIsDirectoryMask)), NotAFile, result = notAFileErr);
1985
1986 /* generate 2 names that are unique in both directories */
1987 theSeed = 0x4a696d4c; /* a fine unlikely filename */
1988
1989 result = GenerateUniqueHFSUniStr(&theSeed, &sourceParentRef, &destParentRef, &sourceUniqueName);
1990 require_noerr(result, GenerateUniqueHFSUniStr1Failed);
1991
1992 result = GenerateUniqueHFSUniStr(&theSeed, &sourceParentRef, &destParentRef, &destUniqueName);
1993 require_noerr(result, GenerateUniqueHFSUniStr2Failed);
1994
1995 /* rename sourceCurrentRef to sourceUniqueName */
1996 result = FSRenameUnicode(&sourceCurrentRef, sourceUniqueName.length, sourceUniqueName.unicode, kTextEncodingUnknown, newSourceRef);
1997 require_noerr(result, FSRenameUnicode1Failed);
1998 BlockMoveData(newSourceRef, &sourceCurrentRef, sizeof(FSRef));
1999
2000 /* rename destCurrentRef to destUniqueName */
2001 result = FSRenameUnicode(&destCurrentRef, destUniqueName.length, destUniqueName.unicode, kTextEncodingUnknown, newDestRef);
2002 require_noerr(result, FSRenameUnicode2Failed);
2003 BlockMoveData(newDestRef, &destCurrentRef, sizeof(FSRef));
2004
2005 /* are the source and destination parent directories the same? */
2006 sameParentDirs = ( sourceCatalogInfo.parentDirID == destCatalogInfo.parentDirID );
2007 if ( !sameParentDirs )
2008 {
2009 /* move source file to dest parent directory */
2010 result = FSMoveObject(&sourceCurrentRef, &destParentRef, newSourceRef);
2011 require_noerr(result, FSMoveObject1Failed);
2012 BlockMoveData(newSourceRef, &sourceCurrentRef, sizeof(FSRef));
2013
2014 /* move dest file to source parent directory */
2015 result = FSMoveObject(&destCurrentRef, &sourceParentRef, newDestRef);
2016 require_noerr(result, FSMoveObject2Failed);
2017 BlockMoveData(newDestRef, &destCurrentRef, sizeof(FSRef));
2018 }
2019
2020 /* At this point, the files are in their new locations (if they were moved). */
2021 /* The source file is named sourceUniqueName and is in the directory referred to */
2022 /* by destParentRef. The destination file is named destUniqueName and is in the */
2023 /* directory referred to by sourceParentRef. */
2024
2025 /* give source file the dest file's catalog information except for mod dates */
2026 result = FSSetCatalogInfo(&sourceCurrentRef, kSetCatinformationMask, &destCatalogInfo);
2027 require_noerr(result, FSSetCatalogInfo1Failed);
2028
2029 /* give dest file the source file's catalog information except for mod dates */
2030 result = FSSetCatalogInfo(&destCurrentRef, kSetCatinformationMask, &sourceCatalogInfo);
2031 require_noerr(result, FSSetCatalogInfo2Failed);
2032
2033 /* rename source file with dest file's name */
2034 result = FSRenameUnicode(&sourceCurrentRef, destName.length, destName.unicode, destCatalogInfo.textEncodingHint, newSourceRef);
2035 require_noerr(result, FSRenameUnicode3Failed);
2036 BlockMoveData(newSourceRef, &sourceCurrentRef, sizeof(FSRef));
2037
2038 /* rename dest file with source file's name */
2039 result = FSRenameUnicode(&destCurrentRef, sourceName.length, sourceName.unicode, sourceCatalogInfo.textEncodingHint, newDestRef);
2040 require_noerr(result, FSRenameUnicode4Failed);
2041
2042 /* we're done with no errors, so swap newSourceRef and newDestRef */
2043 BlockMoveData(newDestRef, newSourceRef, sizeof(FSRef));
2044 BlockMoveData(&sourceCurrentRef, newDestRef, sizeof(FSRef));
2045 }
2046
2047 return ( result );
2048
2049 /**********************/
2050
2051 /* If there are any failures while emulating FSExchangeObjects, attempt to reverse any steps */
2052 /* already taken. In any case, newSourceRef and newDestRef will refer to the files in whatever */
2053 /* state and location they ended up in so that both files can be found by the calling code. */
2054
2055 FSRenameUnicode4Failed:
2056
2057 /* attempt to rename source file to sourceUniqueName */
2058 if ( noErr == FSRenameUnicode(&sourceCurrentRef, sourceUniqueName.length, sourceUniqueName.unicode, kTextEncodingUnknown, newSourceRef) )
2059 {
2060 BlockMoveData(newSourceRef, &sourceCurrentRef, sizeof(FSRef));
2061 }
2062
2063 FSRenameUnicode3Failed:
2064
2065 /* attempt to restore dest file's catalog information */
2066 verify_noerr(FSSetCatalogInfo(&destCurrentRef, kFSCatInfoSettableInfo, &destCatalogInfo));
2067
2068 FSSetCatalogInfo2Failed:
2069
2070 /* attempt to restore source file's catalog information */
2071 verify_noerr(FSSetCatalogInfo(&sourceCurrentRef, kFSCatInfoSettableInfo, &sourceCatalogInfo));
2072
2073 FSSetCatalogInfo1Failed:
2074
2075 if ( !sameParentDirs )
2076 {
2077 /* attempt to move dest file back to dest directory */
2078 if ( noErr == FSMoveObject(&destCurrentRef, &destParentRef, newDestRef) )
2079 {
2080 BlockMoveData(newDestRef, &destCurrentRef, sizeof(FSRef));
2081 }
2082 }
2083
2084 FSMoveObject2Failed:
2085
2086 if ( !sameParentDirs )
2087 {
2088 /* attempt to move source file back to source directory */
2089 if ( noErr == FSMoveObject(&sourceCurrentRef, &sourceParentRef, newSourceRef) )
2090 {
2091 BlockMoveData(newSourceRef, &sourceCurrentRef, sizeof(FSRef));
2092 }
2093 }
2094
2095 FSMoveObject1Failed:
2096
2097 /* attempt to rename dest file to original name */
2098 verify_noerr(FSRenameUnicode(&destCurrentRef, destName.length, destName.unicode, destCatalogInfo.textEncodingHint, newDestRef));
2099
2100 FSRenameUnicode2Failed:
2101
2102 /* attempt to rename source file to original name */
2103 verify_noerr(FSRenameUnicode(&sourceCurrentRef, sourceName.length, sourceName.unicode, sourceCatalogInfo.textEncodingHint, newSourceRef));
2104
2105 FSRenameUnicode1Failed:
2106 GenerateUniqueHFSUniStr2Failed:
2107 GenerateUniqueHFSUniStr1Failed:
2108 NotAFile:
2109 NotSameVolume:
2110 DestFSGetCatalogInfoFailed:
2111 SourceFSGetCatalogInfoFailed:
2112 DetermineSourceVRefNumFailed:
2113 BadParameter:
2114
2115 return ( result );
2116 }
2117
2118 /*****************************************************************************/
2119
2120 #pragma mark ----- Shared Environment Routines -----
2121
2122 /*****************************************************************************/
2123
2124 OSErr
2125 FSLockRangeMoreFilesX(
2126 SInt16 refNum,
2127 SInt32 rangeLength,
2128 SInt32 rangeStart)
2129 {
2130 OSErr result;
2131 ParamBlockRec pb;
2132
2133 pb.ioParam.ioRefNum = refNum;
2134 pb.ioParam.ioReqCount = rangeLength;
2135 pb.ioParam.ioPosMode = fsFromStart;
2136 pb.ioParam.ioPosOffset = rangeStart;
2137 result = PBLockRangeSync(&pb);
2138 require_noerr(result, PBLockRangeSync);
2139
2140 PBLockRangeSync:
2141
2142 return ( result );
2143 }
2144
2145 /*****************************************************************************/
2146
2147 OSErr
2148 FSUnlockRangeMoreFilesX(
2149 SInt16 refNum,
2150 SInt32 rangeLength,
2151 SInt32 rangeStart)
2152 {
2153 OSErr result;
2154 ParamBlockRec pb;
2155
2156 pb.ioParam.ioRefNum = refNum;
2157 pb.ioParam.ioReqCount = rangeLength;
2158 pb.ioParam.ioPosMode = fsFromStart;
2159 pb.ioParam.ioPosOffset = rangeStart;
2160 result = PBUnlockRangeSync(&pb);
2161 require_noerr(result, PBUnlockRangeSync);
2162
2163 PBUnlockRangeSync:
2164
2165 return ( result );
2166 }
2167
2168 /*****************************************************************************/
2169
2170 OSErr
2171 FSGetDirAccess(
2172 const FSRef *ref,
2173 SInt32 *ownerID, /* can be NULL */
2174 SInt32 *groupID, /* can be NULL */
2175 SInt32 *accessRights) /* can be NULL */
2176 {
2177 OSErr result;
2178 FSSpec spec;
2179 HParamBlockRec pb;
2180
2181 /* get FSSpec from FSRef */
2182 result = FSGetCatalogInfo(ref, kFSCatInfoNone, NULL, NULL, &spec, NULL);
2183 require_noerr(result, FSGetCatalogInfo);
2184
2185 /* get directory access info for FSSpec */
2186 pb.accessParam.ioNamePtr = (StringPtr)spec.name;
2187 pb.accessParam.ioVRefNum = spec.vRefNum;
2188 pb.fileParam.ioDirID = spec.parID;
2189 result = PBHGetDirAccessSync(&pb);
2190 require_noerr(result, PBHGetDirAccessSync);
2191
2192 /* return the IDs and access rights */
2193 if ( NULL != ownerID )
2194 {
2195 *ownerID = pb.accessParam.ioACOwnerID;
2196 }
2197 if ( NULL != groupID )
2198 {
2199 *groupID = pb.accessParam.ioACGroupID;
2200 }
2201 if ( NULL != accessRights )
2202 {
2203 *accessRights = pb.accessParam.ioACAccess;
2204 }
2205
2206 PBHGetDirAccessSync:
2207 FSGetCatalogInfo:
2208
2209 return ( result );
2210 }
2211
2212 /*****************************************************************************/
2213
2214 OSErr
2215 FSSetDirAccess(
2216 const FSRef *ref,
2217 SInt32 ownerID,
2218 SInt32 groupID,
2219 SInt32 accessRights)
2220 {
2221 OSErr result;
2222 FSSpec spec;
2223 HParamBlockRec pb;
2224
2225 enum
2226 {
2227 /* Just the bits that can be set */
2228 kSetDirAccessSettableMask = (kioACAccessBlankAccessMask +
2229 kioACAccessEveryoneWriteMask + kioACAccessEveryoneReadMask + kioACAccessEveryoneSearchMask +
2230 kioACAccessGroupWriteMask + kioACAccessGroupReadMask + kioACAccessGroupSearchMask +
2231 kioACAccessOwnerWriteMask + kioACAccessOwnerReadMask + kioACAccessOwnerSearchMask)
2232 };
2233
2234 /* get FSSpec from FSRef */
2235 result = FSGetCatalogInfo(ref, kFSCatInfoNone, NULL, NULL, &spec, NULL);
2236 require_noerr(result, FSGetCatalogInfo);
2237
2238 /* set directory access info for FSSpec */
2239 pb.accessParam.ioNamePtr = (StringPtr)spec.name;
2240 pb.accessParam.ioVRefNum = spec.vRefNum;
2241 pb.fileParam.ioDirID = spec.parID;
2242 pb.accessParam.ioACOwnerID = ownerID;
2243 pb.accessParam.ioACGroupID = groupID;
2244 pb.accessParam.ioACAccess = accessRights & kSetDirAccessSettableMask;
2245 result = PBHSetDirAccessSync(&pb);
2246 require_noerr(result, PBHSetDirAccessSync);
2247
2248 PBHSetDirAccessSync:
2249 FSGetCatalogInfo:
2250
2251 return ( result );
2252 }
2253
2254 /*****************************************************************************/
2255
2256 OSErr
2257 FSGetVolMountInfoSize(
2258 FSVolumeRefNum volRefNum,
2259 SInt16 *size)
2260 {
2261 OSErr result;
2262 ParamBlockRec pb;
2263
2264 /* check parameters */
2265 require_action(NULL != size, BadParameter, result = paramErr);
2266
2267 pb.ioParam.ioNamePtr = NULL;
2268 pb.ioParam.ioVRefNum = volRefNum;
2269 pb.ioParam.ioBuffer = (Ptr)size;
2270 result = PBGetVolMountInfoSize(&pb);
2271 require_noerr(result, PBGetVolMountInfoSize);
2272
2273 PBGetVolMountInfoSize:
2274 BadParameter:
2275
2276 return ( result );
2277 }
2278
2279 /*****************************************************************************/
2280
2281 OSErr
2282 FSGetVolMountInfo(
2283 FSVolumeRefNum volRefNum,
2284 void *volMountInfo)
2285 {
2286 OSErr result;
2287 ParamBlockRec pb;
2288
2289 /* check parameters */
2290 require_action(NULL != volMountInfo, BadParameter, result = paramErr);
2291
2292 pb.ioParam.ioNamePtr = NULL;
2293 pb.ioParam.ioVRefNum = volRefNum;
2294 pb.ioParam.ioBuffer = (Ptr)volMountInfo;
2295 result = PBGetVolMountInfo(&pb);
2296 require_noerr(result, PBGetVolMountInfo);
2297
2298 PBGetVolMountInfo:
2299 BadParameter:
2300
2301 return ( result );
2302 }
2303
2304 /*****************************************************************************/
2305
2306 OSErr
2307 FSVolumeMount(
2308 const void *volMountInfo,
2309 FSVolumeRefNum *volRefNum)
2310 {
2311 OSErr result;
2312 ParamBlockRec pb;
2313
2314 /* check parameters */
2315 require_action(NULL != volRefNum, BadParameter, result = paramErr);
2316
2317 pb.ioParam.ioBuffer = (Ptr)volMountInfo;
2318 result = PBVolumeMount(&pb);
2319 require_noerr(result, PBVolumeMount);
2320
2321 /* return the volume reference number */
2322 *volRefNum = pb.ioParam.ioVRefNum;
2323
2324 PBVolumeMount:
2325 BadParameter:
2326
2327 return ( result );
2328 }
2329
2330 /*****************************************************************************/
2331
2332 OSErr
2333 FSMapID(
2334 FSVolumeRefNum volRefNum,
2335 SInt32 ugID,
2336 SInt16 objType,
2337 Str31 name)
2338 {
2339 OSErr result;
2340 HParamBlockRec pb;
2341
2342 /* check parameters */
2343 require_action(NULL != name, BadParameter, result = paramErr);
2344
2345 pb.objParam.ioNamePtr = NULL;
2346 pb.objParam.ioVRefNum = volRefNum;
2347 pb.objParam.ioObjType = objType;
2348 pb.objParam.ioObjNamePtr = name;
2349 pb.objParam.ioObjID = ugID;
2350 result = PBHMapIDSync(&pb);
2351 require_noerr(result, PBHMapIDSync);
2352
2353 PBHMapIDSync:
2354 BadParameter:
2355
2356 return ( result );
2357 }
2358
2359 /*****************************************************************************/
2360
2361 OSErr
2362 FSMapName(
2363 FSVolumeRefNum volRefNum,
2364 ConstStr255Param name,
2365 SInt16 objType,
2366 SInt32 *ugID)
2367 {
2368 OSErr result;
2369 HParamBlockRec pb;
2370
2371 /* check parameters */
2372 require_action(NULL != ugID, BadParameter, result = paramErr);
2373
2374 pb.objParam.ioNamePtr = NULL;
2375 pb.objParam.ioVRefNum = volRefNum;
2376 pb.objParam.ioObjType = objType;
2377 pb.objParam.ioObjNamePtr = (StringPtr)name;
2378 result = PBHMapNameSync(&pb);
2379 require_noerr(result, PBHMapNameSync);
2380
2381 /* return the user or group ID */
2382 *ugID = pb.objParam.ioObjID;
2383
2384 PBHMapNameSync:
2385 BadParameter:
2386
2387 return ( result );
2388 }
2389
2390 /*****************************************************************************/
2391
2392 OSErr
2393 FSCopyFile(
2394 const FSRef *srcFileRef,
2395 const FSRef *dstDirectoryRef,
2396 UniCharCount nameLength,
2397 const UniChar *copyName, /* can be NULL (no rename during copy) */
2398 TextEncoding textEncodingHint,
2399 FSRef *newRef) /* can be NULL */
2400 {
2401 OSErr result;
2402 FSSpec srcFileSpec;
2403 FSCatalogInfo catalogInfo;
2404 HParamBlockRec pb;
2405 Str31 hfsName;
2406 GetVolParmsInfoBuffer volParmsInfo;
2407 UInt32 infoSize;
2408
2409 /* get source FSSpec from source FSRef */
2410 result = FSGetCatalogInfo(srcFileRef, kFSCatInfoNone, NULL, NULL, &srcFileSpec, NULL);
2411 require_noerr(result, FSGetCatalogInfo_srcFileRef);
2412
2413 /* Make sure the volume supports CopyFile */
2414 result = FSGetVolParms(srcFileSpec.vRefNum, sizeof(GetVolParmsInfoBuffer),
2415 &volParmsInfo, &infoSize);
2416 require_action((noErr == result) && VolHasCopyFile(&volParmsInfo),
2417 NoCopyFileSupport, result = paramErr);
2418
2419 /* get destination volume reference number and destination directory ID from destination FSRef */
2420 result = FSGetCatalogInfo(dstDirectoryRef, kFSCatInfoVolume + kFSCatInfoNodeID,
2421 &catalogInfo, NULL, NULL, NULL);
2422 require_noerr(result, FSGetCatalogInfo_dstDirectoryRef);
2423
2424 /* tell the server to copy the object */
2425 pb.copyParam.ioVRefNum = srcFileSpec.vRefNum;
2426 pb.copyParam.ioDirID = srcFileSpec.parID;
2427 pb.copyParam.ioNamePtr = (StringPtr)srcFileSpec.name;
2428 pb.copyParam.ioDstVRefNum = catalogInfo.volume;
2429 pb.copyParam.ioNewDirID = (long)catalogInfo.nodeID;
2430 pb.copyParam.ioNewName = NULL;
2431 if ( NULL != copyName )
2432 {
2433 result = UnicodeNameGetHFSName(nameLength, copyName, textEncodingHint, false, hfsName);
2434 require_noerr(result, UnicodeNameGetHFSName);
2435
2436 pb.copyParam.ioCopyName = hfsName;
2437 }
2438 else
2439 {
2440 pb.copyParam.ioCopyName = NULL;
2441 }
2442 result = PBHCopyFileSync(&pb);
2443 require_noerr(result, PBHCopyFileSync);
2444
2445 if ( NULL != newRef )
2446 {
2447 verify_noerr(FSMakeFSRef(pb.copyParam.ioDstVRefNum, pb.copyParam.ioNewDirID,
2448 pb.copyParam.ioCopyName, newRef));
2449 }
2450
2451 PBHCopyFileSync:
2452 UnicodeNameGetHFSName:
2453 FSGetCatalogInfo_dstDirectoryRef:
2454 NoCopyFileSupport:
2455 FSGetCatalogInfo_srcFileRef:
2456
2457 return ( result );
2458 }
2459
2460 /*****************************************************************************/
2461
2462 OSErr
2463 FSMoveRename(
2464 const FSRef *srcFileRef,
2465 const FSRef *dstDirectoryRef,
2466 UniCharCount nameLength,
2467 const UniChar *moveName, /* can be NULL (no rename during move) */
2468 TextEncoding textEncodingHint,
2469 FSRef *newRef) /* can be NULL */
2470 {
2471 OSErr result;
2472 FSSpec srcFileSpec;
2473 FSCatalogInfo catalogInfo;
2474 HParamBlockRec pb;
2475 Str31 hfsName;
2476 GetVolParmsInfoBuffer volParmsInfo;
2477 UInt32 infoSize;
2478
2479 /* get source FSSpec from source FSRef */
2480 result = FSGetCatalogInfo(srcFileRef, kFSCatInfoNone, NULL, NULL, &srcFileSpec, NULL);
2481 require_noerr(result, FSGetCatalogInfo_srcFileRef);
2482
2483 /* Make sure the volume supports MoveRename */
2484 result = FSGetVolParms(srcFileSpec.vRefNum, sizeof(GetVolParmsInfoBuffer),
2485 &volParmsInfo, &infoSize);
2486 require_action((noErr == result) && VolHasMoveRename(&volParmsInfo),
2487 NoMoveRenameSupport, result = paramErr);
2488
2489 /* get destination volume reference number and destination directory ID from destination FSRef */
2490 result = FSGetCatalogInfo(dstDirectoryRef, kFSCatInfoVolume + kFSCatInfoNodeID,
2491 &catalogInfo, NULL, NULL, NULL);
2492 require_noerr(result, FSGetCatalogInfo_dstDirectoryRef);
2493
2494 /* make sure the source and destination are on the same volume */
2495 require_action(srcFileSpec.vRefNum == catalogInfo.volume, NotSameVolume, result = diffVolErr);
2496
2497 /* tell the server to move and rename the object */
2498 pb.copyParam.ioVRefNum = srcFileSpec.vRefNum;
2499 pb.copyParam.ioDirID = srcFileSpec.parID;
2500 pb.copyParam.ioNamePtr = (StringPtr)srcFileSpec.name;
2501 pb.copyParam.ioNewDirID = (long)catalogInfo.nodeID;
2502 pb.copyParam.ioNewName = NULL;
2503 if ( NULL != moveName )
2504 {
2505 result = UnicodeNameGetHFSName(nameLength, moveName, textEncodingHint, false, hfsName);
2506 require_noerr(result, UnicodeNameGetHFSName);
2507
2508 pb.copyParam.ioCopyName = hfsName;
2509 }
2510 else
2511 {
2512 pb.copyParam.ioCopyName = NULL;
2513 }
2514 result = PBHMoveRenameSync(&pb);
2515 require_noerr(result, PBHMoveRenameSync);
2516
2517 if ( NULL != newRef )
2518 {
2519 verify_noerr(FSMakeFSRef(pb.copyParam.ioVRefNum, pb.copyParam.ioNewDirID,
2520 pb.copyParam.ioCopyName, newRef));
2521 }
2522
2523 PBHMoveRenameSync:
2524 UnicodeNameGetHFSName:
2525 NotSameVolume:
2526 FSGetCatalogInfo_dstDirectoryRef:
2527 NoMoveRenameSupport:
2528 FSGetCatalogInfo_srcFileRef:
2529
2530 return ( result );
2531 }
2532
2533 /*****************************************************************************/
2534
2535 #pragma mark ----- File ID Routines -----
2536
2537 /*****************************************************************************/
2538
2539 OSErr
2540 FSResolveFileIDRef(
2541 FSVolumeRefNum volRefNum,
2542 SInt32 fileID,
2543 FSRef *ref)
2544 {
2545 OSErr result;
2546 FIDParam pb;
2547 Str255 tempStr;
2548
2549 /* check parameters */
2550 require_action(NULL != ref, BadParameter, result = paramErr);
2551
2552 /* resolve the file ID reference */
2553 tempStr[0] = 0;
2554 pb.ioNamePtr = tempStr;
2555 pb.ioVRefNum = volRefNum;
2556 pb.ioFileID = fileID;
2557 result = PBResolveFileIDRefSync((HParmBlkPtr)&pb);
2558 require_noerr(result, PBResolveFileIDRefSync);
2559
2560 /* and then make an FSRef to the file */
2561 result = FSMakeFSRef(volRefNum, pb.ioSrcDirID, tempStr, ref);
2562 require_noerr(result, FSMakeFSRef);
2563
2564 FSMakeFSRef:
2565 PBResolveFileIDRefSync:
2566 BadParameter:
2567
2568 return ( result );
2569 }
2570
2571 /*****************************************************************************/
2572
2573 OSErr
2574 FSCreateFileIDRef(
2575 const FSRef *ref,
2576 SInt32 *fileID)
2577 {
2578 OSErr result;
2579 FSSpec spec;
2580 FIDParam pb;
2581
2582 /* check parameters */
2583 require_action(NULL != fileID, BadParameter, result = paramErr);
2584
2585 /* Get an FSSpec from the FSRef */
2586 result = FSGetCatalogInfo(ref, kFSCatInfoNone, NULL, NULL, &spec, NULL);
2587 require_noerr(result, FSGetCatalogInfo);
2588
2589 /* Create (or get) the file ID reference using the FSSpec */
2590 pb.ioNamePtr = (StringPtr)spec.name;
2591 pb.ioVRefNum = spec.vRefNum;
2592 pb.ioSrcDirID = spec.parID;
2593 result = PBCreateFileIDRefSync((HParmBlkPtr)&pb);
2594 require((noErr == result) || (fidExists == result) || (afpIDExists == result),
2595 PBCreateFileIDRefSync);
2596
2597 /* return the file ID reference */
2598 *fileID = pb.ioFileID;
2599
2600 PBCreateFileIDRefSync:
2601 FSGetCatalogInfo:
2602 BadParameter:
2603
2604 return ( result );
2605 }
2606
2607 /*****************************************************************************/
2608
2609 #pragma mark ----- Utility Routines -----
2610
2611 /*****************************************************************************/
2612
2613 Ptr
2614 GetTempBuffer(
2615 ByteCount buffReqSize,
2616 ByteCount *buffActSize)
2617 {
2618 enum
2619 {
2620 kSlopMemory = 0x00008000 /* 32K - Amount of free memory to leave when allocating buffers */
2621 };
2622
2623 Ptr tempPtr;
2624
2625 /* check parameters */
2626 require_action(NULL != buffActSize, BadParameter, tempPtr = NULL);
2627
2628 /* Make request a multiple of 4K bytes */
2629 buffReqSize = buffReqSize & 0xfffff000;
2630
2631 if ( buffReqSize < 0x00001000 )
2632 {
2633 /* Request was smaller than 4K bytes - make it 4K */
2634 buffReqSize = 0x00001000;
2635 }
2636
2637 /* Attempt to allocate the memory */
2638 tempPtr = NewPtr(buffReqSize);
2639
2640 /* If request failed, go to backup plan */
2641 if ( (tempPtr == NULL) && (buffReqSize > 0x00001000) )
2642 {
2643 /*
2644 ** Try to get largest 4K byte block available
2645 ** leaving some slop for the toolbox if possible
2646 */
2647 long freeMemory = (FreeMem() - kSlopMemory) & 0xfffff000;
2648
2649 buffReqSize = MaxBlock() & 0xfffff000;
2650
2651 if ( (long)buffReqSize > freeMemory )
2652 {
2653 buffReqSize = freeMemory;
2654 }
2655
2656 if ( buffReqSize == 0 )
2657 {
2658 buffReqSize = 0x00001000;
2659 }
2660
2661 tempPtr = NewPtr(buffReqSize);
2662 }
2663
2664 /* Return bytes allocated */
2665 if ( tempPtr != NULL )
2666 {
2667 *buffActSize = buffReqSize;
2668 }
2669 else
2670 {
2671 *buffActSize = 0;
2672 }
2673
2674 BadParameter:
2675
2676 return ( tempPtr );
2677 }
2678
2679 /*****************************************************************************/
2680
2681 OSErr
2682 FileRefNumGetFSRef(
2683 short refNum,
2684 FSRef *ref)
2685 {
2686 return ( FSGetForkCBInfo(refNum, 0, NULL, NULL, NULL, ref, NULL) );
2687 }
2688
2689 /*****************************************************************************/
2690
2691 OSErr
2692 FSSetDefault(
2693 const FSRef *newDefault,
2694 FSRef *oldDefault)
2695 {
2696 OSErr result;
2697 FSVolumeRefNum vRefNum;
2698 long dirID;
2699 FSCatalogInfo catalogInfo;
2700
2701 /* check parameters */
2702 require_action((NULL != newDefault) && (NULL != oldDefault), BadParameter, result = paramErr);
2703
2704 /* Get nodeFlags, vRefNum and dirID (nodeID) of newDefault */
2705 result = FSGetCatalogInfo(newDefault,
2706 kFSCatInfoNodeFlags + kFSCatInfoVolume + kFSCatInfoNodeID,
2707 &catalogInfo, NULL, NULL, NULL);
2708 require_noerr(result, FSGetCatalogInfo);
2709
2710 /* Make sure newDefault is a directory */
2711 require_action(0 != (kFSNodeIsDirectoryMask & catalogInfo.nodeFlags), NewDefaultNotDirectory,
2712 result = dirNFErr);
2713
2714 /* Get the current working directory. */
2715 result = HGetVol(NULL, &vRefNum, &dirID);
2716 require_noerr(result, HGetVol);
2717
2718 /* Return the oldDefault FSRef */
2719 result = FSMakeFSRef(vRefNum, dirID, NULL, oldDefault);
2720 require_noerr(result, FSMakeFSRef);
2721
2722 /* Set the new current working directory */
2723 result = HSetVol(NULL, catalogInfo.volume, catalogInfo.nodeID);
2724 require_noerr(result, HSetVol);
2725
2726 HSetVol:
2727 FSMakeFSRef:
2728 HGetVol:
2729 NewDefaultNotDirectory:
2730 FSGetCatalogInfo:
2731 BadParameter:
2732
2733 return ( result );
2734 }
2735
2736 /*****************************************************************************/
2737
2738 OSErr
2739 FSRestoreDefault(
2740 const FSRef *oldDefault)
2741 {
2742 OSErr result;
2743 FSCatalogInfo catalogInfo;
2744
2745 /* check parameters */
2746 require_action(NULL != oldDefault, BadParameter, result = paramErr);
2747
2748 /* Get nodeFlags, vRefNum and dirID (nodeID) of oldDefault */
2749 result = FSGetCatalogInfo(oldDefault,
2750 kFSCatInfoNodeFlags + kFSCatInfoVolume + kFSCatInfoNodeID,
2751 &catalogInfo, NULL, NULL, NULL);
2752 require_noerr(result, FSGetCatalogInfo);
2753
2754 /* Make sure oldDefault is a directory */
2755 require_action(0 != (kFSNodeIsDirectoryMask & catalogInfo.nodeFlags), OldDefaultNotDirectory,
2756 result = dirNFErr);
2757
2758 /* Set the current working directory to oldDefault */
2759 result = HSetVol(NULL, catalogInfo.volume, catalogInfo.nodeID);
2760 require_noerr(result, HSetVol);
2761
2762 HSetVol:
2763 OldDefaultNotDirectory:
2764 FSGetCatalogInfo:
2765 BadParameter:
2766
2767 return ( result );
2768 }
2769
2770 /*****************************************************************************/
wxWidgets (Impactor)