CopyHFSMeta/main.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <string.h>
   5 #include <fcntl.h>
   6 #include <err.h>
   7 #include <errno.h>
   8 #include <sys/stat.h>
   9 #include <sys/disk.h>
  10 #include <sys/sysctl.h>
  11 #include <hfs/hfs_mount.h>
  12 #include "hfsmeta.h"
  13 #include "Data.h"
  14 #include "Sparse.h"
  15
  16 /*
  17  * Used to automatically run a corruption program after the
  18  * copying is done.  Only used during development.  Uncomment
  19  * to use.
  20  */
  21 //#define TESTINJECT    1
  22
  23 static const char *kAppleInternal = "/AppleInternal";
  24 static const char *kTestProgram = "HC-Inject-Errors";
  25
  26 int verbose;
  27 int debug;
  28 int printProgress;
  29
  30 /*
  31  * Exit status values.  We use some errno values because
  32  * they are convenient.
  33  * kGoodExit:  we finished copying, and no problems.
  34  * kNoSpaceExit:  Not enough space for the skeleton copy.
  35  * kCopyIOExit:  An I/O error occurred.  This may not be fatal,
  36  *      as it may just mean the source device went away.  We
  37  *      can continue later, perhaps.
  38  * kIntrExit:  The copying was interrupted.  As above, this may
  39  *      not be fatal.
  40  * kBadExit:  Any other problem.
  41  */
  42 enum {
  43         kGoodExit = 0,
  44         kNoSpaceExit = ENOSPC,
  45         kCopyIOExit = EIO,
  46         kIntrExit = EINTR,
  47         kBadExit = 1,
  48 };
  49
  50 /*
  51  * Open the source device.  In addition to opening the device,
  52  * this also attempts to flush the journal, and then sets up a
  53  * DeviceInfo_t object that will be used when doing the actual
  54  * reading.
  55  */
  56 static DeviceInfo_t *
  57 OpenDevice(const char *devname)
  58 {
  59         char *rawname;
  60         DeviceInfo_t *retval = NULL;
  61         int fd;
  62         DeviceInfo_t dev = { 0 };
  63         struct stat sb;
  64         struct vfsconf vfc;
  65
  66         if (stat(devname, &sb) == -1) {
  67                 err(kBadExit, "cannot open device %s", devname);
  68         }
  69         /*
  70          * We only allow a character device (e.g., /dev/rdisk1s2)
  71          * If we're given a non-character device, we'll try to turn
  72          * into a character device assuming a name pattern of /dev/rdisk*
  73          */
  74         if ((sb.st_mode & S_IFMT) == S_IFCHR) {
  75                 dev.devname = strdup(devname);
  76         } else if (strncmp(devname, "/dev/disk", 9) == 0) {
  77                 // Turn "/dev/diskFoo" into "/dev/rdiskFoo"
  78                 char tmpname[strlen(devname) + 2];
  79                 (void)snprintf(tmpname, sizeof(tmpname), "/dev/rdisk%s", devname + sizeof("/dev/disk") - 1);
  80                 if (stat(tmpname, &sb) == -1) {
  81                         err(kBadExit, "cannot open raw device %s", tmpname);
  82                 }
  83                 if ((sb.st_mode & S_IFMT) != S_IFCHR) {
  84                         errx(kBadExit, "raw device %s is not a raw device", tmpname);
  85                 }
  86                 dev.devname = strdup(tmpname);
  87         } else {
  88                 errx(kBadExit, "device name `%s' does not fit pattern", devname);
  89         }
  90         // Only use an exclusive open if we're not debugging.
  91         fd = open(dev.devname, O_RDWR | (debug ? 0 : O_EXLOCK));
  92         if (fd == -1) {
  93                 err(kBadExit, "cannot open raw device %s", dev.devname);
  94         }
  95         // Get the block size and counts for the device.
  96         if (ioctl(fd, DKIOCGETBLOCKSIZE, &dev.blockSize) == -1) {
  97                 dev.blockSize = 512;    // Sane default, I hope
  98         }
  99         if (ioctl(fd, DKIOCGETBLOCKCOUNT, &dev.blockCount) == -1) {
 100                 err(kBadExit, "cannot get size of device %s", dev.devname);
 101         }
 102         /*
 103          * Attempt to flush the journal.  If it fails, we just warn, but don't abort.
 104          */
 105         if (getvfsbyname("hfs", &vfc) == 0) {
 106                 int rv;
 107                 int mib[4];
 108
 109                 mib[0] = CTL_VFS;
 110                 mib[1] = vfc.vfc_typenum;
 111                 mib[2] = HFS_REPLAY_JOURNAL;
 112                 mib[3] = fd;
 113                 if (debug)
 114                         fprintf(stderr, "about to replay journal\n");
 115                 rv = sysctl(mib, 4, NULL, NULL, NULL, 0);
 116                 if (rv == -1) {
 117                         warn("cannot replay journal");
 118                 }
 119                 /* This is probably not necessary, but we couldn't prove it. */
 120                 (void)fcntl(fd, F_FULLFSYNC, 0);
 121         }
 122
 123         dev.size = dev.blockCount * dev.blockSize;
 124         dev.fd = fd;
 125
 126         retval = malloc(sizeof(*retval));
 127         if (retval == NULL) {
 128                 err(kBadExit, "cannot allocate device info structure");
 129         }
 130         *retval = dev;
 131         return retval;
 132 }
 133
 134 /*
 135  * Get the header and alternate header for a device.
 136  */
 137 VolumeDescriptor_t *
 138 VolumeInfo(DeviceInfo_t *devp)
 139 {
 140         uint8_t buffer[devp->blockSize];
 141         VolumeDescriptor_t *vdp = NULL, vd = { 0 };
 142         ssize_t rv;
 143
 144         vd.priOffset = 1024;    // primary volume header is at 1024 bytes
 145         vd.altOffset = devp->size - 1024;       // alternate header is 1024 bytes from the end
 146
 147         rv = GetBlock(devp, vd.priOffset, buffer);
 148         if (rv == -1) {
 149                 err(kBadExit, "cannot get primary volume header for device %s", devp->devname);
 150         }
 151         vd.priHeader = *(HFSPlusVolumeHeader*)buffer;
 152
 153         rv = GetBlock(devp, vd.altOffset, buffer);
 154         if (rv == -1) {
 155                 err(kBadExit, "cannot get alternate volume header for device %s", devp->devname);
 156         }
 157         vd.altHeader = *(HFSPlusVolumeHeader*)buffer;
 158
 159         vdp = malloc(sizeof(*vdp));
 160         *vdp = vd;
 161
 162         return vdp;
 163 }
 164
 165 /*
 166  * Compare two volume headers to see if they're the same.  Some fields
 167  * we may not care about, so we only compare specific fields.  Note that
 168  * since we're looking for equality, we don't need to byte swap.
 169  */
 170 int
 171 CompareVolumeHeaders(HFSPlusVolumeHeader *left, HFSPlusVolumeHeader *right)
 172 {
 173         if (left->signature != right->signature ||
 174             left->version != right->version ||
 175             left->modifyDate != right->modifyDate ||
 176             left->fileCount != right->fileCount ||
 177             left->folderCount != right->folderCount ||
 178             left->nextAllocation != right->nextAllocation ||
 179             left->nextCatalogID != right->nextCatalogID ||
 180             left->writeCount != right->writeCount)
 181                 return 0;
 182         return 1;
 183 }
 184
 185 /*
 186  * Only two (currently) types of signatures are valid: H+ and HX.
 187  */
 188 static int
 189 IsValidSigWord(uint16_t word) {
 190         if (word == kHFSPlusSigWord ||
 191             word == kHFSXSigWord)
 192                 return 1;
 193         return 0;
 194 }
 195
 196 /*
 197  * Add the volume headers to the in-core volume information list.
 198  */
 199 int
 200 AddHeaders(VolumeObjects_t *vop)
 201 {
 202         int retval = 1;
 203         HFSPlusVolumeHeader *hp;
 204         uint8_t buffer[vop->devp->blockSize];
 205         ssize_t rv;
 206
 207         hp = &vop->vdp->priHeader;
 208
 209         if (IsValidSigWord(S16(hp->signature)) == 0) {
 210                 warnx("primary volume header signature = %x, invalid", S16(hp->signature));
 211                 retval = 0;
 212         }
 213         AddExtent(vop, 1024, 512);
 214
 215         hp = &vop->vdp->altHeader;
 216
 217         if (IsValidSigWord(S16(hp->signature)) == 0) {
 218                 warnx("alternate volume header signature = %x, invalid", S16(hp->signature));
 219                 retval = 0;
 220         }
 221         AddExtent(vop, vop->vdp->altOffset, 512);
 222
 223 done:
 224         return retval;
 225 }
 226
 227 /*
 228  * Add the journal information to the in-core volume list.
 229  * This means the journal info block, the journal itself, and
 230  * the contents of the same as described by the alternate volume
 231  * header (if it's different from the primary volume header).
 232  */
 233 void
 234 AddJournal(VolumeObjects_t *vop)
 235 {
 236         DeviceInfo_t *devp = vop->devp;
 237         uint8_t buffer[devp->blockSize];
 238         ssize_t rv;
 239         HFSPlusVolumeHeader *php, *ahp;
 240         JournalInfoBlock *jib;
 241
 242         php = &vop->vdp->priHeader;
 243         ahp = &vop->vdp->altHeader;
 244
 245         if (php->journalInfoBlock) {
 246                 off_t jOffset = (off_t)S32(php->journalInfoBlock) * S32(php->blockSize);
 247                 rv = GetBlock(devp, jOffset, buffer);
 248                 if (rv == -1) {
 249                         err(kBadExit, "cannot get primary header's copy of journal info block");
 250                 }
 251                 AddExtent(vop, jOffset, sizeof(buffer));
 252                 jib = (JournalInfoBlock*)buffer;
 253                 if (S32(jib->flags) & kJIJournalInFSMask) {
 254                         AddExtent(vop, S64(jib->offset), S64(jib->size));
 255                 }
 256         }
 257
 258         if (ahp->journalInfoBlock &&
 259             ahp->journalInfoBlock != php->journalInfoBlock) {
 260                 off_t jOffset = (off_t)S32(ahp->journalInfoBlock) * S32(ahp->blockSize);
 261                 rv = GetBlock(devp, jOffset, buffer);
 262                 if (rv == -1) {
 263                         err(kBadExit, "cannot get alternate header's copy of journal info block");
 264                 }
 265                 AddExtent(vop, jOffset, sizeof(buffer));
 266                 jib = (JournalInfoBlock*)buffer;
 267                 if (S32(jib->flags) & kJIJournalInFSMask) {
 268                         AddExtent(vop, S64(jib->offset), S64(jib->size));
 269                 }
 270         }
 271
 272 }
 273
 274 /*
 275  * Add the extents for the special files in the volume header.  Compare
 276  * them with the alternate volume header's versions, and if they're different,
 277  * add that as well.
 278  */
 279 void
 280 AddFileExtents(VolumeObjects_t *vop)
 281 {
 282         int useAlt = 0;
 283 #define ADDEXTS(vop, file) \
 284         do { \
 285                 off_t pSize = S32(vop->vdp->priHeader.blockSize);       \
 286                 off_t aSize = S32(vop->vdp->altHeader.blockSize);       \
 287                 int i;                                                  \
 288                 if (debug) printf("Adding " #file " extents\n");                \
 289                 for (i = 0; i < kHFSPlusExtentDensity; i++) {           \
 290                         HFSPlusExtentDescriptor *ep = &vop->vdp->priHeader. file .extents[i]; \
 291                         HFSPlusExtentDescriptor *ap = &vop->vdp->altHeader. file .extents[i]; \
 292                         if (debug) printf("\tExtent <%u, %u>\n", S32(ep->startBlock), S32(ep->blockCount)); \
 293                         if (ep->startBlock && ep->blockCount) {         \
 294                                 AddExtent(vop, S32(ep->startBlock) * pSize, S32(ep->blockCount) * pSize); \
 295                                 if (memcmp(ep, ap, sizeof(*ep)) != 0) { \
 296                                         AddExtent(vop, S32(ap->startBlock) * aSize, S32(ap->blockCount) * aSize); \
 297                                         useAlt = 1;                     \
 298                                 }                                       \
 299                         }                                               \
 300                 }                                                       \
 301         } while (0)
 302
 303         ADDEXTS(vop, allocationFile);
 304         ADDEXTS(vop, extentsFile);
 305         ADDEXTS(vop, catalogFile);
 306         ADDEXTS(vop, attributesFile);
 307         ADDEXTS(vop, startupFile);
 308
 309 #undef ADDEXTS
 310
 311         ScanExtents(vop, 0);
 312         if (useAlt)
 313                 ScanExtents(vop, useAlt);
 314
 315         return;
 316 }
 317
 318 static void
 319 usage(const char *progname)
 320 {
 321
 322         errx(kBadExit, "usage: %s [-vdpS] [-g gatherFile] [-r <bytes>] <src device> <destination>", progname);
 323 }
 324
 325
 326 main(int ac, char **av)
 327 {
 328         char *src = NULL;
 329         char *dst = NULL;
 330         DeviceInfo_t *devp = NULL;
 331         VolumeDescriptor_t *vdp = NULL;
 332         VolumeObjects_t *vop = NULL;
 333         IOWrapper_t *wrapper = NULL;
 334         int ch;
 335         off_t restart = 0;
 336         int printEstimate = 0;
 337         const char *progname = av[0];
 338         char *gather = NULL;
 339         int force = 0;
 340         int retval = kGoodExit;
 341
 342         while ((ch = getopt(ac, av, "fvdg:Spr:")) != -1) {
 343                 switch (ch) {
 344                 case 'v':       verbose++; break;
 345                 case 'd':       debug++; verbose++; break;
 346                 case 'S':       printEstimate = 1; break;
 347                 case 'p':       printProgress = 1; break;
 348                 case 'r':       restart = strtoull(optarg, NULL, 0); break;
 349                 case 'g':       gather = strdup(optarg); break;
 350                 case 'f':       force = 1; break;
 351                 default:        usage(progname);
 352                 }
 353         }
 354
 355         ac -= optind;
 356         av += optind;
 357
 358         if (ac == 0 || ac > 2) {
 359                 usage(progname);
 360         }
 361         src = av[0];
 362         if (ac == 2)
 363                 dst = av[1];
 364
 365         // Start by opening the input device
 366         devp = OpenDevice(src);
 367         if (devp == NULL) {
 368                 errx(kBadExit, "cannot get device information for %s", src);
 369         }
 370
 371         // Get the volume information.
 372         vdp = VolumeInfo(devp);
 373
 374         // Start creating the in-core volume list
 375         vop = InitVolumeObject(devp, vdp);
 376
 377         // Add the volume headers
 378         if (AddHeaders(vop) == 0) {
 379                 errx(kBadExit, "Invalid volume header(s) for %s", src);
 380         }
 381         // Add the journal and file extents
 382         AddJournal(vop);
 383         AddFileExtents(vop);
 384
 385         if (debug)
 386                 PrintVolumeObject(vop);
 387
 388         if (printEstimate) {
 389                 printf("Estimate %llu\n", vop->byteCount);
 390         }
 391
 392         // Create a gatherHFS-compatible file, if requested.
 393         if (gather) {
 394                 WriteGatheredData(gather, vop);
 395         }
 396
 397         /*
 398          * If we're given a destination, initialize it.
 399          */
 400         if (dst) {
 401                 wrapper = InitSparseBundle(dst, devp);
 402         }
 403
 404         if (wrapper) {
 405                 // See if we're picking up from a previous copy
 406                 if (restart == 0) {
 407                         restart = wrapper->getprog(wrapper);
 408                         if (debug) {
 409                                 fprintf(stderr, "auto-restarting at offset %lld\n", restart);
 410                         }
 411                 }
 412                 // "force" in this case means try even if the space estimate says we won't succeed.
 413                 if (force == 0) {
 414                         struct statfs sfs;
 415                         if (statfs(dst, &sfs) != -1) {
 416                                 off_t freeSpace = (off_t)sfs.f_bsize * (off_t)sfs.f_bfree;
 417                                 if (freeSpace < (vop->byteCount - restart)) {
 418                                         errx(kNoSpaceExit, "free space (%lld) < required space (%lld)", freeSpace, vop->byteCount - restart);
 419                                 }
 420                         }
 421                 }
 422
 423                 /*
 424                  * If we're restarting, we need to compare the volume headers and see if
 425                  * they're the same.  If they're not, we need to start from the beginning.
 426                  */
 427                 if (restart) {
 428                         HFSPlusVolumeHeader priHeader, altHeader;
 429
 430                         if (wrapper->reader(wrapper, 1024, &priHeader, sizeof(priHeader)) != -1) {
 431                                 if (CompareVolumeHeaders(&priHeader, &vop->vdp->priHeader) == 0) {
 432                                         restart = 0;
 433                                 } else {
 434                                         if (wrapper->reader(wrapper, vop->vdp->altOffset, &altHeader, sizeof(altHeader)) != -1) {
 435                                                 if (CompareVolumeHeaders(&altHeader, &vop->vdp->altHeader) == 0) {
 436                                                         restart = 0;
 437                                                 }
 438                                         }
 439                                 }
 440                         }
 441                         if (restart == 0) {
 442                                 if (verbose)
 443                                         warnx("Destination volume does not match source, starting from beginning");
 444                         }
 445                 }
 446
 447                 // And start copying the objects.
 448                 if (CopyObjectsToDest(vop, wrapper, restart) == -1) {
 449                         if (errno == EIO)
 450                                 retval = kCopyIOExit;
 451                         else if (errno == EINTR)
 452                                 retval = kIntrExit;
 453                         else
 454                                 retval = kBadExit;
 455                         err(retval, "CopyObjectsToDest failed");
 456                 } else {
 457 #if TESTINJECT
 458                         // Copy finished, let's see if we should run a test program
 459                         if (access(kAppleInternal, 0) != -1) {
 460                                 char *home = getenv("HOME");
 461                                 if (home) {
 462                                         char *pName;
 463                                         pName = malloc(strlen(home) + strlen(kTestProgram) + 2);        // '/' and NUL
 464                                         if (pName) {
 465                                                 sprintf(pName, "%s/%s", home, kTestProgram);
 466                                                 execl(pName, kTestProgram, dst, NULL);
 467                                         }
 468                                 }
 469                         }
 470 #endif
 471                 }
 472         }
 473
 474         return retval;
 475 }
 476