VBoxManageDisk.cpp@ 32651

Last change on this file since 32651 was 32536, checked in by vboxsync, 15 years ago

Storage/VBoxHDD: replace custom open flags with regular IPRT file open flags, introduce user-providable filesystem access interface, eliminate dependency on PGM geometry structure, change pvBuffer/cbBuffer parameter ordering to the usual conventions, eliminate the remains of the old I/O code, make more plugin methods optional to reduce redundancy, lots of cleanups

Storage/DrvVD+testcases,Main/Medium+Frontends: adapt to VBoxHDD changes, logging fixes

Storage/VDI+VMDK+DMG+Raw+VHD+Parallels+VCI: made as similar to each other as possible, added inline VFS wrappers to improve readability, full VFS support, VDI files are now 4K aligned, eliminate the remains of the old I/O code, various more or less severe bugfixes, code sort

Storage/iSCSI: support disks bigger than 2T, streamline the code to be more similar to the file-based backends, memory leak fix, error code usage like file-based backends, code sort

log+err: added new error codes/log groups and eliminated unused old ones

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 55.7 KB

Line
1	/* $Id: VBoxManageDisk.cpp 32536 2010-09-15 18:25:32Z vboxsync $ */
2	/** @file
3	* VBoxManage - The disk related commands.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#ifndef VBOX_ONLY_DOCS
19
20	/*******************************************************************************
21	* Header Files *
22	*******************************************************************************/
23	#include <VBox/com/com.h>
24	#include <VBox/com/array.h>
25	#include <VBox/com/ErrorInfo.h>
26	#include <VBox/com/errorprint.h>
27	#include <VBox/com/VirtualBox.h>
28
29	#include <iprt/asm.h>
30	#include <iprt/file.h>
31	#include <iprt/path.h>
32	#include <iprt/param.h>
33	#include <iprt/stream.h>
34	#include <iprt/string.h>
35	#include <iprt/ctype.h>
36	#include <iprt/getopt.h>
37	#include <VBox/log.h>
38	#include <VBox/VBoxHDD.h>
39
40	#include "VBoxManage.h"
41	using namespace com;
42
43
44	// funcs
45	///////////////////////////////////////////////////////////////////////////////
46
47
48	static DECLCALLBACK(void) handleVDError(void pvUser, int rc, RT_SRC_POS_DECL, const char pszFormat, va_list va)
49	{
50	RTPrintf("ERROR: ");
51	RTPrintfV(pszFormat, va);
52	RTPrintf("\n");
53	RTPrintf("Error code %Rrc at %s(%u) in function %s\n", rc, RT_SRC_POS_ARGS);
54	}
55
56
57	static int parseDiskVariant(const char psz, MediumVariant_T pDiskVariant)
58	{
59	int rc = VINF_SUCCESS;
60	unsigned DiskVariant = (unsigned)(*pDiskVariant);
61	while (psz && *psz && RT_SUCCESS(rc))
62	{
63	size_t len;
64	const char *pszComma = strchr(psz, ',');
65	if (pszComma)
66	len = pszComma - psz;
67	else
68	len = strlen(psz);
69	if (len > 0)
70	{
71	// Parsing is intentionally inconsistent: "standard" resets the
72	// variant, whereas the other flags are cumulative.
73	if (!RTStrNICmp(psz, "standard", len))
74	DiskVariant = MediumVariant_Standard;
75	else if ( !RTStrNICmp(psz, "fixed", len)
76	\|\| !RTStrNICmp(psz, "static", len))
77	DiskVariant \|= MediumVariant_Fixed;
78	else if (!RTStrNICmp(psz, "Diff", len))
79	DiskVariant \|= MediumVariant_Diff;
80	else if (!RTStrNICmp(psz, "split2g", len))
81	DiskVariant \|= MediumVariant_VmdkSplit2G;
82	else if ( !RTStrNICmp(psz, "stream", len)
83	\|\| !RTStrNICmp(psz, "streamoptimized", len))
84	DiskVariant \|= MediumVariant_VmdkStreamOptimized;
85	else if (!RTStrNICmp(psz, "esx", len))
86	DiskVariant \|= MediumVariant_VmdkESX;
87	else
88	rc = VERR_PARSE_ERROR;
89	}
90	if (pszComma)
91	psz += len + 1;
92	else
93	psz += len;
94	}
95
96	if (RT_SUCCESS(rc))
97	*pDiskVariant = (MediumVariant_T)DiskVariant;
98	return rc;
99	}
100
101	static int parseDiskType(const char psz, MediumType_T pDiskType)
102	{
103	int rc = VINF_SUCCESS;
104	MediumType_T DiskType = MediumType_Normal;
105	if (!RTStrICmp(psz, "normal"))
106	DiskType = MediumType_Normal;
107	else if (!RTStrICmp(psz, "immutable"))
108	DiskType = MediumType_Immutable;
109	else if (!RTStrICmp(psz, "writethrough"))
110	DiskType = MediumType_Writethrough;
111	else if (!RTStrICmp(psz, "shareable"))
112	DiskType = MediumType_Shareable;
113	else
114	rc = VERR_PARSE_ERROR;
115
116	if (RT_SUCCESS(rc))
117	*pDiskType = DiskType;
118	return rc;
119	}
120
121	/** @todo move this into getopt, as getting bool values is generic */
122	static int parseBool(const char psz, bool pb)
123	{
124	int rc = VINF_SUCCESS;
125	if ( !RTStrICmp(psz, "on")
126	\|\| !RTStrICmp(psz, "yes")
127	\|\| !RTStrICmp(psz, "true")
128	\|\| !RTStrICmp(psz, "1")
129	\|\| !RTStrICmp(psz, "enable")
130	\|\| !RTStrICmp(psz, "enabled"))
131	{
132	*pb = true;
133	}
134	else if ( !RTStrICmp(psz, "off")
135	\|\| !RTStrICmp(psz, "no")
136	\|\| !RTStrICmp(psz, "false")
137	\|\| !RTStrICmp(psz, "0")
138	\|\| !RTStrICmp(psz, "disable")
139	\|\| !RTStrICmp(psz, "disabled"))
140	{
141	*pb = false;
142	}
143	else
144	rc = VERR_PARSE_ERROR;
145
146	return rc;
147	}
148
149	static const RTGETOPTDEF g_aCreateHardDiskOptions[] =
150	{
151	{ "--filename", 'f', RTGETOPT_REQ_STRING },
152	{ "-filename", 'f', RTGETOPT_REQ_STRING }, // deprecated
153	{ "--size", 's', RTGETOPT_REQ_UINT64 },
154	{ "-size", 's', RTGETOPT_REQ_UINT64 }, // deprecated
155	{ "--sizebyte", 'S', RTGETOPT_REQ_UINT64 },
156	{ "--format", 'o', RTGETOPT_REQ_STRING },
157	{ "-format", 'o', RTGETOPT_REQ_STRING }, // deprecated
158	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
159	{ "-static", 'F', RTGETOPT_REQ_NOTHING }, // deprecated
160	{ "--variant", 'm', RTGETOPT_REQ_STRING },
161	{ "-variant", 'm', RTGETOPT_REQ_STRING }, // deprecated
162	{ "--type", 't', RTGETOPT_REQ_STRING },
163	{ "-type", 't', RTGETOPT_REQ_STRING }, // deprecated
164	{ "--comment", 'c', RTGETOPT_REQ_STRING },
165	{ "-comment", 'c', RTGETOPT_REQ_STRING }, // deprecated
166	{ "--remember", 'r', RTGETOPT_REQ_NOTHING },
167	{ "-remember", 'r', RTGETOPT_REQ_NOTHING }, // deprecated
168	{ "--register", 'r', RTGETOPT_REQ_NOTHING }, // deprecated (inofficial)
169	{ "-register", 'r', RTGETOPT_REQ_NOTHING }, // deprecated
170	};
171
172	int handleCreateHardDisk(HandlerArg *a)
173	{
174	HRESULT rc;
175	int vrc;
176	Bstr filename;
177	uint64_t size = 0;
178	Bstr format = "VDI";
179	MediumVariant_T DiskVariant = MediumVariant_Standard;
180	Bstr comment;
181	bool fRemember = false;
182	MediumType_T DiskType = MediumType_Normal;
183
184	int c;
185	RTGETOPTUNION ValueUnion;
186	RTGETOPTSTATE GetState;
187	// start at 0 because main() has hacked both the argc and argv given to us
188	RTGetOptInit(&GetState, a->argc, a->argv, g_aCreateHardDiskOptions, RT_ELEMENTS(g_aCreateHardDiskOptions),
189	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
190	while ((c = RTGetOpt(&GetState, &ValueUnion)))
191	{
192	switch (c)
193	{
194	case 'f': // --filename
195	filename = ValueUnion.psz;
196	break;
197
198	case 's': // --size
199	size = ValueUnion.u64 * _1M;
200	break;
201
202	case 'S': // --sizebyte
203	size = ValueUnion.u64;
204	break;
205
206	case 'o': // --format
207	format = ValueUnion.psz;
208	break;
209
210	case 'F': // --static ("fixed"/"flat")
211	{
212	unsigned uDiskVariant = (unsigned)DiskVariant;
213	uDiskVariant \|= MediumVariant_Fixed;
214	DiskVariant = (MediumVariant_T)uDiskVariant;
215	break;
216	}
217
218	case 'm': // --variant
219	vrc = parseDiskVariant(ValueUnion.psz, &DiskVariant);
220	if (RT_FAILURE(vrc))
221	return errorArgument("Invalid hard disk variant '%s'", ValueUnion.psz);
222	break;
223
224	case 'c': // --comment
225	comment = ValueUnion.psz;
226	break;
227
228	case 'r': // --remember
229	fRemember = true;
230	break;
231
232	case 't': // --type
233	vrc = parseDiskType(ValueUnion.psz, &DiskType);
234	if ( RT_FAILURE(vrc)
235	\|\| ( DiskType != MediumType_Normal
236	&& DiskType != MediumType_Writethrough
237	&& DiskType != MediumType_Shareable))
238	return errorArgument("Invalid hard disk type '%s'", ValueUnion.psz);
239	break;
240
241	case VINF_GETOPT_NOT_OPTION:
242	return errorSyntax(USAGE_CREATEHD, "Invalid parameter '%s'", ValueUnion.psz);
243
244	default:
245	if (c > 0)
246	{
247	if (RT_C_IS_PRINT(c))
248	return errorSyntax(USAGE_CREATEHD, "Invalid option -%c", c);
249	else
250	return errorSyntax(USAGE_CREATEHD, "Invalid option case %i", c);
251	}
252	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
253	return errorSyntax(USAGE_CREATEHD, "unknown option: %s\n", ValueUnion.psz);
254	else if (ValueUnion.pDef)
255	return errorSyntax(USAGE_CREATEHD, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
256	else
257	return errorSyntax(USAGE_CREATEHD, "error: %Rrs", c);
258	}
259	}
260
261	/* check the outcome */
262	if ( !filename
263	\|\| size == 0)
264	return errorSyntax(USAGE_CREATEHD, "Parameters --filename and --size are required");
265
266	/* check for filename extension */
267	Utf8Str strName(filename);
268	if (!RTPathHaveExt(strName.c_str()))
269	{
270	Utf8Str strFormat(format);
271	if (strFormat.compare("vmdk", iprt::MiniString::CaseInsensitive) == 0)
272	strName.append(".vmdk");
273	else if (strFormat.compare("vhd", iprt::MiniString::CaseInsensitive) == 0)
274	strName.append(".vhd");
275	else
276	strName.append(".vdi");
277	filename = Bstr(strName);
278	}
279
280	ComPtr<IMedium> hardDisk;
281	CHECK_ERROR(a->virtualBox, CreateHardDisk(format, filename, hardDisk.asOutParam()));
282	if (SUCCEEDED(rc) && hardDisk)
283	{
284	/* we will close the hard disk after the storage has been successfully
285	* created unless fRemember is set */
286	bool doClose = false;
287
288	if (!comment.isEmpty())
289	{
290	CHECK_ERROR(hardDisk,COMSETTER(Description)(comment));
291	}
292
293	ComPtr<IProgress> progress;
294	CHECK_ERROR(hardDisk, CreateBaseStorage(size, DiskVariant, progress.asOutParam()));
295	if (SUCCEEDED(rc) && progress)
296	{
297	rc = showProgress(progress);
298	if (FAILED(rc))
299	{
300	com::ProgressErrorInfo info(progress);
301	if (info.isBasicAvailable())
302	RTPrintf("Error: failed to create hard disk. Error message: %lS\n", info.getText().raw());
303	else
304	RTPrintf("Error: failed to create hard disk. No error message available!\n");
305	}
306	else
307	{
308	doClose = !fRemember;
309
310	Bstr uuid;
311	CHECK_ERROR(hardDisk, COMGETTER(Id)(uuid.asOutParam()));
312
313	if ( DiskType == MediumType_Writethrough
314	\|\| DiskType == MediumType_Shareable)
315	{
316	CHECK_ERROR(hardDisk, COMSETTER(Type)(DiskType));
317	}
318
319	RTPrintf("Disk image created. UUID: %s\n", Utf8Str(uuid).c_str());
320	}
321	}
322	if (doClose)
323	{
324	CHECK_ERROR(hardDisk, Close());
325	}
326	}
327	return SUCCEEDED(rc) ? 0 : 1;
328	}
329
330	#if 0 /* disabled until disk shrinking is implemented based on VBoxHDD */
331	static DECLCALLBACK(int) hardDiskProgressCallback(PVM pVM, unsigned uPercent, void *pvUser)
332	{
333	unsigned pPercent = (unsigned )pvUser;
334
335	if (*pPercent != uPercent)
336	{
337	*pPercent = uPercent;
338	RTPrintf(".");
339	if ((uPercent % 10) == 0 && uPercent)
340	RTPrintf("%d%%", uPercent);
341	RTStrmFlush(g_pStdOut);
342	}
343
344	return VINF_SUCCESS;
345	}
346	#endif
347
348	static const RTGETOPTDEF g_aModifyHardDiskOptions[] =
349	{
350	{ "--type", 't', RTGETOPT_REQ_STRING },
351	{ "-type", 't', RTGETOPT_REQ_STRING }, // deprecated
352	{ "settype", 't', RTGETOPT_REQ_STRING }, // deprecated
353	{ "--autoreset", 'z', RTGETOPT_REQ_STRING },
354	{ "-autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
355	{ "autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
356	{ "--compact", 'c', RTGETOPT_REQ_NOTHING },
357	{ "-compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
358	{ "compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
359	{ "--resize", 'r', RTGETOPT_REQ_UINT64 }
360	};
361
362	int handleModifyHardDisk(HandlerArg *a)
363	{
364	HRESULT rc;
365	int vrc;
366	ComPtr<IMedium> hardDisk;
367	MediumType_T DiskType;
368	bool AutoReset = false;
369	bool fModifyDiskType = false, fModifyAutoReset = false, fModifyCompact = false;
370	bool fModifyResize = false;
371	uint64_t resizeMB = 0;
372	const char *FilenameOrUuid = NULL;
373
374	int c;
375	RTGETOPTUNION ValueUnion;
376	RTGETOPTSTATE GetState;
377	// start at 0 because main() has hacked both the argc and argv given to us
378	RTGetOptInit(&GetState, a->argc, a->argv, g_aModifyHardDiskOptions, RT_ELEMENTS(g_aModifyHardDiskOptions),
379	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
380	while ((c = RTGetOpt(&GetState, &ValueUnion)))
381	{
382	switch (c)
383	{
384	case 't': // --type
385	vrc = parseDiskType(ValueUnion.psz, &DiskType);
386	if (RT_FAILURE(vrc))
387	return errorArgument("Invalid hard disk type '%s'", ValueUnion.psz);
388	fModifyDiskType = true;
389	break;
390
391	case 'z': // --autoreset
392	vrc = parseBool(ValueUnion.psz, &AutoReset);
393	if (RT_FAILURE(vrc))
394	return errorArgument("Invalid autoreset parameter '%s'", ValueUnion.psz);
395	fModifyAutoReset = true;
396	break;
397
398	case 'c': // --compact
399	fModifyCompact = true;
400	break;
401
402	case 'r': // --resize
403	resizeMB = ValueUnion.u64;
404	fModifyResize = true;
405	break;
406
407	case VINF_GETOPT_NOT_OPTION:
408	if (!FilenameOrUuid)
409	FilenameOrUuid = ValueUnion.psz;
410	else
411	return errorSyntax(USAGE_CREATEHD, "Invalid parameter '%s'", ValueUnion.psz);
412	break;
413
414	default:
415	if (c > 0)
416	{
417	if (RT_C_IS_PRINT(c))
418	return errorSyntax(USAGE_MODIFYHD, "Invalid option -%c", c);
419	else
420	return errorSyntax(USAGE_MODIFYHD, "Invalid option case %i", c);
421	}
422	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
423	return errorSyntax(USAGE_MODIFYHD, "unknown option: %s\n", ValueUnion.psz);
424	else if (ValueUnion.pDef)
425	return errorSyntax(USAGE_MODIFYHD, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
426	else
427	return errorSyntax(USAGE_MODIFYHD, "error: %Rrs", c);
428	}
429	}
430
431	if (!FilenameOrUuid)
432	return errorSyntax(USAGE_MODIFYHD, "Disk name or UUID required");
433
434	if (!fModifyDiskType && !fModifyAutoReset && !fModifyCompact && !fModifyResize)
435	return errorSyntax(USAGE_MODIFYHD, "No operation specified");
436
437	/* first guess is that it's a UUID */
438	CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, hardDisk.asOutParam()));
439	if (FAILED(rc))
440	return 1;
441
442	if (fModifyDiskType)
443	{
444	/* hard disk must be registered */
445	if (SUCCEEDED(rc) && hardDisk)
446	{
447	MediumType_T hddType;
448	CHECK_ERROR(hardDisk, COMGETTER(Type)(&hddType));
449
450	if (hddType != DiskType)
451	CHECK_ERROR(hardDisk, COMSETTER(Type)(DiskType));
452	}
453	else
454	return errorArgument("Hard disk image not registered");
455	}
456
457	if (fModifyAutoReset)
458	{
459	CHECK_ERROR(hardDisk, COMSETTER(AutoReset)(AutoReset));
460	}
461
462	if (fModifyCompact)
463	{
464	bool unknown = false;
465	/* the hard disk image might not be registered */
466	if (!hardDisk)
467	{
468	unknown = true;
469	rc = a->virtualBox->OpenMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam());
470	if (rc == VBOX_E_FILE_ERROR)
471	{
472	char szFilenameAbs[RTPATH_MAX] = "";
473	int irc = RTPathAbs(FilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs));
474	if (RT_FAILURE(irc))
475	{
476	RTPrintf("Cannot convert filename \"%s\" to absolute path\n", FilenameOrUuid);
477	return 1;
478	}
479	CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam()));
480	}
481	}
482	if (SUCCEEDED(rc) && hardDisk)
483	{
484	ComPtr<IProgress> progress;
485	CHECK_ERROR(hardDisk, Compact(progress.asOutParam()));
486	if (SUCCEEDED(rc))
487	rc = showProgress(progress);
488	if (FAILED(rc))
489	{
490	if (rc == E_NOTIMPL)
491	{
492	RTPrintf("Error: Compact hard disk operation is not implemented!\n");
493	RTPrintf("The functionality will be restored later.\n");
494	}
495	else if (rc == VBOX_E_NOT_SUPPORTED)
496	{
497	RTPrintf("Error: Compact hard disk operation for this format is not implemented yet!\n");
498	}
499	else
500	com::GluePrintRCMessage(rc);
501	}
502	if (unknown)
503	hardDisk->Close();
504	}
505	}
506
507	if (fModifyResize)
508	{
509	bool unknown = false;
510	/* the hard disk image might not be registered */
511	if (!hardDisk)
512	{
513	unknown = true;
514	rc = a->virtualBox->OpenMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam());
515	if (rc == VBOX_E_FILE_ERROR)
516	{
517	char szFilenameAbs[RTPATH_MAX] = "";
518	int irc = RTPathAbs(FilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs));
519	if (RT_FAILURE(irc))
520	{
521	RTPrintf("Cannot convert filename \"%s\" to absolute path\n", FilenameOrUuid);
522	return 1;
523	}
524	CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam()));
525	}
526	}
527	if (SUCCEEDED(rc) && hardDisk)
528	{
529	ComPtr<IProgress> progress;
530	CHECK_ERROR(hardDisk, Resize(resizeMB, progress.asOutParam()));
531	if (SUCCEEDED(rc))
532	rc = showProgress(progress);
533	if (FAILED(rc))
534	{
535	if (rc == E_NOTIMPL)
536	{
537	RTPrintf("Error: Resize hard disk operation is not implemented!\n");
538	RTPrintf("The functionality will be restored later.\n");
539	}
540	else if (rc == VBOX_E_NOT_SUPPORTED)
541	{
542	RTPrintf("Error: Resize hard disk operation for this format is not implemented yet!\n");
543	}
544	else
545	com::GluePrintRCMessage(rc);
546	}
547	if (unknown)
548	hardDisk->Close();
549	}
550	}
551
552	return SUCCEEDED(rc) ? 0 : 1;
553	}
554
555	static const RTGETOPTDEF g_aCloneHardDiskOptions[] =
556	{
557	{ "--format", 'o', RTGETOPT_REQ_STRING },
558	{ "-format", 'o', RTGETOPT_REQ_STRING },
559	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
560	{ "-static", 'F', RTGETOPT_REQ_NOTHING },
561	{ "--existing", 'E', RTGETOPT_REQ_NOTHING },
562	{ "--variant", 'm', RTGETOPT_REQ_STRING },
563	{ "-variant", 'm', RTGETOPT_REQ_STRING },
564	{ "--type", 't', RTGETOPT_REQ_STRING },
565	{ "-type", 't', RTGETOPT_REQ_STRING },
566	{ "--remember", 'r', RTGETOPT_REQ_NOTHING },
567	{ "-remember", 'r', RTGETOPT_REQ_NOTHING },
568	{ "--register", 'r', RTGETOPT_REQ_NOTHING },
569	{ "-register", 'r', RTGETOPT_REQ_NOTHING },
570	};
571
572	int handleCloneHardDisk(HandlerArg *a)
573	{
574	HRESULT rc;
575	int vrc;
576	Bstr src, dst;
577	Bstr format;
578	MediumVariant_T DiskVariant = MediumVariant_Standard;
579	bool fExisting = false;
580	bool fRemember = false;
581	bool fSetDiskType = false;
582	MediumType_T DiskType = MediumType_Normal;
583
584	int c;
585	RTGETOPTUNION ValueUnion;
586	RTGETOPTSTATE GetState;
587	// start at 0 because main() has hacked both the argc and argv given to us
588	RTGetOptInit(&GetState, a->argc, a->argv, g_aCloneHardDiskOptions, RT_ELEMENTS(g_aCloneHardDiskOptions),
589	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
590	while ((c = RTGetOpt(&GetState, &ValueUnion)))
591	{
592	switch (c)
593	{
594	case 'o': // --format
595	format = ValueUnion.psz;
596	break;
597
598	case 'F': // --static
599	{
600	unsigned uDiskVariant = (unsigned)DiskVariant;
601	uDiskVariant \|= MediumVariant_Fixed;
602	DiskVariant = (MediumVariant_T)uDiskVariant;
603	break;
604	}
605
606	case 'E': // --existing
607	fExisting = true;
608	break;
609
610	case 'm': // --variant
611	vrc = parseDiskVariant(ValueUnion.psz, &DiskVariant);
612	if (RT_FAILURE(vrc))
613	return errorArgument("Invalid hard disk variant '%s'", ValueUnion.psz);
614	break;
615
616	case 'r': // --remember
617	fRemember = true;
618	break;
619
620	case 't': // --type
621	vrc = parseDiskType(ValueUnion.psz, &DiskType);
622	if (RT_FAILURE(vrc))
623	return errorArgument("Invalid hard disk type '%s'", ValueUnion.psz);
624	fSetDiskType = true;
625	break;
626
627	case VINF_GETOPT_NOT_OPTION:
628	if (src.isEmpty())
629	src = ValueUnion.psz;
630	else if (dst.isEmpty())
631	dst = ValueUnion.psz;
632	else
633	return errorSyntax(USAGE_CLONEHD, "Invalid parameter '%s'", ValueUnion.psz);
634	break;
635
636	default:
637	if (c > 0)
638	{
639	if (RT_C_IS_GRAPH(c))
640	return errorSyntax(USAGE_CLONEHD, "unhandled option: -%c", c);
641	else
642	return errorSyntax(USAGE_CLONEHD, "unhandled option: %i", c);
643	}
644	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
645	return errorSyntax(USAGE_CLONEHD, "unknown option: %s", ValueUnion.psz);
646	else if (ValueUnion.pDef)
647	return errorSyntax(USAGE_CLONEHD, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
648	else
649	return errorSyntax(USAGE_CLONEHD, "error: %Rrs", c);
650	}
651	}
652
653	if (src.isEmpty())
654	return errorSyntax(USAGE_CLONEHD, "Mandatory UUID or input file parameter missing");
655	if (dst.isEmpty())
656	return errorSyntax(USAGE_CLONEHD, "Mandatory output file parameter missing");
657	if (fExisting && (!format.isEmpty() \|\| DiskVariant != MediumType_Normal))
658	return errorSyntax(USAGE_CLONEHD, "Specified options which cannot be used with --existing");
659
660	ComPtr<IMedium> srcDisk;
661	ComPtr<IMedium> dstDisk;
662	bool fSrcUnknown = false;
663	bool fDstUnknown = false;
664
665	rc = a->virtualBox->FindMedium(src, DeviceType_HardDisk, srcDisk.asOutParam());
666	/* no? well, then it's an unknown image */
667	if (FAILED (rc))
668	{
669	rc = a->virtualBox->OpenMedium(src, DeviceType_HardDisk, AccessMode_ReadWrite, srcDisk.asOutParam());
670	if (rc == VBOX_E_FILE_ERROR)
671	{
672	char szFilenameAbs[RTPATH_MAX] = "";
673	int irc = RTPathAbs(Utf8Str(src).c_str(), szFilenameAbs, sizeof(szFilenameAbs));
674	if (RT_FAILURE(irc))
675	{
676	RTPrintf("Cannot convert filename \"%s\" to absolute path\n", Utf8Str(src).c_str());
677	return 1;
678	}
679	CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, srcDisk.asOutParam()));
680	}
681	if (SUCCEEDED (rc))
682	fSrcUnknown = true;
683	}
684
685	do
686	{
687	if (!SUCCEEDED(rc))
688	break;
689
690	/* open/create destination hard disk */
691	if (fExisting)
692	{
693	rc = a->virtualBox->FindMedium(dst, DeviceType_HardDisk, dstDisk.asOutParam());
694	/* no? well, then it's an unknown image */
695	if (FAILED (rc))
696	{
697	rc = a->virtualBox->OpenMedium(dst, DeviceType_HardDisk, AccessMode_ReadWrite, dstDisk.asOutParam());
698	if (rc == VBOX_E_FILE_ERROR)
699	{
700	char szFilenameAbs[RTPATH_MAX] = "";
701	int irc = RTPathAbs(Utf8Str(dst).c_str(), szFilenameAbs, sizeof(szFilenameAbs));
702	if (RT_FAILURE(irc))
703	{
704	RTPrintf("Cannot convert filename \"%s\" to absolute path\n", Utf8Str(dst).c_str());
705	return 1;
706	}
707	CHECK_ERROR_BREAK(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, dstDisk.asOutParam()));
708	}
709	if (SUCCEEDED (rc))
710	fDstUnknown = true;
711	}
712	else
713	fRemember = true;
714	if (SUCCEEDED(rc))
715	{
716	/* Perform accessibility check now. */
717	MediumState_T state;
718	CHECK_ERROR_BREAK(dstDisk, RefreshState(&state));
719	}
720	CHECK_ERROR_BREAK(dstDisk, COMGETTER(Format) (format.asOutParam()));
721	}
722	else
723	{
724	/* use the format of the source hard disk if unspecified */
725	if (format.isEmpty())
726	CHECK_ERROR_BREAK(srcDisk, COMGETTER(Format) (format.asOutParam()));
727	CHECK_ERROR_BREAK(a->virtualBox, CreateHardDisk(format, dst, dstDisk.asOutParam()));
728	}
729
730	ComPtr<IProgress> progress;
731	CHECK_ERROR_BREAK(srcDisk, CloneTo(dstDisk, DiskVariant, NULL, progress.asOutParam()));
732
733	rc = showProgress(progress);
734	if (FAILED(rc))
735	{
736	com::ProgressErrorInfo info(progress);
737	if (info.isBasicAvailable())
738	RTPrintf("Error: failed to clone hard disk. Error message: %lS\n", info.getText().raw());
739	else
740	RTPrintf("Error: failed to clone hard disk. No error message available!\n");
741	break;
742	}
743
744	Bstr uuid;
745	CHECK_ERROR_BREAK(dstDisk, COMGETTER(Id)(uuid.asOutParam()));
746
747	RTPrintf("Clone hard disk created in format '%ls'. UUID: %s\n",
748	format.raw(), Utf8Str(uuid).c_str());
749	}
750	while (0);
751
752	if (!fRemember && !dstDisk.isNull())
753	{
754	/* forget the created clone */
755	dstDisk->Close();
756	}
757	else if (fSetDiskType)
758	{
759	CHECK_ERROR(dstDisk, COMSETTER(Type)(DiskType));
760	}
761
762	if (fSrcUnknown)
763	{
764	/* close the unknown hard disk to forget it again */
765	srcDisk->Close();
766	}
767
768	return SUCCEEDED(rc) ? 0 : 1;
769	}
770
771	static const RTGETOPTDEF g_aConvertFromRawHardDiskOptions[] =
772	{
773	{ "--format", 'o', RTGETOPT_REQ_STRING },
774	{ "-format", 'o', RTGETOPT_REQ_STRING },
775	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
776	{ "-static", 'F', RTGETOPT_REQ_NOTHING },
777	{ "--variant", 'm', RTGETOPT_REQ_STRING },
778	{ "-variant", 'm', RTGETOPT_REQ_STRING },
779	};
780
781	int handleConvertFromRaw(int argc, char *argv[])
782	{
783	int rc = VINF_SUCCESS;
784	bool fReadFromStdIn = false;
785	const char *format = "VDI";
786	const char *srcfilename = NULL;
787	const char *dstfilename = NULL;
788	const char *filesize = NULL;
789	unsigned uImageFlags = VD_IMAGE_FLAGS_NONE;
790	void *pvBuf = NULL;
791
792	int c;
793	RTGETOPTUNION ValueUnion;
794	RTGETOPTSTATE GetState;
795	// start at 0 because main() has hacked both the argc and argv given to us
796	RTGetOptInit(&GetState, argc, argv, g_aConvertFromRawHardDiskOptions, RT_ELEMENTS(g_aConvertFromRawHardDiskOptions),
797	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
798	while ((c = RTGetOpt(&GetState, &ValueUnion)))
799	{
800	switch (c)
801	{
802	case 'o': // --format
803	format = ValueUnion.psz;
804	break;
805
806	case 'm': // --variant
807	MediumVariant_T DiskVariant;
808	rc = parseDiskVariant(ValueUnion.psz, &DiskVariant);
809	if (RT_FAILURE(rc))
810	return errorArgument("Invalid hard disk variant '%s'", ValueUnion.psz);
811	/// @todo cleaner solution than assuming 1:1 mapping?
812	uImageFlags = (unsigned)DiskVariant;
813	break;
814
815	case VINF_GETOPT_NOT_OPTION:
816	if (!srcfilename)
817	{
818	srcfilename = ValueUnion.psz;
819	// If you change the OS list here don't forget to update VBoxManageHelp.cpp.
820	#ifndef RT_OS_WINDOWS
821	fReadFromStdIn = !strcmp(srcfilename, "stdin");
822	#endif
823	}
824	else if (!dstfilename)
825	dstfilename = ValueUnion.psz;
826	else if (fReadFromStdIn && !filesize)
827	filesize = ValueUnion.psz;
828	else
829	return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid parameter '%s'", ValueUnion.psz);
830	break;
831
832	default:
833	return errorGetOpt(USAGE_CONVERTFROMRAW, c, &ValueUnion);
834	}
835	}
836
837	if (!srcfilename \|\| !dstfilename \|\| (fReadFromStdIn && !filesize))
838	return errorSyntax(USAGE_CONVERTFROMRAW, "Incorrect number of parameters");
839	RTPrintf("Converting from raw image file=\"%s\" to file=\"%s\"...\n",
840	srcfilename, dstfilename);
841
842	PVBOXHDD pDisk = NULL;
843
844	PVDINTERFACE pVDIfs = NULL;
845	VDINTERFACE vdInterfaceError;
846	VDINTERFACEERROR vdInterfaceErrorCallbacks;
847	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
848	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
849	vdInterfaceErrorCallbacks.pfnError = handleVDError;
850	vdInterfaceErrorCallbacks.pfnMessage = NULL;
851
852	rc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
853	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
854	AssertRC(rc);
855
856	/* open raw image file. */
857	RTFILE File;
858	if (fReadFromStdIn)
859	File = 0;
860	else
861	rc = RTFileOpen(&File, srcfilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
862	if (RT_FAILURE(rc))
863	{
864	RTPrintf("File=\"%s\" open error: %Rrf\n", srcfilename, rc);
865	goto out;
866	}
867
868	uint64_t cbFile;
869	/* get image size. */
870	if (fReadFromStdIn)
871	cbFile = RTStrToUInt64(filesize);
872	else
873	rc = RTFileGetSize(File, &cbFile);
874	if (RT_FAILURE(rc))
875	{
876	RTPrintf("Error getting image size for file \"%s\": %Rrc\n", srcfilename, rc);
877	goto out;
878	}
879
880	RTPrintf("Creating %s image with size %RU64 bytes (%RU64MB)...\n", (uImageFlags & VD_IMAGE_FLAGS_FIXED) ? "fixed" : "dynamic", cbFile, (cbFile + _1M - 1) / _1M);
881	char pszComment[256];
882	RTStrPrintf(pszComment, sizeof(pszComment), "Converted image from %s", srcfilename);
883	rc = VDCreate(pVDIfs, &pDisk);
884	if (RT_FAILURE(rc))
885	{
886	RTPrintf("Error while creating the virtual disk container: %Rrc\n", rc);
887	goto out;
888	}
889
890	Assert(RT_MIN(cbFile / 512 / 16 / 63, 16383) -
891	(unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383) == 0);
892	VDGEOMETRY PCHS, LCHS;
893	PCHS.cCylinders = (unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383);
894	PCHS.cHeads = 16;
895	PCHS.cSectors = 63;
896	LCHS.cCylinders = 0;
897	LCHS.cHeads = 0;
898	LCHS.cSectors = 0;
899	rc = VDCreateBase(pDisk, format, dstfilename, cbFile,
900	uImageFlags, pszComment, &PCHS, &LCHS, NULL,
901	VD_OPEN_FLAGS_NORMAL, NULL, NULL);
902	if (RT_FAILURE(rc))
903	{
904	RTPrintf("Error while creating the disk image \"%s\": %Rrc\n", dstfilename, rc);
905	goto out;
906	}
907
908	size_t cbBuffer;
909	cbBuffer = _1M;
910	pvBuf = RTMemAlloc(cbBuffer);
911	if (!pvBuf)
912	{
913	rc = VERR_NO_MEMORY;
914	RTPrintf("Not enough memory allocating buffers for image \"%s\": %Rrc\n", dstfilename, rc);
915	goto out;
916	}
917
918	uint64_t offFile;
919	offFile = 0;
920	while (offFile < cbFile)
921	{
922	size_t cbRead;
923	size_t cbToRead;
924	cbRead = 0;
925	cbToRead = cbFile - offFile >= (uint64_t)cbBuffer ?
926	cbBuffer : (size_t) (cbFile - offFile);
927	rc = RTFileRead(File, pvBuf, cbToRead, &cbRead);
928	if (RT_FAILURE(rc) \|\| !cbRead)
929	break;
930	rc = VDWrite(pDisk, offFile, pvBuf, cbRead);
931	if (RT_FAILURE(rc))
932	{
933	RTPrintf("Failed to write to disk image \"%s\": %Rrc\n", dstfilename, rc);
934	goto out;
935	}
936	offFile += cbRead;
937	}
938
939	out:
940	if (pvBuf)
941	RTMemFree(pvBuf);
942	if (pDisk)
943	VDClose(pDisk, RT_FAILURE(rc));
944	if (File != NIL_RTFILE)
945	RTFileClose(File);
946
947	return RT_FAILURE(rc);
948	}
949
950	static const RTGETOPTDEF g_aAddiSCSIDiskOptions[] =
951	{
952	{ "--server", 's', RTGETOPT_REQ_STRING },
953	{ "-server", 's', RTGETOPT_REQ_STRING }, // deprecated
954	{ "--target", 'T', RTGETOPT_REQ_STRING },
955	{ "-target", 'T', RTGETOPT_REQ_STRING }, // deprecated
956	{ "--port", 'p', RTGETOPT_REQ_STRING },
957	{ "-port", 'p', RTGETOPT_REQ_STRING }, // deprecated
958	{ "--lun", 'l', RTGETOPT_REQ_STRING },
959	{ "-lun", 'l', RTGETOPT_REQ_STRING }, // deprecated
960	{ "--encodedlun", 'L', RTGETOPT_REQ_STRING },
961	{ "-encodedlun", 'L', RTGETOPT_REQ_STRING }, // deprecated
962	{ "--username", 'u', RTGETOPT_REQ_STRING },
963	{ "-username", 'u', RTGETOPT_REQ_STRING }, // deprecated
964	{ "--password", 'P', RTGETOPT_REQ_STRING },
965	{ "-password", 'P', RTGETOPT_REQ_STRING }, // deprecated
966	{ "--type", 't', RTGETOPT_REQ_STRING },
967	{ "-type", 't', RTGETOPT_REQ_STRING }, // deprecated
968	{ "--intnet", 'I', RTGETOPT_REQ_NOTHING },
969	{ "-intnet", 'I', RTGETOPT_REQ_NOTHING }, // deprecated
970	};
971
972	int handleAddiSCSIDisk(HandlerArg *a)
973	{
974	HRESULT rc;
975	int vrc;
976	Bstr server;
977	Bstr target;
978	Bstr port;
979	Bstr lun;
980	Bstr username;
981	Bstr password;
982	Bstr comment;
983	bool fIntNet = false;
984	MediumType_T DiskType = MediumType_Normal;
985
986	int c;
987	RTGETOPTUNION ValueUnion;
988	RTGETOPTSTATE GetState;
989	// start at 0 because main() has hacked both the argc and argv given to us
990	RTGetOptInit(&GetState, a->argc, a->argv, g_aAddiSCSIDiskOptions, RT_ELEMENTS(g_aAddiSCSIDiskOptions),
991	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
992	while ((c = RTGetOpt(&GetState, &ValueUnion)))
993	{
994	switch (c)
995	{
996	case 's': // --server
997	server = ValueUnion.psz;
998	break;
999
1000	case 'T': // --target
1001	target = ValueUnion.psz;
1002	break;
1003
1004	case 'p': // --port
1005	port = ValueUnion.psz;
1006	break;
1007
1008	case 'l': // --lun
1009	lun = ValueUnion.psz;
1010	break;
1011
1012	case 'L': // --encodedlun
1013	lun = BstrFmt("enc%s", ValueUnion.psz);
1014	break;
1015
1016	case 'u': // --username
1017	username = ValueUnion.psz;
1018	break;
1019
1020	case 'P': // --password
1021	password = ValueUnion.psz;
1022	break;
1023
1024	case 't': // --type
1025	vrc = parseDiskType(ValueUnion.psz, &DiskType);
1026	if (RT_FAILURE(vrc))
1027	return errorArgument("Invalid hard disk type '%s'", ValueUnion.psz);
1028	break;
1029
1030	case 'I': // --intnet
1031	fIntNet = true;
1032	break;
1033
1034	case VINF_GETOPT_NOT_OPTION:
1035	return errorSyntax(USAGE_ADDISCSIDISK, "Invalid parameter '%s'", ValueUnion.psz);
1036
1037	default:
1038	if (c > 0)
1039	{
1040	if (RT_C_IS_PRINT(c))
1041	return errorSyntax(USAGE_ADDISCSIDISK, "Invalid option -%c", c);
1042	else
1043	return errorSyntax(USAGE_ADDISCSIDISK, "Invalid option case %i", c);
1044	}
1045	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1046	return errorSyntax(USAGE_ADDISCSIDISK, "unknown option: %s\n", ValueUnion.psz);
1047	else if (ValueUnion.pDef)
1048	return errorSyntax(USAGE_ADDISCSIDISK, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1049	else
1050	return errorSyntax(USAGE_ADDISCSIDISK, "error: %Rrs", c);
1051	}
1052	}
1053
1054	/* check for required options */
1055	if (!server \|\| !target)
1056	return errorSyntax(USAGE_ADDISCSIDISK, "Parameters --server and --target are required");
1057
1058	do
1059	{
1060	ComPtr<IMedium> hardDisk;
1061	/** @todo move the location stuff to Main, which can use pfnComposeName
1062	* from the disk backends to construct the location properly. Also do
1063	* not use slashes to separate the parts, as otherwise only the last
1064	* element comtaining information will be shown. */
1065	if (lun.isEmpty() \|\| lun == "0" \|\| lun == "enc0")
1066	{
1067	CHECK_ERROR_BREAK (a->virtualBox,
1068	CreateHardDisk(Bstr ("iSCSI"),
1069	BstrFmt ("%ls\|%ls", server.raw(), target.raw()),
1070	hardDisk.asOutParam()));
1071	}
1072	else
1073	{
1074	CHECK_ERROR_BREAK (a->virtualBox,
1075	CreateHardDisk(Bstr ("iSCSI"),
1076	BstrFmt ("%ls\|%ls\|%ls", server.raw(), target.raw(), lun.raw()),
1077	hardDisk.asOutParam()));
1078	}
1079	if (FAILED(rc)) break;
1080
1081	if (!port.isEmpty())
1082	server = BstrFmt ("%ls:%ls", server.raw(), port.raw());
1083
1084	com::SafeArray <BSTR> names;
1085	com::SafeArray <BSTR> values;
1086
1087	Bstr ("TargetAddress").detachTo (names.appendedRaw());
1088	server.detachTo (values.appendedRaw());
1089	Bstr ("TargetName").detachTo (names.appendedRaw());
1090	target.detachTo (values.appendedRaw());
1091
1092	if (!lun.isEmpty())
1093	{
1094	Bstr ("LUN").detachTo (names.appendedRaw());
1095	lun.detachTo (values.appendedRaw());
1096	}
1097	if (!username.isEmpty())
1098	{
1099	Bstr ("InitiatorUsername").detachTo (names.appendedRaw());
1100	username.detachTo (values.appendedRaw());
1101	}
1102	if (!password.isEmpty())
1103	{
1104	Bstr ("InitiatorSecret").detachTo (names.appendedRaw());
1105	password.detachTo (values.appendedRaw());
1106	}
1107
1108	/// @todo add --initiator option - until that happens rely on the
1109	// defaults of the iSCSI initiator code. Setting it to a constant
1110	// value does more harm than good, as the initiator name is supposed
1111	// to identify a particular initiator uniquely.
1112	// Bstr ("InitiatorName").detachTo (names.appendedRaw());
1113	// Bstr ("iqn.2008-04.com.sun.virtualbox.initiator").detachTo (values.appendedRaw());
1114
1115	/// @todo add --targetName and --targetPassword options
1116
1117	if (fIntNet)
1118	{
1119	Bstr ("HostIPStack").detachTo (names.appendedRaw());
1120	Bstr ("0").detachTo (values.appendedRaw());
1121	}
1122
1123	CHECK_ERROR_BREAK (hardDisk,
1124	SetProperties (ComSafeArrayAsInParam (names),
1125	ComSafeArrayAsInParam (values)));
1126
1127	if (DiskType != MediumType_Normal)
1128	{
1129	CHECK_ERROR(hardDisk, COMSETTER(Type)(DiskType));
1130	}
1131
1132	Bstr guid;
1133	CHECK_ERROR(hardDisk, COMGETTER(Id)(guid.asOutParam()));
1134	RTPrintf("iSCSI disk created. UUID: %s\n", Utf8Str(guid).c_str());
1135	}
1136	while (0);
1137
1138	return SUCCEEDED(rc) ? 0 : 1;
1139	}
1140
1141	static const RTGETOPTDEF g_aShowHardDiskInfoOptions[] =
1142	{
1143	{ "--dummy", 256, RTGETOPT_REQ_NOTHING }, // placeholder for C++
1144	};
1145
1146	int handleShowHardDiskInfo(HandlerArg *a)
1147	{
1148	HRESULT rc;
1149	const char *FilenameOrUuid = NULL;
1150
1151	int c;
1152	RTGETOPTUNION ValueUnion;
1153	RTGETOPTSTATE GetState;
1154	// start at 0 because main() has hacked both the argc and argv given to us
1155	RTGetOptInit(&GetState, a->argc, a->argv, g_aShowHardDiskInfoOptions, RT_ELEMENTS(g_aShowHardDiskInfoOptions),
1156	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1157	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1158	{
1159	switch (c)
1160	{
1161	case VINF_GETOPT_NOT_OPTION:
1162	if (!FilenameOrUuid)
1163	FilenameOrUuid = ValueUnion.psz;
1164	else
1165	return errorSyntax(USAGE_SHOWHDINFO, "Invalid parameter '%s'", ValueUnion.psz);
1166	break;
1167
1168	default:
1169	if (c > 0)
1170	{
1171	if (RT_C_IS_PRINT(c))
1172	return errorSyntax(USAGE_SHOWHDINFO, "Invalid option -%c", c);
1173	else
1174	return errorSyntax(USAGE_SHOWHDINFO, "Invalid option case %i", c);
1175	}
1176	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1177	return errorSyntax(USAGE_SHOWHDINFO, "unknown option: %s\n", ValueUnion.psz);
1178	else if (ValueUnion.pDef)
1179	return errorSyntax(USAGE_SHOWHDINFO, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1180	else
1181	return errorSyntax(USAGE_SHOWHDINFO, "error: %Rrs", c);
1182	}
1183	}
1184
1185	/* check for required options */
1186	if (!FilenameOrUuid)
1187	return errorSyntax(USAGE_SHOWHDINFO, "Disk name or UUID required");
1188
1189	ComPtr<IMedium> hardDisk;
1190	bool unknown = false;
1191	/* first guess is that it's a UUID */
1192	rc = a->virtualBox->FindMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, hardDisk.asOutParam());
1193	/* no? well, then it's an unkwnown image */
1194	if (FAILED (rc))
1195	{
1196	rc = a->virtualBox->OpenMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam());
1197	if (rc == VBOX_E_FILE_ERROR)
1198	{
1199	char szFilenameAbs[RTPATH_MAX] = "";
1200	int vrc = RTPathAbs(FilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs));
1201	if (RT_FAILURE(vrc))
1202	{
1203	RTPrintf("Cannot convert filename \"%s\" to absolute path\n", FilenameOrUuid);
1204	return 1;
1205	}
1206	CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam()));
1207	}
1208	if (SUCCEEDED (rc))
1209	unknown = true;
1210	}
1211	do
1212	{
1213	if (!SUCCEEDED(rc))
1214	break;
1215
1216	Bstr uuid;
1217	hardDisk->COMGETTER(Id)(uuid.asOutParam());
1218	RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
1219
1220	/* check for accessibility */
1221	/// @todo NEWMEDIA check accessibility of all parents
1222	/// @todo NEWMEDIA print the full state value
1223	MediumState_T state;
1224	CHECK_ERROR_BREAK (hardDisk, RefreshState(&state));
1225	RTPrintf("Accessible: %s\n", state != MediumState_Inaccessible ? "yes" : "no");
1226
1227	if (state == MediumState_Inaccessible)
1228	{
1229	Bstr err;
1230	CHECK_ERROR_BREAK (hardDisk, COMGETTER(LastAccessError)(err.asOutParam()));
1231	RTPrintf("Access Error: %lS\n", err.raw());
1232	}
1233
1234	Bstr description;
1235	hardDisk->COMGETTER(Description)(description.asOutParam());
1236	if (description)
1237	{
1238	RTPrintf("Description: %lS\n", description.raw());
1239	}
1240
1241	LONG64 logicalSize;
1242	hardDisk->COMGETTER(LogicalSize)(&logicalSize);
1243	RTPrintf("Logical size: %lld MBytes\n", logicalSize);
1244	LONG64 actualSize;
1245	hardDisk->COMGETTER(Size)(&actualSize);
1246	RTPrintf("Current size on disk: %lld MBytes\n", actualSize >> 20);
1247
1248	ComPtr <IMedium> parent;
1249	hardDisk->COMGETTER(Parent) (parent.asOutParam());
1250
1251	MediumType_T type;
1252	hardDisk->COMGETTER(Type)(&type);
1253	const char *typeStr = "unknown";
1254	switch (type)
1255	{
1256	case MediumType_Normal:
1257	if (!parent.isNull())
1258	typeStr = "normal (differencing)";
1259	else
1260	typeStr = "normal (base)";
1261	break;
1262	case MediumType_Immutable:
1263	typeStr = "immutable";
1264	break;
1265	case MediumType_Writethrough:
1266	typeStr = "writethrough";
1267	break;
1268	case MediumType_Shareable:
1269	typeStr = "shareable";
1270	break;
1271	}
1272	RTPrintf("Type: %s\n", typeStr);
1273
1274	Bstr format;
1275	hardDisk->COMGETTER(Format)(format.asOutParam());
1276	RTPrintf("Storage format: %lS\n", format.raw());
1277
1278	if (!unknown)
1279	{
1280	com::SafeArray<BSTR> machineIds;
1281	hardDisk->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(machineIds));
1282	for (size_t j = 0; j < machineIds.size(); ++ j)
1283	{
1284	ComPtr<IMachine> machine;
1285	CHECK_ERROR(a->virtualBox, GetMachine(machineIds[j], machine.asOutParam()));
1286	ASSERT(machine);
1287	Bstr name;
1288	machine->COMGETTER(Name)(name.asOutParam());
1289	machine->COMGETTER(Id)(uuid.asOutParam());
1290	RTPrintf("%s%lS (UUID: %lS)\n",
1291	j == 0 ? "In use by VMs: " : " ",
1292	name.raw(), machineIds[j]);
1293	}
1294	/// @todo NEWMEDIA check usage in snapshots too
1295	/// @todo NEWMEDIA also list children
1296	}
1297
1298	Bstr loc;
1299	hardDisk->COMGETTER(Location)(loc.asOutParam());
1300	RTPrintf("Location: %lS\n", loc.raw());
1301
1302	/* print out information specific for differencing hard disks */
1303	if (!parent.isNull())
1304	{
1305	BOOL autoReset = FALSE;
1306	hardDisk->COMGETTER(AutoReset)(&autoReset);
1307	RTPrintf("Auto-Reset: %s\n", autoReset ? "on" : "off");
1308	}
1309	}
1310	while (0);
1311
1312	if (unknown)
1313	{
1314	/* close the unknown hard disk to forget it again */
1315	hardDisk->Close();
1316	}
1317
1318	return SUCCEEDED(rc) ? 0 : 1;
1319	}
1320
1321	static const RTGETOPTDEF g_aOpenMediumOptions[] =
1322	{
1323	{ "disk", 'd', RTGETOPT_REQ_NOTHING },
1324	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
1325	{ "floppy", 'f', RTGETOPT_REQ_NOTHING },
1326	{ "--type", 't', RTGETOPT_REQ_STRING },
1327	{ "-type", 't', RTGETOPT_REQ_STRING }, // deprecated
1328	{ "--uuid", 'u', RTGETOPT_REQ_UUID },
1329	{ "--parentuuid", 'p', RTGETOPT_REQ_UUID },
1330	};
1331
1332	int handleOpenMedium(HandlerArg *a)
1333	{
1334	HRESULT rc = S_OK;
1335	int vrc;
1336	DeviceType_T devType = DeviceType_Null;
1337	const char *Filename = NULL;
1338	MediumType_T DiskType = MediumType_Normal;
1339	bool fDiskType = false;
1340	bool fSetImageId = false;
1341	bool fSetParentId = false;
1342	Guid ImageId;
1343	ImageId.clear();
1344	Guid ParentId;
1345	ParentId.clear();
1346
1347	int c;
1348	RTGETOPTUNION ValueUnion;
1349	RTGETOPTSTATE GetState;
1350	// start at 0 because main() has hacked both the argc and argv given to us
1351	RTGetOptInit(&GetState, a->argc, a->argv, g_aOpenMediumOptions, RT_ELEMENTS(g_aOpenMediumOptions),
1352	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1353	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1354	{
1355	switch (c)
1356	{
1357	case 'd': // disk
1358	if (devType != DeviceType_Null)
1359	return errorSyntax(USAGE_OPENMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1360	devType = DeviceType_HardDisk;
1361	break;
1362
1363	case 'D': // DVD
1364	if (devType != DeviceType_Null)
1365	return errorSyntax(USAGE_OPENMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1366	devType = DeviceType_DVD;
1367	break;
1368
1369	case 'f': // floppy
1370	if (devType != DeviceType_Null)
1371	return errorSyntax(USAGE_OPENMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1372	devType = DeviceType_Floppy;
1373	break;
1374
1375	case 't': // --type
1376	vrc = parseDiskType(ValueUnion.psz, &DiskType);
1377	if (RT_FAILURE(vrc))
1378	return errorArgument("Invalid hard disk type '%s'", ValueUnion.psz);
1379	fDiskType = true;
1380	break;
1381
1382	case 'u': // --uuid
1383	ImageId = ValueUnion.Uuid;
1384	fSetImageId = true;
1385	break;
1386
1387	case 'p': // --parentuuid
1388	ParentId = ValueUnion.Uuid;
1389	fSetParentId = true;
1390	break;
1391
1392	case VINF_GETOPT_NOT_OPTION:
1393	if (!Filename)
1394	Filename = ValueUnion.psz;
1395	else
1396	return errorSyntax(USAGE_OPENMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
1397	break;
1398
1399	default:
1400	if (c > 0)
1401	{
1402	if (RT_C_IS_PRINT(c))
1403	return errorSyntax(USAGE_OPENMEDIUM, "Invalid option -%c", c);
1404	else
1405	return errorSyntax(USAGE_OPENMEDIUM, "Invalid option case %i", c);
1406	}
1407	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1408	return errorSyntax(USAGE_OPENMEDIUM, "unknown option: %s\n", ValueUnion.psz);
1409	else if (ValueUnion.pDef)
1410	return errorSyntax(USAGE_OPENMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1411	else
1412	return errorSyntax(USAGE_OPENMEDIUM, "error: %Rrs", c);
1413	}
1414	}
1415
1416	/* check for required options */
1417	if (devType == DeviceType_Null)
1418	return errorSyntax(USAGE_OPENMEDIUM, "Command variant disk/dvd/floppy required");
1419	if (!Filename)
1420	return errorSyntax(USAGE_OPENMEDIUM, "Disk name required");
1421
1422	/** @todo remove this hack!
1423	* First try opening the image as is (using the regular API semantics for
1424	* images with relative path or without path), and if that fails with a
1425	* file related error then try it again with what the client thinks the
1426	* relative path would mean. Requires doing the command twice in certain
1427	* cases. This is an ugly hack and needs to be removed whevever we have a
1428	* chance to clean up the API semantics. */
1429
1430	ComPtr<IMedium> pMedium;
1431	rc = a->virtualBox->OpenMedium(Bstr(Filename), devType, AccessMode_ReadWrite, pMedium.asOutParam());
1432	if (rc == VBOX_E_FILE_ERROR)
1433	{
1434	char szFilenameAbs[RTPATH_MAX] = "";
1435	int irc = RTPathAbs(Filename, szFilenameAbs, sizeof(szFilenameAbs));
1436	if (RT_FAILURE(irc))
1437	{
1438	RTPrintf("Cannot convert filename \"%s\" to absolute path\n", Filename);
1439	return 1;
1440	}
1441	CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), devType, AccessMode_ReadWrite, pMedium.asOutParam()));
1442	}
1443	if (SUCCEEDED(rc) && pMedium)
1444	{
1445	if (devType == DeviceType_HardDisk)
1446	{
1447	if (DiskType != MediumType_Normal)
1448	{
1449	CHECK_ERROR(pMedium, COMSETTER(Type)(DiskType));
1450	}
1451	}
1452	else
1453	{
1454	// DVD or floppy image
1455	if (fDiskType \|\| fSetParentId)
1456	return errorSyntax(USAGE_OPENMEDIUM, "Invalid option for DVD and floppy images");
1457	}
1458	if (fSetImageId \|\| fSetParentId)
1459	{
1460	Bstr ImageIdStr = BstrFmt("%RTuuid", &ImageId);
1461	Bstr ParentIdStr = BstrFmt("%RTuuid", &ParentId);
1462	CHECK_ERROR(pMedium, SetIDs(fSetImageId, ImageIdStr, fSetParentId, ParentIdStr));
1463	}
1464	}
1465
1466	return SUCCEEDED(rc) ? 0 : 1;
1467	}
1468
1469	static const RTGETOPTDEF g_aCloseMediumOptions[] =
1470	{
1471	{ "disk", 'd', RTGETOPT_REQ_NOTHING },
1472	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
1473	{ "floppy", 'f', RTGETOPT_REQ_NOTHING },
1474	{ "--delete", 'r', RTGETOPT_REQ_NOTHING },
1475	};
1476
1477	int handleCloseMedium(HandlerArg *a)
1478	{
1479	HRESULT rc = S_OK;
1480	enum {
1481	CMD_NONE,
1482	CMD_DISK,
1483	CMD_DVD,
1484	CMD_FLOPPY
1485	} cmd = CMD_NONE;
1486	const char *FilenameOrUuid = NULL;
1487	bool fDelete = false;
1488
1489	int c;
1490	RTGETOPTUNION ValueUnion;
1491	RTGETOPTSTATE GetState;
1492	// start at 0 because main() has hacked both the argc and argv given to us
1493	RTGetOptInit(&GetState, a->argc, a->argv, g_aCloseMediumOptions, RT_ELEMENTS(g_aCloseMediumOptions),
1494	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1495	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1496	{
1497	switch (c)
1498	{
1499	case 'd': // disk
1500	if (cmd != CMD_NONE)
1501	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1502	cmd = CMD_DISK;
1503	break;
1504
1505	case 'D': // DVD
1506	if (cmd != CMD_NONE)
1507	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1508	cmd = CMD_DVD;
1509	break;
1510
1511	case 'f': // floppy
1512	if (cmd != CMD_NONE)
1513	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1514	cmd = CMD_FLOPPY;
1515	break;
1516
1517	case 'r': // --delete
1518	fDelete = true;
1519	break;
1520
1521	case VINF_GETOPT_NOT_OPTION:
1522	if (!FilenameOrUuid)
1523	FilenameOrUuid = ValueUnion.psz;
1524	else
1525	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
1526	break;
1527
1528	default:
1529	if (c > 0)
1530	{
1531	if (RT_C_IS_PRINT(c))
1532	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option -%c", c);
1533	else
1534	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option case %i", c);
1535	}
1536	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1537	return errorSyntax(USAGE_CLOSEMEDIUM, "unknown option: %s\n", ValueUnion.psz);
1538	else if (ValueUnion.pDef)
1539	return errorSyntax(USAGE_CLOSEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1540	else
1541	return errorSyntax(USAGE_CLOSEMEDIUM, "error: %Rrs", c);
1542	}
1543	}
1544
1545	/* check for required options */
1546	if (cmd == CMD_NONE)
1547	return errorSyntax(USAGE_CLOSEMEDIUM, "Command variant disk/dvd/floppy required");
1548	if (!FilenameOrUuid)
1549	return errorSyntax(USAGE_CLOSEMEDIUM, "Disk name or UUID required");
1550
1551	ComPtr<IMedium> medium;
1552
1553	if (cmd == CMD_DISK)
1554	CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, medium.asOutParam()));
1555	else if (cmd == CMD_DVD)
1556	CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid), DeviceType_DVD, medium.asOutParam()));
1557	else if (cmd == CMD_FLOPPY)
1558	CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid), DeviceType_Floppy, medium.asOutParam()));
1559
1560	if (SUCCEEDED(rc) && medium)
1561	{
1562	if (fDelete)
1563	{
1564	ComPtr<IProgress> progress;
1565	CHECK_ERROR(medium, DeleteStorage(progress.asOutParam()));
1566	if (SUCCEEDED(rc))
1567	{
1568	rc = showProgress(progress);
1569	if (FAILED(rc))
1570	{
1571	com::ProgressErrorInfo info(progress);
1572	if (info.isBasicAvailable())
1573	RTPrintf("Error: failed to delete medium. Error message: %lS\n", info.getText().raw());
1574	else
1575	RTPrintf("Error: failed to delete medium. No error message available!\n");
1576	}
1577	}
1578	else
1579	RTPrintf("Error: failed to delete medium. Error code %Rrc\n", rc);
1580	}
1581	CHECK_ERROR(medium, Close());
1582	}
1583
1584	return SUCCEEDED(rc) ? 0 : 1;
1585	}
1586	#endif /* !VBOX_ONLY_DOCS */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp@ 32651

Download in other formats: