[apple/hfs.git] / CopyHFSMeta / main.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <err.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/disk.h>
#include <sys/sysctl.h>
#include <hfs/hfs_mount.h>
#include "hfsmeta.h"
#include "Data.h"
#include "Sparse.h"

/*
 * Used to automatically run a corruption program after the
 * copying is done.  Only used during development.  Uncomment
 * to use.
 */
//#define TESTINJECT	1

static const char *kAppleInternal = "/AppleInternal";
static const char *kTestProgram = "HC-Inject-Errors";

int verbose;
int debug;
int printProgress;

/*
 * Exit status values.  We use some errno values because
 * they are convenient.
 * kGoodExit:  we finished copying, and no problems.
 * kNoSpaceExit:  Not enough space for the skeleton copy.
 * kCopyIOExit:  An I/O error occurred.  This may not be fatal,
 *	as it may just mean the source device went away.  We
 *	can continue later, perhaps.
 * kIntrExit:  The copying was interrupted.  As above, this may
 *	not be fatal.
 * kBadExit:  Any other problem.
 */
enum {
	kGoodExit = 0,
	kNoSpaceExit = ENOSPC,
	kCopyIOExit = EIO,
	kIntrExit = EINTR,
	kBadExit = 1,
};

/*
 * Open the source device.  In addition to opening the device,
 * this also attempts to flush the journal, and then sets up a
 * DeviceInfo_t object that will be used when doing the actual
 * reading.
 */
static DeviceInfo_t *
OpenDevice(const char *devname)
{
	char *rawname;
	DeviceInfo_t *retval = NULL;
	int fd;
	DeviceInfo_t dev = { 0 };
	struct stat sb;
	struct vfsconf vfc;

	if (stat(devname, &sb) == -1) {
		err(kBadExit, "cannot open device %s", devname);
	}
	/*
	 * Attempt to flush the journal.  If it fails, we just warn, but don't abort.
	 */
	if (getvfsbyname("hfs", &vfc) == 0) {
		int rv;
		int mib[4];
		char block_device[MAXPATHLEN+1];
		int jfd;

		/*
		 * The journal replay code, sadly, requires a block device.
		 * So we need to go from the raw device to block device, if
		 * necessary.
		 */
		if (strncmp(devname, "/dev/rdisk", 10) == 0) {
			snprintf(block_device, sizeof(block_device), "/dev/%s", devname+6);
		} else {
			snprintf(block_device, sizeof(block_device), "%s", devname);
		}
		jfd = open(block_device, O_RDWR);
		if (jfd == -1) {
			warn("Cannot open block device %s for read-write", block_device);
		} else {
			mib[0] = CTL_VFS;
			mib[1] = vfc.vfc_typenum;
			mib[2] = HFS_REPLAY_JOURNAL;
			mib[3] = jfd;
			if (debug)
				fprintf(stderr, "about to replay journal\n");
			rv = sysctl(mib, 4, NULL, NULL, NULL, 0);
			if (rv == -1) {
				warn("cannot replay journal");
			}
			/* This is probably not necessary, but we couldn't prove it. */
			(void)fcntl(jfd, F_FULLFSYNC, 0);
			close(jfd);
		}
	}
	/*
	 * We only allow a character device (e.g., /dev/rdisk1s2)
	 * If we're given a non-character device, we'll try to turn
	 * into a character device assuming a name pattern of /dev/rdisk*
	 */
	if ((sb.st_mode & S_IFMT) == S_IFCHR) {
		dev.devname = strdup(devname);
	} else if (strncmp(devname, "/dev/disk", 9) == 0) {
		// Turn "/dev/diskFoo" into "/dev/rdiskFoo"
		char tmpname[strlen(devname) + 2];
		(void)snprintf(tmpname, sizeof(tmpname), "/dev/rdisk%s", devname + sizeof("/dev/disk") - 1);
		if (stat(tmpname, &sb) == -1) {
			err(kBadExit, "cannot open raw device %s", tmpname);
		}
		if ((sb.st_mode & S_IFMT) != S_IFCHR) {
			errx(kBadExit, "raw device %s is not a raw device", tmpname);
		}
		dev.devname = strdup(tmpname);
	} else {
		errx(kBadExit, "device name `%s' does not fit pattern", devname);
	}
	// Only use an exclusive open if we're not debugging.
	fd = open(dev.devname, O_RDWR | (debug ? 0 : O_EXLOCK));
	if (fd == -1) {
		err(kBadExit, "cannot open raw device %s", dev.devname);
	}
	// Get the block size and counts for the device.
	if (ioctl(fd, DKIOCGETBLOCKSIZE, &dev.blockSize) == -1) {
		dev.blockSize = 512;	// Sane default, I hope
	}
	if (ioctl(fd, DKIOCGETBLOCKCOUNT, &dev.blockCount) == -1) {
		err(kBadExit, "cannot get size of device %s", dev.devname);
	}

	dev.size = dev.blockCount * dev.blockSize;
	dev.fd = fd;

	retval = malloc(sizeof(*retval));
	if (retval == NULL) {
		err(kBadExit, "cannot allocate device info structure");
	}
	*retval = dev;
	return retval;
}

/*
 * Get the header and alternate header for a device.
 */
VolumeDescriptor_t *
VolumeInfo(DeviceInfo_t *devp)
{
	uint8_t buffer[devp->blockSize];
	VolumeDescriptor_t *vdp = NULL, vd = { 0 };
	ssize_t rv;

	vd.priOffset = 1024;	// primary volume header is at 1024 bytes
	vd.altOffset = devp->size - 1024;	// alternate header is 1024 bytes from the end

	rv = GetBlock(devp, vd.priOffset, buffer);
	if (rv == -1) {
		err(kBadExit, "cannot get primary volume header for device %s", devp->devname);
	}
	vd.priHeader = *(HFSPlusVolumeHeader*)buffer;

	rv = GetBlock(devp, vd.altOffset, buffer);
	if (rv == -1) {
		err(kBadExit, "cannot get alternate volume header for device %s", devp->devname);
	}
	vd.altHeader = *(HFSPlusVolumeHeader*)buffer;

	vdp = malloc(sizeof(*vdp));
	*vdp = vd;

	return vdp;
}

/*
 * Compare two volume headers to see if they're the same.  Some fields
 * we may not care about, so we only compare specific fields.  Note that
 * since we're looking for equality, we don't need to byte swap.
 */
int
CompareVolumeHeaders(HFSPlusVolumeHeader *left, HFSPlusVolumeHeader *right)
{
	if (left->signature != right->signature ||
	    left->version != right->version ||
	    left->modifyDate != right->modifyDate ||
	    left->fileCount != right->fileCount ||
	    left->folderCount != right->folderCount ||
	    left->nextAllocation != right->nextAllocation ||
	    left->nextCatalogID != right->nextCatalogID ||
	    left->writeCount != right->writeCount)
		return 0;
	return 1;
}

/*
 * Only two (currently) types of signatures are valid: H+ and HX.
 */
static int
IsValidSigWord(uint16_t word) {
	if (word == kHFSPlusSigWord ||
	    word == kHFSXSigWord)
		return 1;
	return 0;
}

/*
 * Add the volume headers to the in-core volume information list.
 */
int
AddHeaders(VolumeObjects_t *vop)
{
	int retval = 1;
	HFSPlusVolumeHeader *hp;
	uint8_t buffer[vop->devp->blockSize];
	ssize_t rv;

	hp = &vop->vdp->priHeader;

	if (IsValidSigWord(S16(hp->signature)) == 0) {
		warnx("primary volume header signature = %x, invalid", S16(hp->signature));
		retval = 0;
	}
	AddExtent(vop, 1024, 512);

	hp = &vop->vdp->altHeader;

	if (IsValidSigWord(S16(hp->signature)) == 0) {
		warnx("alternate volume header signature = %x, invalid", S16(hp->signature));
		retval = 0;
	}
	AddExtent(vop, vop->vdp->altOffset, 512);

done:
	return retval;
}

/*
 * Add the journal information to the in-core volume list.
 * This means the journal info block, the journal itself, and
 * the contents of the same as described by the alternate volume
 * header (if it's different from the primary volume header).
 */
void
AddJournal(VolumeObjects_t *vop)
{
	DeviceInfo_t *devp = vop->devp;
	uint8_t buffer[devp->blockSize];
	ssize_t rv;
	HFSPlusVolumeHeader *php, *ahp;
	JournalInfoBlock *jib;

	php = &vop->vdp->priHeader;
	ahp = &vop->vdp->altHeader;

	if (php->journalInfoBlock) {
		off_t jOffset = (off_t)S32(php->journalInfoBlock) * S32(php->blockSize);
		rv = GetBlock(devp, jOffset, buffer);
		if (rv == -1) {
			err(kBadExit, "cannot get primary header's copy of journal info block");
		}
		AddExtent(vop, jOffset, sizeof(buffer));
		jib = (JournalInfoBlock*)buffer;
		if (S32(jib->flags) & kJIJournalInFSMask) {
			AddExtent(vop, S64(jib->offset), S64(jib->size));
		}
	}

	if (ahp->journalInfoBlock &&
	    ahp->journalInfoBlock != php->journalInfoBlock) {
		off_t jOffset = (off_t)S32(ahp->journalInfoBlock) * S32(ahp->blockSize);
		rv = GetBlock(devp, jOffset, buffer);
		if (rv == -1) {
			err(kBadExit, "cannot get alternate header's copy of journal info block");
		}
		AddExtent(vop, jOffset, sizeof(buffer));
		jib = (JournalInfoBlock*)buffer;
		if (S32(jib->flags) & kJIJournalInFSMask) {
			AddExtent(vop, S64(jib->offset), S64(jib->size));
		}
	}

}

/*
 * Add the extents for the special files in the volume header.  Compare
 * them with the alternate volume header's versions, and if they're different,
 * add that as well.
 */
void
AddFileExtents(VolumeObjects_t *vop)
{
	int useAlt = 0;
#define ADDEXTS(vop, file) \
	do { \
		off_t pSize = S32(vop->vdp->priHeader.blockSize);	\
		off_t aSize = S32(vop->vdp->altHeader.blockSize);	\
		int i;							\
		if (debug) printf("Adding " #file " extents\n");		\
		for (i = 0; i < kHFSPlusExtentDensity; i++) {		\
			HFSPlusExtentDescriptor *ep = &vop->vdp->priHeader. file .extents[i]; \
			HFSPlusExtentDescriptor *ap = &vop->vdp->altHeader. file .extents[i]; \
			if (debug) printf("\tExtent <%u, %u>\n", S32(ep->startBlock), S32(ep->blockCount)); \
			if (ep->startBlock && ep->blockCount) {		\
				AddExtent(vop, S32(ep->startBlock) * pSize, S32(ep->blockCount) * pSize); \
				if (memcmp(ep, ap, sizeof(*ep)) != 0) { \
					AddExtent(vop, S32(ap->startBlock) * aSize, S32(ap->blockCount) * aSize); \
					useAlt = 1;			\
				}					\
			}						\
		}							\
	} while (0)

	ADDEXTS(vop, allocationFile);
	ADDEXTS(vop, extentsFile);
	ADDEXTS(vop, catalogFile);
	ADDEXTS(vop, attributesFile);
	ADDEXTS(vop, startupFile);

#undef ADDEXTS

	ScanExtents(vop, 0);
	if (useAlt)
		ScanExtents(vop, useAlt);

	return;
}

static void
usage(const char *progname)
{

	errx(kBadExit, "usage: %s [-vdpS] [-g gatherFile] [-r <bytes>] <src device> <destination>", progname);
}


main(int ac, char **av)
{
	char *src = NULL;
	char *dst = NULL;
	DeviceInfo_t *devp = NULL;
	VolumeDescriptor_t *vdp = NULL;
	VolumeObjects_t *vop = NULL;
	IOWrapper_t *wrapper = NULL;
	int ch;
	off_t restart = 0;
	int printEstimate = 0;
	const char *progname = av[0];
	char *gather = NULL;
	int force = 0;
	int retval = kGoodExit;

	while ((ch = getopt(ac, av, "fvdg:Spr:")) != -1) {
		switch (ch) {
		case 'v':	verbose++; break;
		case 'd':	debug++; verbose++; break;
		case 'S':	printEstimate = 1; break;
		case 'p':	printProgress = 1; break;
		case 'r':	restart = strtoull(optarg, NULL, 0); break;
		case 'g':	gather = strdup(optarg); break;
		case 'f':	force = 1; break;
		default:	usage(progname);
		}
	}

	ac -= optind;
	av += optind;

	if (ac == 0 || ac > 2) {
		usage(progname);
	}
	src = av[0];
	if (ac == 2)
		dst = av[1];

	// Start by opening the input device
	devp = OpenDevice(src);
	if (devp == NULL) {
		errx(kBadExit, "cannot get device information for %s", src);
	}

	// Get the volume information.
	vdp = VolumeInfo(devp);

	// Start creating the in-core volume list
	vop = InitVolumeObject(devp, vdp);

	// Add the volume headers
	if (AddHeaders(vop) == 0) {
		errx(kBadExit, "Invalid volume header(s) for %s", src);
	}
	// Add the journal and file extents
	AddJournal(vop);
	AddFileExtents(vop);

	if (debug)
		PrintVolumeObject(vop);

	if (printEstimate) {
		printf("Estimate %llu\n", vop->byteCount);
	}

	// Create a gatherHFS-compatible file, if requested.
	if (gather) {
		WriteGatheredData(gather, vop);
	}

	/*
	 * If we're given a destination, initialize it.
 	 */
	if (dst) {
		wrapper = InitSparseBundle(dst, devp);
	}

	if (wrapper) {
		// See if we're picking up from a previous copy
		if (restart == 0) {
			restart = wrapper->getprog(wrapper);
			if (debug) {
				fprintf(stderr, "auto-restarting at offset %lld\n", restart);
			}
		}
		// "force" in this case means try even if the space estimate says we won't succeed.
		if (force == 0) {
			struct statfs sfs;
			if (statfs(dst, &sfs) != -1) {
				off_t freeSpace = (off_t)sfs.f_bsize * (off_t)sfs.f_bfree;
				if (freeSpace < (vop->byteCount - restart)) {
					errx(kNoSpaceExit, "free space (%lld) < required space (%lld)", freeSpace, vop->byteCount - restart);
				}
			}
		}

		/*
		 * If we're restarting, we need to compare the volume headers and see if
		 * they're the same.  If they're not, we need to start from the beginning.
		 */
		if (restart) {
			HFSPlusVolumeHeader priHeader, altHeader;

			if (wrapper->reader(wrapper, 1024, &priHeader, sizeof(priHeader)) != -1) {
				if (CompareVolumeHeaders(&priHeader, &vop->vdp->priHeader) == 0) {
					restart = 0;
				} else {
					if (wrapper->reader(wrapper, vop->vdp->altOffset, &altHeader, sizeof(altHeader)) != -1) {
						if (CompareVolumeHeaders(&altHeader, &vop->vdp->altHeader) == 0) {
							restart = 0;
						}
					}
				}
			}
			if (restart == 0) {
				if (verbose)
					warnx("Destination volume does not match source, starting from beginning");
			}
		}

		// And start copying the objects.
		if (CopyObjectsToDest(vop, wrapper, restart) == -1) {
			if (errno == EIO)
				retval = kCopyIOExit;
			else if (errno == EINTR)
				retval = kIntrExit;
			else
				retval = kBadExit;
			err(retval, "CopyObjectsToDest failed");
		} else {
#if TESTINJECT
			// Copy finished, let's see if we should run a test program
			if (access(kAppleInternal, 0) != -1) {
				char *home = getenv("HOME");
				if (home) {
					char *pName;
					pName = malloc(strlen(home) + strlen(kTestProgram) + 2);	// '/' and NUL
					if (pName) {
						sprintf(pName, "%s/%s", home, kTestProgram);
						execl(pName, kTestProgram, dst, NULL);
					}
				}
			}
#endif
		}
	}

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