[apple/hfs.git] / tests / disk-image.m

//
//  disk-image.m
//  hfs
//
//  Created by Chris Suter on 8/12/15.
//
//

#include <unistd.h>
#include <spawn.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/mount.h>
#include <zlib.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stdbool.h>

#include <Foundation/Foundation.h>
#include <TargetConditionals.h>

#include "disk-image.h"
#include "test-utils.h"
#include "systemx.h"

#define RETRY_MAX 3

#if (TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)

#include "dmg.dat"

bool disk_image_cleanup(disk_image_t *di)
{
	pid_t pid;
	bool result = false;
	int eject_retry;
	int status;
	
	// We need to be root
	assert(seteuid(0) == 0);
	
	char *umount_args[]
		= { "umount", "-f", (char *)di->mount_point, NULL };
	
	assert_no_err(posix_spawn(&pid, "/sbin/umount", NULL, NULL, umount_args, NULL));
	
	waitpid(pid, &status, 0);
	
	char *detach_args[]
		= { "hdik", "-e", (char *)di->disk, NULL };

	posix_spawn_file_actions_t facts;
	posix_spawn_file_actions_init(&facts);
	posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);
	posix_spawn_file_actions_addopen(&facts, STDERR_FILENO, "/dev/null", O_APPEND, 0);
	
	for (eject_retry = 0; eject_retry < RETRY_MAX; ++eject_retry) {
		if (!posix_spawn(&pid, "/usr/sbin/hdik", &facts, NULL, detach_args, NULL)) {
			waitpid(pid, &status, 0);
			if (WIFEXITED(status) && !WEXITSTATUS(status))
				break;
		}
		sleep(1);
	}
	
	posix_spawn_file_actions_destroy(&facts);
	
	assert(eject_retry != RETRY_MAX);
	
	struct stat sb;
	
	if (stat(di->disk, &sb) == -1 && errno == ENOENT) {
		unlink(di->path);
		result = true;
		// We are the last user of di, so free it.
		free(di->mount_point);
		free(di->disk);
		free(di->path);
		free(di);
	}

	return result;
}

void *zalloc(__unused void *opaque, uInt items, uInt size)
{
	return malloc(items * size);
}

void zfree(__unused void *opaque, void *ptr)
{
	free(ptr);
}

disk_image_t *disk_image_create(const char *path, disk_image_opts_t *opts)
{
	disk_image_t *di;
	
	di = calloc(1, sizeof(disk_image_t));
	assert(di);
	
	// We need to be root
	uid_t uid_old;
	if ((uid_old = geteuid()) != 0) {
		assert_no_err(seteuid(0));
	}
	
	// Extract the image
	int fd = open(path, O_RDWR | O_TRUNC | O_CREAT, 0666);
	
	z_stream zs = {
		.zalloc = zalloc,
		.zfree = zfree,
	};
	
	inflateInit(&zs);
	
	size_t buf_size = 1024 * 1024;
	void *out_buf = malloc(buf_size);
	assert(out_buf);
	
	zs.next_in = data;
	zs.avail_in = sizeof(data);
	
	int ret;
	
	do {
		zs.next_out = out_buf;
		zs.avail_out = (uInt)buf_size;
		
		ret = inflate(&zs, 0);
		
		size_t todo = buf_size - zs.avail_out;
		
		assert(write(fd, out_buf, todo) == (ssize_t)todo);
	} while (ret == Z_OK);
	
	assert(ret == Z_STREAM_END);
	
	di->path = strdup(path);
	
	// Attach it
	pid_t pid;
	char *attach_args[4] = { "hdik", "-nomount", (char *)di->path, NULL };
	int fds[2];
	
	assert_no_err(pipe(fds));
	
	posix_spawn_file_actions_t actions;
	posix_spawn_file_actions_init(&actions);
	posix_spawn_file_actions_adddup2(&actions, fds[1], STDOUT_FILENO);
	
	assert_no_err(posix_spawn(&pid, "/usr/sbin/hdik", &actions, NULL, attach_args, NULL));
	
	posix_spawn_file_actions_destroy(&actions);
	
	close(fds[1]);
	
	char *line, *slice = NULL;
	size_t lnsz = 64;
	FILE *fp = fdopen(fds[0], "r");
	
	line = malloc(lnsz);
	assert(line);
	
	while (getline(&line, &lnsz, fp) != -1) {
		char *first, *second;
		
		first = strtok(line, " ");
		assert(first);
		
		second = strtok(NULL, " ");
		assert(second);
		
		if (strstr(second, "GUID"))
			di->disk = strdup(first);
		
		// The output of hdik gets truncated, so just search for the leading part of the UUID
		else if (strstr(second, "48465300-0000-11AA"))
			slice = strdup(first);
	}
	
	int status;
	assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1) == pid);
	assert(WIFEXITED(status) && !WEXITSTATUS(status));
	
	assert(di->disk && slice);
	free(line);
	fclose(fp);
	
	// Ensure we have a mount point 
	assert(opts->mount_point);

	// Mount it
	char *mkdir_args[4] = { "mkdir", "-p", (char *)opts->mount_point, NULL };
	assert_no_err(posix_spawn(&pid, "/bin/mkdir", NULL, NULL, mkdir_args, NULL));
	
	assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1) == pid);
	assert(WIFEXITED(status) && !WEXITSTATUS(status));
	
	posix_spawn_file_actions_t facts;
	posix_spawn_file_actions_init(&facts);
	posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);
	posix_spawn_file_actions_addopen(&facts, STDERR_FILENO, "/dev/null", O_APPEND, 0);
	
	char *mount_args[4] = { "mount", slice, (char *)opts->mount_point, NULL };
	assert_no_err(posix_spawn(&pid, "/sbin/mount_hfs", &facts, NULL, mount_args, NULL));
	
	posix_spawn_file_actions_destroy(&facts);
	free(slice);
	
	assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1) == pid);
	assert(WIFEXITED(status) && !WEXITSTATUS(status));
	
	di->mount_point = strdup(opts->mount_point);
	
	if (strcmp(path, SHARED_PATH)) { // Don't register a cleanup for the shared image
		test_cleanup(^ bool {
			return disk_image_cleanup(di);
		});
	}
	
	assert_no_err(seteuid(uid_old));
	
	return di;
}

disk_image_t *disk_image_get(void)
{	
	disk_image_t *di;
	struct statfs sfs;
	
	if (statfs(SHARED_MOUNT, &sfs) == 0) {
		di = calloc(1, sizeof(*di));
		di->mount_point = SHARED_MOUNT;
		di->disk = strdup(sfs.f_mntfromname);
		di->path = SHARED_PATH;

		// Make sure the di struct is freed when tests are complete.
		test_cleanup(^ bool {
			free(di->disk);
			free(di);
			return true;
		});
	} else {
		disk_image_opts_t opts = {
			.mount_point = SHARED_MOUNT
		};
		di = disk_image_create(SHARED_PATH, &opts);
		// Per the contract of disk_image_create(),
		// di will be freed when disk_image_cleanup() is called,
		// so don't free it here.
	}
	
	return di;
}

#else // !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)

bool disk_image_cleanup(disk_image_t *di)
{
	char *detach_args[]
		= { "hdiutil", "detach", (char *)di->disk, "-force", NULL };

	pid_t pid;
	bool result = false;
	int eject_retry;
	int status;

	posix_spawn_file_actions_t facts;
	posix_spawn_file_actions_init(&facts);
	posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);
	posix_spawn_file_actions_addopen(&facts, STDERR_FILENO, "/dev/null", O_APPEND, 0);

	for (eject_retry = 0; eject_retry < RETRY_MAX; ++eject_retry) {
		if (!posix_spawn(&pid, "/usr/bin/hdiutil", &facts, NULL, detach_args, NULL)) {
			waitpid(pid, &status, 0);
			if (WIFEXITED(status) && !WEXITSTATUS(status)) {
				break;
			}
		}
		sleep(1);
	}

	posix_spawn_file_actions_destroy(&facts);

	assert(eject_retry != RETRY_MAX);

	struct stat sb;

	if (stat(di->disk, &sb) == -1 && errno == ENOENT) {
		if (unlink(di->path) && errno == EACCES && !seteuid(0))
			unlink(di->path);
		result = true;

		// We are the last user of di, so free it.
		free(di->mount_point);
		free(di->disk);
		free(di->path);
		free(di);
	}

	return result;
}

disk_image_t *disk_image_create(const char *path, disk_image_opts_t *opts)
{
	pid_t pid;
	char sz[32];
	sprintf(sz, "%llu", opts->size);
	
	if (opts->mount_point) {
		assert(!systemx("/bin/mkdir", SYSTEMX_QUIET, "-p", opts->mount_point, NULL));
	}

	// Start with the basic args
	char *args[64] = { "hdiutil", "create", (char *)path, "-size", sz, "-ov" };

	if (opts && opts->partition_type) {
		args[6] = "-partitionType";
		args[7] = (char *)opts->partition_type;
		args[8] = NULL;

		posix_spawn_file_actions_t facts;
		posix_spawn_file_actions_init(&facts);
		posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);

		assert_no_err(posix_spawn(&pid, "/usr/bin/hdiutil", &facts, NULL,
								  args, NULL));

		posix_spawn_file_actions_destroy(&facts);

		int status;
		assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1));

		assert(WIFEXITED(status) && !WEXITSTATUS(status));

		args[1] = "attach";
		// args[2] == path
		args[3] = "-nomount";
		args[4] = "-plist";
		args[5] = NULL;
	} else if (opts && opts->enable_owners) {
		args[6] = "-fs";
		args[7] = "HFS+J";
		args[8] = NULL;

		posix_spawn_file_actions_t facts;
		posix_spawn_file_actions_init(&facts);
		posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);

		assert_no_err(posix_spawn(&pid, "/usr/bin/hdiutil", &facts, NULL,
								  args, NULL));

		posix_spawn_file_actions_destroy(&facts);

		int status;
		assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1));

		assert(WIFEXITED(status) && !WEXITSTATUS(status));

		args[1] = "attach";
		// args[2] == path
		args[3] = "-plist";
		args[4] = "-owners";
		args[5] = "on";
		if (opts->mount_point) {
			args[6] = "-mountpoint";
			args[7] = (char *)opts->mount_point;
			args[8] = NULL;
		}
		else
			args[6] = NULL;
	} else {
		args[6] = "-fs";
		args[7] = "HFS+J";
		args[8] = NULL;
		
		posix_spawn_file_actions_t facts;
		posix_spawn_file_actions_init(&facts);
		posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);
		
		assert_no_err(posix_spawn(&pid, "/usr/bin/hdiutil", &facts, NULL,
								  args, NULL));
		
		posix_spawn_file_actions_destroy(&facts);
		
		int status;
		assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1));
		
		assert(WIFEXITED(status) && !WEXITSTATUS(status));
		
		args[1] = "attach";
		// args[2] == path
		args[3] = "-plist";
		if (opts->mount_point) {
			args[4] = "-mountpoint";
			args[5] = (char *)opts->mount_point;
			args[6] = NULL;
		}
		else
			args[4] = NULL;
	}

	int fds[2];
	assert_no_err(pipe(fds));

	posix_spawn_file_actions_t actions;
	posix_spawn_file_actions_init(&actions);
	posix_spawn_file_actions_adddup2(&actions, fds[1], STDOUT_FILENO);

	assert_no_err(posix_spawn(&pid, "/usr/bin/hdiutil", &actions, NULL, args, NULL));

	posix_spawn_file_actions_destroy(&actions);

	close(fds[1]);

	char buffer[4096];
	size_t amt = 0;

	for (;;) {
		ssize_t res = read(fds[0], buffer + amt, 4096 - amt);

		if (!res)
			break;

		if (res == -1 && errno == EINTR)
			continue;

		assert_with_errno(res > 0);

		amt += res;

		assert(amt < 4096);
	}

	disk_image_t *di = calloc(1, sizeof(*di));

	di->path = strdup(path);

	@autoreleasepool {
		NSDictionary *results
			= [NSPropertyListSerialization propertyListWithData:
			   [NSData dataWithBytesNoCopy:buffer
									length:amt
							  freeWhenDone:NO]
														options:0
														 format:NULL
														  error:NULL];
		
		for (NSDictionary *entity in results[@"system-entities"]) {
			if (opts && opts->partition_type) {
				if (!strcmp([entity[@"unmapped-content-hint"] UTF8String],
							opts->partition_type)
					|| !strcmp([entity[@"content-hint"] UTF8String],
							   opts->partition_type)) {
					di->disk = strdup([entity[@"dev-entry"] fileSystemRepresentation]);
					break;
				}
			} else if ([entity[@"content-hint"] isEqualToString:@"Apple_HFS"]) {
				di->mount_point = strdup([entity[@"mount-point"] fileSystemRepresentation]);
				di->disk = strdup([entity[@"dev-entry"] fileSystemRepresentation]);
				break;
			}
		}
	}

	int status;
	assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1) == pid);
	assert(WIFEXITED(status) && !WEXITSTATUS(status));
	
	assert(di->disk);

	if (strcmp(path, SHARED_PATH)) { // Don't register a cleanup for the shared image
		test_cleanup(^ bool {
			return disk_image_cleanup(di);
		});
	}

	return di;
}

disk_image_t *disk_image_get(void)
{
	disk_image_t *di;
	struct statfs sfs;
	
	if (statfs(SHARED_MOUNT, &sfs) == 0) {
		di = calloc(1, sizeof(*di));
		
		di->mount_point = SHARED_MOUNT;
		di->disk = strdup(sfs.f_mntfromname);
		di->path = SHARED_PATH;

		// Make sure the di struct is freed when tests are complete.
		test_cleanup(^ bool {
			free(di->disk);
			free(di);
			return true;
		});
	} else {
		disk_image_opts_t opts = {
			.size = 4 GB,
			.mount_point = SHARED_MOUNT
		};
		di = disk_image_create(SHARED_PATH, &opts);
		// Per the contract of disk_image_create(),
		// di will be freed when disk_image_cleanup() is called,
		// so don't free it here.
	}

	return di;
}

#endif // (TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
Commit	Line	Data
558d2836 A	1	//
	2	// disk-image.m
	3	// hfs
	4	//
	5	// Created by Chris Suter on 8/12/15.
	6	//
	7	//
	8
	9	#include <unistd.h>
	10	#include <spawn.h>
	11	#include <sys/stat.h>
	12	#include <sys/param.h>
	13	#include <sys/mount.h>
	14	#include <zlib.h>
	15	#include <stdlib.h>
	16	#include <fcntl.h>
	17	#include <stdbool.h>
	18
	19	#include <Foundation/Foundation.h>
	20	#include <TargetConditionals.h>
	21
	22	#include "disk-image.h"
	23	#include "test-utils.h"
	24	#include "systemx.h"
	25
927b7b56 A	26	#define RETRY_MAX 3
927b7b56 A	27
de8ee011	28	#if (TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
558d2836 A	29
	30	#include "dmg.dat"
	31
	32	bool disk_image_cleanup(disk_image_t *di)
	33	{
	34	pid_t pid;
ec99dd30	35	bool result = false;
927b7b56 A	36	int eject_retry;
927b7b56 A	37	int status;
558d2836 A	38
	39	// We need to be root
	40	assert(seteuid(0) == 0);
	41
	42	char *umount_args[]
	43	= { "umount", "-f", (char *)di->mount_point, NULL };
	44
	45	assert_no_err(posix_spawn(&pid, "/sbin/umount", NULL, NULL, umount_args, NULL));
	46
558d2836 A	47	waitpid(pid, &status, 0);
	48
	49	char *detach_args[]
	50	= { "hdik", "-e", (char *)di->disk, NULL };
927b7b56	51
558d2836 A	52	posix_spawn_file_actions_t facts;
	53	posix_spawn_file_actions_init(&facts);
	54	posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);
	55	posix_spawn_file_actions_addopen(&facts, STDERR_FILENO, "/dev/null", O_APPEND, 0);
	56
927b7b56 A	57	for (eject_retry = 0; eject_retry < RETRY_MAX; ++eject_retry) {
	58	if (!posix_spawn(&pid, "/usr/sbin/hdik", &facts, NULL, detach_args, NULL)) {
	59	waitpid(pid, &status, 0);
	60	if (WIFEXITED(status) && !WEXITSTATUS(status))
	61	break;
	62	}
	63	sleep(1);
	64	}
558d2836 A	65
	66	posix_spawn_file_actions_destroy(&facts);
	67
927b7b56	68	assert(eject_retry != RETRY_MAX);
558d2836 A	69
	70	struct stat sb;
	71
927b7b56	72	if (stat(di->disk, &sb) == -1 && errno == ENOENT) {
558d2836	73	unlink(di->path);
ec99dd30 A	74	result = true;
	75	// We are the last user of di, so free it.
	76	free(di->mount_point);
	77	free(di->disk);
	78	free(di->path);
	79	free(di);
558d2836	80	}
ec99dd30 A	81
ec99dd30 A	82	return result;
558d2836 A	83	}
	84
	85	void zalloc(__unused void opaque, uInt items, uInt size)
	86	{
	87	return malloc(items * size);
	88	}
	89
	90	void zfree(__unused void opaque, void ptr)
	91	{
	92	free(ptr);
	93	}
	94
	95	disk_image_t disk_image_create(const char path, disk_image_opts_t *opts)
	96	{
	97	disk_image_t *di;
	98
	99	di = calloc(1, sizeof(disk_image_t));
	100	assert(di);
	101
	102	// We need to be root
	103	uid_t uid_old;
	104	if ((uid_old = geteuid()) != 0) {
	105	assert_no_err(seteuid(0));
	106	}
	107
	108	// Extract the image
	109	int fd = open(path, O_RDWR \| O_TRUNC \| O_CREAT, 0666);
	110
	111	z_stream zs = {
	112	.zalloc = zalloc,
	113	.zfree = zfree,
	114	};
	115
	116	inflateInit(&zs);
	117
	118	size_t buf_size = 1024 * 1024;
	119	void *out_buf = malloc(buf_size);
	120	assert(out_buf);
	121
	122	zs.next_in = data;
	123	zs.avail_in = sizeof(data);
	124
	125	int ret;
	126
	127	do {
	128	zs.next_out = out_buf;
927b7b56	129	zs.avail_out = (uInt)buf_size;
558d2836 A	130
	131	ret = inflate(&zs, 0);
	132
	133	size_t todo = buf_size - zs.avail_out;
	134
	135	assert(write(fd, out_buf, todo) == (ssize_t)todo);
	136	} while (ret == Z_OK);
	137
	138	assert(ret == Z_STREAM_END);
	139
	140	di->path = strdup(path);
	141
	142	// Attach it
	143	pid_t pid;
	144	char attach_args[4] = { "hdik", "-nomount", (char )di->path, NULL };
	145	int fds[2];
	146
	147	assert_no_err(pipe(fds));
	148
	149	posix_spawn_file_actions_t actions;
	150	posix_spawn_file_actions_init(&actions);
	151	posix_spawn_file_actions_adddup2(&actions, fds[1], STDOUT_FILENO);
	152
	153	assert_no_err(posix_spawn(&pid, "/usr/sbin/hdik", &actions, NULL, attach_args, NULL));
	154
	155	posix_spawn_file_actions_destroy(&actions);
	156
	157	close(fds[1]);
	158
	159	char line, slice = NULL;
	160	size_t lnsz = 64;
	161	FILE *fp = fdopen(fds[0], "r");
	162
	163	line = malloc(lnsz);
	164	assert(line);
	165
	166	while (getline(&line, &lnsz, fp) != -1) {
	167	char first, second;
	168
	169	first = strtok(line, " ");
	170	assert(first);
	171
	172	second = strtok(NULL, " ");
	173	assert(second);
	174
	175	if (strstr(second, "GUID"))
	176	di->disk = strdup(first);
	177
	178	// The output of hdik gets truncated, so just search for the leading part of the UUID
	179	else if (strstr(second, "48465300-0000-11AA"))
	180	slice = strdup(first);
	181	}
	182
	183	int status;
	184	assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1) == pid);
	185	assert(WIFEXITED(status) && !WEXITSTATUS(status));
	186
	187	assert(di->disk && slice);
	188	free(line);
	189	fclose(fp);
	190
de8ee011 A	191	// Ensure we have a mount point
	192	assert(opts->mount_point);
	193
558d2836 A	194	// Mount it
	195	char mkdir_args[4] = { "mkdir", "-p", (char )opts->mount_point, NULL };
	196	assert_no_err(posix_spawn(&pid, "/bin/mkdir", NULL, NULL, mkdir_args, NULL));
	197
	198	assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1) == pid);
	199	assert(WIFEXITED(status) && !WEXITSTATUS(status));
	200
	201	posix_spawn_file_actions_t facts;
	202	posix_spawn_file_actions_init(&facts);
	203	posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);
	204	posix_spawn_file_actions_addopen(&facts, STDERR_FILENO, "/dev/null", O_APPEND, 0);
	205
	206	char mount_args[4] = { "mount", slice, (char )opts->mount_point, NULL };
	207	assert_no_err(posix_spawn(&pid, "/sbin/mount_hfs", &facts, NULL, mount_args, NULL));
	208
	209	posix_spawn_file_actions_destroy(&facts);
	210	free(slice);
	211
	212	assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1) == pid);
	213	assert(WIFEXITED(status) && !WEXITSTATUS(status));
	214
	215	di->mount_point = strdup(opts->mount_point);
	216
558d2836 A	217	if (strcmp(path, SHARED_PATH)) { // Don't register a cleanup for the shared image
	218	test_cleanup(^ bool {
	219	return disk_image_cleanup(di);
	220	});
	221	}
	222
	223	assert_no_err(seteuid(uid_old));
	224
	225	return di;
	226	}
	227
	228	disk_image_t *disk_image_get(void)
	229	{
	230	disk_image_t *di;
	231	struct statfs sfs;
	232
	233	if (statfs(SHARED_MOUNT, &sfs) == 0) {
	234	di = calloc(1, sizeof(*di));
	235	di->mount_point = SHARED_MOUNT;
	236	di->disk = strdup(sfs.f_mntfromname);
	237	di->path = SHARED_PATH;
ec99dd30 A	238
	239	// Make sure the di struct is freed when tests are complete.
	240	test_cleanup(^ bool {
	241	free(di->disk);
	242	free(di);
	243	return true;
	244	});
558d2836 A	245	} else {
	246	disk_image_opts_t opts = {
	247	.mount_point = SHARED_MOUNT
	248	};
	249	di = disk_image_create(SHARED_PATH, &opts);
ec99dd30 A	250	// Per the contract of disk_image_create(),
	251	// di will be freed when disk_image_cleanup() is called,
	252	// so don't free it here.
558d2836 A	253	}
	254
	255	return di;
	256	}
	257
de8ee011	258	#else // !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
558d2836 A	259
	260	bool disk_image_cleanup(disk_image_t *di)
	261	{
	262	char *detach_args[]
	263	= { "hdiutil", "detach", (char *)di->disk, "-force", NULL };
	264
	265	pid_t pid;
ec99dd30	266	bool result = false;
927b7b56 A	267	int eject_retry;
927b7b56 A	268	int status;
558d2836 A	269
	270	posix_spawn_file_actions_t facts;
	271	posix_spawn_file_actions_init(&facts);
	272	posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);
	273	posix_spawn_file_actions_addopen(&facts, STDERR_FILENO, "/dev/null", O_APPEND, 0);
	274
927b7b56 A	275	for (eject_retry = 0; eject_retry < RETRY_MAX; ++eject_retry) {
	276	if (!posix_spawn(&pid, "/usr/bin/hdiutil", &facts, NULL, detach_args, NULL)) {
	277	waitpid(pid, &status, 0);
	278	if (WIFEXITED(status) && !WEXITSTATUS(status)) {
	279	break;
	280	}
	281	}
	282	sleep(1);
	283	}
558d2836 A	284
	285	posix_spawn_file_actions_destroy(&facts);
	286
927b7b56	287	assert(eject_retry != RETRY_MAX);
558d2836 A	288
	289	struct stat sb;
	290
927b7b56	291	if (stat(di->disk, &sb) == -1 && errno == ENOENT) {
558d2836 A	292	if (unlink(di->path) && errno == EACCES && !seteuid(0))
558d2836 A	293	unlink(di->path);
ec99dd30 A	294	result = true;
	295
	296	// We are the last user of di, so free it.
	297	free(di->mount_point);
	298	free(di->disk);
	299	free(di->path);
	300	free(di);
558d2836	301	}
ec99dd30 A	302
ec99dd30 A	303	return result;
558d2836 A	304	}
	305
	306	disk_image_t disk_image_create(const char path, disk_image_opts_t *opts)
	307	{
	308	pid_t pid;
	309	char sz[32];
	310	sprintf(sz, "%llu", opts->size);
	311
	312	if (opts->mount_point) {
	313	assert(!systemx("/bin/mkdir", SYSTEMX_QUIET, "-p", opts->mount_point, NULL));
	314	}
	315
	316	// Start with the basic args
	317	char args[64] = { "hdiutil", "create", (char )path, "-size", sz, "-ov" };
	318
	319	if (opts && opts->partition_type) {
	320	args[6] = "-partitionType";
	321	args[7] = (char *)opts->partition_type;
	322	args[8] = NULL;
	323
	324	posix_spawn_file_actions_t facts;
	325	posix_spawn_file_actions_init(&facts);
	326	posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);
	327
	328	assert_no_err(posix_spawn(&pid, "/usr/bin/hdiutil", &facts, NULL,
	329	args, NULL));
	330
	331	posix_spawn_file_actions_destroy(&facts);
	332
	333	int status;
	334	assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1));
	335
	336	assert(WIFEXITED(status) && !WEXITSTATUS(status));
	337
	338	args[1] = "attach";
	339	// args[2] == path
	340	args[3] = "-nomount";
	341	args[4] = "-plist";
	342	args[5] = NULL;
	343	} else if (opts && opts->enable_owners) {
	344	args[6] = "-fs";
	345	args[7] = "HFS+J";
	346	args[8] = NULL;
	347
	348	posix_spawn_file_actions_t facts;
	349	posix_spawn_file_actions_init(&facts);
	350	posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);
	351
	352	assert_no_err(posix_spawn(&pid, "/usr/bin/hdiutil", &facts, NULL,
	353	args, NULL));
	354
	355	posix_spawn_file_actions_destroy(&facts);
	356
	357	int status;
	358	assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1));
	359
	360	assert(WIFEXITED(status) && !WEXITSTATUS(status));
	361
	362	args[1] = "attach";
	363	// args[2] == path
	364	args[3] = "-plist";
	365	args[4] = "-owners";
	366	args[5] = "on";
	367	if (opts->mount_point) {
368	args[6] = "-mountpoint";
369	args[7] = (char *)opts->mount_point;
370	args[8] = NULL;
371	}
372	else
373	args[6] = NULL;
374	} else {
375	args[6] = "-fs";
376	args[7] = "HFS+J";
377	args[8] = NULL;
378
379	posix_spawn_file_actions_t facts;
380	posix_spawn_file_actions_init(&facts);
381	posix_spawn_file_actions_addopen(&facts, STDOUT_FILENO, "/dev/null", O_APPEND, 0);
382
383	assert_no_err(posix_spawn(&pid, "/usr/bin/hdiutil", &facts, NULL,
384	args, NULL));
385
386	posix_spawn_file_actions_destroy(&facts);
387
388	int status;
389	assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1));
390
391	assert(WIFEXITED(status) && !WEXITSTATUS(status));
392
393	args[1] = "attach";
394	// args[2] == path
395	args[3] = "-plist";
396	if (opts->mount_point) {
397	args[4] = "-mountpoint";
398	args[5] = (char *)opts->mount_point;
399	args[6] = NULL;
400	}
401	else
402	args[4] = NULL;
403	}
404
405	int fds[2];
406	assert_no_err(pipe(fds));
407
408	posix_spawn_file_actions_t actions;
409	posix_spawn_file_actions_init(&actions);
410	posix_spawn_file_actions_adddup2(&actions, fds[1], STDOUT_FILENO);
411
412	assert_no_err(posix_spawn(&pid, "/usr/bin/hdiutil", &actions, NULL, args, NULL));
413
414	posix_spawn_file_actions_destroy(&actions);
415
416	close(fds[1]);
417
418	char buffer[4096];
419	size_t amt = 0;
420
421	for (;;) {
422	ssize_t res = read(fds[0], buffer + amt, 4096 - amt);
423
424	if (!res)
425	break;
426
427	if (res == -1 && errno == EINTR)
428	continue;
429
430	assert_with_errno(res > 0);
431
432	amt += res;
433
434	assert(amt < 4096);
435	}
436
437	disk_image_t di = calloc(1, sizeof(di));
438
439	di->path = strdup(path);
440
441	@autoreleasepool {
442	NSDictionary *results
443	= [NSPropertyListSerialization propertyListWithData:
444	[NSData dataWithBytesNoCopy:buffer
445	length:amt
446	freeWhenDone:NO]
447	options:0
448	format:NULL
449	error:NULL];
450
451	for (NSDictionary *entity in results[@"system-entities"]) {
452	if (opts && opts->partition_type) {
453	if (!strcmp([entity[@"unmapped-content-hint"] UTF8String],
454	opts->partition_type)
455	\|\| !strcmp([entity[@"content-hint"] UTF8String],
456	opts->partition_type)) {
457	di->disk = strdup([entity[@"dev-entry"] fileSystemRepresentation]);
458	break;
459	}
460	} else if ([entity[@"content-hint"] isEqualToString:@"Apple_HFS"]) {
461	di->mount_point = strdup([entity[@"mount-point"] fileSystemRepresentation]);
462	di->disk = strdup([entity[@"dev-entry"] fileSystemRepresentation]);
463	break;
464	}
465	}
466	}
467
468	int status;
469	assert_with_errno(ignore_eintr(waitpid(pid, &status, 0), -1) == pid);
470	assert(WIFEXITED(status) && !WEXITSTATUS(status));
471
472	assert(di->disk);
473
474	if (strcmp(path, SHARED_PATH)) { // Don't register a cleanup for the shared image
475	test_cleanup(^ bool {
476	return disk_image_cleanup(di);
477	});
478	}
479
480	return di;
481	}
482
483	disk_image_t *disk_image_get(void)
484	{
485	disk_image_t *di;
486	struct statfs sfs;
487
488	if (statfs(SHARED_MOUNT, &sfs) == 0) {
489	di = calloc(1, sizeof(*di));
490
491	di->mount_point = SHARED_MOUNT;
492	di->disk = strdup(sfs.f_mntfromname);
493	di->path = SHARED_PATH;
ec99dd30 A	494
	495	// Make sure the di struct is freed when tests are complete.
	496	test_cleanup(^ bool {
	497	free(di->disk);
	498	free(di);
	499	return true;
	500	});
558d2836 A	501	} else {
	502	disk_image_opts_t opts = {
	503	.size = 4 GB,
	504	.mount_point = SHARED_MOUNT
	505	};
	506	di = disk_image_create(SHARED_PATH, &opts);
ec99dd30 A	507	// Per the contract of disk_image_create(),
	508	// di will be freed when disk_image_cleanup() is called,
	509	// so don't free it here.
558d2836 A	510	}
	511
	512	return di;
	513	}
	514
de8ee011	515	#endif // (TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)