VBoxManageDisk.cpp@ 45733

Last change on this file since 45733 was 44498, checked in by vboxsync, 12 years ago
Frontends/VBoxManage: Unify the code showing medium information, and resolve all todos so that really any information is shown which the API knows about. When listing all medium objects default to a smaller set of items, and show everything with --long.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 45.1 KB

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

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

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

Download in other formats: