vdkcmd.c

Virtual Disk Driver

		printf("%s\n", VdkStatusStr(ret));
		return -1;
	}

	PrintMessage(MSG_DISK_DEVICE, disk_device);

	return 0;
}

//
//	Delete a virtual disk device
//	Command Line Parameters: none
//
int Delete(char **args)
{
	ULONG disk_device;
	DWORD ret;

	UNREFERENCED_PARAMETER(args);

	//	ensure that the driver is installed

	if (driver_state == VDK_NOT_INSTALLED) {
		PrintMessage(MSG_NOT_INSTALLED);
		return -1;
	}

	//	ensure that the driver is running

	if (driver_state != SERVICE_RUNNING) {
		PrintMessage(MSG_NOT_RUNNING);
		return -1;
	}

	//	get current number of disk devices

	ret = VdkGetDriverInfo(NULL, &disk_device, NULL, NULL, NULL);

	if (ret != ERROR_SUCCESS) {
		PrintMessage(MSG_GET_CONFIG_NG);
		printf("%s\n", VdkStatusStr(ret));
		return -1;
	}

	if (disk_device == 1) {
		PrintMessage(MSG_NO_LESS_DISK);
		return -1;
	}

	//	delete disk

	ret = VdkDeleteDisk(NULL);

	if (ret != ERROR_SUCCESS) {
		PrintMessage(MSG_DELETEDISK_NG, disk_device - 1);
		printf("%s\n", VdkStatusStr(ret));
		return -1;
	}

	PrintMessage(MSG_DELETEDISK_OK, disk_device - 1);

	//	print new number of disk devices

	ret = VdkGetDriverInfo(NULL, &disk_device, NULL, NULL, NULL);

	if (ret != ERROR_SUCCESS) {
		PrintMessage(MSG_GET_CONFIG_NG);
		printf("%s\n", VdkStatusStr(ret));
		return -1;
	}

	PrintMessage(MSG_DISK_DEVICE, disk_device);

	return 0;
}

//
//	Print disk image files information
//	Command Line Parameters:
//		path
//
int	View(char **args)
{
	PVOID				disk		= NULL;
	PVDK_OPEN_FILE_INFO	open_info	= NULL;
	VDK_DISK_INFO		disk_info	= { 0 };
	ULONG				info_size;
	DWORD				ret;

	//	Create File structure

	VDiskSetCallBack(VDiskCallback);

	ret = VDiskLoadFile(&disk, *args, NULL);

	if (ret != ERROR_SUCCESS || disk == NULL) {
		PrintMessage(MSG_OPENIMAGE_NG);
		printf("%s\n", VdkStatusStr(ret == ERROR_SUCCESS ? ERROR_INVALID_FUNCTION : ret));
		goto cleanup;
	}

	ret = VDiskCreateTree(disk);

	if (ret != ERROR_SUCCESS) {
		PrintMessage(MSG_OPENIMAGE_NG);
		printf("%s\n", VdkStatusStr(ret));
		goto cleanup;
	}

	ret = VDiskMapToOpenInfo(disk, (PVOID *)&open_info, &info_size);

	if (ret != ERROR_SUCCESS) {
		PrintMessage(MSG_OPENIMAGE_NG);
		printf("%s\n", VdkStatusStr(ret));
		goto cleanup;
	}

	//	print image file information

	PrintMessage(MSG_DISKIMAGE_NAME, VDiskGetDiskName(disk));
	PrintFileInfo(open_info);

	//	open virtual disk

	open_info->DiskType = VDK_DISKTYPE_READONLY;

	ret = VdkOpenDisk(open_info, &disk_info);

	if (ret != ERROR_SUCCESS) {
		PrintMessage(MSG_OPENIMAGE_NG);
		printf("%s\n", VdkStatusStr(ret));
		goto cleanup;
	}

	//	print partition info

	PrintMessage(MSG_PARTITION_HEADER);

	ret = VdkListPartitions(&disk_info, NULL, 0, PartList_Callback, (PVOID)-1);

	if (ret != ERROR_SUCCESS) {
		PrintMessage(MSG_GET_PART_NG);
		printf("%s\n", VdkStatusStr(ret));
	}

cleanup:
	if (disk) {
		VDiskDelete(disk);
	}

	if (open_info) {
		VdkFreeMem(open_info);
	}

	if (disk_info.DiskType) {
		VdkCloseDisk(&disk_info);
	}

	return (ret == ERROR_SUCCESS ? 0 : -1);
}

//
//	Opens virtual disk image
//	Command Line Parameters:
//		disk number
//		image file path
//		(optional) access mode - default to read-only
//		(optional) partition to assign drive letter - default to all mountable
//		(optional) drive letters - default to the first available letter
//
int	Open(char **args)
{
	// for command line parameters
	ULONG	disk_number;
	LPTSTR	file_path;
	BOOL	writable		= FALSE;
	BOOL	undoable		= FALSE;
	BOOL	writeblock		= FALSE;
	LPTSTR	drive_letters	= NULL;
	ULONG	part_number		= (ULONG)-1;

	//	for virtual disk operation
	PVOID	disk			= NULL;

	// for vdk driver operation
	ULONG	access;
	HANDLE	hDevice			= NULL;
	PVDK_OPEN_FILE_INFO		file_info = NULL;
	ASSIGN_PARAM			assign;

	DWORD	ret;

	//	process command line parameters
	if (**args == '*') {
		disk_number = (ULONG)-1;
	}
	else if (isdigit(**args)) {
		disk_number = atol(*args);

		if (disk_number >= VDK_MAXIMUM_DISK_NUM) {
			PrintMessage(MSG_INVALID_DISK, *args);
			return -1;
		}
	}
	else {
		PrintMessage(MSG_INVALID_DISK, *args);
		return -1;
	}

	args++;

	if (!*args || !**args) {
		PrintMessage(MSG_USAGE_OPEN);
		return -1;
	}

	file_path = *args;

	while (*(++args)) {
		if (_stricmp(*args, "/rw") == 0) {
			if (writable) {
				PrintMessage(MSG_DUPLICATE_ARGS, *args);
				return -1;
			}

			writable = TRUE;
		}
		else if (_stricmp(*args, "/undo") == 0) {
			if (undoable) {
				PrintMessage(MSG_DUPLICATE_ARGS, *args);
				return -1;
			}

			undoable = TRUE;
		}
		else if (_stricmp(*args, "/wb") == 0) {
			if (writeblock) {
				PrintMessage(MSG_DUPLICATE_ARGS, *args);
				return -1;
			}

			writeblock = TRUE;
		}
		else if (_strnicmp(*args, "/l:", 3) == 0) {
			if (drive_letters) {
				PrintMessage(MSG_DUPLICATE_ARGS, "/L");
				return -1;
			}

			drive_letters = *args + 3;
		}
		else if (_strnicmp(*args, "/p:", 3) == 0) {
			if (part_number != (ULONG)-1) {
				PrintMessage(MSG_DUPLICATE_ARGS, "/P");
				return -1;
			}

			if (!isdigit(*(*args + 3))) {
				PrintMessage(MSG_INVALID_PART, *args + 3);
				return -1;
			}

			part_number = atol(*args + 3);
		}
		else {
			PrintMessage(MSG_UNKNOWN_OPTION, *args, "OPEN");
			return -1;
		}
	}

	if ((writable && undoable) ||
		(writable && writeblock) ||
		(undoable && writeblock)) {
		PrintMessage(MSG_OPENMODE_OPTION);
		return -1;
	}

	//	ensure that the driver is installed

	if (driver_state == VDK_NOT_INSTALLED) {
		if ((ret = VdkInstall(NULL, FALSE)) == ERROR_SUCCESS) {
			PrintMessage(MSG_INSTALL_OK);
		}
		else {
			PrintMessage(MSG_INSTALL_NG);
			printf("%s\n", VdkStatusStr(ret));
			return -1;
		}
	}

	//	ensure that the driver is started

	if (driver_state != SERVICE_RUNNING) {
		if ((ret = VdkStart(&driver_state)) == ERROR_SUCCESS) {
			PrintMessage(MSG_START_OK);
		}
		else {
			PrintMessage(MSG_START_NG);
			printf("%s\n", VdkStatusStr(ret));
			return -1;
		}
	}

	//	Open device

	if (disk_number == (ULONG)-1) {
		disk_number = 0;

		for (;;) {
			ret = VdkCheckDeviceState(NULL, disk_number, 0);

			if (ret == ERROR_NOT_READY) {
				//	drive is empty -- use this disk
				break;
			}
			else if (ret == ERROR_SUCCESS || ret == ERROR_BUSY) {
				//	drive is busy --  try next disk
				CloseHandle(hDevice);
				disk_number++;
			}
			else if (ret == ERROR_PATH_NOT_FOUND) {
				//	no more drive
				//	-- create a new disk
				ret = VdkCreateDisk(NULL);

				if (ret != ERROR_SUCCESS) {
					PrintMessage(MSG_CREATEDISK_NG, disk_number);
					printf("%s\n", VdkStatusStr(ret));
					return -1;
				}

				PrintMessage(MSG_CREATEDISK_OK, disk_number);
			}
			else {
				//	unexpected error -- abort operation
				PrintMessage(MSG_OPENIMAGE_NG);
				printf("%s\n", VdkStatusStr(ret));
				return -1;
			}
		}
	}
	else {
		//	Ensure that another image is not opened

		ret = VdkCheckDeviceState(NULL, disk_number, 0);

		if (ret != ERROR_NOT_READY) {
			PrintMessage(MSG_OPENIMAGE_NG);
			printf("%s\n", VdkStatusStr(ret == ERROR_SUCCESS ? ERROR_BUSY : ret));
			return -1;
		}
	}

	hDevice = VdkOpenDevice(disk_number, 0);

	if (hDevice == INVALID_HANDLE_VALUE) {
		ret = GetLastError();
		PrintMessage(MSG_OPENIMAGE_NG);
		printf("%s\n", VdkStatusStr(ret));
		return -1;
	}

	//
	//	Create File structure
	//
	VDiskSetCallBack(VDiskCallback);

	ret = VDiskLoadFile(&disk, file_path, NULL);

	if (ret != ERROR_SUCCESS || disk == NULL) {
		PrintMessage(MSG_OPENIMAGE_NG);
		printf("%s\n", VdkStatusStr(ret == ERROR_SUCCESS ? ERROR_INVALID_FUNCTION : ret));
		goto cleanup;
	}

	ret = VDiskCreateTree(disk);

	if (ret != ERROR_SUCCESS) {
		PrintMessage(MSG_OPENIMAGE_NG);
		printf("%s\n", VdkStatusStr(ret));
		goto cleanup;
	}

	//
	//	Create REDO log
	//
	if (undoable) {
		ret = VDiskCreateRedo(&disk);

		if (ret != ERROR_SUCCESS) {
			PrintMessage(MSG_CREATEREDO_NG);
			printf("%s\n", VdkStatusStr(ret));
			VDiskDelete(disk);
			return -1;
		}
	}

	//	Open the image files
	if (undoable || writable) {
		access = VDK_DISKTYPE_WRITABLE;
	}
	else if (writeblock) {
		access = VDK_DISKTYPE_WRITEBLOCK;
	}
	else {
		access = VDK_DISKTYPE_READONLY;
	}

	PrintMessage(MSG_VIRTUAL_DISK, disk_number);

	ret = VdkOpen(hDevice, 0, disk, access);

	if (ret != ERROR_SUCCESS) {
		PrintMessage(MSG_OPENIMAGE_NG);
		printf("%s\n", VdkStatusStr(ret));
		goto cleanup;
	}

	//
	//	print file information
	//
	if ((ret = VdkGetFileInfo(hDevice, 0, &file_info)) != ERROR_SUCCESS) {
		PrintMessage(MSG_GET_IMAGE_NG, disk_number);
		printf("%s\n", VdkStatusStr(ret));
		goto cleanup;
	}

	if (file_info) {
		PrintFileInfo(file_info);
	}

	//
	//	assign drive letters and print partition info
	//
	PrintMessage(MSG_PARTITION_HEADER);

	assign.disk_number	= disk_number;
	assign.part_number	= part_number;
	assign.read_only	= (access == VDK_DISKTYPE_READONLY);
	assign.drive_letters = drive_letters;

	ret = VdkListPartitions(NULL, hDevice, file_info->Capacity, Assign_Callback, &assign);

	if (ret != ERROR_SUCCESS) {
		PrintMessage(MSG_GET_PART_NG);
		printf("%s\n", VdkStatusStr(ret));
		goto cleanup;
	}

cleanup:
	if (hDevice && hDevice != INVALID_HANDLE_VALUE) {
		CloseHandle(hDevice);
	}

	if (file_info) {
		VdkFreeMem(file_info);
	}

	if (disk) {
		VDiskDelete(disk);
	}

	return (ret == ERROR_SUCCESS ? 0 : -1);
}

//
//	Close current file(s)
//	Command Line Parameters:
//		disk number or drive letter
//
#define CLOSE_PROMPT	0
#define CLOSE_QUIET		1
#define CLOSE_FORCE		2

int	Close(char **args)
{
	ULONG	disk_number;
	ULONG	max_disk;
	CHAR	drive_letter;
	ULONG	interact = CLOSE_PROMPT;
	DWORD	ret;

	if (**args == '*') {
		disk_number = (ULONG)-1;
		drive_letter = '\0';
	}
	else if (isdigit(**args)) {
		disk_number = atol(*args);
		drive_letter = '\0';
	}
	else if (isalpha(**args)) {
		disk_number = (ULONG)-1;
		drive_letter = (CHAR)toupper(**args);
	}
	else {
		PrintMessage(MSG_INVALID_DISK, *args);
		return -1;
	}

	if (*(++args)) {
		if (!_stricmp(*args, "/q")) {
			interact = CLOSE_QUIET;
		}
		else if (!_stricmp(*args, "/f")) {
			interact = CLOSE_FORCE;
		}
		else {
			PrintMessage(MSG_UNKNOWN_OPTION, *args, "CLOSE");
			return -1;
		}
	}

	//	ensure that the driver is installed

	if (driver_state == VDK_NOT_INSTALLED) {
		PrintMessage(MSG_NOT_INSTALLED);
		return -1;
	}

	//	ensure that the driver is running

	if (driver_state != SERVICE_RUNNING) {
		PrintMessage(MSG_NOT_RUNNING);
		return -1;
	}

	//	get the disk number from the drive letter

	if (drive_letter) {
		ret = GetDiskFromDrive(drive_letter, &disk_number);

		if (ret != ERROR_SUCCESS) {
			PrintMessage(MSG_RESOLVE_LINK_NG, drive_letter);
			printf("%s\n", VdkStatusStr(ret));
			return -1;
		}
	}

	//	Close virtual disk

	if (disk_number == (ULONG)-1) {
		disk_number = 0;

		ret = VdkGetDriverInfo(NULL, &max_disk, NULL, NULL, NULL);

		if (ret != ERROR_SUCCESS) {
			PrintMessage(MSG_GET_CONFIG_NG);
			printf("%s\n", VdkStatusStr(ret));
			return -1;
		}
	}
	else {
		max_disk = 0;
	}

	do {
		PrintMessage(MSG_CLOSING_DISK, disk_number);
		fflush(stdout);

		ret = VdkCloseDrive(
			disk_number, Retry_Callback, Continue_Callback, (PVOID)interact);

		if (ret == ERROR_SUCCESS) {
			PrintMessage(MSG_CLOSE_OK);
		}
		else if (ret == ERROR_NOT_READY) {
			PrintMessage(MSG_DEVICE_EMPTY);
		}
		else if (ret == ERROR_BUSY) {
			PrintMessage(MSG_DEVICE_BUSY);
		}
		else if (!interact || max_disk == 0) {
			return -1;
		}
	}
	while (++disk_number < max_disk);

	return 0;
}

//
//	Assign a drive letter to a partition
//	Command Line Parameters:
//		disk number - required
//		partition number - required
//		(optional) drive letter - default to first available letter
//
int	Link(char **args)
{
	ULONG	disk_number;
	ULONG	part_number;
	char	drive_letter;
	DWORD	ret;

	//	ensure that the driver is installed

	if (driver_state == VDK_NOT_INSTALLED) {
		PrintMessage(MSG_NOT_INSTALLED);
		return -1;
	}

	//	ensure that the driver is running

	if (driver_state != SERVICE_RUNNING) {
		PrintMessage(MSG_NOT_RUNNING);
		return -1;
	}

	//	process command line parameters

	if (!isdigit(**args)) {
		PrintMessage(MSG_INVALID_DISK, *args);
		return -1;
	}

	disk_number = atol(*(args++));

	if (!isdigit(**args)) {
		PrintMessage(MSG_INVALID_PART, *args);
		return -1;
	}

	part_number = atol(*(args++));

	if (*args) {
		if (!isalpha(**args)) {
			PrintMessage(MSG_UNKNOWN_OPTION, *args, "LINK");
			return -1;
		}

		drive_letter = **args;
	}
	else {
		drive_letter = ChooseDriveLetter();

		if (!isalpha(drive_letter)) {
			PrintMessage(MSG_DRIVE_FULL);
			return -1;
		}
	}

	drive_letter = (char)toupper(drive_letter);

	ret = VdkSetDriveLetter(disk_number, part_number, drive_letter);

	if (ret != ERROR_SUCCESS) {
		PrintMessage(MSG_LINK_NG, drive_letter, disk_number, part_number);
		printf("%s\n", VdkStatusStr(ret));
		return -1;
	}

	PrintMessage(MSG_LINK_OK, drive_letter, disk_number, part_number);

	return 0;
}

//
//	Remove a drive letter from a partition
//	Command Line Parameters:
//		partition number or drive letter
//
int	Unlink(char **args)
{
	ULONG	disk_number		= (ULONG)-1;
	ULONG	part_number		= (ULONG)-1;
	TCHAR	drive_letter	= '\0';
	DWORD	ret;

	//	ensure that the driver is installed

	if (driver_state == VDK_NOT_INSTALLED) {
		PrintMessage(MSG_NOT_INSTALLED);
		return -1;
	}

	//	ensure that the driver is running

	if (driver_state != SERVICE_RUNNING) {
		PrintMessage(MSG_NOT_RUNNING);
		return -1;
	}

	//	process command line parameters

	if (isdigit(**args)) {
		disk_number = atol(*(args++));

		if (!*args) {
			PrintMessage(MSG_USAGE_ULINK);