VirtualBox

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

Last change on this file since 25275 was 25149, checked in by vboxsync, 14 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use