src/mac/morefile/Director.cpp

   1 /*
   2 **      Apple Macintosh Developer Technical Support
   3 **
   4 **      DirectoryCopy: A robust, general purpose directory copy routine.
   5 **
   6 **      by Jim Luther, Apple Developer Technical Support Emeritus
   7 **
   8 **      File:           DirectoryCopy.c
   9 **
  10 **      Copyright © 1992-1998 Apple Computer, Inc.
  11 **      All rights reserved.
  12 **
  13 **      You may incorporate this sample code into your applications without
  14 **      restriction, though the sample code has been provided "AS IS" and the
  15 **      responsibility for its operation is 100% yours.  However, what you are
  16 **      not permitted to do is to redistribute the source as "DSC Sample Code"
  17 **      after having made changes. If you're going to re-distribute the source,
  18 **      we require that you make it clear in the source that the code was
  19 **      descended from Apple Sample Code, but that you've made changes.
  20 */
  21
  22 #include <Types.h>
  23 #include <Errors.h>
  24 #include <Memory.h>
  25 #include <Files.h>
  26 #include <Script.h>
  27
  28 #define __COMPILINGMOREFILES
  29
  30 #include "MoreFile.h"
  31 #include "MoreExtr.h"
  32 #include "MoreDesk.h"
  33 #include "FileCopy.h"
  34 #include "Director.h"
  35
  36 /*****************************************************************************/
  37
  38 /* local constants */
  39
  40 enum
  41 {
  42         dirCopyBigCopyBuffSize  = 0x00004000,
  43         dirCopyMinCopyBuffSize  = 0x00000200
  44 };
  45
  46
  47 /*****************************************************************************/
  48
  49 /* local data structures */
  50
  51 /* The EnumerateGlobals structure is used to minimize the amount of
  52 ** stack space used when recursively calling CopyLevel and to hold
  53 ** global information that might be needed at any time. */
  54
  55 #if PRAGMA_ALIGN_SUPPORTED
  56 #pragma options align=mac68k
  57 #endif
  58 struct EnumerateGlobals
  59 {
  60         Ptr                     copyBuffer;                     /* pointer to buffer used for file copy operations */
  61         long            bufferSize;                     /* the size of the copy buffer */
  62         CopyErrProcPtr errorHandler;    /* pointer to error handling function */
  63         CopyFilterProcPtr copyFilterProc; /* pointer to filter function */
  64         OSErr           error;                          /* temporary holder of results - saves 2 bytes of stack each level */
  65         Boolean         bailout;                        /* set to true to by error handling function if fatal error */
  66         short           destinationVRefNum;     /* the destination vRefNum */
  67         Str63           itemName;                       /* the name of the current item */
  68         CInfoPBRec      myCPB;                          /* the parameter block used for PBGetCatInfo calls */
  69 };
  70 #if PRAGMA_ALIGN_SUPPORTED
  71 #pragma options align=reset
  72 #endif
  73
  74 typedef struct EnumerateGlobals EnumerateGlobals;
  75 typedef EnumerateGlobals *EnumerateGlobalsPtr;
  76
  77
  78 /* The PreflightGlobals structure is used to minimize the amount of
  79 ** stack space used when recursively calling GetLevelSize and to hold
  80 ** global information that might be needed at any time. */
  81
  82 #if PRAGMA_ALIGN_SUPPORTED
  83 #pragma options align=mac68k
  84 #endif
  85 struct PreflightGlobals
  86 {
  87         OSErr                   result;                         /* temporary holder of results - saves 2 bytes of stack each level */
  88         Str63                   itemName;                       /* the name of the current item */
  89         CInfoPBRec              myCPB;                          /* the parameter block used for PBGetCatInfo calls */
  90
  91         unsigned long   dstBlksPerAllocBlk;     /* the number of 512 byte blocks per allocation block on destination */
  92
  93         unsigned long   allocBlksNeeded;        /* the total number of allocation blocks needed  */
  94
  95         unsigned long   tempBlocks;                     /* temporary storage for calculations (save some stack space)  */
  96         CopyFilterProcPtr copyFilterProc;       /* pointer to filter function */
  97 };
  98 #if PRAGMA_ALIGN_SUPPORTED
  99 #pragma options align=reset
 100 #endif
 101
 102 typedef struct PreflightGlobals PreflightGlobals;
 103 typedef PreflightGlobals *PreflightGlobalsPtr;
 104
 105 /*****************************************************************************/
 106
 107 /* static prototypes */
 108
 109 static  void    GetLevelSize(long currentDirID,
 110                                                          PreflightGlobals *theGlobals);
 111
 112 static  OSErr   PreflightDirectoryCopySpace(short srcVRefNum,
 113                                                                                         long srcDirID,
 114                                                                                         short dstVRefNum,
 115                                                                                         CopyFilterProcPtr copyFilterProc,
 116                                                                                         Boolean *spaceOK);
 117
 118 static  void    CopyLevel(long sourceDirID,
 119                                                   long dstDirID,
 120                                                   EnumerateGlobals *theGlobals);
 121
 122 /*****************************************************************************/
 123
 124 static  void    GetLevelSize(long currentDirID,
 125                                                          PreflightGlobals *theGlobals)
 126 {
 127         short   index = 1;
 128
 129         do
 130         {
 131                 theGlobals->myCPB.dirInfo.ioFDirIndex = index;
 132                 theGlobals->myCPB.dirInfo.ioDrDirID = currentDirID;     /* we need to do this every time */
 133                                                                                                                         /* through, since GetCatInfo  */
 134                                                                                                                         /* returns ioFlNum in this field */
 135                 theGlobals->result = PBGetCatInfoSync(&theGlobals->myCPB);
 136                 if ( theGlobals->result == noErr )
 137                 {
 138                         if ( (theGlobals->copyFilterProc == NULL) ||
 139                                  CallCopyFilterProc(theGlobals->copyFilterProc, &theGlobals->myCPB) ) /* filter if filter proc was supplied */
 140                         {
 141                                 /* Either there's no filter proc OR the filter proc says to use this item */
 142                                 if ( (theGlobals->myCPB.dirInfo.ioFlAttrib & ioDirMask) != 0 )
 143                                 {
 144                                         /* we have a directory */
 145
 146                                         GetLevelSize(theGlobals->myCPB.dirInfo.ioDrDirID, theGlobals); /* recurse */
 147                                         theGlobals->result = noErr; /* clear error return on way back */
 148                                 }
 149                                 else
 150                                 {
 151                                         /* We have a file - add its allocation blocks to allocBlksNeeded. */
 152                                         /* Since space on Mac OS disks is always allocated in allocation blocks, */
 153                                         /* this takes into account rounding up to the end of an allocation block. */
 154
 155                                         /* get number of 512-byte blocks needed for data fork */
 156                                         if ( ((unsigned long)theGlobals->myCPB.hFileInfo.ioFlLgLen & 0x000001ff) != 0 )
 157                                         {
 158                                                 theGlobals->tempBlocks = ((unsigned long)theGlobals->myCPB.hFileInfo.ioFlLgLen >> 9) + 1;
 159                                         }
 160                                         else
 161                                         {
 162                                                 theGlobals->tempBlocks = (unsigned long)theGlobals->myCPB.hFileInfo.ioFlLgLen >> 9;
 163                                         }
 164                                         /* now, calculate number of new allocation blocks needed for the data fork and add it to the total */
 165                                         if ( theGlobals->tempBlocks % theGlobals->dstBlksPerAllocBlk )
 166                                         {
 167                                                 theGlobals->allocBlksNeeded += (theGlobals->tempBlocks / theGlobals->dstBlksPerAllocBlk) + 1;
 168                                         }
 169                                         else
 170                                         {
 171                                                 theGlobals->allocBlksNeeded += theGlobals->tempBlocks / theGlobals->dstBlksPerAllocBlk;
 172                                         }
 173
 174                                         /* get number of 512-byte blocks needed for resource fork */
 175                                         if ( ((unsigned long)theGlobals->myCPB.hFileInfo.ioFlRLgLen & 0x000001ff) != 0 )
 176                                         {
 177                                                 theGlobals->tempBlocks = ((unsigned long)theGlobals->myCPB.hFileInfo.ioFlRLgLen >> 9) + 1;
 178                                         }
 179                                         else
 180                                         {
 181                                                 theGlobals->tempBlocks = (unsigned long)theGlobals->myCPB.hFileInfo.ioFlRLgLen >> 9;
 182                                         }
 183                                         /* now, calculate number of new allocation blocks needed for the resource  fork and add it to the total */
 184                                         if ( theGlobals->tempBlocks % theGlobals->dstBlksPerAllocBlk )
 185                                         {
 186                                                 theGlobals->allocBlksNeeded += (theGlobals->tempBlocks / theGlobals->dstBlksPerAllocBlk) + 1;
 187                                         }
 188                                         else
 189                                         {
 190                                                 theGlobals->allocBlksNeeded += theGlobals->tempBlocks / theGlobals->dstBlksPerAllocBlk;
 191                                         }
 192                                 }
 193                         }
 194                 }
 195                 ++index;
 196         } while ( theGlobals->result == noErr );
 197 }
 198
 199 /*****************************************************************************/
 200
 201 static  OSErr   PreflightDirectoryCopySpace(short srcVRefNum,
 202                                                                                         long srcDirID,
 203                                                                                         short dstVRefNum,
 204                                                                                         CopyFilterProcPtr copyFilterProc,
 205                                                                                         Boolean *spaceOK)
 206 {
 207         XVolumeParam pb;
 208         OSErr error;
 209         unsigned long dstFreeBlocks;
 210         PreflightGlobals theGlobals;
 211
 212         error = XGetVolumeInfoNoName(NULL, dstVRefNum, &pb);
 213         if ( error == noErr )
 214         {
 215                 /* Convert freeBytes to free disk blocks (512-byte blocks) */
 216                 dstFreeBlocks = (pb.ioVFreeBytes.hi << 23) + (pb.ioVFreeBytes.lo >> 9);
 217
 218                 /* get allocation block size (always multiple of 512) and divide by 512
 219                   to get number of 512-byte blocks per allocation block */
 220                 theGlobals.dstBlksPerAllocBlk = ((unsigned long)pb.ioVAlBlkSiz >> 9);
 221
 222                 theGlobals.allocBlksNeeded = 0;
 223
 224                 theGlobals.myCPB.dirInfo.ioNamePtr = theGlobals.itemName;
 225                 theGlobals.myCPB.dirInfo.ioVRefNum = srcVRefNum;
 226
 227                 theGlobals.copyFilterProc = copyFilterProc;
 228
 229                 GetLevelSize(srcDirID, &theGlobals);
 230
 231                 /* Is there enough room on the destination volume for the source file?                                  */
 232                 /* Note:        This will work because the largest number of disk blocks supported                      */
 233                 /*                      on a 2TB volume is 0xffffffff and (allocBlksNeeded * dstBlksPerAllocBlk)        */
 234                 /*                      will always be less than 0xffffffff.                                                                            */
 235                 *spaceOK = ((theGlobals.allocBlksNeeded * theGlobals.dstBlksPerAllocBlk) <= dstFreeBlocks);
 236         }
 237
 238         return ( error );
 239 }
 240
 241 /*****************************************************************************/
 242
 243 static  void    CopyLevel(long sourceDirID,
 244                                                   long dstDirID,
 245                                                   EnumerateGlobals *theGlobals)
 246 {
 247         long currentSrcDirID;
 248         long newDirID;
 249         short index = 1;
 250
 251         do
 252         {
 253                 /* Get next source item at the current directory level */
 254
 255                 theGlobals->myCPB.dirInfo.ioFDirIndex = index;
 256                 theGlobals->myCPB.dirInfo.ioDrDirID = sourceDirID;
 257                 theGlobals->error = PBGetCatInfoSync(&theGlobals->myCPB);
 258
 259                 if ( theGlobals->error == noErr )
 260                 {
 261                         if ( (theGlobals->copyFilterProc == NULL) ||
 262                                  CallCopyFilterProc(theGlobals->copyFilterProc, &theGlobals->myCPB) ) /* filter if filter proc was supplied */
 263                         {
 264                                 /* Either there's no filter proc OR the filter proc says to use this item */
 265
 266                                 /* We have an item.  Is it a file or directory? */
 267                                 if ( (theGlobals->myCPB.hFileInfo.ioFlAttrib & ioDirMask) != 0 )
 268                                 {
 269                                         /* We have a directory */
 270
 271                                         /* Create a new directory at the destination. No errors allowed! */
 272                                         theGlobals->error = DirCreate(theGlobals->destinationVRefNum, dstDirID, theGlobals->itemName, &newDirID);
 273                                         if ( theGlobals->error == noErr )
 274                                         {
 275                                                 /* Save the current source directory ID where we can get it when we come back
 276                                                 ** from recursion land. */
 277                                                 currentSrcDirID = theGlobals->myCPB.dirInfo.ioDrDirID;
 278
 279                                                 /* Dive again (copy the directory level we just found below this one) */
 280                                                 CopyLevel(theGlobals->myCPB.dirInfo.ioDrDirID, newDirID, theGlobals);
 281
 282                                                 if ( !theGlobals->bailout )
 283                                                 {
 284                                                         /* Copy comment from old to new directory. */
 285                                                         /* Ignore the result because we really don't care if it worked or not. */
 286                                                         (void) DTCopyComment(theGlobals->myCPB.dirInfo.ioVRefNum, currentSrcDirID, NULL, theGlobals->destinationVRefNum, newDirID, NULL);
 287
 288                                                         /* Copy directory attributes (dates, etc.) to newDirID. */
 289                                                         /* No errors allowed */
 290                                                         theGlobals->error = CopyFileMgrAttributes(theGlobals->myCPB.dirInfo.ioVRefNum, currentSrcDirID, NULL, theGlobals->destinationVRefNum, newDirID, NULL, true);
 291
 292                                                         /* handle any errors from CopyFileMgrAttributes */
 293                                                         if ( theGlobals->error != noErr )
 294                                                         {
 295                                                                 if ( theGlobals->errorHandler != NULL )
 296                                                                 {
 297                                                                         theGlobals->bailout =  CallCopyErrProc(theGlobals->errorHandler, theGlobals->error, copyDirFMAttributesOp,
 298                                                                                                                         theGlobals->myCPB.dirInfo.ioVRefNum, currentSrcDirID, NULL,
 299                                                                                                                         theGlobals->destinationVRefNum, newDirID, NULL);
 300                                                                 }
 301                                                                 else
 302                                                                 {
 303                                                                         /* If you don't handle the errors with an error handler, */
 304                                                                         /* then the copy stops here. */
 305                                                                         theGlobals->bailout = true;
 306                                                                 }
 307                                                         }
 308                                                 }
 309                                         }
 310                                         else    /* error handling for DirCreate */
 311                                         {
 312                                                 if ( theGlobals->errorHandler != NULL )
 313                                                 {
 314                                                         theGlobals->bailout = CallCopyErrProc(theGlobals->errorHandler, theGlobals->error, dirCreateOp,
 315                                                                                                                 theGlobals->myCPB.dirInfo.ioVRefNum, currentSrcDirID, NULL,
 316                                                                                                                 theGlobals->destinationVRefNum, dstDirID, theGlobals->itemName);
 317                                                 }
 318                                                 else
 319                                                 {
 320                                                         /* If you don't handle the errors with an error handler, */
 321                                                         /* then the copy stops here. */
 322                                                         theGlobals->bailout = true;
 323                                                 }
 324                                         }
 325
 326                                         if ( !theGlobals->bailout )
 327                                         {
 328                                                 /* clear error return on way back if we aren't bailing out */
 329                                                 theGlobals->error = noErr;
 330                                         }
 331                                 }
 332                                 else
 333                                 {
 334                                         /* We have a file, so copy it */
 335
 336                                         theGlobals->error = FileCopy(theGlobals->myCPB.hFileInfo.ioVRefNum,
 337                                                                                                  theGlobals->myCPB.hFileInfo.ioFlParID,
 338                                                                                                  theGlobals->itemName,
 339                                                                                                  theGlobals->destinationVRefNum,
 340                                                                                                  dstDirID,
 341                                                                                                  NULL,
 342                                                                                                  NULL,
 343                                                                                                  theGlobals->copyBuffer,
 344                                                                                                  theGlobals->bufferSize,
 345                                                                                                  false);
 346
 347                                         /* handle any errors from FileCopy */
 348                                         if ( theGlobals->error != noErr )
 349                                         {
 350                                                 if ( theGlobals->errorHandler != NULL )
 351                                                 {
 352                                                         theGlobals->bailout = CallCopyErrProc(theGlobals->errorHandler, theGlobals->error, fileCopyOp,
 353                                                                                                         theGlobals->myCPB.hFileInfo.ioVRefNum, theGlobals->myCPB.hFileInfo.ioFlParID, theGlobals->itemName,
 354                                                                                                         theGlobals->destinationVRefNum, dstDirID, NULL);
 355                                                         if ( !theGlobals->bailout )
 356                                                         {
 357                                                                 /* If the CopyErrProc handled the problem, clear the error here */
 358                                                                 theGlobals->error = noErr;
 359                                                         }
 360                                                 }
 361                                                 else
 362                                                 {
 363                                                         /* If you don't handle the errors with an error handler, */
 364                                                         /* then the copy stops here. */
 365                                                         theGlobals->bailout = true;
 366                                                 }
 367                                         }
 368                                 }
 369                         }
 370                 }
 371                 else
 372                 {       /* error handling for PBGetCatInfo */
 373                         /* it's normal to get a fnfErr when indexing; that only means you've hit the end of the directory */
 374                         if ( theGlobals->error != fnfErr )
 375                         {
 376                                 if ( theGlobals->errorHandler != NULL )
 377                                 {
 378                                         theGlobals->bailout = CallCopyErrProc(theGlobals->errorHandler, theGlobals->error, getNextItemOp,
 379                                                                                         theGlobals->myCPB.dirInfo.ioVRefNum, sourceDirID, NULL, 0, 0, NULL);
 380                                         if ( !theGlobals->bailout )
 381                                         {
 382                                                 /* If the CopyErrProc handled the problem, clear the error here */
 383                                                 theGlobals->error = noErr;
 384                                         }
 385                                 }
 386                                 else
 387                                 {
 388                                         /* If you don't handle the errors with an error handler, */
 389                                         /* then the copy stops here. */
 390                                         theGlobals->bailout = true;
 391                                 }
 392                         }
 393                 }
 394                 ++index; /* prepare to get next item */
 395         } while ( (theGlobals->error == noErr) && (!theGlobals->bailout) ); /* time to fall back a level? */
 396 }
 397
 398 /*****************************************************************************/
 399
 400 pascal  OSErr   FilteredDirectoryCopy(short srcVRefNum,
 401                                                                           long srcDirID,
 402                                                                           ConstStr255Param srcName,
 403                                                                           short dstVRefNum,
 404                                                                           long dstDirID,
 405                                                                           ConstStr255Param dstName,
 406                                                                           void *copyBufferPtr,
 407                                                                           long copyBufferSize,
 408                                                                           Boolean preflight,
 409                                                                           CopyErrProcPtr copyErrHandler,
 410                                                                           CopyFilterProcPtr copyFilterProc)
 411 {
 412         EnumerateGlobals theGlobals;
 413         Boolean isDirectory;
 414         OSErr   error;
 415         Boolean ourCopyBuffer = false;
 416         Str63   srcDirName, oldDiskName;
 417         Boolean spaceOK;
 418
 419         /* Make sure a copy buffer is allocated. */
 420         if ( copyBufferPtr == NULL )
 421         {
 422                 /* The caller didn't supply a copy buffer so grab one from the application heap.
 423                 ** Try to get a big copy buffer, if we can't, try for a 512-byte buffer.
 424                 ** If 512 bytes aren't available, we're in trouble. */
 425                 copyBufferSize = dirCopyBigCopyBuffSize;
 426                 copyBufferPtr = NewPtr(copyBufferSize);
 427                 if ( copyBufferPtr == NULL )
 428                 {
 429                         copyBufferSize = dirCopyMinCopyBuffSize;
 430                         copyBufferPtr = NewPtr(copyBufferSize);
 431                         if ( copyBufferPtr == NULL )
 432                         {
 433                                 return ( memFullErr );
 434                         }
 435                 }
 436                 ourCopyBuffer = true;
 437         }
 438
 439         /* Get the real dirID where we're copying from and make sure it is a directory. */
 440         error = GetDirectoryID(srcVRefNum, srcDirID, srcName, &srcDirID, &isDirectory);
 441         if ( error != noErr )
 442         {
 443                 goto ErrorExit;
 444         }
 445         if ( !isDirectory )
 446         {
 447                 error = dirNFErr;
 448                 goto ErrorExit;
 449         }
 450
 451         /* Special case destination if it is the root parent directory. */
 452         /* Since you can't create the root directory, this is needed if */
 453         /* you want to copy a directory's content to a disk's root directory. */
 454         if ( (dstDirID == fsRtParID) && (dstName == NULL) )
 455         {
 456                 dstDirID = fsRtParID;
 457                 isDirectory = true;
 458                 error = noErr;
 459         }
 460         else
 461         {
 462                 /*  Get the real dirID where we're going to put the copy and make sure it is a directory. */
 463                 error = GetDirectoryID(dstVRefNum, dstDirID, dstName, &dstDirID, &isDirectory);
 464                 if ( error != noErr )
 465                 {
 466                         goto ErrorExit;
 467                 }
 468                 if ( !isDirectory )
 469                 {
 470                         error =  dirNFErr;
 471                         goto ErrorExit;
 472                 }
 473         }
 474
 475         /* Get the real vRefNum of both the source and destination */
 476         error = DetermineVRefNum(srcName, srcVRefNum, &srcVRefNum);
 477         if ( error != noErr )
 478         {
 479                 goto ErrorExit;
 480         }
 481         error = DetermineVRefNum(dstName, dstVRefNum, &dstVRefNum);
 482         if ( error != noErr )
 483         {
 484                 goto ErrorExit;
 485         }
 486
 487         if ( preflight )
 488         {
 489                 error = PreflightDirectoryCopySpace(srcVRefNum, srcDirID, dstVRefNum, copyFilterProc, &spaceOK);
 490                 if ( error != noErr )
 491                 {
 492                         goto ErrorExit;
 493                 }
 494                 if ( !spaceOK )
 495                 {
 496                         error = dskFulErr; /* not enough room on destination */
 497                         goto ErrorExit;
 498                 }
 499         }
 500
 501         /* Create the new directory in the destination directory with the */
 502         /* same name as the source directory. */
 503         error = GetDirName(srcVRefNum, srcDirID, srcDirName);
 504         if ( error != noErr )
 505         {
 506                 goto ErrorExit;
 507         }
 508
 509         /* Again, special case destination if the destination is the */
 510         /* root parent directory. This time, we'll rename the disk to */
 511         /* the source directory name. */
 512         if ( dstDirID == fsRtParID )
 513         {
 514                 /* Get the current name of the destination disk */
 515                 error = GetDirName(dstVRefNum, fsRtDirID, oldDiskName);
 516                 if ( error == noErr )
 517                 {
 518                         /* Shorten the name if it's too long to be the volume name */
 519                         TruncPString(srcDirName, srcDirName, 27);
 520
 521                         /* Rename the disk */
 522                         error = HRename(dstVRefNum, fsRtParID, oldDiskName, srcDirName);
 523                         /* and copy to the root directory */
 524                         dstDirID = fsRtDirID;
 525                 }
 526         }
 527         else
 528         {
 529                 error = DirCreate(dstVRefNum, dstDirID, srcDirName, &dstDirID);
 530         }
 531         if ( error != noErr )
 532         {
 533                 /* handle any errors from DirCreate */
 534                 if ( copyErrHandler != NULL )
 535                 {
 536                         if ( CallCopyErrProc(copyErrHandler, error, dirCreateOp,
 537                                                                                                         srcVRefNum, srcDirID, NULL,
 538                                                                                                         dstVRefNum, dstDirID, srcDirName) )
 539                         {
 540                                 goto ErrorExit;
 541                         }
 542                         else
 543                         {
 544                                 /* If the CopyErrProc handled the problem, clear the error here */
 545                                 /* and continue */
 546                                 error = noErr;
 547                         }
 548                 }
 549                 else
 550                 {
 551                         /* If you don't handle the errors with an error handler, */
 552                         /* then the copy stops here. */
 553                         goto ErrorExit;
 554                 }
 555         }
 556
 557         /* dstDirID is now the newly created directory! */
 558
 559         /* Set up the globals we need to access from the recursive routine. */
 560         theGlobals.copyBuffer = (Ptr)copyBufferPtr;
 561         theGlobals.bufferSize = copyBufferSize;
 562         theGlobals.destinationVRefNum = dstVRefNum; /* so we can get to it always */
 563         theGlobals.myCPB.hFileInfo.ioNamePtr = (StringPtr)&theGlobals.itemName;
 564         theGlobals.myCPB.hFileInfo.ioVRefNum = srcVRefNum;
 565         theGlobals.errorHandler = copyErrHandler;
 566         theGlobals.bailout = false;
 567         theGlobals.copyFilterProc =  copyFilterProc;
 568
 569         /* Here we go into recursion land... */
 570         CopyLevel(srcDirID, dstDirID, &theGlobals);
 571         error = theGlobals.error;       /* get the result */
 572
 573         if ( !theGlobals.bailout )
 574         {
 575                 /* Copy comment from source to destination directory. */
 576                 /* Ignore the result because we really don't care if it worked or not. */
 577                 (void) DTCopyComment(srcVRefNum, srcDirID, NULL, dstVRefNum, dstDirID, NULL);
 578
 579                 /* Copy the File Manager attributes */
 580                 error = CopyFileMgrAttributes(srcVRefNum, srcDirID, NULL,
 581                                         dstVRefNum, dstDirID, NULL, true);
 582
 583                 /* handle any errors from CopyFileMgrAttributes */
 584                 if ( (error != noErr) && (copyErrHandler != NULL) )
 585                 {
 586                         theGlobals.bailout = CallCopyErrProc(copyErrHandler, error, copyDirFMAttributesOp,
 587                                                                                                 srcVRefNum, srcDirID, NULL,
 588                                                                                                 dstVRefNum, dstDirID, NULL);
 589                 }
 590         }
 591
 592 ErrorExit:
 593         /* Get rid of the copy buffer if we allocated it. */
 594         if ( ourCopyBuffer )
 595         {
 596                 DisposePtr((Ptr)copyBufferPtr);
 597         }
 598
 599         return ( error );
 600 }
 601
 602 /*****************************************************************************/
 603
 604 pascal  OSErr   DirectoryCopy(short srcVRefNum,
 605                                                           long srcDirID,
 606                                                           ConstStr255Param srcName,
 607                                                           short dstVRefNum,
 608                                                           long dstDirID,
 609                                                           ConstStr255Param dstName,
 610                                                           void *copyBufferPtr,
 611                                                           long copyBufferSize,
 612                                                           Boolean preflight,
 613                                                           CopyErrProcPtr copyErrHandler)
 614 {
 615         return ( FilteredDirectoryCopy(srcVRefNum, srcDirID, srcName,
 616                                                                    dstVRefNum, dstDirID, dstName,
 617                                                                    copyBufferPtr, copyBufferSize, preflight,
 618                                                                    copyErrHandler, NULL) );
 619 }
 620
 621 /*****************************************************************************/
 622
 623 pascal  OSErr   FSpFilteredDirectoryCopy(const FSSpec *srcSpec,
 624                                                                                  const FSSpec *dstSpec,
 625                                                                                  void *copyBufferPtr,
 626                                                                                  long copyBufferSize,
 627                                                                                  Boolean preflight,
 628                                                                                  CopyErrProcPtr copyErrHandler,
 629                                                                                  CopyFilterProcPtr copyFilterProc)
 630 {
 631         return ( FilteredDirectoryCopy(srcSpec->vRefNum, srcSpec->parID, srcSpec->name,
 632                                                                    dstSpec->vRefNum, dstSpec->parID, dstSpec->name,
 633                                                                    copyBufferPtr, copyBufferSize, preflight,
 634                                                                    copyErrHandler, copyFilterProc) );
 635 }
 636
 637 /*****************************************************************************/
 638
 639 pascal  OSErr   FSpDirectoryCopy(const FSSpec *srcSpec,
 640                                                                  const FSSpec *dstSpec,
 641                                                                  void *copyBufferPtr,
 642                                                                  long copyBufferSize,
 643                                                                  Boolean preflight,
 644                                                                  CopyErrProcPtr copyErrHandler)
 645 {
 646         return ( FilteredDirectoryCopy(srcSpec->vRefNum, srcSpec->parID, srcSpec->name,
 647                                                                    dstSpec->vRefNum, dstSpec->parID, dstSpec->name,
 648                                                                    copyBufferPtr, copyBufferSize, preflight,
 649                                                                    copyErrHandler, NULL) );
 650 }
 651
 652 /*****************************************************************************/
 653