1 /*
2 	vfdcmd.c
3 
4 	Virtual Floppy Drive for Windows
5 	Driver control program (console version)
6 
7 	Copyright (C) 2003-2008 Ken Kato
8 */
9 
10 #ifdef __cplusplus
11 #pragma message(__FILE__": Compiled as C++ for testing purpose.")
12 #endif	// __cplusplus
13 
14 #define WIN32_LEAN_AND_MEAN
15 #define _CRTDBG_MAP_ALLOC
16 #include <windows.h>
17 #include <stdio.h>
18 #include <stdarg.h>
19 #include <stdlib.h>
20 #include <crtdbg.h>
21 
22 #ifndef INVALID_FILE_ATTRIBUTES
23 #define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
24 #endif	// INVALID_FILE_ATTRIBUTES
25 
26 #include "vfdtypes.h"
27 #include "vfdapi.h"
28 #include "vfdver.h"
29 #include "vfdmsg.h"
30 
31 //
32 //	current driver state
33 //
34 static DWORD driver_state = VFD_NOT_INSTALLED;
35 
36 //
37 //	interactive flag
38 //
39 static const char *help_progname = "VFD.EXE ";
40 
41 //
42 //	command functions return value
43 //
44 #define VFD_OK	0
45 #define VFD_NG	1
46 
47 //
48 //	operation mode
49 //
50 #define OPERATION_ASK	0		//	ask user on error
51 #define OPERATION_QUIT	1		//	quits on error
52 #define OPERATION_FORCE 2		//	force on error
53 
54 //
55 //	invalid target number
56 //
57 #define TARGET_NONE		(ULONG)-1
58 
59 //
60 //	command processing functions
61 //
62 typedef int (*cmdfnc)(const char **args);
63 
64 static int Install(const char **args);
65 static int Remove(const char **args);
66 static int Config(const char **args);
67 static int Start(const char **args);
68 static int Stop(const char **args);
69 static int Shell(const char **args);
70 static int Open(const char **args);
71 static int Close(const char **args);
72 static int Save(const char **args);
73 static int Protect(const char **args);
74 static int Format(const char **args);
75 static int Link(const char **args);
76 static int Unlink(const char **args);
77 static int Status(const char **args);
78 static int Help(const char **args);
79 static int Version(const char **args);
80 
81 //
82 //	Command table
83 //
84 static const struct {
85 	char	*cmd;				// command string
86 	int		max_args;			// maximum allowed number of argc
87 	cmdfnc	func;				// command processing function
88 	DWORD	hint;				// command hint message id
89 }
90 Commands[] = {
91 	{"INSTALL", 2, Install,	MSG_HINT_INSTALL},
92 	{"REMOVE",	1, Remove,	MSG_HINT_REMOVE	},
93 	{"CONFIG",	1, Config,	MSG_HINT_CONFIG	},
94 	{"START",	0, Start,	MSG_HINT_START	},
95 	{"STOP",	1, Stop,	MSG_HINT_STOP	},
96 	{"SHELL",	1, Shell,	MSG_HINT_SHELL	},
97 	{"OPEN",	6, Open,	MSG_HINT_OPEN	},
98 	{"CLOSE",	2, Close,	MSG_HINT_CLOSE	},
99 	{"SAVE",	3, Save,	MSG_HINT_SAVE,	},
100 	{"PROTECT", 2, Protect,	MSG_HINT_PROTECT},
101 	{"FORMAT",	2, Format,	MSG_HINT_FORMAT	},
102 	{"LINK",	3, Link,	MSG_HINT_LINK	},
103 	{"ULINK",	1, Unlink,	MSG_HINT_ULINK	},
104 	{"STATUS",	0, Status,	MSG_HINT_STATUS	},
105 	{"HELP",	1, Help,	MSG_HELP_HELP	},
106 	{"?",		1, Help,	MSG_HELP_HELP	},
107 	{"VERSION", 0, Version,	MSG_HINT_VERSION},
108 	{0, 0, 0, 0}
109 };
110 
111 //
112 //	Help message table
113 //
114 static const struct {
115 	char	*keyword;			//	help keyword
116 	DWORD	help;				//	help message id
117 }
118 HelpMsg[] = {
119 	{"GENERAL", MSG_HELP_GENERAL},
120 	{"CONSOLE",	MSG_HELP_CONSOLE},
121 	{"INSTALL", MSG_HELP_INSTALL},
122 	{"REMOVE",	MSG_HELP_REMOVE	},
123 	{"CONFIG",	MSG_HELP_CONFIG	},
124 	{"START",	MSG_HELP_START	},
125 	{"STOP",	MSG_HELP_STOP	},
126 	{"SHELL",	MSG_HELP_SHELL	},
127 	{"OPEN",	MSG_HELP_OPEN	},
128 	{"CLOSE",	MSG_HELP_CLOSE	},
129 	{"SAVE",	MSG_HELP_SAVE	},
130 	{"PROTECT", MSG_HELP_PROTECT},
131 	{"FORMAT",	MSG_HELP_FORMAT	},
132 	{"LINK",	MSG_HELP_LINK	},
133 	{"ULINK",	MSG_HELP_ULINK	},
134 	{"STATUS",	MSG_HELP_STATUS	},
135 	{"HELP",	MSG_HELP_HELP	},
136 	{"VERSION", MSG_HINT_VERSION},
137 	{0, 0}
138 };
139 
140 //
141 //	local functions
142 //
143 static int InteractiveConsole();
144 static int ProcessCommandLine(int argc, const char **args);
145 static int ParseCommand(const char *cmd);
146 static int ParseHelpTopic(const char *topic);
147 static int CheckDriver();
148 static int InputChar(ULONG msg, PCSTR ans);
149 static void PrintImageInfo(HANDLE hDevice);
150 static void PrintDriveLetter(HANDLE hDevice, ULONG nDrive);
151 static void PrintMessage(UINT msg, ...);
152 static BOOL ConsolePager(char *pBuffer, BOOL bReset);
153 static const char *SystemError(DWORD err);
154 static void ConvertPathCase(char *src, char *dst);
155 
156 //
157 //	utility macro
158 //
159 #define IS_WINDOWS_NT()		((GetVersion() & 0xff) < 5)
160 
161 //
162 //	main
163 //
main(int argc,const char ** argv)164 int main(int argc, const char **argv)
165 {
166 #ifdef _DEBUG
167 
168 	//	output vfd.exe command reference text
169 
170 	if (*(argv + 1) && !_stricmp(*(argv + 1), "doc")) {
171 		int idx = 0;
172 		char *buf = "";
173 
174 		printf("\r\n  VFD.EXE Command Reference\r\n");
175 
176 		while (HelpMsg[idx].keyword) {
177 			int len = strlen(HelpMsg[idx].keyword);
178 
179 			printf(
180 				"\r\n\r\n"
181 				"====================\r\n"
182 				"%*s\r\n"
183 				"====================\r\n"
184 				"\r\n",
185 				(20 + len) / 2, HelpMsg[idx].keyword);
186 
187 			FormatMessage(
188 				FORMAT_MESSAGE_FROM_HMODULE |
189 				FORMAT_MESSAGE_ALLOCATE_BUFFER |
190 				FORMAT_MESSAGE_ARGUMENT_ARRAY,
191 				NULL, HelpMsg[idx].help, 0,
192 				(LPTSTR)&buf, 0, (va_list *)&help_progname);
193 
194 			printf("%s", buf);
195 
196 			LocalFree(buf);
197 
198 			idx++;
199 		}
200 
201 		return 0;
202 	}
203 #endif
204 
205 	//	Reports memory leaks at process termination
206 
207 	_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
208 
209 	//	Check the operating system version
210 
211 	if (!VfdIsValidPlatform()) {
212 		PrintMessage(MSG_WRONG_PLATFORM);
213 		return VFD_NG;
214 	}
215 
216 	if (argc < 2) {
217 		//	If no parameter is given, enter the interactive mode
218 
219 		return InteractiveConsole();
220 	}
221 	else {
222 		//	Perform a single operation
223 
224 		return ProcessCommandLine(argc - 1, argv + 1);
225 	}
226 }
227 
228 //
229 //	VFD interactive console
230 //
InteractiveConsole()231 int InteractiveConsole()
232 {
233 	char		input[1024];	//	user input buffer
234 
235 	int			argc;			//	number of args in the user input
236 	char		*args[10];		//	args to pass to command functions
237 
238 	char		sepa;			//	argument separator
239 	char		*p;				//	work pointer
240 
241 	//	Disable the system default Ctrl+C handler
242 
243 	SetConsoleCtrlHandler(NULL, TRUE);
244 
245 	//	Set the console title
246 
247 	SetConsoleTitle(VFD_PRODUCT_DESC);
248 
249 	//	print version information and the console hint text
250 
251 	Version(NULL);
252 
253 	PrintMessage(MSG_CONSOLE_HINT);
254 
255 	//	set interactive flag to exclude "VFD.EXE" from help text
256 
257 	help_progname = "";
258 
259 	//	process user input
260 
261 	for (;;) {
262 
263 		//	print the prompt
264 
265 		printf("[VFD] ");
266 		fflush(stdout);
267 
268 		//	read user input
269 
270 		fflush(stdin);
271 		p = fgets(input, sizeof(input), stdin);
272 
273 		if (p == NULL) {
274 
275 			//	most likely <ctrl+c>
276 
277 			printf("exit\n");
278 			break;
279 		}
280 
281 		//	skip leading blank characters
282 
283 		while (*p == ' ' || *p == '\t' || *p == '\n') {
284 			p++;
285 		}
286 
287 		if (*p == '\0') {
288 
289 			//	empty input
290 
291 			continue;
292 		}
293 
294 		//	handle external commands
295 
296 		if (!_strnicmp(p, "dir", 3) ||
297 			!_strnicmp(p, "attrib", 6)) {
298 
299 			//	special cases - frequently used commands
300 			//	pass these to system() even without '.'
301 
302 			system(p);
303 			printf("\n");
304 			continue;
305 		}
306 		else if (*p == '.') {
307 
308 			//	external command
309 
310 			system(p + 1);
311 			printf("\n");
312 			continue;
313 		}
314 
315 		//	split the input line into parameters (10 parameters max)
316 
317 		argc = 0;
318 		ZeroMemory(args, sizeof(args));
319 
320 		do {
321 			//	top of a parameter
322 
323 			args[argc++] = p;
324 
325 			//	is the parameter quoted?
326 
327 			if (*p == '\"' || *p == '\'') {
328 				sepa = *(p++);
329 			}
330 			else {
331 				sepa = ' ';
332 			}
333 
334 			//	search the end of the parameter
335 
336 			while (*p && *p != '\n') {
337 				if (sepa == ' ') {
338 					if (*p == '\t' || *p == ' ') {
339 						break;			//	tail of a non-quoted parameter
340 					}
341 				}
342 				else {
343 					if (*p == sepa) {
344 						sepa = ' ';		//	close quote
345 					}
346 				}
347 				p++;
348 			}
349 
350 			//	terminate the parameter
351 
352 			if (*p) {
353 				*(p++) = '\0';
354 			}
355 
356 			//	skip trailing blank characters
357 
358 			while (*p == ' ' || *p == '\t' || *p == '\n') {
359 				p++;
360 			}
361 
362 			if (*p == '\0') {
363 
364 				//	end of the input line - no more args
365 
366 				break;
367 			}
368 		}
369 		while (argc < sizeof(args) / sizeof(args[0]));
370 
371 		//	check the first parameter for special commands
372 
373 		if (!_stricmp(args[0], "exit") ||
374 			!_stricmp(args[0], "quit") ||
375 			!_stricmp(args[0], "bye")) {
376 
377 			//	exit command
378 
379 			break;
380 		}
381 		else if (!_stricmp(args[0], "cd") ||
382 			!_stricmp(args[0], "chdir")) {
383 
384 			//	internal change directory command
385 
386 			if (args[1]) {
387 				char path[MAX_PATH];
388 				int i;
389 
390 				//	ignore the /d option (of the standard cd command)
391 
392 				if (_stricmp(args[1], "/d")) {
393 					i = 1;
394 				}
395 				else {
396 					i = 2;
397 				}
398 
399 				p = args[i];
400 
401 				if (*p == '\"' || *p == '\'') {
402 
403 					//	the parameter is quoted -- remove quotations
404 
405 					p++;
406 
407 					while (*p && *p != *args[i]) {
408 						p++;
409 					}
410 
411 					args[i]++;		// skip a leading quote
412 					*p = '\0';		// remove a trailing quote
413 				}
414 				else {
415 
416 					//	the parameter is not quoted
417 					//	-- concatenate params to allow spaces in unquoted path
418 
419 					while (i < argc - 1) {
420 						*(args[i] + strlen(args[i])) = ' ';
421 						i++;
422 					}
423 				}
424 
425 				//	Match the case of the path to the name on the disk
426 
427 				ConvertPathCase(p, path);
428 
429 				if (!SetCurrentDirectory(path)) {
430 					DWORD ret = GetLastError();
431 
432 					if (ret == ERROR_FILE_NOT_FOUND) {
433 						ret = ERROR_PATH_NOT_FOUND;
434 					}
435 
436 					printf("%s", SystemError(ret));
437 				}
438 			}
439 			else {
440 				if (!GetCurrentDirectory(sizeof(input), input)) {
441 					printf("%s", SystemError(GetLastError()));
442 				}
443 				else {
444 					printf("%s\n", input);
445 				}
446 			}
447 		}
448 		else if (isalpha(*args[0]) &&
449 			*(args[0] + 1) == ':' &&
450 			*(args[0] + 2) == '\0') {
451 
452 			//	internal change drive command
453 
454 			*args[0] = (char)toupper(*args[0]);
455 			*(args[0] + 2) = '\\';
456 			*(args[0] + 3) = '\0';
457 
458 			if (!SetCurrentDirectory(args[0])) {
459 				printf("%s", SystemError(GetLastError()));
460 			}
461 		}
462 		else {
463 
464 			//	perform the requested VFD command
465 
466 			ProcessCommandLine(argc, (const char **)args);
467 		}
468 
469 		printf("\n");
470 	}
471 
472 	return VFD_OK;
473 }
474 
475 //
476 //	process a single command
477 //
ProcessCommandLine(int argc,const char ** args)478 int ProcessCommandLine(int argc, const char **args)
479 {
480 	int		cmd;
481 	DWORD	ret;
482 
483 	//
484 	//	Decide a command to perform
485 	//
486 	cmd = ParseCommand(*args);
487 
488 	if (cmd < 0) {
489 
490 		//	no matching command
491 
492 		return VFD_NG;
493 	}
494 
495 	if (*(++args) &&
496 		(!strcmp(*args, "/?") ||
497 		!_stricmp(*args, "/h"))) {
498 
499 		//	print a short hint for the command
500 
501 		PrintMessage(Commands[cmd].hint);
502 		return VFD_NG;
503 	}
504 
505 	if (--argc > Commands[cmd].max_args) {
506 
507 		// too many parameters for the command
508 
509 		PrintMessage(MSG_TOO_MANY_ARGS);
510 		PrintMessage(Commands[cmd].hint);
511 		return VFD_NG;
512 	}
513 
514 	//	Get the current driver state
515 
516 	ret = VfdGetDriverState(&driver_state);
517 
518 	if (ret != ERROR_SUCCESS) {
519 		PrintMessage(MSG_GET_STAT_NG);
520 		printf("%s", SystemError(ret));
521 		return VFD_NG;
522 	}
523 
524 	//	Perform the requested operation
525 
526 	return (*Commands[cmd].func)(args);
527 }
528 
529 //
530 //	Install the Virtual Floppy Driver
531 //	Command Line Parameters:
532 //	(optional) driver file path	- default to executive's dir
533 //	(optional) auto start switch - default to demand start
534 //
Install(const char ** args)535 int	Install(const char **args)
536 {
537 	const char *install_path = NULL;
538 	DWORD start_type = SERVICE_DEMAND_START;
539 
540 	DWORD ret;
541 
542 	//	process parameters
543 
544 	while (args && *args) {
545 
546 		if (!_stricmp(*args, "/a") ||
547 			!_stricmp(*args, "/auto")) {
548 
549 			if (start_type != SERVICE_DEMAND_START) {
550 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
551 				return VFD_NG;
552 			}
553 /*
554 			if (IS_WINDOWS_NT()) {
555 
556 				//	On Windows NT, SYSTEM start drivers must be placed
557 				//	under the winnt\system32 directory.  Since I don't
558 				//	care to handle driver file copying, I use the AUTO
559 				//	start method for Windows NT.
560 
561 				start_type = SERVICE_AUTO_START;
562 			}
563 			else {
564 
565 				//	On Windows XP, the VFD driver must be running when
566 				//	the shell starts -- otherwise the shell doesn't
567 				//	recognize the VFD drives.  Since Windows XP allows
568 				//	SYSTEM start drivers to be placed in any local
569 				//	directories, I use the SYSTEM start method here.
570 				//
571 				//	This is not an issue when the driver is started
572 				//	manually because in that case VFD.EXE and VFDWIN.EXE
573 				//	notify the shell of the VFD drives.
574 				//
575 				//	On Windows 2000 both SYSTEM and AUTO work fine.
576 
577 				start_type = SERVICE_SYSTEM_START;
578 			}
579 */
580 			//	On second thought -- Win2K / XP mount manager assigns
581 			//	arbitrary drive letters to all drives it finds during
582 			//	the system start up.  There is no way to prevent it
583 			//	until the driver is fully PnP compatible, so I'd settle
584 			//	for AUTO start for the time being.
585 
586 			start_type = SERVICE_AUTO_START;
587 		}
588 		else if (**args == '/') {
589 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
590 			PrintMessage(MSG_HINT_INSTALL, help_progname);
591 			return VFD_NG;
592 		}
593 		else {
594 			if (install_path) {
595 				PrintMessage(MSG_DUPLICATE_ARGS, "path");
596 				return VFD_NG;
597 			}
598 
599 			install_path = *args;
600 		}
601 
602 		args++;
603 	}
604 
605 	//	already installed?
606 
607 	if (driver_state != VFD_NOT_INSTALLED) {
608 		PrintMessage(MSG_DRIVER_EXISTS);
609 		return VFD_NG;
610 	}
611 
612 	//	install the driver
613 
614 	ret = VfdInstallDriver(
615 		install_path,
616 		start_type);
617 
618 	if (ret != ERROR_SUCCESS) {
619 		PrintMessage(MSG_INSTALL_NG);
620 		printf("%s", SystemError(ret));
621 		return VFD_NG;
622 	}
623 
624 	//	Get the latest driver state
625 
626 	ret = VfdGetDriverState(&driver_state);
627 
628 	if (ret != ERROR_SUCCESS) {
629 		PrintMessage(MSG_GET_STAT_NG);
630 		printf("%s", SystemError(ret));
631 		return VFD_NG;
632 	}
633 
634 	//	operation successfull
635 
636 	PrintMessage(MSG_INSTALL_OK);
637 
638 	return VFD_OK;
639 }
640 
641 //
642 //	Remove Virtual Floppy Driver from system
643 //	Command Line Parameters:
644 //		[/F | /FORCE | /Q | /QUIT]
645 //		/F	forces remove operation if the driver cannot be stopped
646 //		/Q	quits remove operation if the driver cannot be stopped
647 //
Remove(const char ** args)648 int	Remove(const char **args)
649 {
650 	int			mode = OPERATION_ASK;
651 	const char	*stop_params[] = { NULL, NULL };
652 	DWORD		ret;
653 	int			idx;
654 
655 	//	parse parameters
656 
657 	while (args && *args) {
658 
659 		if (!_stricmp(*args, "/f") ||
660 			!_stricmp(*args, "/force")) {
661 
662 			if (mode != OPERATION_ASK) {
663 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
664 				return VFD_NG;
665 			}
666 
667 			mode = OPERATION_FORCE;
668 			stop_params[0] = *args;
669 		}
670 		else if (!_stricmp(*args, "/q") ||
671 			!_stricmp(*args, "/quit")) {
672 
673 			if (mode != OPERATION_ASK) {
674 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
675 				return VFD_NG;
676 			}
677 
678 			mode = OPERATION_QUIT;
679 			stop_params[0] = *args;
680 		}
681 		else {
682 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
683 			PrintMessage(MSG_HINT_REMOVE, help_progname);
684 			return VFD_NG;
685 		}
686 
687 		args++;
688 	}
689 
690 	//	ensure the driver is installed
691 
692 	if (driver_state == VFD_NOT_INSTALLED) {
693 		PrintMessage(MSG_NOT_INSTALLED);
694 		return VFD_NG;
695 	}
696 
697 	//	ensure the driver is stopped
698 
699 	if (driver_state == SERVICE_RUNNING) {
700 
701 		//	Try to stop with the same command line option (/F or /Q)
702 
703 		while (Stop(stop_params) != VFD_OK) {
704 
705 			//	stop failed
706 
707 			if (mode == OPERATION_FORCE) {
708 				PrintMessage(MSG_REMOVE_FORCE);
709 				break;
710 			}
711 			else if (mode == OPERATION_QUIT) {
712 				PrintMessage(MSG_REMOVE_QUIT);
713 				return VFD_NG;
714 			}
715 			else {
716 				int c;
717 
718 				PrintMessage(MSG_REMOVE_WARN);
719 
720 				c = InputChar(MSG_RETRY_FORCE_CANCEL, "rfc");
721 
722 				if (c == 'f') {			//	force
723 					break;
724 				}
725 				else if (c == 'c') {	//	cancel
726 					return VFD_NG;
727 				}
728 			}
729 		}
730 	}
731 
732 	//	remove the driver
733 
734 	ret = VfdRemoveDriver();
735 
736 	if (ret != ERROR_SUCCESS) {
737 		PrintMessage(MSG_REMOVE_NG);
738 		printf("%s", SystemError(ret));
739 		return VFD_NG;
740 	}
741 
742 	// Wait for the driver to be actually removed for 3 secs Max.
743 
744 	for (idx = 0; idx < 10; idx++) {
745 
746 		ret = VfdGetDriverState(&driver_state);
747 
748 		if (ret != ERROR_SUCCESS) {
749 			PrintMessage(MSG_GET_STAT_NG);
750 			printf("%s", SystemError(ret));
751 			return VFD_NG;
752 		}
753 
754 		if (driver_state == VFD_NOT_INSTALLED) {
755 			break;
756 		}
757 
758 		Sleep(300);
759 	}
760 
761 	if (driver_state != VFD_NOT_INSTALLED) {
762 		PrintMessage(MSG_REMOVE_PENDING);
763 		return VFD_NG;
764 	}
765 
766 	//	operation successful
767 
768 	PrintMessage(MSG_REMOVE_OK);
769 
770 	return VFD_OK;
771 }
772 
773 //
774 //	Configure the Virtual Floppy Driver
775 //	Command Line Parameters:
776 //	/auto, /manual
777 //
Config(const char ** args)778 int	Config(const char **args)
779 {
780 	DWORD	start_type = SERVICE_DISABLED;
781 	DWORD	ret;
782 
783 	while (args && *args) {
784 		if (!_stricmp(*args, "/a") ||
785 			!_stricmp(*args, "/auto")) {
786 
787 			if (start_type != SERVICE_DISABLED) {
788 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
789 				return VFD_NG;
790 			}
791 
792 			start_type = SERVICE_AUTO_START;
793 		}
794 		else if (!_stricmp(*args, "/m") ||
795 			!_stricmp(*args, "/manual")) {
796 
797 			if (start_type != SERVICE_DISABLED) {
798 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
799 				return VFD_NG;
800 			}
801 
802 			start_type = SERVICE_DEMAND_START;
803 		}
804 		else {
805 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
806 			PrintMessage(MSG_HINT_CONFIG, help_progname);
807 			return VFD_NG;
808 		}
809 
810 		args++;
811 	}
812 
813 	if (start_type == SERVICE_DISABLED) {
814 		//	no parameter is specified
815 		PrintMessage(MSG_HINT_CONFIG, help_progname);
816 		return VFD_NG;
817 	}
818 
819 	//	ensure that the driver is installed
820 
821 	if (driver_state == VFD_NOT_INSTALLED) {
822 		PrintMessage(MSG_NOT_INSTALLED);
823 		return VFD_NG;
824 	}
825 
826 	//	ensure that the driver is up to date
827 
828 	if (CheckDriver() != VFD_OK) {
829 		return VFD_NG;
830 	}
831 
832 	//	configure the driver
833 
834 	ret = VfdConfigDriver(start_type);
835 
836 	if (ret != ERROR_SUCCESS) {
837 		PrintMessage(MSG_CONFIG_NG);
838 		printf("%s", SystemError(ret));
839 		return VFD_NG;
840 	}
841 
842 	//	operation successfull
843 
844 	PrintMessage(MSG_CONFIG_OK);
845 
846 	return VFD_OK;
847 }
848 
849 //
850 //	Start the Virtual Floppy Driver
851 //	Command Line Parameters: None
852 //
Start(const char ** args)853 int	Start(const char **args)
854 {
855 	DWORD	ret;
856 
857 	UNREFERENCED_PARAMETER(args);
858 
859 	//	ensure that the driver is installed
860 
861 	if (driver_state == VFD_NOT_INSTALLED &&
862 		Install(NULL) != VFD_OK) {
863 		return VFD_NG;
864 	}
865 
866 	//	ensure that the driver is up to date
867 
868 	if (CheckDriver() != VFD_OK) {
869 		return VFD_NG;
870 	}
871 
872 	//	ensure that the driver is not running
873 
874 	if (driver_state == SERVICE_RUNNING) {
875 		PrintMessage(MSG_ALREADY_RUNNING);
876 		return VFD_NG;
877 	}
878 
879 	//	start the driver
880 
881 	ret = VfdStartDriver(&driver_state);
882 
883 	if (ret != ERROR_SUCCESS) {
884 		PrintMessage(MSG_START_NG);
885 		printf("%s", SystemError(ret));
886 		return VFD_NG;
887 	}
888 
889 	//	operation successfull
890 
891 	PrintMessage(MSG_START_OK);
892 
893 	return VFD_OK;
894 }
895 
896 //
897 //	Stop the Virtual Floppy Driver
898 //	Command Line Parameters:
899 //		/FORCE | /F		Forces the operation on error
900 //		/QUIT  | /Q		Quits the operation on error
901 //
Stop(const char ** args)902 int	Stop(const char **args)
903 {
904 	int			mode = OPERATION_ASK;
905 	const char	*close_params[] = { "*", NULL, NULL };
906 	DWORD		ret;
907 
908 	while (args && *args) {
909 		if (!_stricmp(*args, "/f") ||
910 			!_stricmp(*args, "/force")) {
911 
912 			if (mode != OPERATION_ASK) {
913 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
914 				return VFD_NG;
915 			}
916 
917 			mode = OPERATION_FORCE;
918 
919 			//	parameter to pass to the Close() function
920 			close_params[1] = *args;
921 		}
922 		else if (!_stricmp(*args, "/q") ||
923 			!_stricmp(*args, "/quit")) {
924 
925 			if (mode != OPERATION_ASK) {
926 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
927 				return VFD_NG;
928 			}
929 
930 			mode = OPERATION_QUIT;
931 
932 			//	parameter to pass to the Close() function
933 			close_params[1] = *args;
934 		}
935 		else {
936 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
937 			PrintMessage(MSG_HINT_STOP, help_progname);
938 			return VFD_NG;
939 		}
940 
941 		args++;
942 	}
943 
944 	//	ensure that the driver is installed
945 
946 	if (driver_state == VFD_NOT_INSTALLED) {
947 		PrintMessage(MSG_NOT_INSTALLED);
948 		return VFD_NG;
949 	}
950 
951 	//	ensure that the driver is running
952 
953 	if (driver_state == SERVICE_STOPPED) {
954 		PrintMessage(MSG_NOT_STARTED);
955 		return VFD_NG;
956 	}
957 
958 	//	ensure that all drives are empty
959 
960 	if (driver_state == SERVICE_RUNNING) {
961 
962 		//	Try to close drives with the same operation mode (/F or /Q)
963 
964 		while (Close(close_params) != VFD_OK) {
965 
966 			//	close failed
967 
968 			if (mode == OPERATION_FORCE) {
969 				PrintMessage(MSG_STOP_FORCE);
970 				break;
971 			}
972 			else if (mode == OPERATION_QUIT) {
973 				PrintMessage(MSG_STOP_QUIT);
974 				return VFD_NG;
975 			}
976 			else {
977 				int c;
978 
979 				PrintMessage(MSG_STOP_WARN);
980 
981 				c = InputChar(MSG_RETRY_FORCE_CANCEL, "rfc");
982 
983 				if (c == 'f') {			//	force
984 					break;
985 				}
986 				else if (c == 'c') {	//	cancel
987 					return VFD_NG;
988 				}
989 			}
990 		}
991 	}
992 
993 	//	stop the driver
994 
995 	ret = VfdStopDriver(&driver_state);
996 
997 	if (ret != ERROR_SUCCESS) {
998 		PrintMessage(MSG_STOP_NG);
999 		printf("%s", SystemError(ret));
1000 		return VFD_NG;
1001 	}
1002 
1003 	if (driver_state != SERVICE_STOPPED) {
1004 		PrintMessage(MSG_STOP_PENDING);
1005 		return VFD_NG;
1006 	}
1007 
1008 	//	operation successful
1009 
1010 	PrintMessage(MSG_STOP_OK);
1011 
1012 	return VFD_OK;
1013 }
1014 
1015 //
1016 //	Enable / Disable the shell extension
1017 //	Command Line Parameters:
1018 //	(optional) /ON or /OFF
1019 //
Shell(const char ** args)1020 int Shell(const char **args)
1021 {
1022 	DWORD ret;
1023 
1024 	ret = VfdCheckHandlers();
1025 
1026 	if (ret != ERROR_SUCCESS &&
1027 		ret != ERROR_PATH_NOT_FOUND &&
1028 		ret != ERROR_FILE_NOT_FOUND) {
1029 		PrintMessage(MSG_GET_SHELLEXT_NG);
1030 		printf("%s", SystemError(ret));
1031 		return VFD_NG;
1032 	}
1033 
1034 	if (args && *args) {
1035 		if (_stricmp(*args, "/on") == 0) {
1036 			if (ret != ERROR_SUCCESS) {
1037 				ret = VfdRegisterHandlers();
1038 
1039 				if (ret != ERROR_SUCCESS) {
1040 					PrintMessage(MSG_SET_SHELLEXT_NG);
1041 					printf("%s", SystemError(ret));
1042 					return VFD_NG;
1043 				}
1044 			}
1045 		}
1046 		else if (_stricmp(*args, "/off") == 0) {
1047 			if (ret == ERROR_SUCCESS) {
1048 				ret = VfdUnregisterHandlers();
1049 
1050 				if (ret != ERROR_SUCCESS) {
1051 					PrintMessage(MSG_SET_SHELLEXT_NG);
1052 					printf("%s", SystemError(ret));
1053 					return VFD_NG;
1054 				}
1055 			}
1056 		}
1057 		else {
1058 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
1059 			PrintMessage(MSG_HINT_SHELL, help_progname);
1060 			return VFD_NG;
1061 		}
1062 
1063 		ret = VfdCheckHandlers();
1064 	}
1065 
1066 	if (ret == ERROR_PATH_NOT_FOUND ||
1067 		ret == ERROR_FILE_NOT_FOUND) {
1068 		PrintMessage(MSG_SHELLEXT_DISABLED);
1069 	}
1070 	else if (ret == ERROR_SUCCESS) {
1071 		PrintMessage(MSG_SHELLEXT_ENABLED);
1072 	}
1073 	else {
1074 		PrintMessage(MSG_GET_SHELLEXT_NG);
1075 		printf("%s", SystemError(ret));
1076 		return VFD_NG;
1077 	}
1078 
1079 	return VFD_OK;
1080 }
1081 
1082 //
1083 //	Open an image file to a Virtual Floppy Drive
1084 //	Command Line Parameters:
1085 //	[drive:] [file] [/NEW] [/RAM] [/P | /W]
1086 //	[/size] [/media] [/F | /FORCE | /Q | /QUIT]
1087 
Open(const char ** args)1088 int	Open(const char **args)
1089 {
1090 	int				mode		= OPERATION_ASK;
1091 	BOOL			create		= FALSE;
1092 	ULONG			target		= TARGET_NONE;
1093 	PCSTR			file_name	= NULL;
1094 	VFD_DISKTYPE	disk_type	= VFD_DISKTYPE_FILE;
1095 	CHAR			protect		= '\0';
1096 	VFD_MEDIA		media_type	= VFD_MEDIA_NONE;
1097 	BOOL			five_inch	= FALSE;
1098 	VFD_FLAGS		media_flags	= 0;
1099 	HANDLE			hDevice;
1100 	CHAR			letter;
1101 	DWORD			ret;
1102 
1103 	//	process parameters
1104 
1105 	while (args && *args) {
1106 
1107 		if (!_stricmp(*args, "/f") ||
1108 			!_stricmp(*args, "/force")) {
1109 
1110 			if (mode != OPERATION_ASK) {
1111 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1112 				return VFD_NG;
1113 			}
1114 
1115 			mode = OPERATION_FORCE;
1116 		}
1117 		else if (!_stricmp(*args, "/q") ||
1118 			!_stricmp(*args, "/quit")) {
1119 
1120 			if (mode != OPERATION_ASK) {
1121 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1122 				return VFD_NG;
1123 			}
1124 
1125 			mode = OPERATION_QUIT;
1126 		}
1127 
1128 		else if (!_stricmp(*args, "/new")) {
1129 
1130 			if (create) {
1131 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1132 				return VFD_NG;
1133 			}
1134 
1135 			create = TRUE;
1136 		}
1137 
1138 		//	Disk type options
1139 
1140 		else if (_stricmp(*args, "/ram") == 0) {
1141 
1142 			if (disk_type != VFD_DISKTYPE_FILE) {
1143 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1144 				return VFD_NG;
1145 			}
1146 
1147 			disk_type = VFD_DISKTYPE_RAM;
1148 		}
1149 
1150 		//	Protect options
1151 		else if (_stricmp(*args, "/p") == 0 ||
1152 			_stricmp(*args, "/w") == 0) {
1153 
1154 			if (protect) {
1155 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1156 				return VFD_NG;
1157 			}
1158 
1159 			protect = (CHAR)toupper(*(*args + 1));
1160 		}
1161 
1162 		//	media size options
1163 
1164 		else if (strcmp(*args, "/160") == 0) {
1165 			if (media_type) {
1166 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1167 				return VFD_NG;
1168 			}
1169 
1170 			media_type = VFD_MEDIA_F5_160;
1171 		}
1172 		else if (strcmp(*args, "/180") == 0) {
1173 			if (media_type) {
1174 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1175 				return VFD_NG;
1176 			}
1177 
1178 			media_type = VFD_MEDIA_F5_180;
1179 		}
1180 		else if (strcmp(*args, "/320") == 0) {
1181 			if (media_type) {
1182 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1183 				return VFD_NG;
1184 			}
1185 
1186 			media_type = VFD_MEDIA_F5_320;
1187 		}
1188 		else if (strcmp(*args, "/360") == 0) {
1189 			if (media_type) {
1190 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1191 				return VFD_NG;
1192 			}
1193 
1194 			media_type = VFD_MEDIA_F5_360;
1195 		}
1196 		else if (strcmp(*args, "/640") == 0) {
1197 			if (media_type) {
1198 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1199 				return VFD_NG;
1200 			}
1201 
1202 			media_type = VFD_MEDIA_F3_640;
1203 		}
1204 		else if (strcmp(*args, "/720") == 0) {
1205 			if (media_type) {
1206 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1207 				return VFD_NG;
1208 			}
1209 
1210 			media_type = VFD_MEDIA_F3_720;
1211 		}
1212 		else if (strcmp(*args, "/820") == 0) {
1213 			if (media_type) {
1214 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1215 				return VFD_NG;
1216 			}
1217 
1218 			media_type = VFD_MEDIA_F3_820;
1219 		}
1220 		else if (strcmp(*args, "/120") == 0 ||
1221 			strcmp(*args, "/1.20") == 0) {
1222 			if (media_type) {
1223 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1224 				return VFD_NG;
1225 			}
1226 
1227 			media_type = VFD_MEDIA_F3_1P2;
1228 		}
1229 		else if (strcmp(*args, "/144") == 0 ||
1230 			strcmp(*args, "/1.44") == 0) {
1231 			if (media_type) {
1232 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1233 				return VFD_NG;
1234 			}
1235 
1236 			media_type = VFD_MEDIA_F3_1P4;
1237 		}
1238 		else if (strcmp(*args, "/168") == 0 ||
1239 			strcmp(*args, "/1.68") == 0) {
1240 			if (media_type) {
1241 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1242 				return VFD_NG;
1243 			}
1244 
1245 			media_type = VFD_MEDIA_F3_1P6;
1246 		}
1247 		else if (strcmp(*args, "/172") == 0 ||
1248 			strcmp(*args, "/1.72") == 0) {
1249 			if (media_type) {
1250 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1251 				return VFD_NG;
1252 			}
1253 
1254 			media_type = VFD_MEDIA_F3_1P7;
1255 		}
1256 		else if (strcmp(*args, "/288") == 0 ||
1257 			strcmp(*args, "/2.88") == 0) {
1258 			if (media_type) {
1259 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1260 				return VFD_NG;
1261 			}
1262 
1263 			media_type = VFD_MEDIA_F3_2P8;
1264 		}
1265 
1266 		//	5.25 inch media
1267 
1268 		else if (strcmp(*args, "/5") == 0 ||
1269 			strcmp(*args, "/525") == 0 ||
1270 			strcmp(*args, "/5.25") == 0) {
1271 
1272 			if (five_inch) {
1273 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1274 				return VFD_NG;
1275 			}
1276 
1277 			five_inch = TRUE;
1278 		}
1279 
1280 		//	target option
1281 
1282 		else if (isalnum(**args) &&
1283 			*(*args + 1) == ':' &&
1284 			*(*args + 2) == '\0') {
1285 
1286 			if (target != TARGET_NONE) {
1287 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1288 				return VFD_NG;
1289 			}
1290 
1291 			target = toupper(**args);
1292 		}
1293 
1294 		//	filename
1295 
1296 		else if (**args != '/') {
1297 			if (file_name) {
1298 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1299 				return VFD_NG;
1300 			}
1301 
1302 			file_name = *args;
1303 		}
1304 		else {
1305 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
1306 			PrintMessage(MSG_HINT_OPEN, help_progname);
1307 			return VFD_NG;
1308 		}
1309 
1310 		args++;
1311 	}
1312 
1313 	if (target == TARGET_NONE) {
1314 		// default target
1315 		target = '0';
1316 		PrintMessage(MSG_TARGET_NOTICE, target);
1317 	}
1318 
1319 	//	check target file
1320 
1321 	if (file_name) {
1322 		DWORD			file_attr;
1323 		VFD_FILETYPE	file_type;
1324 		ULONG			image_size;
1325 		BOOL			overwrite = FALSE;
1326 
1327 		ret = VfdCheckImageFile(
1328 			file_name, &file_attr, &file_type, &image_size);
1329 
1330 		if (ret == ERROR_FILE_NOT_FOUND) {
1331 
1332 			//	the target file does not exist
1333 
1334 			if (!create) {				// create option not specified
1335 
1336 				if (mode == OPERATION_FORCE) {
1337 					PrintMessage(MSG_CREATE_NOTICE);
1338 				}
1339 				else {
1340 					printf("%s", SystemError(ret));
1341 
1342 					if (mode == OPERATION_QUIT ||
1343 						InputChar(MSG_CREATE_CONFIRM, "yn") == 'n') {
1344 						return VFD_NG;
1345 					}
1346 				}
1347 
1348 				create = TRUE;
1349 			}
1350 		}
1351 		else if (ret == ERROR_SUCCESS) {
1352 
1353 			//	the target file exists
1354 
1355 			if (create) {				//	create option is specified
1356 
1357 				if (mode == OPERATION_FORCE) {
1358 					PrintMessage(MSG_OVERWRITE_NOTICE);
1359 				}
1360 				else {
1361 					printf("%s", SystemError(ERROR_FILE_EXISTS));
1362 
1363 					if (mode == OPERATION_QUIT ||
1364 						InputChar(MSG_OVERWRITE_CONFIRM, "yn") == 'n') {
1365 						return VFD_NG;
1366 					}
1367 				}
1368 
1369 				overwrite = TRUE;
1370 			}
1371 		}
1372 		else {
1373 			PrintMessage(MSG_OPEN_NG, file_name);
1374 			printf("%s", SystemError(ret));
1375 			return VFD_NG;
1376 		}
1377 
1378 		//
1379 		//	create or overwrite the target file
1380 		//
1381 
1382 		if (create) {
1383 
1384 			if (media_type == VFD_MEDIA_NONE) {
1385 
1386 				if (mode == OPERATION_FORCE) {
1387 					PrintMessage(MSG_CREATE144_NOTICE);
1388 				}
1389 				else {
1390 					PrintMessage(MSG_FILE_MEDIA_UNKNOWN);
1391 
1392 					if (mode == OPERATION_QUIT ||
1393 						InputChar(MSG_CREATE144_CONFIRM, "yn") == 'n') {
1394 						return VFD_NG;
1395 					}
1396 				}
1397 
1398 				media_type = VFD_MEDIA_F3_1P4;
1399 			}
1400 
1401 			ret = VfdCreateImageFile(
1402 				file_name, media_type, VFD_FILETYPE_RAW, overwrite);
1403 
1404 			if (ret != ERROR_SUCCESS) {
1405 				PrintMessage(MSG_CREATE_NG, file_name);
1406 				printf("%s", SystemError(ret));
1407 				return VFD_NG;
1408 			}
1409 
1410 			PrintMessage(MSG_FILE_CREATED);
1411 
1412 			ret = VfdCheckImageFile(
1413 				file_name, &file_attr, &file_type, &image_size);
1414 
1415 			if (ret != ERROR_SUCCESS) {
1416 				PrintMessage(MSG_OPEN_NG, file_name);
1417 				printf("%s", SystemError(ret));
1418 				return VFD_NG;
1419 			}
1420 		}
1421 		else {
1422 			//
1423 			//	use the existing target file
1424 			//	check image size and the media type
1425 			//
1426 
1427 			VFD_MEDIA	def_media;	//	default media for image size
1428 			ULONG		media_size;	//	specified media size
1429 
1430 			media_size	= VfdGetMediaSize(media_type);
1431 
1432 			if (media_size > image_size) {
1433 
1434 				//	specified media is too large for the image
1435 
1436 				PrintMessage(MSG_IMAGE_TOO_SMALL);
1437 				return VFD_NG;
1438 			}
1439 
1440 			def_media	= VfdLookupMedia(image_size);
1441 
1442 			if (def_media == VFD_MEDIA_NONE) {
1443 
1444 				//	image is too small for the smallest media
1445 
1446 				PrintMessage(MSG_IMAGE_TOO_SMALL);
1447 				return VFD_NG;
1448 			}
1449 
1450 			if (media_type == VFD_MEDIA_NONE) {
1451 
1452 				//	media type is not specified
1453 
1454 				ULONG def_size = VfdGetMediaSize(def_media);
1455 
1456 				if (def_size != image_size) {
1457 
1458 					//	image size does not match the largest media size
1459 
1460 					PrintMessage(MSG_NO_MATCHING_MEDIA, image_size);
1461 
1462 					if (mode == OPERATION_FORCE) {
1463 						PrintMessage(MSG_MEDIATYPE_NOTICE,
1464 							VfdMediaTypeName(def_media), def_size);
1465 					}
1466 					else if (mode == OPERATION_QUIT) {
1467 						return VFD_NG;
1468 					}
1469 					else {
1470 						PrintMessage(MSG_MEDIATYPE_SUGGEST,
1471 							VfdMediaTypeName(def_media), def_size);
1472 
1473 						if (InputChar(MSG_MEDIATYPE_CONFIRM, "yn") == 'n') {
1474 							return VFD_NG;
1475 						}
1476 					}
1477 				}
1478 
1479 				media_type = def_media;
1480 			}
1481 		}
1482 
1483 		//	check file attributes against the disk type
1484 
1485 		if (file_type == VFD_FILETYPE_ZIP ||
1486 			(file_attr & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_COMPRESSED | FILE_ATTRIBUTE_ENCRYPTED))) {
1487 
1488 			if (disk_type != VFD_DISKTYPE_RAM) {
1489 
1490 				if (mode == OPERATION_FORCE) {
1491 					PrintMessage(MSG_RAM_MODE_NOTICE);
1492 				}
1493 				else {
1494 					PrintMessage(MSG_RAM_MODE_ONLY);
1495 
1496 					if (mode == OPERATION_QUIT ||
1497 						InputChar(MSG_RAM_MODE_CONFIRM, "yn") == 'n') {
1498 						return VFD_NG;
1499 					}
1500 				}
1501 
1502 				disk_type = VFD_DISKTYPE_RAM;
1503 			}
1504 		}
1505 
1506 		if (disk_type != VFD_DISKTYPE_FILE) {
1507 			if (!protect) {
1508 				PrintMessage(MSG_DEFAULT_PROTECT);
1509 				protect = 'P';
1510 			}
1511 		}
1512 	}
1513 	else {
1514 		//
1515 		//	pure RAM disk
1516 		//
1517 		disk_type = VFD_DISKTYPE_RAM;
1518 
1519 		if (media_type == VFD_MEDIA_NONE) {
1520 
1521 			if (mode == OPERATION_FORCE) {
1522 				PrintMessage(MSG_CREATE144_NOTICE);
1523 			}
1524 			else {
1525 				PrintMessage(MSG_RAM_MEDIA_UNKNOWN);
1526 
1527 				if (mode == OPERATION_QUIT ||
1528 					InputChar(MSG_CREATE144_CONFIRM, "yn") == 'n') {
1529 					return VFD_NG;
1530 				}
1531 			}
1532 
1533 			media_type = VFD_MEDIA_F3_1P4;
1534 		}
1535 	}
1536 
1537 	if (protect == 'P') {
1538 		media_flags |= VFD_FLAG_WRITE_PROTECTED;
1539 	}
1540 
1541 	if (five_inch &&
1542 		VfdGetMediaSize(media_type) ==
1543 		VfdGetMediaSize((VFD_MEDIA)(media_type + 1))) {
1544 		media_type = (VFD_MEDIA)(media_type + 1);
1545 	}
1546 
1547 	//	ensure that the driver is installed
1548 
1549 	if (driver_state == VFD_NOT_INSTALLED &&
1550 		Install(NULL) != VFD_OK) {
1551 		return VFD_NG;
1552 	}
1553 
1554 	//	ensure that the driver is up to date
1555 
1556 	if (CheckDriver() != VFD_OK) {
1557 		return VFD_NG;
1558 	}
1559 
1560 	//	ensure that the driver is running
1561 
1562 	if (driver_state != SERVICE_RUNNING &&
1563 		Start(NULL) != VFD_OK) {
1564 		return VFD_NG;
1565 	}
1566 
1567 	//	Open the target device
1568 
1569 	hDevice = VfdOpenDevice(target);
1570 
1571 	if (hDevice == INVALID_HANDLE_VALUE) {
1572 		ret = GetLastError();
1573 		PrintMessage(MSG_ACCESS_NG, target);
1574 		printf("%s", SystemError(ret));
1575 		return VFD_NG;
1576 	}
1577 
1578 	//	Ensure that the drive is empty
1579 
1580 	ret = VfdGetMediaState(hDevice);
1581 
1582 	if (ret != ERROR_NOT_READY) {
1583 		if (ret == ERROR_SUCCESS ||
1584 			ret == ERROR_WRITE_PROTECT) {
1585 			PrintMessage(MSG_DRIVE_BUSY);
1586 		}
1587 		else {
1588 			PrintMessage(MSG_GET_MEDIA_NG);
1589 			printf("%s", SystemError(ret));
1590 		}
1591 
1592 		CloseHandle(hDevice);
1593 		return VFD_NG;
1594 	}
1595 
1596 	//	Open the image file
1597 
1598 	ret = VfdOpenImage(hDevice, file_name,
1599 		disk_type, media_type, media_flags);
1600 
1601 	if (ret != ERROR_SUCCESS) {
1602 		PrintMessage(MSG_OPEN_NG, file_name ? file_name : "<RAM>");
1603 		printf("%s", SystemError(ret));
1604 
1605 		CloseHandle(hDevice);
1606 		return VFD_NG;
1607 	}
1608 
1609 	//	assign a drive letter if the drive has none
1610 
1611 	VfdGetGlobalLink(hDevice, &letter);
1612 
1613 	if (!isalpha(letter)) {
1614 		VfdGetLocalLink(hDevice, &letter);
1615 	}
1616 
1617 	if (!isalpha(letter)) {
1618 		VfdSetLocalLink(hDevice, VfdChooseLetter());
1619 	}
1620 
1621 	//	Get the actually opened image information.
1622 
1623 	PrintImageInfo(hDevice);
1624 
1625 	CloseHandle(hDevice);
1626 
1627 	return VFD_OK;
1628 }
1629 
1630 //
1631 //	Close the current virtual floppy image
1632 //	Command Line Parameters:
1633 //		drive number or drive letter
1634 //		/F | /FORCE | /Q | /QUIT
1635 //
Close(const char ** args)1636 int	Close(const char **args)
1637 {
1638 	ULONG			mode = OPERATION_ASK;
1639 
1640 	ULONG			target_min = TARGET_NONE;
1641 	ULONG			target_max = TARGET_NONE;
1642 	HANDLE			hDevice;
1643 
1644 	VFD_MEDIA		media_type;
1645 	VFD_FLAGS		media_flags;
1646 
1647 	DWORD			ret;
1648 
1649 	//	check parameterS
1650 
1651 	while (args && *args) {
1652 
1653 		if (!_stricmp(*args, "/f") ||
1654 			!_stricmp(*args, "/force")) {
1655 
1656 			if (mode != OPERATION_ASK) {
1657 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1658 				return VFD_NG;
1659 			}
1660 
1661 			mode = OPERATION_FORCE;
1662 		}
1663 		else if (!_stricmp(*args, "/q") ||
1664 			!_stricmp(*args, "/quit")) {
1665 
1666 			if (mode != OPERATION_ASK) {
1667 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1668 				return VFD_NG;
1669 			}
1670 
1671 			mode = OPERATION_QUIT;
1672 		}
1673 		else if ((isalnum(**args) || **args == '*') &&
1674 			(*(*args + 1) == ':' || *(*args + 1) == '\0')) {
1675 
1676 			if (target_min != TARGET_NONE) {
1677 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1678 				return VFD_NG;
1679 			}
1680 
1681 			if (**args == '*') {
1682 				target_min = '0';
1683 				target_max = '0' + VFD_MAXIMUM_DEVICES;
1684 			}
1685 			else {
1686 				target_min = toupper(**args);
1687 				target_max = target_min + 1;
1688 			}
1689 		}
1690 		else {
1691 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
1692 			PrintMessage(MSG_HINT_CLOSE, help_progname);
1693 			return VFD_NG;
1694 		}
1695 
1696 		args++;
1697 	}
1698 
1699 	if (target_min == TARGET_NONE) {
1700 		// default target = drive 0
1701 		target_min = '0';
1702 		target_max = '1';
1703 		PrintMessage(MSG_TARGET_NOTICE, target_min);
1704 	}
1705 
1706 	//	ensure that the driver is installed
1707 
1708 	if (driver_state == VFD_NOT_INSTALLED) {
1709 		PrintMessage(MSG_NOT_INSTALLED);
1710 		return VFD_NG;
1711 	}
1712 
1713 	//	ensure that the driver is running
1714 
1715 	if (driver_state != SERVICE_RUNNING) {
1716 		PrintMessage(MSG_NOT_STARTED);
1717 		return VFD_NG;
1718 	}
1719 
1720 	//	Close the drive(s)
1721 
1722 	while (target_min < target_max) {
1723 
1724 		//	open the target device
1725 
1726 		hDevice = VfdOpenDevice(target_min);
1727 
1728 		if (hDevice == INVALID_HANDLE_VALUE) {
1729 			ret = GetLastError();
1730 
1731 			PrintMessage(MSG_ACCESS_NG, target_min);
1732 			printf("%s", SystemError(ret));
1733 
1734 			if (mode != OPERATION_FORCE) {
1735 				return VFD_NG;
1736 			}
1737 
1738 			target_min++;
1739 			continue;
1740 		}
1741 
1742 		//	get the current image information
1743 
1744 		ret = VfdGetImageInfo(hDevice, NULL, NULL,
1745 			&media_type, &media_flags, NULL, NULL);
1746 
1747 		if (ret != ERROR_SUCCESS) {
1748 			PrintMessage(MSG_ACCESS_NG, target_min);
1749 			printf("%s", SystemError(ret));
1750 
1751 			CloseHandle(hDevice);
1752 
1753 			if (mode != OPERATION_FORCE) {
1754 				return VFD_NG;
1755 			}
1756 
1757 			target_min++;
1758 			continue;
1759 		}
1760 
1761 		if (media_type == VFD_MEDIA_NONE) {
1762 
1763 			//	drive is empty
1764 
1765 			CloseHandle(hDevice);
1766 			target_min++;
1767 			continue;
1768 		}
1769 
1770 		if (media_flags & VFD_FLAG_DATA_MODIFIED) {
1771 
1772 			//	RAM disk data is modified
1773 
1774 			PrintMessage(MSG_MEDIA_MODIFIED, target_min);
1775 
1776 			if (mode == OPERATION_FORCE) {
1777 				PrintMessage(MSG_CLOSE_FORCE);
1778 			}
1779 			else if (mode == OPERATION_QUIT) {
1780 				PrintMessage(MSG_CLOSE_QUIT);
1781 				CloseHandle(hDevice);
1782 				return VFD_NG;
1783 			}
1784 			else {
1785 				if (InputChar(MSG_CLOSE_CONFIRM, "yn") == 'n') {
1786 					CloseHandle(hDevice);
1787 					return VFD_NG;
1788 				}
1789 			}
1790 		}
1791 
1792 retry:
1793 		ret = VfdCloseImage(
1794 			hDevice, (mode == OPERATION_FORCE));
1795 
1796 		if (ret == ERROR_ACCESS_DENIED) {
1797 
1798 			PrintMessage(MSG_LOCK_NG, target_min);
1799 
1800 			if (mode == OPERATION_QUIT) {
1801 				CloseHandle(hDevice);
1802 				return VFD_NG;
1803 			}
1804 			else if (mode == OPERATION_ASK) {
1805 
1806 				int c;
1807 
1808 				if (IS_WINDOWS_NT()) {
1809 					c = InputChar(MSG_RETRY_CANCEL, "rc");
1810 				}
1811 				else {
1812 					c = InputChar(MSG_RETRY_FORCE_CANCEL, "rfc");
1813 				}
1814 
1815 				if (c == 'f') {				//	force
1816 					ret = VfdCloseImage(hDevice, TRUE);
1817 				}
1818 				else if (c == 'c') {		//	cancel
1819 					CloseHandle(hDevice);
1820 					return VFD_NG;
1821 				}
1822 				else {
1823 					goto retry;
1824 				}
1825 			}
1826 		}
1827 
1828 		CloseHandle(hDevice);
1829 
1830 		if (ret == ERROR_SUCCESS) {
1831 			PrintMessage(MSG_CLOSE_OK, target_min);
1832 		}
1833 		else if (ret != ERROR_NOT_READY) {
1834 			PrintMessage(MSG_CLOSE_NG, target_min);
1835 			printf("%s", SystemError(ret));
1836 
1837 			if (mode != OPERATION_FORCE) {
1838 				return VFD_NG;
1839 			}
1840 		}
1841 
1842 		target_min++;
1843 	}
1844 
1845 	return VFD_OK;
1846 }
1847 
1848 //
1849 //	Save the current image into a file
1850 //
Save(const char ** args)1851 int	Save(const char **args)
1852 {
1853 	int				mode		= OPERATION_ASK;
1854 	ULONG			target		= TARGET_NONE;
1855 	CHAR			file_name[MAX_PATH]	= {0};
1856 	BOOL			overwrite	= FALSE;
1857 	BOOL			truncate	= FALSE;
1858 
1859 	HANDLE			hDevice;
1860 	CHAR			current[MAX_PATH] = {0};
1861 	VFD_MEDIA		media_type;
1862 	VFD_FLAGS		media_flags;
1863 	VFD_FILETYPE	file_type;
1864 	DWORD			file_attr;
1865 	ULONG			image_size;
1866 	DWORD			ret;
1867 
1868 	//	check parameters
1869 
1870 	while (args && *args) {
1871 
1872 		if (!_stricmp(*args, "/f") ||
1873 			!_stricmp(*args, "/force")) {
1874 
1875 			if (mode != OPERATION_ASK) {
1876 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1877 				return VFD_NG;
1878 			}
1879 
1880 			mode = OPERATION_FORCE;
1881 		}
1882 		else if (!_stricmp(*args, "/q") ||
1883 			!_stricmp(*args, "/quit")) {
1884 
1885 			if (mode != OPERATION_ASK) {
1886 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1887 				return VFD_NG;
1888 			}
1889 
1890 			mode = OPERATION_QUIT;
1891 		}
1892 		else if (!_stricmp(*args, "/o") ||
1893 			!_stricmp(*args, "/over")) {
1894 
1895 			if (truncate || overwrite) {
1896 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1897 				return VFD_NG;
1898 			}
1899 
1900 			overwrite = TRUE;
1901 		}
1902 		else if (!_stricmp(*args, "/t") ||
1903 			!_stricmp(*args, "/trunc")) {
1904 
1905 			if (truncate || overwrite) {
1906 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1907 				return VFD_NG;
1908 			}
1909 
1910 			truncate = TRUE;
1911 		}
1912 		else if (isalnum(**args) &&
1913 			*(*args + 1) == ':' &&
1914 			*(*args + 2) == '\0') {
1915 
1916 			if (target != TARGET_NONE) {
1917 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
1918 				return VFD_NG;
1919 			}
1920 
1921 			target = toupper(**args);
1922 		}
1923 		else if (**args == '/') {
1924 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
1925 			PrintMessage(MSG_HINT_SAVE, help_progname);
1926 			return VFD_NG;
1927 		}
1928 		else {
1929 			strcpy(file_name, *args);
1930 		}
1931 
1932 		args++;
1933 	}
1934 
1935 	if (target == TARGET_NONE) {
1936 		target = '0';
1937 		PrintMessage(MSG_TARGET_NOTICE, target);
1938 	}
1939 
1940 	//	ensure that the driver is installed
1941 
1942 	if (driver_state == VFD_NOT_INSTALLED) {
1943 		PrintMessage(MSG_NOT_INSTALLED);
1944 		return VFD_NG;
1945 	}
1946 
1947 	//	ensure that the driver is up to date
1948 
1949 	if (CheckDriver() != VFD_OK) {
1950 		return VFD_NG;
1951 	}
1952 
1953 	//	ensure that the driver is running
1954 
1955 	if (driver_state != SERVICE_RUNNING) {
1956 		PrintMessage(MSG_NOT_STARTED);
1957 		return VFD_NG;
1958 	}
1959 
1960 	//	Open the target device
1961 
1962 	hDevice = VfdOpenDevice(target);
1963 
1964 	if (hDevice == INVALID_HANDLE_VALUE) {
1965 		ret = GetLastError();
1966 		PrintMessage(MSG_ACCESS_NG, target);
1967 		printf("%s", SystemError(ret));
1968 		return VFD_NG;
1969 	}
1970 
1971 	//	Get the current image info
1972 
1973 	ret = VfdGetImageInfo(hDevice, current, NULL,
1974 		&media_type, &media_flags, NULL, NULL);
1975 
1976 	if (ret != ERROR_SUCCESS) {
1977 		printf("%s", SystemError(ret));
1978 		CloseHandle(hDevice);
1979 		return VFD_NG;
1980 	}
1981 
1982 	if (media_type == VFD_MEDIA_NONE) {
1983 		printf("%s", SystemError(ERROR_NOT_READY));
1984 		CloseHandle(hDevice);
1985 		return VFD_NG;
1986 	}
1987 
1988 	if (file_name[0] == '\0') {
1989 
1990 		if (current[0] == '\0') {
1991 
1992 			PrintMessage(MSG_TARGET_REQUIRED);
1993 			CloseHandle(hDevice);
1994 
1995 			return VFD_NG;
1996 		}
1997 
1998 		strcpy(file_name, current);
1999 	}
2000 
2001 	if (!_stricmp(file_name, current)) {
2002 
2003 		//	target is the current image file
2004 
2005 		if (!(media_flags & VFD_FLAG_DATA_MODIFIED)) {
2006 
2007 			//	FILE disk (always up to date) or RAM disk is not modified
2008 
2009 			PrintMessage(MSG_TARGET_UP_TO_DATE);
2010 			CloseHandle(hDevice);
2011 
2012 			return VFD_OK;
2013 		}
2014 
2015 		overwrite = TRUE;
2016 	}
2017 
2018 	//	check target file
2019 
2020 	ret = VfdCheckImageFile(file_name,
2021 		&file_attr, &file_type, &image_size);
2022 
2023 	if (ret == ERROR_SUCCESS) {
2024 
2025 		if (!overwrite && !truncate) {
2026 
2027 			if (mode == OPERATION_FORCE) {
2028 				PrintMessage(MSG_OVERWRITE_NOTICE);
2029 				overwrite = TRUE;
2030 			}
2031 			else if (mode == OPERATION_QUIT) {
2032 				printf("%s", SystemError(ERROR_FILE_EXISTS));
2033 				CloseHandle(hDevice);
2034 
2035 				return VFD_NG;
2036 			}
2037 			else {
2038 				int c;
2039 
2040 				printf("%s", SystemError(ERROR_FILE_EXISTS));
2041 
2042 				c = InputChar(MSG_OVERWRITE_PROMPT, "otc");
2043 
2044 				if (c == 'o') {
2045 					overwrite = TRUE;
2046 				}
2047 				else if (c == 't') {
2048 					truncate = TRUE;
2049 				}
2050 				else {
2051 					CloseHandle(hDevice);
2052 					return VFD_NG;
2053 				}
2054 			}
2055 		}
2056 	}
2057 	else if (ret != ERROR_FILE_NOT_FOUND) {
2058 
2059 		printf("%s", SystemError(ret));
2060 		CloseHandle(hDevice);
2061 
2062 		return VFD_NG;
2063 	}
2064 
2065 	if (file_type == VFD_FILETYPE_ZIP) {
2066 
2067 		//	Cannot update a zip file
2068 
2069 		PrintMessage(MSG_TARGET_IS_ZIP);
2070 		CloseHandle(hDevice);
2071 
2072 		return VFD_NG;
2073 	}
2074 
2075 retry:
2076 	ret = VfdDismountVolume(
2077 		hDevice, (mode == OPERATION_FORCE));
2078 
2079 	if (ret == ERROR_ACCESS_DENIED) {
2080 
2081 		PrintMessage(MSG_LOCK_NG, target);
2082 
2083 		if (mode == OPERATION_FORCE) {
2084 			PrintMessage(MSG_SAVE_FORCE);
2085 		}
2086 		else if (mode == OPERATION_QUIT) {
2087 			PrintMessage(MSG_SAVE_QUIT);
2088 			CloseHandle(hDevice);
2089 			return VFD_NG;
2090 		}
2091 		else {
2092 			int c = InputChar(MSG_RETRY_FORCE_CANCEL, "rfc");
2093 
2094 			if (c == 'r') {			// retry
2095 				goto retry;
2096 			}
2097 			else if (c == 'f') {	//	force
2098 				VfdDismountVolume(hDevice, TRUE);
2099 			}
2100 			else {					//	cancel
2101 				CloseHandle(hDevice);
2102 				return VFD_NG;
2103 			}
2104 		}
2105 	}
2106 	else if (ret != ERROR_SUCCESS) {
2107 		printf("%s", SystemError(ret));
2108 		CloseHandle(hDevice);
2109 		return VFD_NG;
2110 	}
2111 
2112 	ret = VfdSaveImage(hDevice, file_name,
2113 		(overwrite || truncate), truncate);
2114 
2115 	CloseHandle(hDevice);
2116 
2117 	if (ret != ERROR_SUCCESS) {
2118 		PrintMessage(MSG_SAVE_NG, target, file_name);
2119 		printf("%s", SystemError(ret));
2120 
2121 		return VFD_NG;
2122 	}
2123 
2124 	PrintMessage(MSG_SAVE_OK, target, file_name);
2125 
2126 	return VFD_OK;
2127 }
2128 
2129 //
2130 //	Enable/disable virtual media write protection
2131 //
Protect(const char ** args)2132 int	Protect(const char **args)
2133 {
2134 #define PROTECT_NONE	0
2135 #define PROTECT_ON		1
2136 #define PROTECT_OFF		2
2137 	ULONG	protect	= PROTECT_NONE;
2138 	ULONG	target	= TARGET_NONE;
2139 	HANDLE	hDevice;
2140 	DWORD	ret;
2141 
2142 	//	check parameters
2143 
2144 	while (args && *args) {
2145 
2146 		//	Disk type options
2147 
2148 		if (_stricmp(*args, "/on") == 0) {
2149 
2150 			if (protect) {
2151 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
2152 				return VFD_NG;
2153 			}
2154 
2155 			protect = PROTECT_ON;
2156 		}
2157 		else if (_stricmp(*args, "/off") == 0) {
2158 
2159 			if (protect) {
2160 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
2161 				return VFD_NG;
2162 			}
2163 
2164 			protect = PROTECT_OFF;
2165 		}
2166 		else if (isalnum(**args)) {
2167 
2168 			if (target != TARGET_NONE) {
2169 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
2170 				return VFD_NG;
2171 			}
2172 
2173 			target = toupper(**args);
2174 		}
2175 		else {
2176 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
2177 			PrintMessage(MSG_HINT_PROTECT, help_progname);
2178 			return VFD_NG;
2179 		}
2180 
2181 		args++;
2182 	}
2183 
2184 	if (target == TARGET_NONE) {
2185 		target = '0';
2186 		PrintMessage(MSG_TARGET_NOTICE, target);
2187 	}
2188 
2189 	//	ensure that the driver is installed
2190 
2191 	if (driver_state == VFD_NOT_INSTALLED) {
2192 		PrintMessage(MSG_NOT_INSTALLED);
2193 		return VFD_NG;
2194 	}
2195 
2196 	//	ensure that the driver is up to date
2197 
2198 	if (CheckDriver() != VFD_OK) {
2199 		return VFD_NG;
2200 	}
2201 
2202 	//	ensure that the driver is running
2203 
2204 	if (driver_state != SERVICE_RUNNING) {
2205 		PrintMessage(MSG_NOT_STARTED);
2206 		return VFD_NG;
2207 	}
2208 
2209 	//	open the target drive
2210 
2211 	hDevice = VfdOpenDevice(target);
2212 
2213 	if (hDevice == INVALID_HANDLE_VALUE) {
2214 		ret = GetLastError();
2215 		PrintMessage(MSG_ACCESS_NG, target);
2216 		printf("%s", SystemError(ret));
2217 		return VFD_NG;
2218 	}
2219 
2220 	if (protect) {
2221 		//	change protect state
2222 
2223 		ret = VfdWriteProtect(
2224 			hDevice, (protect == PROTECT_ON));
2225 
2226 		if (ret != ERROR_SUCCESS) {
2227 			PrintMessage(MSG_PROTECT_NG, target);
2228 			printf("%s", SystemError(ret));
2229 
2230 			CloseHandle(hDevice);
2231 			return VFD_NG;
2232 		}
2233 	}
2234 
2235 	//	get the current protect state
2236 
2237 	ret = VfdGetMediaState(hDevice);
2238 
2239 	CloseHandle(hDevice);
2240 
2241 	if (ret == ERROR_SUCCESS) {
2242 		PrintMessage(MSG_MEDIA_WRITABLE);
2243 	}
2244 	else if (ret == ERROR_WRITE_PROTECT) {
2245 		PrintMessage(MSG_MEDIA_PROTECTED);
2246 	}
2247 	else {
2248 		PrintMessage(MSG_GET_MEDIA_NG);
2249 		printf("%s", SystemError(ret));
2250 		return VFD_NG;
2251 	}
2252 
2253 	return VFD_OK;
2254 }
2255 
2256 //
2257 //	Format the virtual media with FAT12
2258 //
Format(const char ** args)2259 int	Format(const char **args)
2260 {
2261 	int		mode = OPERATION_ASK;
2262 	ULONG	target	= TARGET_NONE;
2263 	HANDLE	hDevice;
2264 	DWORD	ret;
2265 
2266 	//	check parameters
2267 
2268 	while (args && *args) {
2269 
2270 		if (!_stricmp(*args, "/f") ||
2271 			!_stricmp(*args, "/force")) {
2272 
2273 			if (mode != OPERATION_ASK) {
2274 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
2275 				return VFD_NG;
2276 			}
2277 
2278 			mode = OPERATION_FORCE;
2279 		}
2280 		else if (!_stricmp(*args, "/q") ||
2281 			!_stricmp(*args, "/quit")) {
2282 
2283 			if (mode != OPERATION_ASK) {
2284 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
2285 				return VFD_NG;
2286 			}
2287 
2288 			mode = OPERATION_QUIT;
2289 		}
2290 		else if (isalnum(**args)) {
2291 			if (target != TARGET_NONE) {
2292 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
2293 				return VFD_NG;
2294 			}
2295 
2296 			target = toupper(**args);
2297 		}
2298 		else {
2299 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
2300 			PrintMessage(MSG_HINT_FORMAT, help_progname);
2301 			return VFD_NG;
2302 		}
2303 
2304 		args++;
2305 	}
2306 
2307 	if (target == TARGET_NONE) {
2308 		target = '0';
2309 		PrintMessage(MSG_TARGET_NOTICE, target);
2310 	}
2311 
2312 	//	ensure that the driver is installed
2313 
2314 	if (driver_state == VFD_NOT_INSTALLED) {
2315 		PrintMessage(MSG_NOT_INSTALLED);
2316 		return VFD_NG;
2317 	}
2318 
2319 	//	ensure that the driver is up to date
2320 
2321 	if (CheckDriver() != VFD_OK) {
2322 		return VFD_NG;
2323 	}
2324 
2325 	//	ensure that the driver is running
2326 
2327 	if (driver_state != SERVICE_RUNNING) {
2328 		PrintMessage(MSG_NOT_STARTED);
2329 		return VFD_NG;
2330 	}
2331 
2332 	//	Open the device
2333 
2334 	hDevice = VfdOpenDevice(target);
2335 
2336 	if (hDevice == INVALID_HANDLE_VALUE) {
2337 		ret = GetLastError();
2338 		PrintMessage(MSG_ACCESS_NG, target);
2339 		printf("%s", SystemError(ret));
2340 		return VFD_NG;
2341 	}
2342 
2343 	//	check if the media is writable
2344 
2345 	ret = VfdGetMediaState(hDevice);
2346 
2347 	if (ret != ERROR_SUCCESS) {
2348 		PrintMessage(MSG_FORMAT_NG, target);
2349 		printf("%s", SystemError(ret));
2350 
2351 		CloseHandle(hDevice);
2352 		return VFD_NG;
2353 	}
2354 
2355 	//	format the media
2356 
2357 retry:
2358 	ret = VfdDismountVolume(
2359 		hDevice, (mode == OPERATION_FORCE));
2360 
2361 	if (ret == ERROR_ACCESS_DENIED) {
2362 
2363 		PrintMessage(MSG_LOCK_NG, target);
2364 
2365 		if (mode == OPERATION_FORCE) {
2366 			PrintMessage(MSG_FORMAT_FORCE);
2367 		}
2368 		else if (mode == OPERATION_QUIT) {
2369 			PrintMessage(MSG_FORMAT_QUIT);
2370 			CloseHandle(hDevice);
2371 			return VFD_NG;
2372 		}
2373 		else {
2374 			int c = InputChar(MSG_RETRY_FORCE_CANCEL, "rfc");
2375 
2376 			if (c == 'r') {			// retry
2377 				goto retry;
2378 			}
2379 			else if (c == 'f') {	//	force
2380 				VfdDismountVolume(hDevice, TRUE);
2381 			}
2382 			else {					//	cancel
2383 				CloseHandle(hDevice);
2384 				return VFD_NG;
2385 			}
2386 		}
2387 	}
2388 	else if (ret != ERROR_SUCCESS) {
2389 		PrintMessage(MSG_LOCK_NG, target);
2390 		CloseHandle(hDevice);
2391 		return VFD_NG;
2392 	}
2393 
2394 	ret = VfdFormatMedia(hDevice);
2395 
2396 	CloseHandle(hDevice);
2397 
2398 	if (ret != ERROR_SUCCESS) {
2399 		PrintMessage(MSG_FORMAT_NG, target);
2400 		printf("%s", SystemError(ret));
2401 		return VFD_NG;
2402 	}
2403 
2404 	//	successful operation
2405 
2406 	PrintMessage(MSG_FORMAT_OK);
2407 
2408 	return VFD_OK;
2409 }
2410 
2411 //
2412 //	Assign a drive letter to a Virtual Floppy Drive
2413 //
Link(const char ** args)2414 int Link(const char **args)
2415 {
2416 	ULONG	target_min = TARGET_NONE;
2417 	ULONG	target_max = TARGET_NONE;
2418 	PCSTR	letters = NULL;
2419 	BOOL	global	= TRUE;
2420 	HANDLE	hDevice;
2421 	DWORD	ret;
2422 
2423 	while (args && *args) {
2424 		if (!_stricmp(*args, "/g")) {
2425 			global = TRUE;
2426 		}
2427 		else if (!_stricmp(*args, "/l")) {
2428 			global = FALSE;
2429 		}
2430 		else if (isdigit(**args) || **args == '*') {
2431 			if (target_min != TARGET_NONE) {
2432 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
2433 				return VFD_NG;
2434 			}
2435 
2436 			if (**args == '*') {
2437 				target_min = '0';
2438 				target_max = '0' + VFD_MAXIMUM_DEVICES;
2439 			}
2440 			else {
2441 				target_min = **args;
2442 				target_max = target_min + 1;
2443 			}
2444 		}
2445 		else if (isalpha(**args)) {
2446 			if (letters) {
2447 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
2448 				return VFD_NG;
2449 			}
2450 			letters = *args;
2451 		}
2452 		else {
2453 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
2454 			PrintMessage(MSG_HINT_LINK, help_progname);
2455 			return VFD_NG;
2456 		}
2457 
2458 		args++;
2459 	}
2460 
2461 	if (target_min == TARGET_NONE) {
2462 		// default: drive 0
2463 		target_min = '0';
2464 		target_max = '1';
2465 		PrintMessage(MSG_TARGET_NOTICE, target_min);
2466 	}
2467 
2468 	//	ensure that the driver is installed
2469 
2470 	if (driver_state == VFD_NOT_INSTALLED) {
2471 		PrintMessage(MSG_NOT_INSTALLED);
2472 		return VFD_NG;
2473 	}
2474 
2475 	//	ensure that the driver is up to date
2476 
2477 	if (CheckDriver() != VFD_OK) {
2478 		return VFD_NG;
2479 	}
2480 
2481 	//	ensure that the driver is running
2482 
2483 	if (driver_state != SERVICE_RUNNING) {
2484 		PrintMessage(MSG_NOT_STARTED);
2485 		return VFD_NG;
2486 	}
2487 
2488 	while (target_min < target_max) {
2489 		ULONG number;
2490 		CHAR letter;
2491 
2492 		hDevice = VfdOpenDevice(target_min);
2493 
2494 		if (hDevice == INVALID_HANDLE_VALUE) {
2495 			ret = GetLastError();
2496 			PrintMessage(MSG_ACCESS_NG, target_min);
2497 			printf("%s", SystemError(ret));
2498 			target_min++;
2499 			continue;
2500 		}
2501 
2502 		ret = VfdGetDeviceNumber(hDevice, &number);
2503 
2504 		if (ret != ERROR_SUCCESS) {
2505 			PrintMessage(MSG_ACCESS_NG, target_min);
2506 			printf("%s", SystemError(ret));
2507 			CloseHandle(hDevice);
2508 			target_min++;
2509 			continue;
2510 		}
2511 
2512 		if (letters && isalpha(*letters)) {
2513 			letter = (CHAR)toupper(*(letters++));
2514 		}
2515 		else {
2516 			letter = VfdChooseLetter();
2517 		}
2518 
2519 		if (letter) {
2520 			if (global) {
2521 				ret = VfdSetGlobalLink(hDevice, letter);
2522 			}
2523 			else {
2524 				ret = VfdSetLocalLink(hDevice, letter);
2525 			}
2526 
2527 			if (ret != ERROR_SUCCESS) {
2528 				PrintMessage(MSG_LINK_NG, number, letter);
2529 				printf("%s", SystemError(ret));
2530 			}
2531 		}
2532 		else {
2533 			PrintMessage(MSG_LINK_FULL);
2534 		}
2535 
2536 		PrintDriveLetter(hDevice, number);
2537 
2538 		CloseHandle(hDevice);
2539 
2540 		target_min++;
2541 	}
2542 
2543 	return VFD_OK;
2544 }
2545 
2546 //
2547 //	Remove a drive letter from a Virtual Floppy Drive
2548 //
Unlink(const char ** args)2549 int Unlink(const char **args)
2550 {
2551 	ULONG	target_min = TARGET_NONE;
2552 	ULONG	target_max = TARGET_NONE;
2553 	HANDLE	hDevice;
2554 	DWORD	ret;
2555 
2556 	while (args && *args) {
2557 		if ((isalnum(**args) || **args == '*') &&
2558 			(*(*args + 1) == ':' || *(*args + 1) == '\0')) {
2559 
2560 			if (target_min != TARGET_NONE) {
2561 				PrintMessage(MSG_DUPLICATE_ARGS, *args);
2562 				return VFD_NG;
2563 			}
2564 
2565 			if (**args == '*') {
2566 				target_min = '0';
2567 				target_max = '0' + VFD_MAXIMUM_DEVICES;
2568 			}
2569 			else {
2570 				target_min = **args;
2571 				target_max = target_min + 1;
2572 			}
2573 		}
2574 		else {
2575 			PrintMessage(MSG_UNKNOWN_OPTION, *args);
2576 			PrintMessage(MSG_HINT_ULINK, help_progname);
2577 			return VFD_NG;
2578 		}
2579 
2580 		args++;
2581 	}
2582 
2583 	if (target_min == TARGET_NONE) {
2584 		// default: drive 0
2585 		target_min = '0';
2586 		target_max = '1';
2587 		PrintMessage(MSG_TARGET_NOTICE, target_min);
2588 	}
2589 
2590 	//	ensure that the driver is installed
2591 
2592 	if (driver_state == VFD_NOT_INSTALLED) {
2593 		PrintMessage(MSG_NOT_INSTALLED);
2594 		return VFD_NG;
2595 	}
2596 
2597 	//	ensure that the driver is up to date
2598 
2599 	if (CheckDriver() != VFD_OK) {
2600 		return VFD_NG;
2601 	}
2602 
2603 	//	ensure that the driver is running
2604 
2605 	if (driver_state != SERVICE_RUNNING) {
2606 		PrintMessage(MSG_NOT_STARTED);
2607 		return VFD_NG;
2608 	}
2609 
2610 	while (target_min < target_max) {
2611 		ULONG number;
2612 
2613 		hDevice = VfdOpenDevice(target_min);
2614 
2615 		if (hDevice == INVALID_HANDLE_VALUE) {
2616 			ret = GetLastError();
2617 			PrintMessage(MSG_ACCESS_NG, target_min);
2618 			printf("%s", SystemError(ret));
2619 			target_min++;
2620 			continue;
2621 		}
2622 
2623 		ret = VfdGetDeviceNumber(hDevice, &number);
2624 
2625 		if (ret != ERROR_SUCCESS) {
2626 			PrintMessage(MSG_ACCESS_NG, target_min);
2627 			printf("%s", SystemError(ret));
2628 			CloseHandle(hDevice);
2629 			target_min++;
2630 			continue;
2631 		}
2632 
2633 		VfdSetGlobalLink(hDevice, 0);
2634 		VfdSetLocalLink(hDevice, 0);
2635 
2636 		PrintDriveLetter(hDevice, number);
2637 
2638 		CloseHandle(hDevice);
2639 
2640 		target_min++;
2641 	}
2642 
2643 	return VFD_OK;
2644 }
2645 
2646 //
2647 //	Print current driver state
2648 //	Command Line Parameters: None
2649 //
Status(const char ** args)2650 int	Status(const char **args)
2651 {
2652 	HANDLE	hDevice;
2653 	TCHAR	path[MAX_PATH];
2654 	DWORD	start_type;
2655 	DWORD	version;
2656 	ULONG	target;
2657 	DWORD	ret;
2658 
2659 	UNREFERENCED_PARAMETER(args);
2660 
2661 	if (driver_state == VFD_NOT_INSTALLED) {
2662 		PrintMessage(MSG_NOT_INSTALLED);
2663 	}
2664 	else {
2665 
2666 		//	get current driver config
2667 
2668 		ret = VfdGetDriverConfig(path, &start_type);
2669 
2670 		if (ret != ERROR_SUCCESS) {
2671 			PrintMessage(MSG_GET_CONFIG_NG);
2672 			printf("%s", SystemError(ret));
2673 			return VFD_NG;
2674 		}
2675 
2676 		//	print driver file path
2677 
2678 		PrintMessage(MSG_DRIVER_FILE, path);
2679 
2680 		//	print driver version
2681 		version = 0;
2682 
2683 		if (driver_state == SERVICE_RUNNING) {
2684 
2685 			hDevice = VfdOpenDevice(0);
2686 
2687 			if (hDevice != INVALID_HANDLE_VALUE) {
2688 				ret = VfdGetDriverVersion(hDevice, &version);
2689 
2690 				CloseHandle(hDevice);
2691 			}
2692 
2693 		}
2694 
2695 		if (version == 0) {
2696 			ret = VfdCheckDriverFile(path, &version);
2697 		}
2698 
2699 		if (ret == ERROR_SUCCESS) {
2700 			PrintMessage(MSG_DRIVER_VERSION,
2701 				HIWORD(version) & 0x7fff,
2702 				LOWORD(version),
2703 				(version & 0x80000000) ? "(debug)" : "");
2704 		}
2705 		else {
2706 			PrintMessage(MSG_GET_VERSION_NG);
2707 			printf("%s", SystemError(ret));
2708 		}
2709 
2710 
2711 		//	print driver start type
2712 
2713 		PrintMessage(MSG_START_TYPE);
2714 
2715 		switch (start_type) {
2716 		case SERVICE_AUTO_START:
2717 			PrintMessage(MSG_START_AUTO);
2718 			break;
2719 
2720 		case SERVICE_BOOT_START:
2721 			PrintMessage(MSG_START_BOOT);
2722 			break;
2723 
2724 		case SERVICE_DEMAND_START:
2725 			PrintMessage(MSG_START_DEMAND);
2726 			break;
2727 
2728 		case SERVICE_DISABLED:
2729 			PrintMessage(MSG_START_DISABLED);
2730 			break;
2731 
2732 		case SERVICE_SYSTEM_START :
2733 			PrintMessage(MSG_START_SYSTEM);
2734 			break;
2735 
2736 		default:
2737 			PrintMessage(MSG_UNKNOWN_LONG, start_type);
2738 			break;
2739 		}
2740 
2741 		//	print current driver state
2742 
2743 		PrintMessage(MSG_DRIVER_STATUS);
2744 
2745 		switch (driver_state) {
2746 		case SERVICE_STOPPED:
2747 			PrintMessage(MSG_STATUS_STOPPED);
2748 			break;
2749 
2750 		case SERVICE_START_PENDING:
2751 			PrintMessage(MSG_STATUS_START_P);
2752 			break;
2753 
2754 		case SERVICE_STOP_PENDING:
2755 			PrintMessage(MSG_STATUS_STOP_P);
2756 			break;
2757 
2758 		case SERVICE_RUNNING:
2759 			PrintMessage(MSG_STATUS_RUNNING);
2760 			break;
2761 
2762 		case SERVICE_CONTINUE_PENDING:
2763 			PrintMessage(MSG_STATUS_CONT_P);
2764 			break;
2765 
2766 		case SERVICE_PAUSE_PENDING:
2767 			PrintMessage(MSG_STATUS_PAUSE_P);
2768 			break;
2769 
2770 		case SERVICE_PAUSED:
2771 			PrintMessage(MSG_STATUS_PAUSED);
2772 			break;
2773 
2774 		default:
2775 			PrintMessage(MSG_UNKNOWN_LONG, driver_state);
2776 			break;
2777 		}
2778 	}
2779 
2780 	//	print shell extension status
2781 
2782 	printf("\n");
2783 
2784 	if (VfdCheckHandlers() == ERROR_SUCCESS) {
2785 		PrintMessage(MSG_SHELLEXT_ENABLED);
2786 	}
2787 	else {
2788 		PrintMessage(MSG_SHELLEXT_DISABLED);
2789 	}
2790 
2791 	//	if driver is not running, no more info
2792 
2793 	if (driver_state != SERVICE_RUNNING) {
2794 		return VFD_OK;
2795 	}
2796 
2797 	//	print image information
2798 
2799 	for (target = 0; target < VFD_MAXIMUM_DEVICES; target++) {
2800 		HANDLE hDevice = VfdOpenDevice(target);
2801 
2802 		if (hDevice == INVALID_HANDLE_VALUE) {
2803 			ret = GetLastError();
2804 			PrintMessage(MSG_ACCESS_NG, target + '0');
2805 			printf("%s", SystemError(ret));
2806 			return VFD_NG;
2807 		}
2808 
2809 		PrintImageInfo(hDevice);
2810 
2811 		CloseHandle(hDevice);
2812 	}
2813 
2814 	return VFD_OK;
2815 }
2816 
2817 //
2818 //	Print usage help
2819 //
Help(const char ** args)2820 int	Help(const char **args)
2821 {
2822 	DWORD	msg = MSG_HELP_GENERAL;
2823 	char	*buf = NULL;
2824 
2825 	if (args && *args) {
2826 		int cmd = ParseHelpTopic(*args);
2827 
2828 		if (cmd < 0) {
2829 			msg = MSG_HELP_HELP;
2830 		}
2831 		else {
2832 			msg = HelpMsg[cmd].help;
2833 		}
2834 	}
2835 
2836 	FormatMessage(
2837 		FORMAT_MESSAGE_FROM_HMODULE |
2838 		FORMAT_MESSAGE_ALLOCATE_BUFFER |
2839 		FORMAT_MESSAGE_ARGUMENT_ARRAY,
2840 		NULL, msg, 0, (LPTSTR)&buf, 0,
2841 		(va_list *)&help_progname);
2842 
2843 	if (buf == NULL) {
2844 		printf("%s", SystemError(GetLastError()));
2845 		return VFD_NG;
2846 	}
2847 
2848 	ConsolePager(buf, TRUE);
2849 	LocalFree(buf);
2850 
2851 	return VFD_OK;
2852 }
2853 
2854 //
2855 //	Print version information
2856 //
Version(const char ** args)2857 int	Version(const char **args)
2858 {
2859 	UNREFERENCED_PARAMETER(args);
2860 
2861 	printf(VFD_PRODUCT_DESC "\n" VFD_COPYRIGHT_STR "\n"
2862 		"http://chitchat.at.infoseek.co.jp/vmware/vfd.html\n");
2863 
2864 	return VFD_OK;
2865 }
2866 
2867 //
2868 //	Parse command parameter
2869 //
ParseCommand(const char * cmd)2870 int ParseCommand(const char *cmd)
2871 {
2872 #define CMD_MATCH_NONE	-1
2873 #define CMD_MATCH_MULTI	-2
2874 
2875 	size_t len;
2876 	int idx;
2877 	int match;
2878 
2879 	//	skip a leading '/'
2880 
2881 	if (*cmd == '/') {
2882 		cmd++;
2883 	}
2884 
2885 	if (*cmd == '\0') {
2886 
2887 		//	empty command
2888 
2889 		return CMD_MATCH_NONE;
2890 	}
2891 
2892 	//	find a match
2893 	len = strlen(cmd);
2894 	idx = 0;
2895 	match = CMD_MATCH_NONE;
2896 
2897 	while (Commands[idx].cmd) {
2898 
2899 		if (strlen(Commands[idx].cmd) >= len &&
2900 			!_strnicmp(cmd, Commands[idx].cmd, len)) {
2901 
2902 			if (match == CMD_MATCH_NONE) {		//	first match
2903 				match = idx;
2904 			}
2905 			else {								//	multiple matches
2906 				if (match != CMD_MATCH_MULTI) {	//	first time
2907 					PrintMessage(MSG_AMBIGUOUS_COMMAND, cmd);
2908 					printf("> %s ", Commands[match].cmd);
2909 					match = CMD_MATCH_MULTI;
2910 				}
2911 
2912 				printf("%s ", Commands[idx].cmd);
2913 			}
2914 		}
2915 
2916 		idx++;
2917 	}
2918 
2919 	if (match == CMD_MATCH_NONE) {				//	match not found
2920 		PrintMessage(MSG_UNKNOWN_COMMAND, cmd);
2921 	}
2922 	else if (match == CMD_MATCH_MULTI) {		//	multiple matches
2923 		printf("\n");
2924 	}
2925 
2926 	return match;
2927 }
2928 
ParseHelpTopic(const char * topic)2929 int ParseHelpTopic(const char *topic)
2930 {
2931 	size_t	len;
2932 	int		idx;
2933 	int		match;
2934 
2935 	if (*topic == '\0') {
2936 
2937 		//	empty command
2938 
2939 		return CMD_MATCH_NONE;
2940 	}
2941 
2942 	//	find a match
2943 	len = strlen(topic);
2944 	idx = 0;
2945 	match = CMD_MATCH_NONE;
2946 
2947 	while (HelpMsg[idx].keyword) {
2948 
2949 		if (strlen(HelpMsg[idx].keyword) >= len &&
2950 			!_strnicmp(topic, HelpMsg[idx].keyword, len)) {
2951 
2952 			if (match == CMD_MATCH_NONE) {		//	first match
2953 				match = idx;
2954 			}
2955 			else {								//	multiple matches
2956 				if (match != CMD_MATCH_MULTI) {	//	first time
2957 					PrintMessage(MSG_AMBIGUOUS_COMMAND, topic);
2958 					printf("> %s ", HelpMsg[match].keyword);
2959 					match = CMD_MATCH_MULTI;
2960 				}
2961 
2962 				printf("%s ", HelpMsg[idx].keyword);
2963 			}
2964 		}
2965 
2966 		idx++;
2967 	}
2968 
2969 	if (match == CMD_MATCH_NONE) {				//	match not found
2970 		PrintMessage(MSG_UNKNOWN_COMMAND, topic);
2971 	}
2972 	else if (match == CMD_MATCH_MULTI) {		//	multiple matches
2973 		printf("\n");
2974 	}
2975 
2976 	return match;
2977 }
2978 
2979 //
2980 //	Check driver version and update if necessary
2981 //
CheckDriver()2982 int CheckDriver()
2983 {
2984 	char	path[MAX_PATH];
2985 	DWORD	start;
2986 
2987 	//	check installed driver file version
2988 
2989 	if (VfdGetDriverConfig(path, &start) == ERROR_SUCCESS &&
2990 		VfdCheckDriverFile(path, NULL) == ERROR_SUCCESS) {
2991 
2992 		HANDLE hDevice;
2993 
2994 		if (driver_state != SERVICE_RUNNING) {
2995 			return VFD_OK;
2996 		}
2997 
2998 		//	check running driver version
2999 
3000 		hDevice = VfdOpenDevice(0);
3001 
3002 		if (hDevice != INVALID_HANDLE_VALUE) {
3003 			CloseHandle(hDevice);
3004 			return VFD_OK;
3005 		}
3006 	}
3007 
3008 	PrintMessage(MSG_WRONG_DRIVER);
3009 	return VFD_NG;
3010 }
3011 
3012 //
3013 //	Print a prompt message and accept the reply input
3014 //
InputChar(ULONG msg,PCSTR ans)3015 int InputChar(ULONG msg, PCSTR ans)
3016 {
3017 	HANDLE			hStdIn;
3018 	INPUT_RECORD	input;
3019 	DWORD			result;
3020 	int				reply;
3021 
3022 	PrintMessage(msg);
3023 	fflush(NULL);
3024 
3025 	hStdIn	= GetStdHandle(STD_INPUT_HANDLE);
3026 
3027 	FlushConsoleInputBuffer(hStdIn);
3028 
3029 	for (;;) {
3030 		ReadConsoleInput(hStdIn, &input, sizeof(input), &result);
3031 
3032 		if (input.EventType == KEY_EVENT &&
3033 			input.Event.KeyEvent.bKeyDown) {
3034 
3035 			reply = tolower(input.Event.KeyEvent.uChar.AsciiChar);
3036 
3037 			if (strchr(ans, reply)) {
3038 				break;
3039 			}
3040 		}
3041 	}
3042 
3043 	printf("%c\n", reply);
3044 
3045 	return reply;
3046 }
3047 
3048 //
3049 //	Print image information on a Virtual Floppy Drive
3050 //
PrintImageInfo(HANDLE hDevice)3051 void PrintImageInfo(
3052 	HANDLE			hDevice)
3053 {
3054 	ULONG			device_number;
3055 	CHAR			file_name[MAX_PATH];
3056 	CHAR			file_desc[MAX_PATH];
3057 	VFD_DISKTYPE	disk_type;
3058 	VFD_MEDIA		media_type;
3059 	VFD_FLAGS		media_flags;
3060 	VFD_FILETYPE	file_type;
3061 	ULONG			image_size;
3062 	DWORD			ret;
3063 
3064 	printf("\n");
3065 
3066 	//	get current device number
3067 
3068 	ret = VfdGetDeviceNumber(hDevice, &device_number);
3069 
3070 	if (ret != ERROR_SUCCESS) {
3071 		PrintMessage(MSG_GET_LINK_NG);
3072 		printf("%s", SystemError(ret));
3073 		device_number = (ULONG)-1;
3074 	}
3075 
3076 	//	get current drive letters
3077 
3078 	PrintDriveLetter(hDevice, device_number);
3079 
3080 	//	image file information
3081 
3082 	ret = VfdGetImageInfo(hDevice, file_name, &disk_type,
3083 		&media_type, &media_flags, &file_type, &image_size);
3084 
3085 	if (ret != ERROR_SUCCESS) {
3086 		PrintMessage(MSG_GET_FILE_NG);
3087 		printf("%s", SystemError(ret));
3088 		return;
3089 	}
3090 
3091 	//	print image file information
3092 	if (media_type == VFD_MEDIA_NONE) {
3093 		PrintMessage(MSG_IMAGE_NONE);
3094 		return;
3095 	}
3096 
3097 	if (file_name[0]) {
3098 		PrintMessage(MSG_IMAGE_NAME, file_name);
3099 
3100 		VfdMakeFileDesc(file_desc, sizeof(file_desc),
3101 			file_type, image_size, GetFileAttributes(file_name));
3102 	}
3103 	else {
3104 		PrintMessage(MSG_IMAGE_NAME, "<RAM>");
3105 
3106 		VfdMakeFileDesc(file_desc, sizeof(file_desc),
3107 			VFD_FILETYPE_NONE, image_size, 0);
3108 	}
3109 
3110 	PrintMessage(MSG_FILE_DESC, file_desc);
3111 
3112 	if (disk_type == VFD_DISKTYPE_FILE) {
3113 		PrintMessage(MSG_DISKTYPE_FILE);
3114 	}
3115 	else {
3116 		if (media_flags & VFD_FLAG_DATA_MODIFIED) {
3117 			PrintMessage(MSG_DISKTYPE_RAM_DIRTY);
3118 		}
3119 		else {
3120 			PrintMessage(MSG_DISKTYPE_RAM_CLEAN);
3121 		}
3122 	}
3123 
3124 	//	print other file info
3125 
3126 	PrintMessage(MSG_MEDIA_TYPE, VfdMediaTypeName(media_type));
3127 
3128 	if (media_flags & VFD_FLAG_WRITE_PROTECTED) {
3129 		PrintMessage(MSG_MEDIA_PROTECTED);
3130 	}
3131 	else {
3132 		PrintMessage(MSG_MEDIA_WRITABLE);
3133 	}
3134 }
3135 
3136 //
3137 //	Print drive letters on a virtual floppy drive
3138 //
PrintDriveLetter(HANDLE hDevice,ULONG nDrive)3139 void PrintDriveLetter(
3140 	HANDLE			hDevice,
3141 	ULONG			nDrive)
3142 {
3143 	CHAR			letter;
3144 
3145 	PrintMessage(MSG_DRIVE_LETTER, nDrive);
3146 
3147 	VfdGetGlobalLink(hDevice, &letter);
3148 
3149 	if (isalpha(letter)) {
3150 		PrintMessage(MSG_PERSISTENT, toupper(letter));
3151 	}
3152 
3153 	while (VfdGetLocalLink(hDevice, &letter) == ERROR_SUCCESS &&
3154 		isalpha(letter)) {
3155 		PrintMessage(MSG_EPHEMERAL, toupper(letter));
3156 	}
3157 
3158 	printf("\n");
3159 }
3160 
3161 //
3162 //	Prints a text on screen a page a time
3163 //
ConsolePager(char * pBuffer,BOOL bReset)3164 BOOL ConsolePager(char *pBuffer, BOOL bReset)
3165 {
3166 	static int	rows = 0;
3167 	char		prompt[80];
3168 	int			prompt_len = 0;
3169 	HANDLE		hStdOut;
3170 	HANDLE		hStdIn;
3171 
3172 	//
3173 	//	prepare the console input and output handles
3174 	//
3175 	hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
3176 	hStdIn	= GetStdHandle(STD_INPUT_HANDLE);
3177 
3178 	for (;;) {
3179 		CONSOLE_SCREEN_BUFFER_INFO	info;
3180 		INPUT_RECORD	input;
3181 		DWORD			result;
3182 		DWORD			mode;
3183 		int				cols;
3184 		char			*cur;
3185 		char			save;
3186 
3187 		//
3188 		//	Get the current console screen information
3189 		//
3190 		GetConsoleScreenBufferInfo(hStdOut, &info);
3191 
3192 		if (bReset || rows <= 0) {
3193 			rows = info.srWindow.Bottom - info.srWindow.Top - 1;
3194 		}
3195 
3196 		cols = info.dwSize.X;
3197 
3198 		//	console window is too small for paging
3199 
3200 		if (rows <= 0) {
3201 			//	print all text and exit
3202 			printf("%s", pBuffer);
3203 			break;
3204 		}
3205 
3206 		//
3207 		//	find the tail of the text to be printed this time
3208 		//
3209 		cur = pBuffer;
3210 		save = '\0';
3211 
3212 		while (*cur) {
3213 			if (*(cur++) == '\n' || (cols--) == 0) {
3214 				//	reached the end of a line
3215 				if (--rows == 0) {
3216 					//	reached the end of a page
3217 					//	insert a terminating NULL char
3218 					save = *cur;
3219 					*cur = '\0';
3220 					break;
3221 				}
3222 
3223 				cols = info.dwSize.X;
3224 			}
3225 		}
3226 
3227 		//	print the current page
3228 		printf("%s", pBuffer);
3229 
3230 		//	end of the whole text?
3231 		if (save == '\0') {
3232 			break;
3233 		}
3234 
3235 		//
3236 		//	prompt for the next page
3237 		//
3238 
3239 		//	prepare the prompt text
3240 
3241 		if (prompt_len == 0) {
3242 
3243 			prompt_len = FormatMessage(
3244 				FORMAT_MESSAGE_FROM_HMODULE |
3245 				FORMAT_MESSAGE_IGNORE_INSERTS,
3246 				NULL, MSG_PAGER_PROMPT, 0,
3247 				prompt, sizeof(prompt), NULL);
3248 
3249 			if (prompt_len == 0) {
3250 				strcpy(prompt, "Press any key to continue...");
3251 				prompt_len = strlen(prompt);
3252 			}
3253 		}
3254 
3255 		//	get the current console input mode
3256 
3257 		GetConsoleMode(hStdIn, &mode);
3258 
3259 		//	change the mode to receive Ctrl+C as a regular input
3260 
3261 		SetConsoleMode(hStdIn, (mode & ~ENABLE_PROCESSED_INPUT));
3262 
3263 		//	get the current cursor position
3264 
3265 		GetConsoleScreenBufferInfo(hStdOut, &info);
3266 
3267 		//	print the prompt text
3268 
3269 		WriteConsoleOutputCharacter(hStdOut, prompt,
3270 			prompt_len, info.dwCursorPosition, &result);
3271 
3272 		//	reverse the text color
3273 
3274 		FillConsoleOutputAttribute(hStdOut,
3275 			(WORD)(info.wAttributes | COMMON_LVB_REVERSE_VIDEO),
3276 			prompt_len, info.dwCursorPosition, &result);
3277 
3278 		//	move cursor to the end of the prompt text
3279 
3280 		info.dwCursorPosition.X =
3281 			(short)(info.dwCursorPosition.X + prompt_len);
3282 
3283 		SetConsoleCursorPosition(hStdOut, info.dwCursorPosition);
3284 
3285 		//	wait for a key press event
3286 
3287 		FlushConsoleInputBuffer(hStdIn);
3288 
3289 		do {
3290 			ReadConsoleInput(hStdIn, &input, sizeof(input), &result);
3291 		}
3292 		while (input.EventType != KEY_EVENT ||
3293 			!input.Event.KeyEvent.bKeyDown ||
3294 			!input.Event.KeyEvent.uChar.AsciiChar);
3295 
3296 		//	restore the original cursor position
3297 
3298 		info.dwCursorPosition.X =
3299 			(short)(info.dwCursorPosition.X - prompt_len);
3300 
3301 		SetConsoleCursorPosition(hStdOut, info.dwCursorPosition);
3302 
3303 		//	delete the prompt text
3304 
3305 		FillConsoleOutputCharacter(hStdOut, ' ',
3306 			prompt_len, info.dwCursorPosition, &result);
3307 
3308 		//	restore the text attribute to norml
3309 
3310 		FillConsoleOutputAttribute(hStdOut, info.wAttributes,
3311 			prompt_len, info.dwCursorPosition, &result);
3312 
3313 		//	restore the original console mode
3314 
3315 		SetConsoleMode(hStdIn, mode);
3316 
3317 		//	check if the input was 'q', <esc> or <Ctrl+C> ?
3318 
3319 		if (input.Event.KeyEvent.uChar.AsciiChar == VK_CANCEL ||
3320 			input.Event.KeyEvent.uChar.AsciiChar == VK_ESCAPE ||
3321 			tolower(input.Event.KeyEvent.uChar.AsciiChar) == 'q') {
3322 
3323 			//	cancelled by the user
3324 			return FALSE;
3325 		}
3326 
3327 		//
3328 		//	process the next page
3329 		//
3330 		*cur = save;
3331 		pBuffer = cur;
3332 	}
3333 
3334 	return TRUE;
3335 }
3336 
3337 //
3338 //	Format and print a message text
3339 //
PrintMessage(UINT msg,...)3340 void PrintMessage(UINT msg, ...)
3341 {
3342 	char *buf = NULL;
3343 	va_list list;
3344 
3345 	va_start(list, msg);
3346 
3347 	if (FormatMessage(
3348 		FORMAT_MESSAGE_FROM_HMODULE |
3349 		FORMAT_MESSAGE_ALLOCATE_BUFFER,
3350 		NULL, msg, 0, (LPTSTR)&buf, 0, &list)) {
3351 
3352 		printf("%s", buf);
3353 	}
3354 	else {
3355 		printf("Unknown Message ID %u\n", msg);
3356 	}
3357 
3358 	va_end(list);
3359 
3360 	if (buf) {
3361 		LocalFree(buf);
3362 	}
3363 }
3364 
3365 //
3366 //	Return a system error message text
3367 //
SystemError(DWORD err)3368 const char *SystemError(DWORD err)
3369 {
3370 	static char msg[256];
3371 
3372 	if (!FormatMessage(
3373 		FORMAT_MESSAGE_FROM_SYSTEM |
3374 		FORMAT_MESSAGE_IGNORE_INSERTS,
3375 		NULL, err, 0, msg, sizeof(msg), NULL)) {
3376 #ifndef __REACTOS__
3377 		sprintf(msg, "Unknown system error %lu (0x%08x)\n", err, err);
3378 #else
3379 		sprintf(msg, "Unknown system error %lu (0x%08lx)\n", err, err);
3380 #endif
3381 	}
3382 
3383 	return msg;
3384 }
3385 
3386 //
3387 //	Convert a path to match the case of names on the disk
3388 //
ConvertPathCase(char * src,char * dst)3389 void ConvertPathCase(char *src, char *dst)
3390 {
3391 	HANDLE hFind;
3392 	WIN32_FIND_DATA find;
3393 	char *p;
3394 
3395 	p = dst;
3396 
3397 	if (*src == '\"') {
3398 		src++;
3399 	}
3400 
3401 	if (*(src + strlen(src) - 1) == '\"') {
3402 		*(src + strlen(src) - 1) = '\0';
3403 	}
3404 
3405 	//
3406 	//	handle drive / remote server name
3407 	//
3408 	if (isalpha(*src) && *(src + 1) == ':') {
3409 
3410 		//	drive name
3411 
3412 		*(p++) = (char)toupper(*src);
3413 		strcpy(p++, ":\\");
3414 
3415 		src += 2;
3416 	}
3417 	else if (*src == '\\' || *src == '/') {
3418 
3419 		//	absolute path or remote name
3420 
3421 		if ((*(src + 1) == '\\' || *(src + 1) == '/') &&
3422 			*(src + 2) && *(src + 2) != '\\' && *(src + 2) != '/') {
3423 
3424 			//	remote path
3425 
3426 			*(p++) = '\\';
3427 			*(p++) = '\\';
3428 			src += 2;
3429 
3430 			while (*src && *src != '\\' && *src != '/') {
3431 				*(p++) = *(src++);
3432 			}
3433 		}
3434 
3435 		strcpy(p, "\\");
3436 	}
3437 	else {
3438 		*p = '\0';
3439 	}
3440 
3441 	//	skip redundant '\'
3442 
3443 	while (*src == '\\' || *src == '/') {
3444 		src++;
3445 	}
3446 
3447 	//	process the path
3448 
3449 	while (*src) {
3450 
3451 		char *q = src;
3452 
3453 		//	separate the next part
3454 
3455 		while (*q && *q != '\\' && *q != '/') {
3456 			q++;
3457 		}
3458 
3459 		if ((q - src) == 2 && !strncmp(src, "..", 2)) {
3460 			//	parent dir - copy as it is
3461 			if (p != dst) {
3462 				*p++ = '\\';
3463 			}
3464 
3465 			strcpy(p, "..");
3466 			p += 2;
3467 		}
3468 		else if ((q - src) > 1 || *src != '.') {
3469 			//	path name other than "."
3470 			if (p != dst) {
3471 				*(p++) = '\\';
3472 			}
3473 
3474 			strncpy(p, src, (q - src));
3475 			*(p + (q - src)) = '\0';
3476 
3477 			hFind = FindFirstFile(dst, &find);
3478 
3479 			if (hFind == INVALID_HANDLE_VALUE) {
3480 				strcpy(p, src);
3481 				break;
3482 			}
3483 
3484 			FindClose(hFind);
3485 
3486 			strcpy(p, find.cFileName);
3487 			p += strlen(p);
3488 		}
3489 
3490 		//	skip trailing '\'s
3491 
3492 		while (*q == '\\' || *q == '/') {
3493 			q++;
3494 		}
3495 
3496 		src = q;
3497 	}
3498 }
3499