VBoxManageDisk.cpp@ 43629

Last change on this file since 43629 was 42248, checked in by vboxsync, 12 years ago
API change for SetVideoModeHint to be able to disable guest screens and to set the origin of guest screens
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 42.6 KB

Line
1	/* $Id: VBoxManageDisk.cpp 42248 2012-07-20 08:39:45Z vboxsync $ */
2	/** @file
3	* VBoxManage - The disk related commands.
4	*/
5
6	/*
7	* Copyright (C) 2006-2012 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/vd.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	RTMsgError(pszFormat, va);
51	RTMsgError("Error code %Rrc at %s(%u) in function %s", rc, RT_SRC_POS_ARGS);
52	}
53
54
55	static int parseDiskVariant(const char psz, MediumVariant_T pDiskVariant)
56	{
57	int rc = VINF_SUCCESS;
58	unsigned DiskVariant = (unsigned)(*pDiskVariant);
59	while (psz && *psz && RT_SUCCESS(rc))
60	{
61	size_t len;
62	const char *pszComma = strchr(psz, ',');
63	if (pszComma)
64	len = pszComma - psz;
65	else
66	len = strlen(psz);
67	if (len > 0)
68	{
69	// Parsing is intentionally inconsistent: "standard" resets the
70	// variant, whereas the other flags are cumulative.
71	if (!RTStrNICmp(psz, "standard", len))
72	DiskVariant = MediumVariant_Standard;
73	else if ( !RTStrNICmp(psz, "fixed", len)
74	\|\| !RTStrNICmp(psz, "static", len))
75	DiskVariant \|= MediumVariant_Fixed;
76	else if (!RTStrNICmp(psz, "Diff", len))
77	DiskVariant \|= MediumVariant_Diff;
78	else if (!RTStrNICmp(psz, "split2g", len))
79	DiskVariant \|= MediumVariant_VmdkSplit2G;
80	else if ( !RTStrNICmp(psz, "stream", len)
81	\|\| !RTStrNICmp(psz, "streamoptimized", len))
82	DiskVariant \|= MediumVariant_VmdkStreamOptimized;
83	else if (!RTStrNICmp(psz, "esx", len))
84	DiskVariant \|= MediumVariant_VmdkESX;
85	else
86	rc = VERR_PARSE_ERROR;
87	}
88	if (pszComma)
89	psz += len + 1;
90	else
91	psz += len;
92	}
93
94	if (RT_SUCCESS(rc))
95	*pDiskVariant = (MediumVariant_T)DiskVariant;
96	return rc;
97	}
98
99	int parseDiskType(const char psz, MediumType_T pDiskType)
100	{
101	int rc = VINF_SUCCESS;
102	MediumType_T DiskType = MediumType_Normal;
103	if (!RTStrICmp(psz, "normal"))
104	DiskType = MediumType_Normal;
105	else if (!RTStrICmp(psz, "immutable"))
106	DiskType = MediumType_Immutable;
107	else if (!RTStrICmp(psz, "writethrough"))
108	DiskType = MediumType_Writethrough;
109	else if (!RTStrICmp(psz, "shareable"))
110	DiskType = MediumType_Shareable;
111	else if (!RTStrICmp(psz, "readonly"))
112	DiskType = MediumType_Readonly;
113	else if (!RTStrICmp(psz, "multiattach"))
114	DiskType = MediumType_MultiAttach;
115	else
116	rc = VERR_PARSE_ERROR;
117
118	if (RT_SUCCESS(rc))
119	*pDiskType = DiskType;
120	return rc;
121	}
122
123	/** @todo move this into getopt, as getting bool values is generic */
124	int parseBool(const char psz, bool pb)
125	{
126	int rc = VINF_SUCCESS;
127	if ( !RTStrICmp(psz, "on")
128	\|\| !RTStrICmp(psz, "yes")
129	\|\| !RTStrICmp(psz, "true")
130	\|\| !RTStrICmp(psz, "1")
131	\|\| !RTStrICmp(psz, "enable")
132	\|\| !RTStrICmp(psz, "enabled"))
133	{
134	*pb = true;
135	}
136	else if ( !RTStrICmp(psz, "off")
137	\|\| !RTStrICmp(psz, "no")
138	\|\| !RTStrICmp(psz, "false")
139	\|\| !RTStrICmp(psz, "0")
140	\|\| !RTStrICmp(psz, "disable")
141	\|\| !RTStrICmp(psz, "disabled"))
142	{
143	*pb = false;
144	}
145	else
146	rc = VERR_PARSE_ERROR;
147
148	return rc;
149	}
150
151	HRESULT findMedium(HandlerArg a, const char pszFilenameOrUuid,
152	DeviceType_T enmDevType, bool fSilent,
153	ComPtr<IMedium> &pMedium)
154	{
155	HRESULT rc;
156	Guid id(pszFilenameOrUuid);
157	char szFilenameAbs[RTPATH_MAX] = "";
158
159	/* If it is no UUID, convert the filename to an absolute one. */
160	if (id.isEmpty())
161	{
162	int irc = RTPathAbs(pszFilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs));
163	if (RT_FAILURE(irc))
164	{
165	if (!fSilent)
166	RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilenameOrUuid);
167	return E_FAIL;
168	}
169	pszFilenameOrUuid = szFilenameAbs;
170	}
171
172	if (!fSilent)
173	CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(pszFilenameOrUuid).raw(),
174	enmDevType,
175	AccessMode_ReadWrite,
176	/fForceNewUidOnOpen / false,
177	pMedium.asOutParam()));
178	else
179	rc = a->virtualBox->OpenMedium(Bstr(pszFilenameOrUuid).raw(),
180	enmDevType,
181	AccessMode_ReadWrite,
182	/fForceNewUidOnOpen / false,
183	pMedium.asOutParam());
184	return rc;
185	}
186
187	HRESULT findOrOpenMedium(HandlerArg a, const char pszFilenameOrUuid,
188	DeviceType_T enmDevType, AccessMode_T enmAccessMode,
189	ComPtr<IMedium> &pMedium, bool fForceNewUuidOnOpen,
190	bool *pfWasUnknown)
191	{
192	HRESULT rc;
193	bool fWasUnknown = false;
194	Guid id(pszFilenameOrUuid);
195	char szFilenameAbs[RTPATH_MAX] = "";
196
197	/* If it is no UUID, convert the filename to an absolute one. */
198	if (id.isEmpty())
199	{
200	int irc = RTPathAbs(pszFilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs));
201	if (RT_FAILURE(irc))
202	{
203	RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilenameOrUuid);
204	return E_FAIL;
205	}
206	pszFilenameOrUuid = szFilenameAbs;
207	}
208
209	rc = a->virtualBox->OpenMedium(Bstr(pszFilenameOrUuid).raw(),
210	enmDevType,
211	enmAccessMode,
212	/fForceNewUidOnOpen / false,
213	pMedium.asOutParam());
214	/* If the medium is unknown try to open it. */
215	if (!pMedium)
216	{
217	CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(pszFilenameOrUuid).raw(),
218	enmDevType, enmAccessMode,
219	fForceNewUuidOnOpen,
220	pMedium.asOutParam()));
221	if (SUCCEEDED(rc))
222	fWasUnknown = true;
223	}
224	if (RT_VALID_PTR(pfWasUnknown))
225	*pfWasUnknown = fWasUnknown;
226	return rc;
227	}
228
229	static HRESULT createHardDisk(HandlerArg a, const char pszFormat,
230	const char *pszFilename, ComPtr<IMedium> &pMedium)
231	{
232	HRESULT rc;
233	char szFilenameAbs[RTPATH_MAX] = "";
234
235	/** @todo laziness shortcut. should really check the MediumFormatCapabilities */
236	if (RTStrICmp(pszFormat, "iSCSI"))
237	{
238	int irc = RTPathAbs(pszFilename, szFilenameAbs, sizeof(szFilenameAbs));
239	if (RT_FAILURE(irc))
240	{
241	RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilename);
242	return E_FAIL;
243	}
244	pszFilename = szFilenameAbs;
245	}
246
247	CHECK_ERROR(a->virtualBox, CreateHardDisk(Bstr(pszFormat).raw(),
248	Bstr(pszFilename).raw(),
249	pMedium.asOutParam()));
250	return rc;
251	}
252
253	static const RTGETOPTDEF g_aCreateHardDiskOptions[] =
254	{
255	{ "--filename", 'f', RTGETOPT_REQ_STRING },
256	{ "-filename", 'f', RTGETOPT_REQ_STRING }, // deprecated
257	{ "--diffparent", 'd', RTGETOPT_REQ_STRING },
258	{ "--size", 's', RTGETOPT_REQ_UINT64 },
259	{ "-size", 's', RTGETOPT_REQ_UINT64 }, // deprecated
260	{ "--sizebyte", 'S', RTGETOPT_REQ_UINT64 },
261	{ "--format", 'o', RTGETOPT_REQ_STRING },
262	{ "-format", 'o', RTGETOPT_REQ_STRING }, // deprecated
263	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
264	{ "-static", 'F', RTGETOPT_REQ_NOTHING }, // deprecated
265	{ "--variant", 'm', RTGETOPT_REQ_STRING },
266	{ "-variant", 'm', RTGETOPT_REQ_STRING }, // deprecated
267	};
268
269	int handleCreateHardDisk(HandlerArg *a)
270	{
271	HRESULT rc;
272	int vrc;
273	const char *filename = NULL;
274	const char *diffparent = NULL;
275	uint64_t size = 0;
276	const char *format = NULL;
277	bool fBase = true;
278	MediumVariant_T DiskVariant = MediumVariant_Standard;
279
280	int c;
281	RTGETOPTUNION ValueUnion;
282	RTGETOPTSTATE GetState;
283	// start at 0 because main() has hacked both the argc and argv given to us
284	RTGetOptInit(&GetState, a->argc, a->argv, g_aCreateHardDiskOptions, RT_ELEMENTS(g_aCreateHardDiskOptions),
285	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
286	while ((c = RTGetOpt(&GetState, &ValueUnion)))
287	{
288	switch (c)
289	{
290	case 'f': // --filename
291	filename = ValueUnion.psz;
292	break;
293
294	case 'd': // --diffparent
295	diffparent = ValueUnion.psz;
296	fBase = false;
297	break;
298
299	case 's': // --size
300	size = ValueUnion.u64 * _1M;
301	break;
302
303	case 'S': // --sizebyte
304	size = ValueUnion.u64;
305	break;
306
307	case 'o': // --format
308	format = ValueUnion.psz;
309	break;
310
311	case 'F': // --static ("fixed"/"flat")
312	{
313	unsigned uDiskVariant = (unsigned)DiskVariant;
314	uDiskVariant \|= MediumVariant_Fixed;
315	DiskVariant = (MediumVariant_T)uDiskVariant;
316	break;
317	}
318
319	case 'm': // --variant
320	vrc = parseDiskVariant(ValueUnion.psz, &DiskVariant);
321	if (RT_FAILURE(vrc))
322	return errorArgument("Invalid hard disk variant '%s'", ValueUnion.psz);
323	break;
324
325	case VINF_GETOPT_NOT_OPTION:
326	return errorSyntax(USAGE_CREATEHD, "Invalid parameter '%s'", ValueUnion.psz);
327
328	default:
329	if (c > 0)
330	{
331	if (RT_C_IS_PRINT(c))
332	return errorSyntax(USAGE_CREATEHD, "Invalid option -%c", c);
333	else
334	return errorSyntax(USAGE_CREATEHD, "Invalid option case %i", c);
335	}
336	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
337	return errorSyntax(USAGE_CREATEHD, "unknown option: %s\n", ValueUnion.psz);
338	else if (ValueUnion.pDef)
339	return errorSyntax(USAGE_CREATEHD, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
340	else
341	return errorSyntax(USAGE_CREATEHD, "error: %Rrs", c);
342	}
343	}
344
345	/* check the outcome */
346	bool fUnknownParent = false;
347	ComPtr<IMedium> parentHardDisk;
348	if (fBase)
349	{
350	if ( !filename
351	\|\| !*filename
352	\|\| size == 0)
353	return errorSyntax(USAGE_CREATEHD, "Parameters --filename and --size are required");
354	if (!format \|\| !*format)
355	format = "VDI";
356	}
357	else
358	{
359	if ( !filename
360	\|\| !*filename)
361	return errorSyntax(USAGE_CREATEHD, "Parameters --filename is required");
362	size = 0;
363	DiskVariant = MediumVariant_Diff;
364	if (!format \|\| !*format)
365	{
366	const char *pszExt = RTPathExt(filename);
367	/* Skip over . if there is an extension. */
368	if (pszExt)
369	pszExt++;
370	if (!pszExt \|\| !*pszExt)
371	format = "VDI";
372	else
373	format = pszExt;
374	}
375	rc = findOrOpenMedium(a, diffparent, DeviceType_HardDisk, AccessMode_ReadWrite,
376	parentHardDisk, false /* fForceNewUuidOnOpen */,
377	&fUnknownParent);
378	if (FAILED(rc))
379	return 1;
380	if (parentHardDisk.isNull())
381	{
382	RTMsgError("Invalid parent hard disk reference, avoiding crash");
383	return 1;
384	}
385	MediumState_T state;
386	CHECK_ERROR(parentHardDisk, COMGETTER(State)(&state));
387	if (FAILED(rc))
388	return 1;
389	if (state == MediumState_Inaccessible)
390	{
391	CHECK_ERROR(parentHardDisk, RefreshState(&state));
392	if (FAILED(rc))
393	return 1;
394	}
395	}
396	/* check for filename extension */
397	/** @todo use IMediumFormat to cover all extensions generically */
398	Utf8Str strName(filename);
399	if (!RTPathHaveExt(strName.c_str()))
400	{
401	Utf8Str strFormat(format);
402	if (strFormat.compare("vmdk", RTCString::CaseInsensitive) == 0)
403	strName.append(".vmdk");
404	else if (strFormat.compare("vhd", RTCString::CaseInsensitive) == 0)
405	strName.append(".vhd");
406	else
407	strName.append(".vdi");
408	filename = strName.c_str();
409	}
410
411	ComPtr<IMedium> hardDisk;
412	rc = createHardDisk(a, format, filename, hardDisk);
413	if (SUCCEEDED(rc) && hardDisk)
414	{
415	ComPtr<IProgress> progress;
416	if (fBase)
417	CHECK_ERROR(hardDisk, CreateBaseStorage(size, DiskVariant, progress.asOutParam()));
418	else
419	CHECK_ERROR(parentHardDisk, CreateDiffStorage(hardDisk, DiskVariant, progress.asOutParam()));
420	if (SUCCEEDED(rc) && progress)
421	{
422	rc = showProgress(progress);
423	CHECK_PROGRESS_ERROR(progress, ("Failed to create hard disk"));
424	if (SUCCEEDED(rc))
425	{
426	Bstr uuid;
427	CHECK_ERROR(hardDisk, COMGETTER(Id)(uuid.asOutParam()));
428	RTPrintf("Disk image created. UUID: %s\n", Utf8Str(uuid).c_str());
429	}
430	}
431
432	CHECK_ERROR(hardDisk, Close());
433	if (!fBase && fUnknownParent)
434	CHECK_ERROR(parentHardDisk, Close());
435	}
436	return SUCCEEDED(rc) ? 0 : 1;
437	}
438
439	static const RTGETOPTDEF g_aModifyHardDiskOptions[] =
440	{
441	{ "--type", 't', RTGETOPT_REQ_STRING },
442	{ "-type", 't', RTGETOPT_REQ_STRING }, // deprecated
443	{ "settype", 't', RTGETOPT_REQ_STRING }, // deprecated
444	{ "--autoreset", 'z', RTGETOPT_REQ_STRING },
445	{ "-autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
446	{ "autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
447	{ "--compact", 'c', RTGETOPT_REQ_NOTHING },
448	{ "-compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
449	{ "compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
450	{ "--resize", 'r', RTGETOPT_REQ_UINT64 },
451	{ "--resizebyte", 'R', RTGETOPT_REQ_UINT64 }
452	};
453
454	int handleModifyHardDisk(HandlerArg *a)
455	{
456	HRESULT rc;
457	int vrc;
458	ComPtr<IMedium> hardDisk;
459	MediumType_T DiskType;
460	bool AutoReset = false;
461	bool fModifyDiskType = false, fModifyAutoReset = false, fModifyCompact = false;
462	bool fModifyResize = false;
463	uint64_t cbResize = 0;
464	const char *FilenameOrUuid = NULL;
465	bool unknown = false;
466
467	int c;
468	RTGETOPTUNION ValueUnion;
469	RTGETOPTSTATE GetState;
470	// start at 0 because main() has hacked both the argc and argv given to us
471	RTGetOptInit(&GetState, a->argc, a->argv, g_aModifyHardDiskOptions, RT_ELEMENTS(g_aModifyHardDiskOptions),
472	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
473	while ((c = RTGetOpt(&GetState, &ValueUnion)))
474	{
475	switch (c)
476	{
477	case 't': // --type
478	vrc = parseDiskType(ValueUnion.psz, &DiskType);
479	if (RT_FAILURE(vrc))
480	return errorArgument("Invalid hard disk type '%s'", ValueUnion.psz);
481	fModifyDiskType = true;
482	break;
483
484	case 'z': // --autoreset
485	vrc = parseBool(ValueUnion.psz, &AutoReset);
486	if (RT_FAILURE(vrc))
487	return errorArgument("Invalid autoreset parameter '%s'", ValueUnion.psz);
488	fModifyAutoReset = true;
489	break;
490
491	case 'c': // --compact
492	fModifyCompact = true;
493	break;
494
495	case 'r': // --resize
496	cbResize = ValueUnion.u64 * _1M;
497	fModifyResize = true;
498	break;
499
500	case 'R': // --resizebyte
501	cbResize = ValueUnion.u64;
502	fModifyResize = true;
503	break;
504
505	case VINF_GETOPT_NOT_OPTION:
506	if (!FilenameOrUuid)
507	FilenameOrUuid = ValueUnion.psz;
508	else
509	return errorSyntax(USAGE_MODIFYHD, "Invalid parameter '%s'", ValueUnion.psz);
510	break;
511
512	default:
513	if (c > 0)
514	{
515	if (RT_C_IS_PRINT(c))
516	return errorSyntax(USAGE_MODIFYHD, "Invalid option -%c", c);
517	else
518	return errorSyntax(USAGE_MODIFYHD, "Invalid option case %i", c);
519	}
520	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
521	return errorSyntax(USAGE_MODIFYHD, "unknown option: %s\n", ValueUnion.psz);
522	else if (ValueUnion.pDef)
523	return errorSyntax(USAGE_MODIFYHD, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
524	else
525	return errorSyntax(USAGE_MODIFYHD, "error: %Rrs", c);
526	}
527	}
528
529	if (!FilenameOrUuid)
530	return errorSyntax(USAGE_MODIFYHD, "Disk name or UUID required");
531
532	if (!fModifyDiskType && !fModifyAutoReset && !fModifyCompact && !fModifyResize)
533	return errorSyntax(USAGE_MODIFYHD, "No operation specified");
534
535	/* Depending on the operation the medium must be in the registry or
536	* may be opened on demand. */
537	if (fModifyDiskType \|\| fModifyAutoReset)
538	rc = findMedium(a, FilenameOrUuid, DeviceType_HardDisk, false /* fSilent */, hardDisk);
539	else
540	rc = findOrOpenMedium(a, FilenameOrUuid, DeviceType_HardDisk, AccessMode_ReadWrite,
541	hardDisk, false /* fForceNewUuidOnOpen */, &unknown);
542	if (FAILED(rc))
543	return 1;
544	if (hardDisk.isNull())
545	{
546	RTMsgError("Invalid hard disk reference, avoiding crash");
547	return 1;
548	}
549
550	if (fModifyDiskType)
551	{
552	MediumType_T hddType;
553	CHECK_ERROR(hardDisk, COMGETTER(Type)(&hddType));
554
555	if (hddType != DiskType)
556	CHECK_ERROR(hardDisk, COMSETTER(Type)(DiskType));
557	}
558
559	if (fModifyAutoReset)
560	{
561	CHECK_ERROR(hardDisk, COMSETTER(AutoReset)(AutoReset));
562	}
563
564	if (fModifyCompact)
565	{
566	ComPtr<IProgress> progress;
567	CHECK_ERROR(hardDisk, Compact(progress.asOutParam()));
568	if (SUCCEEDED(rc))
569	rc = showProgress(progress);
570	if (FAILED(rc))
571	{
572	if (rc == E_NOTIMPL)
573	RTMsgError("Compact hard disk operation is not implemented!");
574	else if (rc == VBOX_E_NOT_SUPPORTED)
575	RTMsgError("Compact hard disk operation for this format is not implemented yet!");
576	else if (!progress.isNull())
577	CHECK_PROGRESS_ERROR(progress, ("Failed to compact hard disk"));
578	else
579	RTMsgError("Failed to compact hard disk!");
580	}
581	}
582
583	if (fModifyResize)
584	{
585	ComPtr<IProgress> progress;
586	CHECK_ERROR(hardDisk, Resize(cbResize, progress.asOutParam()));
587	if (SUCCEEDED(rc))
588	rc = showProgress(progress);
589	if (FAILED(rc))
590	{
591	if (rc == E_NOTIMPL)
592	RTMsgError("Resize hard disk operation is not implemented!");
593	else if (rc == VBOX_E_NOT_SUPPORTED)
594	RTMsgError("Resize hard disk operation for this format is not implemented yet!");
595	else
596	CHECK_PROGRESS_ERROR(progress, ("Failed to resize hard disk"));
597	}
598	}
599
600	if (unknown)
601	hardDisk->Close();
602
603	return SUCCEEDED(rc) ? 0 : 1;
604	}
605
606	static const RTGETOPTDEF g_aCloneHardDiskOptions[] =
607	{
608	{ "--format", 'o', RTGETOPT_REQ_STRING },
609	{ "-format", 'o', RTGETOPT_REQ_STRING },
610	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
611	{ "-static", 'F', RTGETOPT_REQ_NOTHING },
612	{ "--existing", 'E', RTGETOPT_REQ_NOTHING },
613	{ "--variant", 'm', RTGETOPT_REQ_STRING },
614	{ "-variant", 'm', RTGETOPT_REQ_STRING },
615	};
616
617	int handleCloneHardDisk(HandlerArg *a)
618	{
619	HRESULT rc;
620	int vrc;
621	const char *pszSrc = NULL;
622	const char *pszDst = NULL;
623	Bstr format;
624	MediumVariant_T DiskVariant = MediumVariant_Standard;
625	bool fExisting = false;
626
627	int c;
628	RTGETOPTUNION ValueUnion;
629	RTGETOPTSTATE GetState;
630	// start at 0 because main() has hacked both the argc and argv given to us
631	RTGetOptInit(&GetState, a->argc, a->argv, g_aCloneHardDiskOptions, RT_ELEMENTS(g_aCloneHardDiskOptions),
632	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
633	while ((c = RTGetOpt(&GetState, &ValueUnion)))
634	{
635	switch (c)
636	{
637	case 'o': // --format
638	format = ValueUnion.psz;
639	break;
640
641	case 'F': // --static
642	{
643	unsigned uDiskVariant = (unsigned)DiskVariant;
644	uDiskVariant \|= MediumVariant_Fixed;
645	DiskVariant = (MediumVariant_T)uDiskVariant;
646	break;
647	}
648
649	case 'E': // --existing
650	fExisting = true;
651	break;
652
653	case 'm': // --variant
654	vrc = parseDiskVariant(ValueUnion.psz, &DiskVariant);
655	if (RT_FAILURE(vrc))
656	return errorArgument("Invalid hard disk variant '%s'", ValueUnion.psz);
657	break;
658
659	case VINF_GETOPT_NOT_OPTION:
660	if (!pszSrc)
661	pszSrc = ValueUnion.psz;
662	else if (!pszDst)
663	pszDst = ValueUnion.psz;
664	else
665	return errorSyntax(USAGE_CLONEHD, "Invalid parameter '%s'", ValueUnion.psz);
666	break;
667
668	default:
669	if (c > 0)
670	{
671	if (RT_C_IS_GRAPH(c))
672	return errorSyntax(USAGE_CLONEHD, "unhandled option: -%c", c);
673	else
674	return errorSyntax(USAGE_CLONEHD, "unhandled option: %i", c);
675	}
676	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
677	return errorSyntax(USAGE_CLONEHD, "unknown option: %s", ValueUnion.psz);
678	else if (ValueUnion.pDef)
679	return errorSyntax(USAGE_CLONEHD, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
680	else
681	return errorSyntax(USAGE_CLONEHD, "error: %Rrs", c);
682	}
683	}
684
685	if (!pszSrc)
686	return errorSyntax(USAGE_CLONEHD, "Mandatory UUID or input file parameter missing");
687	if (!pszDst)
688	return errorSyntax(USAGE_CLONEHD, "Mandatory output file parameter missing");
689	if (fExisting && (!format.isEmpty() \|\| DiskVariant != MediumType_Normal))
690	return errorSyntax(USAGE_CLONEHD, "Specified options which cannot be used with --existing");
691
692	ComPtr<IMedium> srcDisk;
693	ComPtr<IMedium> dstDisk;
694	bool fSrcUnknown = false;
695	bool fDstUnknown = false;
696
697	rc = findOrOpenMedium(a, pszSrc, DeviceType_HardDisk, AccessMode_ReadOnly,
698	srcDisk, false /* fForceNewUuidOnOpen */, &fSrcUnknown);
699	if (FAILED(rc))
700	return 1;
701
702	do
703	{
704	/* open/create destination hard disk */
705	if (fExisting)
706	{
707	rc = findOrOpenMedium(a, pszDst, DeviceType_HardDisk, AccessMode_ReadWrite,
708	dstDisk, false /* fForceNewUuidOnOpen */, &fDstUnknown);
709	if (FAILED(rc))
710	break;
711
712	/* Perform accessibility check now. */
713	MediumState_T state;
714	CHECK_ERROR_BREAK(dstDisk, RefreshState(&state));
715	CHECK_ERROR_BREAK(dstDisk, COMGETTER(Format)(format.asOutParam()));
716	}
717	else
718	{
719	/* use the format of the source hard disk if unspecified */
720	if (format.isEmpty())
721	CHECK_ERROR_BREAK(srcDisk, COMGETTER(Format)(format.asOutParam()));
722	rc = createHardDisk(a, Utf8Str(format).c_str(), pszDst, dstDisk);
723	if (FAILED(rc))
724	break;
725	fDstUnknown = true;
726	}
727
728	ComPtr<IProgress> progress;
729	CHECK_ERROR_BREAK(srcDisk, CloneTo(dstDisk, DiskVariant, NULL, progress.asOutParam()));
730
731	rc = showProgress(progress);
732	CHECK_PROGRESS_ERROR_BREAK(progress, ("Failed to clone hard disk"));
733
734	Bstr uuid;
735	CHECK_ERROR_BREAK(dstDisk, COMGETTER(Id)(uuid.asOutParam()));
736
737	RTPrintf("Clone hard disk created in format '%ls'. UUID: %s\n",
738	format.raw(), Utf8Str(uuid).c_str());
739	}
740	while (0);
741
742	if (fDstUnknown && !dstDisk.isNull())
743	{
744	/* forget the created clone */
745	dstDisk->Close();
746	}
747	if (fSrcUnknown)
748	{
749	/* close the unknown hard disk to forget it again */
750	srcDisk->Close();
751	}
752
753	return SUCCEEDED(rc) ? 0 : 1;
754	}
755
756	static const RTGETOPTDEF g_aConvertFromRawHardDiskOptions[] =
757	{
758	{ "--format", 'o', RTGETOPT_REQ_STRING },
759	{ "-format", 'o', RTGETOPT_REQ_STRING },
760	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
761	{ "-static", 'F', RTGETOPT_REQ_NOTHING },
762	{ "--variant", 'm', RTGETOPT_REQ_STRING },
763	{ "-variant", 'm', RTGETOPT_REQ_STRING },
764	{ "--uuid", 'u', RTGETOPT_REQ_STRING },
765	};
766
767	RTEXITCODE handleConvertFromRaw(int argc, char *argv[])
768	{
769	int rc = VINF_SUCCESS;
770	bool fReadFromStdIn = false;
771	const char *format = "VDI";
772	const char *srcfilename = NULL;
773	const char *dstfilename = NULL;
774	const char *filesize = NULL;
775	unsigned uImageFlags = VD_IMAGE_FLAGS_NONE;
776	void *pvBuf = NULL;
777	RTUUID uuid;
778	PCRTUUID pUuid = NULL;
779
780	int c;
781	RTGETOPTUNION ValueUnion;
782	RTGETOPTSTATE GetState;
783	// start at 0 because main() has hacked both the argc and argv given to us
784	RTGetOptInit(&GetState, argc, argv, g_aConvertFromRawHardDiskOptions, RT_ELEMENTS(g_aConvertFromRawHardDiskOptions),
785	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
786	while ((c = RTGetOpt(&GetState, &ValueUnion)))
787	{
788	switch (c)
789	{
790	case 'u': // --uuid
791	if (RT_FAILURE(RTUuidFromStr(&uuid, ValueUnion.psz)))
792	return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid UUID '%s'", ValueUnion.psz);
793	pUuid = &uuid;
794	break;
795	case 'o': // --format
796	format = ValueUnion.psz;
797	break;
798
799	case 'm': // --variant
800	MediumVariant_T DiskVariant;
801	rc = parseDiskVariant(ValueUnion.psz, &DiskVariant);
802	if (RT_FAILURE(rc))
803	return errorArgument("Invalid hard disk variant '%s'", ValueUnion.psz);
804	/// @todo cleaner solution than assuming 1:1 mapping?
805	uImageFlags = (unsigned)DiskVariant;
806	break;
807
808	case VINF_GETOPT_NOT_OPTION:
809	if (!srcfilename)
810	{
811	srcfilename = ValueUnion.psz;
812	fReadFromStdIn = !strcmp(srcfilename, "stdin");
813	}
814	else if (!dstfilename)
815	dstfilename = ValueUnion.psz;
816	else if (fReadFromStdIn && !filesize)
817	filesize = ValueUnion.psz;
818	else
819	return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid parameter '%s'", ValueUnion.psz);
820	break;
821
822	default:
823	return errorGetOpt(USAGE_CONVERTFROMRAW, c, &ValueUnion);
824	}
825	}
826
827	if (!srcfilename \|\| !dstfilename \|\| (fReadFromStdIn && !filesize))
828	return errorSyntax(USAGE_CONVERTFROMRAW, "Incorrect number of parameters");
829	RTStrmPrintf(g_pStdErr, "Converting from raw image file=\"%s\" to file=\"%s\"...\n",
830	srcfilename, dstfilename);
831
832	PVBOXHDD pDisk = NULL;
833
834	PVDINTERFACE pVDIfs = NULL;
835	VDINTERFACEERROR vdInterfaceError;
836	vdInterfaceError.pfnError = handleVDError;
837	vdInterfaceError.pfnMessage = NULL;
838
839	rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
840	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
841	AssertRC(rc);
842
843	/* open raw image file. */
844	RTFILE File;
845	if (fReadFromStdIn)
846	rc = RTFileFromNative(&File, RTFILE_NATIVE_STDIN);
847	else
848	rc = RTFileOpen(&File, srcfilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
849	if (RT_FAILURE(rc))
850	{
851	RTMsgError("Cannot open file \"%s\": %Rrc", srcfilename, rc);
852	goto out;
853	}
854
855	uint64_t cbFile;
856	/* get image size. */
857	if (fReadFromStdIn)
858	cbFile = RTStrToUInt64(filesize);
859	else
860	rc = RTFileGetSize(File, &cbFile);
861	if (RT_FAILURE(rc))
862	{
863	RTMsgError("Cannot get image size for file \"%s\": %Rrc", srcfilename, rc);
864	goto out;
865	}
866
867	RTStrmPrintf(g_pStdErr, "Creating %s image with size %RU64 bytes (%RU64MB)...\n",
868	(uImageFlags & VD_IMAGE_FLAGS_FIXED) ? "fixed" : "dynamic", cbFile, (cbFile + _1M - 1) / _1M);
869	char pszComment[256];
870	RTStrPrintf(pszComment, sizeof(pszComment), "Converted image from %s", srcfilename);
871	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
872	if (RT_FAILURE(rc))
873	{
874	RTMsgError("Cannot create the virtual disk container: %Rrc", rc);
875	goto out;
876	}
877
878	Assert(RT_MIN(cbFile / 512 / 16 / 63, 16383) -
879	(unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383) == 0);
880	VDGEOMETRY PCHS, LCHS;
881	PCHS.cCylinders = (unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383);
882	PCHS.cHeads = 16;
883	PCHS.cSectors = 63;
884	LCHS.cCylinders = 0;
885	LCHS.cHeads = 0;
886	LCHS.cSectors = 0;
887	rc = VDCreateBase(pDisk, format, dstfilename, cbFile,
888	uImageFlags, pszComment, &PCHS, &LCHS, pUuid,
889	VD_OPEN_FLAGS_NORMAL, NULL, NULL);
890	if (RT_FAILURE(rc))
891	{
892	RTMsgError("Cannot create the disk image \"%s\": %Rrc", dstfilename, rc);
893	goto out;
894	}
895
896	size_t cbBuffer;
897	cbBuffer = _1M;
898	pvBuf = RTMemAlloc(cbBuffer);
899	if (!pvBuf)
900	{
901	rc = VERR_NO_MEMORY;
902	RTMsgError("Out of memory allocating buffers for image \"%s\": %Rrc", dstfilename, rc);
903	goto out;
904	}
905
906	uint64_t offFile;
907	offFile = 0;
908	while (offFile < cbFile)
909	{
910	size_t cbRead;
911	size_t cbToRead;
912	cbRead = 0;
913	cbToRead = cbFile - offFile >= (uint64_t)cbBuffer ?
914	cbBuffer : (size_t)(cbFile - offFile);
915	rc = RTFileRead(File, pvBuf, cbToRead, &cbRead);
916	if (RT_FAILURE(rc) \|\| !cbRead)
917	break;
918	rc = VDWrite(pDisk, offFile, pvBuf, cbRead);
919	if (RT_FAILURE(rc))
920	{
921	RTMsgError("Failed to write to disk image \"%s\": %Rrc", dstfilename, rc);
922	goto out;
923	}
924	offFile += cbRead;
925	}
926
927	out:
928	if (pvBuf)
929	RTMemFree(pvBuf);
930	if (pDisk)
931	VDClose(pDisk, RT_FAILURE(rc));
932	if (File != NIL_RTFILE)
933	RTFileClose(File);
934
935	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
936	}
937
938	static const RTGETOPTDEF g_aShowHardDiskInfoOptions[] =
939	{
940	{ "--dummy", 256, RTGETOPT_REQ_NOTHING }, // placeholder for C++
941	};
942
943	int handleShowHardDiskInfo(HandlerArg *a)
944	{
945	HRESULT rc;
946	const char *FilenameOrUuid = NULL;
947
948	int c;
949	RTGETOPTUNION ValueUnion;
950	RTGETOPTSTATE GetState;
951	// start at 0 because main() has hacked both the argc and argv given to us
952	RTGetOptInit(&GetState, a->argc, a->argv, g_aShowHardDiskInfoOptions, RT_ELEMENTS(g_aShowHardDiskInfoOptions),
953	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
954	while ((c = RTGetOpt(&GetState, &ValueUnion)))
955	{
956	switch (c)
957	{
958	case VINF_GETOPT_NOT_OPTION:
959	if (!FilenameOrUuid)
960	FilenameOrUuid = ValueUnion.psz;
961	else
962	return errorSyntax(USAGE_SHOWHDINFO, "Invalid parameter '%s'", ValueUnion.psz);
963	break;
964
965	default:
966	if (c > 0)
967	{
968	if (RT_C_IS_PRINT(c))
969	return errorSyntax(USAGE_SHOWHDINFO, "Invalid option -%c", c);
970	else
971	return errorSyntax(USAGE_SHOWHDINFO, "Invalid option case %i", c);
972	}
973	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
974	return errorSyntax(USAGE_SHOWHDINFO, "unknown option: %s\n", ValueUnion.psz);
975	else if (ValueUnion.pDef)
976	return errorSyntax(USAGE_SHOWHDINFO, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
977	else
978	return errorSyntax(USAGE_SHOWHDINFO, "error: %Rrs", c);
979	}
980	}
981
982	/* check for required options */
983	if (!FilenameOrUuid)
984	return errorSyntax(USAGE_SHOWHDINFO, "Disk name or UUID required");
985
986	ComPtr<IMedium> hardDisk;
987	bool unknown = false;
988
989	rc = findOrOpenMedium(a, FilenameOrUuid, DeviceType_HardDisk, AccessMode_ReadOnly,
990	hardDisk, false /* fForceNewUuidOnOpen */, &unknown);
991	if (FAILED(rc))
992	return 1;
993
994	do
995	{
996	Bstr uuid;
997	hardDisk->COMGETTER(Id)(uuid.asOutParam());
998	RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
999
1000	/* check for accessibility */
1001	/// @todo NEWMEDIA check accessibility of all parents
1002	/// @todo NEWMEDIA print the full state value
1003	MediumState_T state;
1004	CHECK_ERROR_BREAK(hardDisk, RefreshState(&state));
1005	RTPrintf("Accessible: %s\n", state != MediumState_Inaccessible ? "yes" : "no");
1006
1007	if (state == MediumState_Inaccessible)
1008	{
1009	Bstr err;
1010	CHECK_ERROR_BREAK(hardDisk, COMGETTER(LastAccessError)(err.asOutParam()));
1011	RTPrintf("Access Error: %ls\n", err.raw());
1012	}
1013
1014	Bstr description;
1015	hardDisk->COMGETTER(Description)(description.asOutParam());
1016	if (!description.isEmpty())
1017	{
1018	RTPrintf("Description: %ls\n", description.raw());
1019	}
1020
1021	LONG64 logicalSize;
1022	hardDisk->COMGETTER(LogicalSize)(&logicalSize);
1023	RTPrintf("Logical size: %lld MBytes\n", logicalSize >> 20);
1024	LONG64 actualSize;
1025	hardDisk->COMGETTER(Size)(&actualSize);
1026	RTPrintf("Current size on disk: %lld MBytes\n", actualSize >> 20);
1027
1028	ComPtr <IMedium> parent;
1029	hardDisk->COMGETTER(Parent)(parent.asOutParam());
1030
1031	MediumType_T type;
1032	hardDisk->COMGETTER(Type)(&type);
1033	const char *typeStr = "unknown";
1034	switch (type)
1035	{
1036	case MediumType_Normal:
1037	if (!parent.isNull())
1038	typeStr = "normal (differencing)";
1039	else
1040	typeStr = "normal (base)";
1041	break;
1042	case MediumType_Immutable:
1043	typeStr = "immutable";
1044	break;
1045	case MediumType_Writethrough:
1046	typeStr = "writethrough";
1047	break;
1048	case MediumType_Shareable:
1049	typeStr = "shareable";
1050	break;
1051	case MediumType_Readonly:
1052	typeStr = "readonly";
1053	break;
1054	case MediumType_MultiAttach:
1055	typeStr = "multiattach";
1056	break;
1057	}
1058	RTPrintf("Type: %s\n", typeStr);
1059
1060	Bstr format;
1061	hardDisk->COMGETTER(Format)(format.asOutParam());
1062	RTPrintf("Storage format: %ls\n", format.raw());
1063	ULONG variant;
1064	hardDisk->COMGETTER(Variant)(&variant);
1065	const char *variantStr = "unknown";
1066	switch (variant & ~(MediumVariant_Fixed \| MediumVariant_Diff))
1067	{
1068	case MediumVariant_VmdkSplit2G:
1069	variantStr = "split2G";
1070	break;
1071	case MediumVariant_VmdkStreamOptimized:
1072	variantStr = "streamOptimized";
1073	break;
1074	case MediumVariant_VmdkESX:
1075	variantStr = "ESX";
1076	break;
1077	case MediumVariant_Standard:
1078	variantStr = "default";
1079	break;
1080	}
1081	const char *variantTypeStr = "dynamic";
1082	if (variant & MediumVariant_Fixed)
1083	variantTypeStr = "fixed";
1084	else if (variant & MediumVariant_Diff)
1085	variantTypeStr = "differencing";
1086	RTPrintf("Format variant: %s %s\n", variantTypeStr, variantStr);
1087
1088	/// @todo also dump config parameters (iSCSI)
1089
1090	if (!unknown)
1091	{
1092	com::SafeArray<BSTR> machineIds;
1093	hardDisk->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(machineIds));
1094	for (size_t j = 0; j < machineIds.size(); ++ j)
1095	{
1096	ComPtr<IMachine> machine;
1097	CHECK_ERROR(a->virtualBox, FindMachine(machineIds[j], machine.asOutParam()));
1098	ASSERT(machine);
1099	Bstr name;
1100	machine->COMGETTER(Name)(name.asOutParam());
1101	machine->COMGETTER(Id)(uuid.asOutParam());
1102	RTPrintf("%s%ls (UUID: %ls)\n",
1103	j == 0 ? "In use by VMs: " : " ",
1104	name.raw(), machineIds[j]);
1105	}
1106	/// @todo NEWMEDIA check usage in snapshots too
1107	/// @todo NEWMEDIA also list children
1108	}
1109
1110	Bstr loc;
1111	hardDisk->COMGETTER(Location)(loc.asOutParam());
1112	RTPrintf("Location: %ls\n", loc.raw());
1113
1114	/* print out information specific for differencing hard disks */
1115	if (!parent.isNull())
1116	{
1117	BOOL autoReset = FALSE;
1118	hardDisk->COMGETTER(AutoReset)(&autoReset);
1119	RTPrintf("Auto-Reset: %s\n", autoReset ? "on" : "off");
1120	}
1121	}
1122	while (0);
1123
1124	if (unknown)
1125	{
1126	/* close the unknown hard disk to forget it again */
1127	hardDisk->Close();
1128	}
1129
1130	return SUCCEEDED(rc) ? 0 : 1;
1131	}
1132
1133	static const RTGETOPTDEF g_aCloseMediumOptions[] =
1134	{
1135	{ "disk", 'd', RTGETOPT_REQ_NOTHING },
1136	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
1137	{ "floppy", 'f', RTGETOPT_REQ_NOTHING },
1138	{ "--delete", 'r', RTGETOPT_REQ_NOTHING },
1139	};
1140
1141	int handleCloseMedium(HandlerArg *a)
1142	{
1143	HRESULT rc = S_OK;
1144	enum {
1145	CMD_NONE,
1146	CMD_DISK,
1147	CMD_DVD,
1148	CMD_FLOPPY
1149	} cmd = CMD_NONE;
1150	const char *FilenameOrUuid = NULL;
1151	bool fDelete = false;
1152
1153	int c;
1154	RTGETOPTUNION ValueUnion;
1155	RTGETOPTSTATE GetState;
1156	// start at 0 because main() has hacked both the argc and argv given to us
1157	RTGetOptInit(&GetState, a->argc, a->argv, g_aCloseMediumOptions, RT_ELEMENTS(g_aCloseMediumOptions),
1158	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1159	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1160	{
1161	switch (c)
1162	{
1163	case 'd': // disk
1164	if (cmd != CMD_NONE)
1165	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1166	cmd = CMD_DISK;
1167	break;
1168
1169	case 'D': // DVD
1170	if (cmd != CMD_NONE)
1171	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1172	cmd = CMD_DVD;
1173	break;
1174
1175	case 'f': // floppy
1176	if (cmd != CMD_NONE)
1177	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1178	cmd = CMD_FLOPPY;
1179	break;
1180
1181	case 'r': // --delete
1182	fDelete = true;
1183	break;
1184
1185	case VINF_GETOPT_NOT_OPTION:
1186	if (!FilenameOrUuid)
1187	FilenameOrUuid = ValueUnion.psz;
1188	else
1189	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
1190	break;
1191
1192	default:
1193	if (c > 0)
1194	{
1195	if (RT_C_IS_PRINT(c))
1196	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option -%c", c);
1197	else
1198	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option case %i", c);
1199	}
1200	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1201	return errorSyntax(USAGE_CLOSEMEDIUM, "unknown option: %s\n", ValueUnion.psz);
1202	else if (ValueUnion.pDef)
1203	return errorSyntax(USAGE_CLOSEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1204	else
1205	return errorSyntax(USAGE_CLOSEMEDIUM, "error: %Rrs", c);
1206	}
1207	}
1208
1209	/* check for required options */
1210	if (cmd == CMD_NONE)
1211	return errorSyntax(USAGE_CLOSEMEDIUM, "Command variant disk/dvd/floppy required");
1212	if (!FilenameOrUuid)
1213	return errorSyntax(USAGE_CLOSEMEDIUM, "Disk name or UUID required");
1214
1215	ComPtr<IMedium> medium;
1216
1217	if (cmd == CMD_DISK)
1218	rc = findMedium(a, FilenameOrUuid, DeviceType_HardDisk, false /* fSilent */, medium);
1219	else if (cmd == CMD_DVD)
1220	rc = findMedium(a, FilenameOrUuid, DeviceType_DVD, false /* fSilent */, medium);
1221	else if (cmd == CMD_FLOPPY)
1222	rc = findMedium(a, FilenameOrUuid, DeviceType_Floppy, false /* fSilent */, medium);
1223
1224	if (SUCCEEDED(rc) && medium)
1225	{
1226	if (fDelete)
1227	{
1228	ComPtr<IProgress> progress;
1229	CHECK_ERROR(medium, DeleteStorage(progress.asOutParam()));
1230	if (SUCCEEDED(rc))
1231	{
1232	rc = showProgress(progress);
1233	CHECK_PROGRESS_ERROR(progress, ("Failed to delete medium"));
1234	}
1235	else
1236	RTMsgError("Failed to delete medium. Error code %Rrc", rc);
1237	}
1238	CHECK_ERROR(medium, Close());
1239	}
1240
1241	return SUCCEEDED(rc) ? 0 : 1;
1242	}
1243	#endif /* !VBOX_ONLY_DOCS */

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

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

Download in other formats: