VirtualBox

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

Last change on this file since 77329 was 76553, checked in by vboxsync, 6 years ago

scm --update-copyright-year

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 90.4 KB
Line 
1/* $Id: VBoxManageDisk.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * VBoxManage - The disk/medium related commands.
4 */
5
6/*
7 * Copyright (C) 2006-2019 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/*********************************************************************************************************************************
22* Header Files *
23*********************************************************************************************************************************/
24#include <VBox/com/com.h>
25#include <VBox/com/array.h>
26#include <VBox/com/ErrorInfo.h>
27#include <VBox/com/errorprint.h>
28#include <VBox/com/VirtualBox.h>
29
30#include <iprt/asm.h>
31#include <iprt/file.h>
32#include <iprt/path.h>
33#include <iprt/param.h>
34#include <iprt/stream.h>
35#include <iprt/string.h>
36#include <iprt/ctype.h>
37#include <iprt/getopt.h>
38#include <VBox/log.h>
39#include <VBox/vd.h>
40
41#include "VBoxManage.h"
42using namespace com;
43
44/** Medium category. */
45typedef enum MEDIUMCATEGORY
46{
47 MEDIUMCATEGORY_NONE = 0,
48 MEDIUMCATEGORY_DISK,
49 MEDIUMCATEGORY_DVD,
50 MEDIUMCATEGORY_FLOPPY
51} MEDIUMCATEGORY;
52
53
54
55// funcs
56///////////////////////////////////////////////////////////////////////////////
57
58
59static DECLCALLBACK(void) handleVDError(void *pvUser, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
60{
61 RT_NOREF(pvUser);
62 RTMsgErrorV(pszFormat, va);
63 RTMsgError("Error code %Rrc at %s(%u) in function %s", rc, RT_SRC_POS_ARGS);
64}
65
66static int parseMediumVariant(const char *psz, MediumVariant_T *pMediumVariant)
67{
68 int rc = VINF_SUCCESS;
69 unsigned uMediumVariant = (unsigned)(*pMediumVariant);
70 while (psz && *psz && RT_SUCCESS(rc))
71 {
72 size_t len;
73 const char *pszComma = strchr(psz, ',');
74 if (pszComma)
75 len = pszComma - psz;
76 else
77 len = strlen(psz);
78 if (len > 0)
79 {
80 // Parsing is intentionally inconsistent: "standard" resets the
81 // variant, whereas the other flags are cumulative.
82 if (!RTStrNICmp(psz, "standard", len))
83 uMediumVariant = MediumVariant_Standard;
84 else if ( !RTStrNICmp(psz, "fixed", len)
85 || !RTStrNICmp(psz, "static", len))
86 uMediumVariant |= MediumVariant_Fixed;
87 else if (!RTStrNICmp(psz, "Diff", len))
88 uMediumVariant |= MediumVariant_Diff;
89 else if (!RTStrNICmp(psz, "split2g", len))
90 uMediumVariant |= MediumVariant_VmdkSplit2G;
91 else if ( !RTStrNICmp(psz, "stream", len)
92 || !RTStrNICmp(psz, "streamoptimized", len))
93 uMediumVariant |= MediumVariant_VmdkStreamOptimized;
94 else if (!RTStrNICmp(psz, "esx", len))
95 uMediumVariant |= MediumVariant_VmdkESX;
96 else if (!RTStrNICmp(psz, "formatted", len))
97 uMediumVariant |= MediumVariant_Formatted;
98 else
99 rc = VERR_PARSE_ERROR;
100 }
101 if (pszComma)
102 psz += len + 1;
103 else
104 psz += len;
105 }
106
107 if (RT_SUCCESS(rc))
108 *pMediumVariant = (MediumVariant_T)uMediumVariant;
109 return rc;
110}
111
112int parseMediumType(const char *psz, MediumType_T *penmMediumType)
113{
114 int rc = VINF_SUCCESS;
115 MediumType_T enmMediumType = MediumType_Normal;
116 if (!RTStrICmp(psz, "normal"))
117 enmMediumType = MediumType_Normal;
118 else if (!RTStrICmp(psz, "immutable"))
119 enmMediumType = MediumType_Immutable;
120 else if (!RTStrICmp(psz, "writethrough"))
121 enmMediumType = MediumType_Writethrough;
122 else if (!RTStrICmp(psz, "shareable"))
123 enmMediumType = MediumType_Shareable;
124 else if (!RTStrICmp(psz, "readonly"))
125 enmMediumType = MediumType_Readonly;
126 else if (!RTStrICmp(psz, "multiattach"))
127 enmMediumType = MediumType_MultiAttach;
128 else
129 rc = VERR_PARSE_ERROR;
130
131 if (RT_SUCCESS(rc))
132 *penmMediumType = enmMediumType;
133 return rc;
134}
135
136/** @todo move this into getopt, as getting bool values is generic */
137int parseBool(const char *psz, bool *pb)
138{
139 int rc = VINF_SUCCESS;
140 if ( !RTStrICmp(psz, "on")
141 || !RTStrICmp(psz, "yes")
142 || !RTStrICmp(psz, "true")
143 || !RTStrICmp(psz, "1")
144 || !RTStrICmp(psz, "enable")
145 || !RTStrICmp(psz, "enabled"))
146 {
147 *pb = true;
148 }
149 else if ( !RTStrICmp(psz, "off")
150 || !RTStrICmp(psz, "no")
151 || !RTStrICmp(psz, "false")
152 || !RTStrICmp(psz, "0")
153 || !RTStrICmp(psz, "disable")
154 || !RTStrICmp(psz, "disabled"))
155 {
156 *pb = false;
157 }
158 else
159 rc = VERR_PARSE_ERROR;
160
161 return rc;
162}
163
164HRESULT openMedium(HandlerArg *a, const char *pszFilenameOrUuid,
165 DeviceType_T enmDevType, AccessMode_T enmAccessMode,
166 ComPtr<IMedium> &pMedium, bool fForceNewUuidOnOpen,
167 bool fSilent)
168{
169 HRESULT rc;
170 Guid id(pszFilenameOrUuid);
171 char szFilenameAbs[RTPATH_MAX] = "";
172
173 /* If it is no UUID, convert the filename to an absolute one. */
174 if (!id.isValid())
175 {
176 int irc = RTPathAbs(pszFilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs));
177 if (RT_FAILURE(irc))
178 {
179 if (!fSilent)
180 RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilenameOrUuid);
181 return E_FAIL;
182 }
183 pszFilenameOrUuid = szFilenameAbs;
184 }
185
186 if (!fSilent)
187 CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(pszFilenameOrUuid).raw(),
188 enmDevType,
189 enmAccessMode,
190 fForceNewUuidOnOpen,
191 pMedium.asOutParam()));
192 else
193 rc = a->virtualBox->OpenMedium(Bstr(pszFilenameOrUuid).raw(),
194 enmDevType,
195 enmAccessMode,
196 fForceNewUuidOnOpen,
197 pMedium.asOutParam());
198
199 return rc;
200}
201
202static HRESULT createMedium(HandlerArg *a, const char *pszFormat,
203 const char *pszFilename, DeviceType_T enmDevType,
204 AccessMode_T enmAccessMode, ComPtr<IMedium> &pMedium)
205{
206 HRESULT rc;
207 char szFilenameAbs[RTPATH_MAX] = "";
208
209 /** @todo laziness shortcut. should really check the MediumFormatCapabilities */
210 if (RTStrICmp(pszFormat, "iSCSI"))
211 {
212 int irc = RTPathAbs(pszFilename, szFilenameAbs, sizeof(szFilenameAbs));
213 if (RT_FAILURE(irc))
214 {
215 RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilename);
216 return E_FAIL;
217 }
218 pszFilename = szFilenameAbs;
219 }
220
221 CHECK_ERROR(a->virtualBox, CreateMedium(Bstr(pszFormat).raw(),
222 Bstr(pszFilename).raw(),
223 enmAccessMode,
224 enmDevType,
225 pMedium.asOutParam()));
226 return rc;
227}
228
229static const RTGETOPTDEF g_aCreateMediumOptions[] =
230{
231 { "disk", 'H', RTGETOPT_REQ_NOTHING },
232 { "dvd", 'D', RTGETOPT_REQ_NOTHING },
233 { "floppy", 'L', RTGETOPT_REQ_NOTHING },
234 { "--filename", 'f', RTGETOPT_REQ_STRING },
235 { "-filename", 'f', RTGETOPT_REQ_STRING }, // deprecated
236 { "--diffparent", 'd', RTGETOPT_REQ_STRING },
237 { "--size", 's', RTGETOPT_REQ_UINT64 },
238 { "-size", 's', RTGETOPT_REQ_UINT64 }, // deprecated
239 { "--sizebyte", 'S', RTGETOPT_REQ_UINT64 },
240 { "--format", 'o', RTGETOPT_REQ_STRING },
241 { "-format", 'o', RTGETOPT_REQ_STRING }, // deprecated
242 { "--static", 'F', RTGETOPT_REQ_NOTHING },
243 { "-static", 'F', RTGETOPT_REQ_NOTHING }, // deprecated
244 { "--variant", 'm', RTGETOPT_REQ_STRING },
245 { "-variant", 'm', RTGETOPT_REQ_STRING }, // deprecated
246};
247
248RTEXITCODE handleCreateMedium(HandlerArg *a)
249{
250 HRESULT rc;
251 int vrc;
252 const char *filename = NULL;
253 const char *diffparent = NULL;
254 uint64_t size = 0;
255 enum {
256 CMD_NONE,
257 CMD_DISK,
258 CMD_DVD,
259 CMD_FLOPPY
260 } cmd = CMD_NONE;
261 const char *format = NULL;
262 bool fBase = true;
263 MediumVariant_T enmMediumVariant = MediumVariant_Standard;
264
265 int c;
266 RTGETOPTUNION ValueUnion;
267 RTGETOPTSTATE GetState;
268 // start at 0 because main() has hacked both the argc and argv given to us
269 RTGetOptInit(&GetState, a->argc, a->argv, g_aCreateMediumOptions, RT_ELEMENTS(g_aCreateMediumOptions),
270 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
271 while ((c = RTGetOpt(&GetState, &ValueUnion)))
272 {
273 switch (c)
274 {
275 case 'H': // disk
276 if (cmd != CMD_NONE)
277 return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
278 cmd = CMD_DISK;
279 break;
280
281 case 'D': // DVD
282 if (cmd != CMD_NONE)
283 return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
284 cmd = CMD_DVD;
285 break;
286
287 case 'L': // floppy
288 if (cmd != CMD_NONE)
289 return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
290 cmd = CMD_FLOPPY;
291 break;
292
293 case 'f': // --filename
294 filename = ValueUnion.psz;
295 break;
296
297 case 'd': // --diffparent
298 diffparent = ValueUnion.psz;
299 fBase = false;
300 break;
301
302 case 's': // --size
303 size = ValueUnion.u64 * _1M;
304 break;
305
306 case 'S': // --sizebyte
307 size = ValueUnion.u64;
308 break;
309
310 case 'o': // --format
311 format = ValueUnion.psz;
312 break;
313
314 case 'F': // --static ("fixed"/"flat")
315 {
316 unsigned uMediumVariant = (unsigned)enmMediumVariant;
317 uMediumVariant |= MediumVariant_Fixed;
318 enmMediumVariant = (MediumVariant_T)uMediumVariant;
319 break;
320 }
321
322 case 'm': // --variant
323 vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
324 if (RT_FAILURE(vrc))
325 return errorArgument("Invalid medium variant '%s'", ValueUnion.psz);
326 break;
327
328 case VINF_GETOPT_NOT_OPTION:
329 return errorSyntax(USAGE_CREATEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
330
331 default:
332 if (c > 0)
333 {
334 if (RT_C_IS_PRINT(c))
335 return errorSyntax(USAGE_CREATEMEDIUM, "Invalid option -%c", c);
336 else
337 return errorSyntax(USAGE_CREATEMEDIUM, "Invalid option case %i", c);
338 }
339 else if (c == VERR_GETOPT_UNKNOWN_OPTION)
340 return errorSyntax(USAGE_CREATEMEDIUM, "unknown option: %s\n", ValueUnion.psz);
341 else if (ValueUnion.pDef)
342 return errorSyntax(USAGE_CREATEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
343 else
344 return errorSyntax(USAGE_CREATEMEDIUM, "error: %Rrs", c);
345 }
346 }
347
348 /* check the outcome */
349 if (cmd == CMD_NONE)
350 cmd = CMD_DISK;
351 ComPtr<IMedium> pParentMedium;
352 if (fBase)
353 {
354 if ( !filename
355 || !*filename
356 || size == 0)
357 return errorSyntax(USAGE_CREATEMEDIUM, "Parameters --filename and --size are required");
358 if (!format || !*format)
359 {
360 if (cmd == CMD_DISK)
361 format = "VDI";
362 else if (cmd == CMD_DVD || cmd == CMD_FLOPPY)
363 {
364 format = "RAW";
365 unsigned uMediumVariant = (unsigned)enmMediumVariant;
366 uMediumVariant |= MediumVariant_Fixed;
367 enmMediumVariant = (MediumVariant_T)uMediumVariant;
368 }
369 }
370 }
371 else
372 {
373 if ( !filename
374 || !*filename)
375 return errorSyntax(USAGE_CREATEMEDIUM, "Parameters --filename is required");
376 size = 0;
377 if (cmd != CMD_DISK)
378 return errorSyntax(USAGE_CREATEMEDIUM, "Creating a differencing medium is only supported for hard disks");
379 enmMediumVariant = MediumVariant_Diff;
380 if (!format || !*format)
381 {
382 const char *pszExt = RTPathSuffix(filename);
383 /* Skip over . if there is an extension. */
384 if (pszExt)
385 pszExt++;
386 if (!pszExt || !*pszExt)
387 format = "VDI";
388 else
389 format = pszExt;
390 }
391 rc = openMedium(a, diffparent, DeviceType_HardDisk,
392 AccessMode_ReadWrite, pParentMedium,
393 false /* fForceNewUuidOnOpen */, false /* fSilent */);
394 if (FAILED(rc))
395 return RTEXITCODE_FAILURE;
396 if (pParentMedium.isNull())
397 return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid parent hard disk reference, avoiding crash");
398 MediumState_T state;
399 CHECK_ERROR(pParentMedium, COMGETTER(State)(&state));
400 if (FAILED(rc))
401 return RTEXITCODE_FAILURE;
402 if (state == MediumState_Inaccessible)
403 {
404 CHECK_ERROR(pParentMedium, RefreshState(&state));
405 if (FAILED(rc))
406 return RTEXITCODE_FAILURE;
407 }
408 }
409 /* check for filename extension */
410 /** @todo use IMediumFormat to cover all extensions generically */
411 Utf8Str strName(filename);
412 if (!RTPathHasSuffix(strName.c_str()))
413 {
414 Utf8Str strFormat(format);
415 if (cmd == CMD_DISK)
416 {
417 if (strFormat.compare("vmdk", RTCString::CaseInsensitive) == 0)
418 strName.append(".vmdk");
419 else if (strFormat.compare("vhd", RTCString::CaseInsensitive) == 0)
420 strName.append(".vhd");
421 else
422 strName.append(".vdi");
423 } else if (cmd == CMD_DVD)
424 strName.append(".iso");
425 else if (cmd == CMD_FLOPPY)
426 strName.append(".img");
427 filename = strName.c_str();
428 }
429
430 ComPtr<IMedium> pMedium;
431 if (cmd == CMD_DISK)
432 rc = createMedium(a, format, filename, DeviceType_HardDisk,
433 AccessMode_ReadWrite, pMedium);
434 else if (cmd == CMD_DVD)
435 rc = createMedium(a, format, filename, DeviceType_DVD,
436 AccessMode_ReadOnly, pMedium);
437 else if (cmd == CMD_FLOPPY)
438 rc = createMedium(a, format, filename, DeviceType_Floppy,
439 AccessMode_ReadWrite, pMedium);
440 else
441 rc = E_INVALIDARG; /* cannot happen but make gcc happy */
442
443 if (SUCCEEDED(rc) && pMedium)
444 {
445 ComPtr<IProgress> pProgress;
446 com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8);
447
448 for (ULONG i = 0; i < l_variants.size(); ++i)
449 {
450 ULONG temp = enmMediumVariant;
451 temp &= 1<<i;
452 l_variants [i] = (MediumVariant_T)temp;
453 }
454
455 if (fBase)
456 CHECK_ERROR(pMedium, CreateBaseStorage(size, ComSafeArrayAsInParam(l_variants), pProgress.asOutParam()));
457 else
458 CHECK_ERROR(pParentMedium, CreateDiffStorage(pMedium, ComSafeArrayAsInParam(l_variants), pProgress.asOutParam()));
459 if (SUCCEEDED(rc) && pProgress)
460 {
461 rc = showProgress(pProgress);
462 CHECK_PROGRESS_ERROR(pProgress, ("Failed to create medium"));
463 }
464 }
465
466 if (SUCCEEDED(rc) && pMedium)
467 {
468 Bstr uuid;
469 CHECK_ERROR(pMedium, COMGETTER(Id)(uuid.asOutParam()));
470 RTPrintf("Medium created. UUID: %s\n", Utf8Str(uuid).c_str());
471
472 //CHECK_ERROR(pMedium, Close());
473 }
474 return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
475}
476
477static const RTGETOPTDEF g_aModifyMediumOptions[] =
478{
479 { "disk", 'H', RTGETOPT_REQ_NOTHING },
480 { "dvd", 'D', RTGETOPT_REQ_NOTHING },
481 { "floppy", 'L', RTGETOPT_REQ_NOTHING },
482 { "--type", 't', RTGETOPT_REQ_STRING },
483 { "-type", 't', RTGETOPT_REQ_STRING }, // deprecated
484 { "settype", 't', RTGETOPT_REQ_STRING }, // deprecated
485 { "--autoreset", 'z', RTGETOPT_REQ_STRING },
486 { "-autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
487 { "autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
488 { "--property", 'p', RTGETOPT_REQ_STRING },
489 { "--compact", 'c', RTGETOPT_REQ_NOTHING },
490 { "-compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
491 { "compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
492 { "--resize", 'r', RTGETOPT_REQ_UINT64 },
493 { "--resizebyte", 'R', RTGETOPT_REQ_UINT64 },
494 { "--move", 'm', RTGETOPT_REQ_STRING },
495 { "--setlocation", 'l', RTGETOPT_REQ_STRING },
496 { "--description", 'd', RTGETOPT_REQ_STRING }
497};
498
499RTEXITCODE handleModifyMedium(HandlerArg *a)
500{
501 HRESULT rc;
502 int vrc;
503 enum {
504 CMD_NONE,
505 CMD_DISK,
506 CMD_DVD,
507 CMD_FLOPPY
508 } cmd = CMD_NONE;
509 ComPtr<IMedium> pMedium;
510 MediumType_T enmMediumType = MediumType_Normal; /* Shut up MSC */
511 bool AutoReset = false;
512 SafeArray<BSTR> mediumPropNames;
513 SafeArray<BSTR> mediumPropValues;
514 bool fModifyMediumType = false;
515 bool fModifyAutoReset = false;
516 bool fModifyProperties = false;
517 bool fModifyCompact = false;
518 bool fModifyResize = false;
519 bool fModifyResizeMB = false;
520 bool fMoveMedium = false;
521 bool fModifyDescription = false;
522 bool fSetNewLocation = false;
523 uint64_t cbResize = 0;
524 const char *pszFilenameOrUuid = NULL;
525 char *pszNewLocation = NULL;
526
527 int c;
528 RTGETOPTUNION ValueUnion;
529 RTGETOPTSTATE GetState;
530 // start at 0 because main() has hacked both the argc and argv given to us
531 RTGetOptInit(&GetState, a->argc, a->argv, g_aModifyMediumOptions, RT_ELEMENTS(g_aModifyMediumOptions),
532 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
533 while ((c = RTGetOpt(&GetState, &ValueUnion)))
534 {
535 switch (c)
536 {
537 case 'H': // disk
538 if (cmd != CMD_NONE)
539 return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
540 cmd = CMD_DISK;
541 break;
542
543 case 'D': // DVD
544 if (cmd != CMD_NONE)
545 return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
546 cmd = CMD_DVD;
547 break;
548
549 case 'L': // floppy
550 if (cmd != CMD_NONE)
551 return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
552 cmd = CMD_FLOPPY;
553 break;
554
555 case 't': // --type
556 vrc = parseMediumType(ValueUnion.psz, &enmMediumType);
557 if (RT_FAILURE(vrc))
558 return errorArgument("Invalid medium type '%s'", ValueUnion.psz);
559 fModifyMediumType = true;
560 break;
561
562 case 'z': // --autoreset
563 vrc = parseBool(ValueUnion.psz, &AutoReset);
564 if (RT_FAILURE(vrc))
565 return errorArgument("Invalid autoreset parameter '%s'", ValueUnion.psz);
566 fModifyAutoReset = true;
567 break;
568
569 case 'p': // --property
570 {
571 /* Parse 'name=value' */
572 char *pszProperty = RTStrDup(ValueUnion.psz);
573 if (pszProperty)
574 {
575 char *pDelimiter = strchr(pszProperty, '=');
576 if (pDelimiter)
577 {
578 *pDelimiter = '\0';
579
580 Bstr bstrName(pszProperty);
581 Bstr bstrValue(&pDelimiter[1]);
582 bstrName.detachTo(mediumPropNames.appendedRaw());
583 bstrValue.detachTo(mediumPropValues.appendedRaw());
584 fModifyProperties = true;
585 }
586 else
587 {
588 errorArgument("Invalid --property argument '%s'", ValueUnion.psz);
589 rc = E_FAIL;
590 }
591 RTStrFree(pszProperty);
592 }
593 else
594 {
595 RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for medium property '%s'\n", ValueUnion.psz);
596 rc = E_FAIL;
597 }
598 break;
599 }
600
601 case 'c': // --compact
602 fModifyCompact = true;
603 break;
604
605 case 'r': // --resize
606 cbResize = ValueUnion.u64 * _1M;
607 fModifyResize = true;
608 fModifyResizeMB = true; // do sanity check!
609 break;
610
611 case 'R': // --resizebyte
612 cbResize = ValueUnion.u64;
613 fModifyResize = true;
614 break;
615
616 case 'm': // --move
617 /* Get a new location */
618 pszNewLocation = RTPathAbsDup(ValueUnion.psz);
619 fMoveMedium = true;
620 break;
621
622 case 'l': // --setlocation
623 /* Get a new location */
624 pszNewLocation = RTPathAbsDup(ValueUnion.psz);
625 fSetNewLocation = true;
626 break;
627
628 case 'd': // --description
629 /* Get a new description */
630 pszNewLocation = RTStrDup(ValueUnion.psz);
631 fModifyDescription = true;
632 break;
633
634 case VINF_GETOPT_NOT_OPTION:
635 if (!pszFilenameOrUuid)
636 pszFilenameOrUuid = ValueUnion.psz;
637 else
638 return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
639 break;
640
641 default:
642 if (c > 0)
643 {
644 if (RT_C_IS_PRINT(c))
645 return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid option -%c", c);
646 else
647 return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid option case %i", c);
648 }
649 else if (c == VERR_GETOPT_UNKNOWN_OPTION)
650 return errorSyntax(USAGE_MODIFYMEDIUM, "unknown option: %s\n", ValueUnion.psz);
651 else if (ValueUnion.pDef)
652 return errorSyntax(USAGE_MODIFYMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
653 else
654 return errorSyntax(USAGE_MODIFYMEDIUM, "error: %Rrs", c);
655 }
656 }
657
658 if (cmd == CMD_NONE)
659 cmd = CMD_DISK;
660
661 if (!pszFilenameOrUuid)
662 return errorSyntax(USAGE_MODIFYMEDIUM, "Medium name or UUID required");
663
664 if (!fModifyMediumType
665 && !fModifyAutoReset
666 && !fModifyProperties
667 && !fModifyCompact
668 && !fModifyResize
669 && !fMoveMedium
670 && !fSetNewLocation
671 && !fModifyDescription
672 )
673 return errorSyntax(USAGE_MODIFYMEDIUM, "No operation specified");
674
675 /* Always open the medium if necessary, there is no other way. */
676 if (cmd == CMD_DISK)
677 rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
678 AccessMode_ReadWrite, pMedium,
679 false /* fForceNewUuidOnOpen */, false /* fSilent */);
680 else if (cmd == CMD_DVD)
681 rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
682 AccessMode_ReadOnly, pMedium,
683 false /* fForceNewUuidOnOpen */, false /* fSilent */);
684 else if (cmd == CMD_FLOPPY)
685 rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
686 AccessMode_ReadWrite, pMedium,
687 false /* fForceNewUuidOnOpen */, false /* fSilent */);
688 else
689 rc = E_INVALIDARG; /* cannot happen but make gcc happy */
690 if (FAILED(rc))
691 return RTEXITCODE_FAILURE;
692 if (pMedium.isNull())
693 {
694 RTMsgError("Invalid medium reference, avoiding crash");
695 return RTEXITCODE_FAILURE;
696 }
697
698 if ( fModifyResize
699 && fModifyResizeMB)
700 {
701 // Sanity check
702 //
703 // In general users should know what they do but in this case users have no
704 // alternative to VBoxManage. If happens that one wants to resize the disk
705 // and uses --resize and does not consider that this parameter expects the
706 // new medium size in MB not Byte. If the operation is started and then
707 // aborted by the user, the result is most likely a medium which doesn't
708 // work anymore.
709 MediumState_T state;
710 pMedium->RefreshState(&state);
711 LONG64 logicalSize;
712 pMedium->COMGETTER(LogicalSize)(&logicalSize);
713 if (cbResize > (uint64_t)logicalSize * 1000)
714 {
715 RTMsgError("Error: Attempt to resize the medium from %RU64.%RU64 MB to %RU64.%RU64 MB. Use --resizebyte if this is intended!\n",
716 logicalSize / _1M, (logicalSize % _1M) / (_1M / 10), cbResize / _1M, (cbResize % _1M) / (_1M / 10));
717 return RTEXITCODE_FAILURE;
718 }
719 }
720
721 if (fModifyMediumType)
722 {
723 MediumType_T enmCurrMediumType;
724 CHECK_ERROR(pMedium, COMGETTER(Type)(&enmCurrMediumType));
725
726 if (enmCurrMediumType != enmMediumType)
727 CHECK_ERROR(pMedium, COMSETTER(Type)(enmMediumType));
728 }
729
730 if (fModifyAutoReset)
731 {
732 CHECK_ERROR(pMedium, COMSETTER(AutoReset)(AutoReset));
733 }
734
735 if (fModifyProperties)
736 {
737 CHECK_ERROR(pMedium, SetProperties(ComSafeArrayAsInParam(mediumPropNames), ComSafeArrayAsInParam(mediumPropValues)));
738 }
739
740 if (fModifyCompact)
741 {
742 ComPtr<IProgress> pProgress;
743 CHECK_ERROR(pMedium, Compact(pProgress.asOutParam()));
744 if (SUCCEEDED(rc))
745 rc = showProgress(pProgress);
746 if (FAILED(rc))
747 {
748 if (rc == E_NOTIMPL)
749 RTMsgError("Compact medium operation is not implemented!");
750 else if (rc == VBOX_E_NOT_SUPPORTED)
751 RTMsgError("Compact medium operation for this format is not implemented yet!");
752 else if (!pProgress.isNull())
753 CHECK_PROGRESS_ERROR(pProgress, ("Failed to compact medium"));
754 else
755 RTMsgError("Failed to compact medium!");
756 }
757 }
758
759 if (fModifyResize)
760 {
761 ComPtr<IProgress> pProgress;
762 CHECK_ERROR(pMedium, Resize(cbResize, pProgress.asOutParam()));
763 if (SUCCEEDED(rc))
764 rc = showProgress(pProgress);
765 if (FAILED(rc))
766 {
767 if (!pProgress.isNull())
768 CHECK_PROGRESS_ERROR(pProgress, ("Failed to resize medium"));
769 else if (rc == E_NOTIMPL)
770 RTMsgError("Resize medium operation is not implemented!");
771 else if (rc == VBOX_E_NOT_SUPPORTED)
772 RTMsgError("Resize medium operation for this format is not implemented yet!");
773 else
774 RTMsgError("Failed to resize medium!");
775 }
776 }
777
778 if (fMoveMedium)
779 {
780 do
781 {
782 ComPtr<IProgress> pProgress;
783 Utf8Str strLocation(pszNewLocation);
784 RTStrFree(pszNewLocation);
785 CHECK_ERROR(pMedium, MoveTo(Bstr(strLocation).raw(), pProgress.asOutParam()));
786
787 if (SUCCEEDED(rc) && !pProgress.isNull())
788 {
789 rc = showProgress(pProgress);
790 CHECK_PROGRESS_ERROR(pProgress, ("Failed to move medium"));
791 }
792
793 Bstr uuid;
794 CHECK_ERROR_BREAK(pMedium, COMGETTER(Id)(uuid.asOutParam()));
795
796 RTPrintf("Move medium with UUID %s finished\n", Utf8Str(uuid).c_str());
797 }
798 while (0);
799 }
800
801 if (fSetNewLocation)
802 {
803 Utf8Str strLocation(pszNewLocation);
804 RTStrFree(pszNewLocation);
805 CHECK_ERROR(pMedium, COMSETTER(Location)(Bstr(strLocation).raw()));
806
807 Bstr uuid;
808 CHECK_ERROR(pMedium, COMGETTER(Id)(uuid.asOutParam()));
809 RTPrintf("Set new location of medium with UUID %s finished\n", Utf8Str(uuid).c_str());
810 }
811
812 if (fModifyDescription)
813 {
814 CHECK_ERROR(pMedium, COMSETTER(Description)(Bstr(pszNewLocation).raw()));
815
816 RTPrintf("Medium description has been changed.\n");
817 }
818
819 return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
820}
821
822static const RTGETOPTDEF g_aCloneMediumOptions[] =
823{
824 { "disk", 'd', RTGETOPT_REQ_NOTHING },
825 { "dvd", 'D', RTGETOPT_REQ_NOTHING },
826 { "floppy", 'f', RTGETOPT_REQ_NOTHING },
827 { "--format", 'o', RTGETOPT_REQ_STRING },
828 { "-format", 'o', RTGETOPT_REQ_STRING },
829 { "--static", 'F', RTGETOPT_REQ_NOTHING },
830 { "-static", 'F', RTGETOPT_REQ_NOTHING },
831 { "--existing", 'E', RTGETOPT_REQ_NOTHING },
832 { "--variant", 'm', RTGETOPT_REQ_STRING },
833 { "-variant", 'm', RTGETOPT_REQ_STRING },
834};
835
836RTEXITCODE handleCloneMedium(HandlerArg *a)
837{
838 HRESULT rc;
839 int vrc;
840 enum {
841 CMD_NONE,
842 CMD_DISK,
843 CMD_DVD,
844 CMD_FLOPPY
845 } cmd = CMD_NONE;
846 const char *pszSrc = NULL;
847 const char *pszDst = NULL;
848 Bstr format;
849 MediumVariant_T enmMediumVariant = MediumVariant_Standard;
850 bool fExisting = false;
851
852 int c;
853 RTGETOPTUNION ValueUnion;
854 RTGETOPTSTATE GetState;
855 // start at 0 because main() has hacked both the argc and argv given to us
856 RTGetOptInit(&GetState, a->argc, a->argv, g_aCloneMediumOptions, RT_ELEMENTS(g_aCloneMediumOptions),
857 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
858 while ((c = RTGetOpt(&GetState, &ValueUnion)))
859 {
860 switch (c)
861 {
862 case 'd': // disk
863 if (cmd != CMD_NONE)
864 return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
865 cmd = CMD_DISK;
866 break;
867
868 case 'D': // DVD
869 if (cmd != CMD_NONE)
870 return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
871 cmd = CMD_DVD;
872 break;
873
874 case 'f': // floppy
875 if (cmd != CMD_NONE)
876 return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
877 cmd = CMD_FLOPPY;
878 break;
879
880 case 'o': // --format
881 format = ValueUnion.psz;
882 break;
883
884 case 'F': // --static
885 {
886 unsigned uMediumVariant = (unsigned)enmMediumVariant;
887 uMediumVariant |= MediumVariant_Fixed;
888 enmMediumVariant = (MediumVariant_T)uMediumVariant;
889 break;
890 }
891
892 case 'E': // --existing
893 fExisting = true;
894 break;
895
896 case 'm': // --variant
897 vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
898 if (RT_FAILURE(vrc))
899 return errorArgument("Invalid medium variant '%s'", ValueUnion.psz);
900 break;
901
902 case VINF_GETOPT_NOT_OPTION:
903 if (!pszSrc)
904 pszSrc = ValueUnion.psz;
905 else if (!pszDst)
906 pszDst = ValueUnion.psz;
907 else
908 return errorSyntax(USAGE_CLONEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
909 break;
910
911 default:
912 if (c > 0)
913 {
914 if (RT_C_IS_GRAPH(c))
915 return errorSyntax(USAGE_CLONEMEDIUM, "unhandled option: -%c", c);
916 else
917 return errorSyntax(USAGE_CLONEMEDIUM, "unhandled option: %i", c);
918 }
919 else if (c == VERR_GETOPT_UNKNOWN_OPTION)
920 return errorSyntax(USAGE_CLONEMEDIUM, "unknown option: %s", ValueUnion.psz);
921 else if (ValueUnion.pDef)
922 return errorSyntax(USAGE_CLONEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
923 else
924 return errorSyntax(USAGE_CLONEMEDIUM, "error: %Rrs", c);
925 }
926 }
927
928 if (cmd == CMD_NONE)
929 cmd = CMD_DISK;
930 if (!pszSrc)
931 return errorSyntax(USAGE_CLONEMEDIUM, "Mandatory UUID or input file parameter missing");
932 if (!pszDst)
933 return errorSyntax(USAGE_CLONEMEDIUM, "Mandatory output file parameter missing");
934 if (fExisting && (!format.isEmpty() || enmMediumVariant != MediumVariant_Standard))
935 return errorSyntax(USAGE_CLONEMEDIUM, "Specified options which cannot be used with --existing");
936
937 ComPtr<IMedium> pSrcMedium;
938 ComPtr<IMedium> pDstMedium;
939
940 if (cmd == CMD_DISK)
941 rc = openMedium(a, pszSrc, DeviceType_HardDisk, AccessMode_ReadOnly, pSrcMedium,
942 false /* fForceNewUuidOnOpen */, false /* fSilent */);
943 else if (cmd == CMD_DVD)
944 rc = openMedium(a, pszSrc, DeviceType_DVD, AccessMode_ReadOnly, pSrcMedium,
945 false /* fForceNewUuidOnOpen */, false /* fSilent */);
946 else if (cmd == CMD_FLOPPY)
947 rc = openMedium(a, pszSrc, DeviceType_Floppy, AccessMode_ReadOnly, pSrcMedium,
948 false /* fForceNewUuidOnOpen */, false /* fSilent */);
949 else
950 rc = E_INVALIDARG; /* cannot happen but make gcc happy */
951 if (FAILED(rc))
952 return RTEXITCODE_FAILURE;
953
954 do
955 {
956 /* open/create destination medium */
957 if (fExisting)
958 {
959 if (cmd == CMD_DISK)
960 rc = openMedium(a, pszDst, DeviceType_HardDisk, AccessMode_ReadWrite, pDstMedium,
961 false /* fForceNewUuidOnOpen */, false /* fSilent */);
962 else if (cmd == CMD_DVD)
963 rc = openMedium(a, pszDst, DeviceType_DVD, AccessMode_ReadOnly, pDstMedium,
964 false /* fForceNewUuidOnOpen */, false /* fSilent */);
965 else if (cmd == CMD_FLOPPY)
966 rc = openMedium(a, pszDst, DeviceType_Floppy, AccessMode_ReadWrite, pDstMedium,
967 false /* fForceNewUuidOnOpen */, false /* fSilent */);
968 if (FAILED(rc))
969 break;
970
971 /* Perform accessibility check now. */
972 MediumState_T state;
973 CHECK_ERROR_BREAK(pDstMedium, RefreshState(&state));
974 CHECK_ERROR_BREAK(pDstMedium, COMGETTER(Format)(format.asOutParam()));
975 }
976 else
977 {
978 /*
979 * In case the format is unspecified check that the source medium supports
980 * image creation and use the same format for the destination image.
981 * Use the default image format if it is not supported.
982 */
983 if (format.isEmpty())
984 {
985 ComPtr<IMediumFormat> pMediumFmt;
986 com::SafeArray<MediumFormatCapabilities_T> l_caps;
987 CHECK_ERROR_BREAK(pSrcMedium, COMGETTER(MediumFormat)(pMediumFmt.asOutParam()));
988 CHECK_ERROR_BREAK(pMediumFmt, COMGETTER(Capabilities)(ComSafeArrayAsOutParam(l_caps)));
989 ULONG caps=0;
990 for (size_t i = 0; i < l_caps.size(); i++)
991 caps |= l_caps[i];
992 if (caps & ( MediumFormatCapabilities_CreateDynamic
993 | MediumFormatCapabilities_CreateFixed))
994 CHECK_ERROR_BREAK(pMediumFmt, COMGETTER(Id)(format.asOutParam()));
995 }
996 Utf8Str strFormat(format);
997 if (cmd == CMD_DISK)
998 rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_HardDisk,
999 AccessMode_ReadWrite, pDstMedium);
1000 else if (cmd == CMD_DVD)
1001 rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_DVD,
1002 AccessMode_ReadOnly, pDstMedium);
1003 else if (cmd == CMD_FLOPPY)
1004 rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_Floppy,
1005 AccessMode_ReadWrite, pDstMedium);
1006 if (FAILED(rc))
1007 break;
1008 }
1009
1010 ComPtr<IProgress> pProgress;
1011 com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8);
1012
1013 for (ULONG i = 0; i < l_variants.size(); ++i)
1014 {
1015 ULONG temp = enmMediumVariant;
1016 temp &= 1<<i;
1017 l_variants [i] = (MediumVariant_T)temp;
1018 }
1019
1020 CHECK_ERROR_BREAK(pSrcMedium, CloneTo(pDstMedium, ComSafeArrayAsInParam(l_variants), NULL, pProgress.asOutParam()));
1021
1022 rc = showProgress(pProgress);
1023 CHECK_PROGRESS_ERROR_BREAK(pProgress, ("Failed to clone medium"));
1024
1025 Bstr uuid;
1026 CHECK_ERROR_BREAK(pDstMedium, COMGETTER(Id)(uuid.asOutParam()));
1027
1028 RTPrintf("Clone medium created in format '%ls'. UUID: %s\n",
1029 format.raw(), Utf8Str(uuid).c_str());
1030 }
1031 while (0);
1032
1033 return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1034}
1035
1036static const RTGETOPTDEF g_aConvertFromRawHardDiskOptions[] =
1037{
1038 { "--format", 'o', RTGETOPT_REQ_STRING },
1039 { "-format", 'o', RTGETOPT_REQ_STRING },
1040 { "--static", 'F', RTGETOPT_REQ_NOTHING },
1041 { "-static", 'F', RTGETOPT_REQ_NOTHING },
1042 { "--variant", 'm', RTGETOPT_REQ_STRING },
1043 { "-variant", 'm', RTGETOPT_REQ_STRING },
1044 { "--uuid", 'u', RTGETOPT_REQ_STRING },
1045};
1046
1047RTEXITCODE handleConvertFromRaw(HandlerArg *a)
1048{
1049 int rc = VINF_SUCCESS;
1050 bool fReadFromStdIn = false;
1051 const char *format = "VDI";
1052 const char *srcfilename = NULL;
1053 const char *dstfilename = NULL;
1054 const char *filesize = NULL;
1055 unsigned uImageFlags = VD_IMAGE_FLAGS_NONE;
1056 void *pvBuf = NULL;
1057 RTUUID uuid;
1058 PCRTUUID pUuid = NULL;
1059
1060 int c;
1061 RTGETOPTUNION ValueUnion;
1062 RTGETOPTSTATE GetState;
1063 // start at 0 because main() has hacked both the argc and argv given to us
1064 RTGetOptInit(&GetState, a->argc, a->argv, g_aConvertFromRawHardDiskOptions, RT_ELEMENTS(g_aConvertFromRawHardDiskOptions),
1065 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1066 while ((c = RTGetOpt(&GetState, &ValueUnion)))
1067 {
1068 switch (c)
1069 {
1070 case 'u': // --uuid
1071 if (RT_FAILURE(RTUuidFromStr(&uuid, ValueUnion.psz)))
1072 return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid UUID '%s'", ValueUnion.psz);
1073 pUuid = &uuid;
1074 break;
1075 case 'o': // --format
1076 format = ValueUnion.psz;
1077 break;
1078
1079 case 'm': // --variant
1080 {
1081 MediumVariant_T enmMediumVariant = MediumVariant_Standard;
1082 rc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
1083 if (RT_FAILURE(rc))
1084 return errorArgument("Invalid medium variant '%s'", ValueUnion.psz);
1085 /// @todo cleaner solution than assuming 1:1 mapping?
1086 uImageFlags = (unsigned)enmMediumVariant;
1087 break;
1088 }
1089 case VINF_GETOPT_NOT_OPTION:
1090 if (!srcfilename)
1091 {
1092 srcfilename = ValueUnion.psz;
1093 fReadFromStdIn = !strcmp(srcfilename, "stdin");
1094 }
1095 else if (!dstfilename)
1096 dstfilename = ValueUnion.psz;
1097 else if (fReadFromStdIn && !filesize)
1098 filesize = ValueUnion.psz;
1099 else
1100 return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid parameter '%s'", ValueUnion.psz);
1101 break;
1102
1103 default:
1104 return errorGetOpt(USAGE_CONVERTFROMRAW, c, &ValueUnion);
1105 }
1106 }
1107
1108 if (!srcfilename || !dstfilename || (fReadFromStdIn && !filesize))
1109 return errorSyntax(USAGE_CONVERTFROMRAW, "Incorrect number of parameters");
1110 RTStrmPrintf(g_pStdErr, "Converting from raw image file=\"%s\" to file=\"%s\"...\n",
1111 srcfilename, dstfilename);
1112
1113 PVDISK pDisk = NULL;
1114
1115 PVDINTERFACE pVDIfs = NULL;
1116 VDINTERFACEERROR vdInterfaceError;
1117 vdInterfaceError.pfnError = handleVDError;
1118 vdInterfaceError.pfnMessage = NULL;
1119
1120 rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1121 NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
1122 AssertRC(rc);
1123
1124 /* open raw image file. */
1125 RTFILE File;
1126 if (fReadFromStdIn)
1127 rc = RTFileFromNative(&File, RTFILE_NATIVE_STDIN);
1128 else
1129 rc = RTFileOpen(&File, srcfilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
1130 if (RT_FAILURE(rc))
1131 {
1132 RTMsgError("Cannot open file \"%s\": %Rrc", srcfilename, rc);
1133 goto out;
1134 }
1135
1136 uint64_t cbFile;
1137 /* get image size. */
1138 if (fReadFromStdIn)
1139 cbFile = RTStrToUInt64(filesize);
1140 else
1141 rc = RTFileGetSize(File, &cbFile);
1142 if (RT_FAILURE(rc))
1143 {
1144 RTMsgError("Cannot get image size for file \"%s\": %Rrc", srcfilename, rc);
1145 goto out;
1146 }
1147
1148 RTStrmPrintf(g_pStdErr, "Creating %s image with size %RU64 bytes (%RU64MB)...\n",
1149 (uImageFlags & VD_IMAGE_FLAGS_FIXED) ? "fixed" : "dynamic", cbFile, (cbFile + _1M - 1) / _1M);
1150 char pszComment[256];
1151 RTStrPrintf(pszComment, sizeof(pszComment), "Converted image from %s", srcfilename);
1152 rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
1153 if (RT_FAILURE(rc))
1154 {
1155 RTMsgError("Cannot create the virtual disk container: %Rrc", rc);
1156 goto out;
1157 }
1158
1159 Assert(RT_MIN(cbFile / 512 / 16 / 63, 16383) -
1160 (unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383) == 0);
1161 VDGEOMETRY PCHS, LCHS;
1162 PCHS.cCylinders = (unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383);
1163 PCHS.cHeads = 16;
1164 PCHS.cSectors = 63;
1165 LCHS.cCylinders = 0;
1166 LCHS.cHeads = 0;
1167 LCHS.cSectors = 0;
1168 rc = VDCreateBase(pDisk, format, dstfilename, cbFile,
1169 uImageFlags, pszComment, &PCHS, &LCHS, pUuid,
1170 VD_OPEN_FLAGS_NORMAL, NULL, NULL);
1171 if (RT_FAILURE(rc))
1172 {
1173 RTMsgError("Cannot create the disk image \"%s\": %Rrc", dstfilename, rc);
1174 goto out;
1175 }
1176
1177 size_t cbBuffer;
1178 cbBuffer = _1M;
1179 pvBuf = RTMemAlloc(cbBuffer);
1180 if (!pvBuf)
1181 {
1182 rc = VERR_NO_MEMORY;
1183 RTMsgError("Out of memory allocating buffers for image \"%s\": %Rrc", dstfilename, rc);
1184 goto out;
1185 }
1186
1187 uint64_t offFile;
1188 offFile = 0;
1189 while (offFile < cbFile)
1190 {
1191 size_t cbRead;
1192 size_t cbToRead;
1193 cbRead = 0;
1194 cbToRead = cbFile - offFile >= (uint64_t)cbBuffer ?
1195 cbBuffer : (size_t)(cbFile - offFile);
1196 rc = RTFileRead(File, pvBuf, cbToRead, &cbRead);
1197 if (RT_FAILURE(rc) || !cbRead)
1198 break;
1199 rc = VDWrite(pDisk, offFile, pvBuf, cbRead);
1200 if (RT_FAILURE(rc))
1201 {
1202 RTMsgError("Failed to write to disk image \"%s\": %Rrc", dstfilename, rc);
1203 goto out;
1204 }
1205 offFile += cbRead;
1206 }
1207
1208out:
1209 if (pvBuf)
1210 RTMemFree(pvBuf);
1211 if (pDisk)
1212 VDClose(pDisk, RT_FAILURE(rc));
1213 if (File != NIL_RTFILE)
1214 RTFileClose(File);
1215
1216 return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1217}
1218
1219HRESULT showMediumInfo(const ComPtr<IVirtualBox> &pVirtualBox,
1220 const ComPtr<IMedium> &pMedium,
1221 const char *pszParentUUID,
1222 bool fOptLong)
1223{
1224 HRESULT rc = S_OK;
1225 do
1226 {
1227 Bstr uuid;
1228 pMedium->COMGETTER(Id)(uuid.asOutParam());
1229 RTPrintf("UUID: %ls\n", uuid.raw());
1230 if (pszParentUUID)
1231 RTPrintf("Parent UUID: %s\n", pszParentUUID);
1232
1233 /* check for accessibility */
1234 MediumState_T enmState;
1235 CHECK_ERROR_BREAK(pMedium, RefreshState(&enmState));
1236 const char *pszState = "unknown";
1237 switch (enmState)
1238 {
1239 case MediumState_NotCreated:
1240 pszState = "not created";
1241 break;
1242 case MediumState_Created:
1243 pszState = "created";
1244 break;
1245 case MediumState_LockedRead:
1246 pszState = "locked read";
1247 break;
1248 case MediumState_LockedWrite:
1249 pszState = "locked write";
1250 break;
1251 case MediumState_Inaccessible:
1252 pszState = "inaccessible";
1253 break;
1254 case MediumState_Creating:
1255 pszState = "creating";
1256 break;
1257 case MediumState_Deleting:
1258 pszState = "deleting";
1259 break;
1260#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1261 case MediumState_32BitHack: break; /* Shut up compiler warnings. */
1262#endif
1263 }
1264 RTPrintf("State: %s\n", pszState);
1265
1266 if (fOptLong && enmState == MediumState_Inaccessible)
1267 {
1268 Bstr err;
1269 CHECK_ERROR_BREAK(pMedium, COMGETTER(LastAccessError)(err.asOutParam()));
1270 RTPrintf("Access Error: %ls\n", err.raw());
1271 }
1272
1273 if (fOptLong)
1274 {
1275 Bstr description;
1276 pMedium->COMGETTER(Description)(description.asOutParam());
1277 if (!description.isEmpty())
1278 RTPrintf("Description: %ls\n", description.raw());
1279 }
1280
1281 MediumType_T type;
1282 pMedium->COMGETTER(Type)(&type);
1283 const char *typeStr = "unknown";
1284 switch (type)
1285 {
1286 case MediumType_Normal:
1287 if (pszParentUUID && Guid(pszParentUUID).isValid())
1288 typeStr = "normal (differencing)";
1289 else
1290 typeStr = "normal (base)";
1291 break;
1292 case MediumType_Immutable:
1293 typeStr = "immutable";
1294 break;
1295 case MediumType_Writethrough:
1296 typeStr = "writethrough";
1297 break;
1298 case MediumType_Shareable:
1299 typeStr = "shareable";
1300 break;
1301 case MediumType_Readonly:
1302 typeStr = "readonly";
1303 break;
1304 case MediumType_MultiAttach:
1305 typeStr = "multiattach";
1306 break;
1307#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1308 case MediumType_32BitHack: break; /* Shut up compiler warnings. */
1309#endif
1310 }
1311 RTPrintf("Type: %s\n", typeStr);
1312
1313 /* print out information specific for differencing media */
1314 if (fOptLong && pszParentUUID && Guid(pszParentUUID).isValid())
1315 {
1316 BOOL autoReset = FALSE;
1317 pMedium->COMGETTER(AutoReset)(&autoReset);
1318 RTPrintf("Auto-Reset: %s\n", autoReset ? "on" : "off");
1319 }
1320
1321 Bstr loc;
1322 pMedium->COMGETTER(Location)(loc.asOutParam());
1323 RTPrintf("Location: %ls\n", loc.raw());
1324
1325 Bstr format;
1326 pMedium->COMGETTER(Format)(format.asOutParam());
1327 RTPrintf("Storage format: %ls\n", format.raw());
1328
1329 if (fOptLong)
1330 {
1331 com::SafeArray<MediumVariant_T> safeArray_variant;
1332
1333 pMedium->COMGETTER(Variant)(ComSafeArrayAsOutParam(safeArray_variant));
1334 ULONG variant=0;
1335 for (size_t i = 0; i < safeArray_variant.size(); i++)
1336 variant |= safeArray_variant[i];
1337
1338 const char *variantStr = "unknown";
1339 switch (variant & ~(MediumVariant_Fixed | MediumVariant_Diff))
1340 {
1341 case MediumVariant_VmdkSplit2G:
1342 variantStr = "split2G";
1343 break;
1344 case MediumVariant_VmdkStreamOptimized:
1345 variantStr = "streamOptimized";
1346 break;
1347 case MediumVariant_VmdkESX:
1348 variantStr = "ESX";
1349 break;
1350 case MediumVariant_Standard:
1351 variantStr = "default";
1352 break;
1353 }
1354 const char *variantTypeStr = "dynamic";
1355 if (variant & MediumVariant_Fixed)
1356 variantTypeStr = "fixed";
1357 else if (variant & MediumVariant_Diff)
1358 variantTypeStr = "differencing";
1359 RTPrintf("Format variant: %s %s\n", variantTypeStr, variantStr);
1360 }
1361
1362 LONG64 logicalSize;
1363 pMedium->COMGETTER(LogicalSize)(&logicalSize);
1364 RTPrintf("Capacity: %lld MBytes\n", logicalSize >> 20);
1365 if (fOptLong)
1366 {
1367 LONG64 actualSize;
1368 pMedium->COMGETTER(Size)(&actualSize);
1369 RTPrintf("Size on disk: %lld MBytes\n", actualSize >> 20);
1370 }
1371
1372 Bstr strCipher;
1373 Bstr strPasswordId;
1374 HRESULT rc2 = pMedium->GetEncryptionSettings(strCipher.asOutParam(), strPasswordId.asOutParam());
1375 if (SUCCEEDED(rc2))
1376 {
1377 RTPrintf("Encryption: enabled\n");
1378 if (fOptLong)
1379 {
1380 RTPrintf("Cipher: %ls\n", strCipher.raw());
1381 RTPrintf("Password ID: %ls\n", strPasswordId.raw());
1382 }
1383 }
1384 else
1385 RTPrintf("Encryption: disabled\n");
1386
1387 if (fOptLong)
1388 {
1389 com::SafeArray<BSTR> names;
1390 com::SafeArray<BSTR> values;
1391 pMedium->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values));
1392 size_t cNames = names.size();
1393 size_t cValues = values.size();
1394 bool fFirst = true;
1395 for (size_t i = 0; i < cNames; i++)
1396 {
1397 Bstr value;
1398 if (i < cValues)
1399 value = values[i];
1400 RTPrintf("%s%ls=%ls\n",
1401 fFirst ? "Property: " : " ",
1402 names[i], value.raw());
1403 fFirst = false;
1404 }
1405 }
1406
1407 if (fOptLong)
1408 {
1409 bool fFirst = true;
1410 com::SafeArray<BSTR> machineIds;
1411 pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(machineIds));
1412 for (size_t i = 0; i < machineIds.size(); i++)
1413 {
1414 ComPtr<IMachine> pMachine;
1415 CHECK_ERROR(pVirtualBox, FindMachine(machineIds[i], pMachine.asOutParam()));
1416 if (pMachine)
1417 {
1418 Bstr name;
1419 pMachine->COMGETTER(Name)(name.asOutParam());
1420 pMachine->COMGETTER(Id)(uuid.asOutParam());
1421 RTPrintf("%s%ls (UUID: %ls)",
1422 fFirst ? "In use by VMs: " : " ",
1423 name.raw(), machineIds[i]);
1424 fFirst = false;
1425 com::SafeArray<BSTR> snapshotIds;
1426 pMedium->GetSnapshotIds(machineIds[i],
1427 ComSafeArrayAsOutParam(snapshotIds));
1428 for (size_t j = 0; j < snapshotIds.size(); j++)
1429 {
1430 ComPtr<ISnapshot> pSnapshot;
1431 pMachine->FindSnapshot(snapshotIds[j], pSnapshot.asOutParam());
1432 if (pSnapshot)
1433 {
1434 Bstr snapshotName;
1435 pSnapshot->COMGETTER(Name)(snapshotName.asOutParam());
1436 RTPrintf(" [%ls (UUID: %ls)]", snapshotName.raw(), snapshotIds[j]);
1437 }
1438 }
1439 RTPrintf("\n");
1440 }
1441 }
1442 }
1443
1444 if (fOptLong)
1445 {
1446 com::SafeIfaceArray<IMedium> children;
1447 pMedium->COMGETTER(Children)(ComSafeArrayAsOutParam(children));
1448 bool fFirst = true;
1449 for (size_t i = 0; i < children.size(); i++)
1450 {
1451 ComPtr<IMedium> pChild(children[i]);
1452 if (pChild)
1453 {
1454 Bstr childUUID;
1455 pChild->COMGETTER(Id)(childUUID.asOutParam());
1456 RTPrintf("%s%ls\n",
1457 fFirst ? "Child UUIDs: " : " ",
1458 childUUID.raw());
1459 fFirst = false;
1460 }
1461 }
1462 }
1463 }
1464 while (0);
1465
1466 return rc;
1467}
1468
1469static const RTGETOPTDEF g_aShowMediumInfoOptions[] =
1470{
1471 { "disk", 'd', RTGETOPT_REQ_NOTHING },
1472 { "dvd", 'D', RTGETOPT_REQ_NOTHING },
1473 { "floppy", 'f', RTGETOPT_REQ_NOTHING },
1474};
1475
1476RTEXITCODE handleShowMediumInfo(HandlerArg *a)
1477{
1478 enum {
1479 CMD_NONE,
1480 CMD_DISK,
1481 CMD_DVD,
1482 CMD_FLOPPY
1483 } cmd = CMD_NONE;
1484 const char *pszFilenameOrUuid = NULL;
1485
1486 int c;
1487 RTGETOPTUNION ValueUnion;
1488 RTGETOPTSTATE GetState;
1489 // start at 0 because main() has hacked both the argc and argv given to us
1490 RTGetOptInit(&GetState, a->argc, a->argv, g_aShowMediumInfoOptions, RT_ELEMENTS(g_aShowMediumInfoOptions),
1491 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1492 while ((c = RTGetOpt(&GetState, &ValueUnion)))
1493 {
1494 switch (c)
1495 {
1496 case 'd': // disk
1497 if (cmd != CMD_NONE)
1498 return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz);
1499 cmd = CMD_DISK;
1500 break;
1501
1502 case 'D': // DVD
1503 if (cmd != CMD_NONE)
1504 return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz);
1505 cmd = CMD_DVD;
1506 break;
1507
1508 case 'f': // floppy
1509 if (cmd != CMD_NONE)
1510 return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz);
1511 cmd = CMD_FLOPPY;
1512 break;
1513
1514 case VINF_GETOPT_NOT_OPTION:
1515 if (!pszFilenameOrUuid)
1516 pszFilenameOrUuid = ValueUnion.psz;
1517 else
1518 return errorSyntax(USAGE_SHOWMEDIUMINFO, "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_SHOWMEDIUMINFO, "Invalid option -%c", c);
1526 else
1527 return errorSyntax(USAGE_SHOWMEDIUMINFO, "Invalid option case %i", c);
1528 }
1529 else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1530 return errorSyntax(USAGE_SHOWMEDIUMINFO, "unknown option: %s\n", ValueUnion.psz);
1531 else if (ValueUnion.pDef)
1532 return errorSyntax(USAGE_SHOWMEDIUMINFO, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1533 else
1534 return errorSyntax(USAGE_SHOWMEDIUMINFO, "error: %Rrs", c);
1535 }
1536 }
1537
1538 if (cmd == CMD_NONE)
1539 cmd = CMD_DISK;
1540
1541 /* check for required options */
1542 if (!pszFilenameOrUuid)
1543 return errorSyntax(USAGE_SHOWMEDIUMINFO, "Medium name or UUID required");
1544
1545 HRESULT rc = S_OK; /* Prevents warning. */
1546
1547 ComPtr<IMedium> pMedium;
1548 if (cmd == CMD_DISK)
1549 rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1550 AccessMode_ReadOnly, pMedium,
1551 false /* fForceNewUuidOnOpen */, false /* fSilent */);
1552 else if (cmd == CMD_DVD)
1553 rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
1554 AccessMode_ReadOnly, pMedium,
1555 false /* fForceNewUuidOnOpen */, false /* fSilent */);
1556 else if (cmd == CMD_FLOPPY)
1557 rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
1558 AccessMode_ReadOnly, pMedium,
1559 false /* fForceNewUuidOnOpen */, false /* fSilent */);
1560 if (FAILED(rc))
1561 return RTEXITCODE_FAILURE;
1562
1563 Utf8Str strParentUUID("base");
1564 ComPtr<IMedium> pParent;
1565 pMedium->COMGETTER(Parent)(pParent.asOutParam());
1566 if (!pParent.isNull())
1567 {
1568 Bstr bstrParentUUID;
1569 pParent->COMGETTER(Id)(bstrParentUUID.asOutParam());
1570 strParentUUID = bstrParentUUID;
1571 }
1572
1573 rc = showMediumInfo(a->virtualBox, pMedium, strParentUUID.c_str(), true);
1574
1575 return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1576}
1577
1578static const RTGETOPTDEF g_aCloseMediumOptions[] =
1579{
1580 { "disk", 'd', RTGETOPT_REQ_NOTHING },
1581 { "dvd", 'D', RTGETOPT_REQ_NOTHING },
1582 { "floppy", 'f', RTGETOPT_REQ_NOTHING },
1583 { "--delete", 'r', RTGETOPT_REQ_NOTHING },
1584};
1585
1586RTEXITCODE handleCloseMedium(HandlerArg *a)
1587{
1588 HRESULT rc = S_OK;
1589 enum {
1590 CMD_NONE,
1591 CMD_DISK,
1592 CMD_DVD,
1593 CMD_FLOPPY
1594 } cmd = CMD_NONE;
1595 const char *pszFilenameOrUuid = NULL;
1596 bool fDelete = false;
1597
1598 int c;
1599 RTGETOPTUNION ValueUnion;
1600 RTGETOPTSTATE GetState;
1601 // start at 0 because main() has hacked both the argc and argv given to us
1602 RTGetOptInit(&GetState, a->argc, a->argv, g_aCloseMediumOptions, RT_ELEMENTS(g_aCloseMediumOptions),
1603 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1604 while ((c = RTGetOpt(&GetState, &ValueUnion)))
1605 {
1606 switch (c)
1607 {
1608 case 'd': // disk
1609 if (cmd != CMD_NONE)
1610 return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1611 cmd = CMD_DISK;
1612 break;
1613
1614 case 'D': // DVD
1615 if (cmd != CMD_NONE)
1616 return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1617 cmd = CMD_DVD;
1618 break;
1619
1620 case 'f': // floppy
1621 if (cmd != CMD_NONE)
1622 return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1623 cmd = CMD_FLOPPY;
1624 break;
1625
1626 case 'r': // --delete
1627 fDelete = true;
1628 break;
1629
1630 case VINF_GETOPT_NOT_OPTION:
1631 if (!pszFilenameOrUuid)
1632 pszFilenameOrUuid = ValueUnion.psz;
1633 else
1634 return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
1635 break;
1636
1637 default:
1638 if (c > 0)
1639 {
1640 if (RT_C_IS_PRINT(c))
1641 return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option -%c", c);
1642 else
1643 return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option case %i", c);
1644 }
1645 else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1646 return errorSyntax(USAGE_CLOSEMEDIUM, "unknown option: %s\n", ValueUnion.psz);
1647 else if (ValueUnion.pDef)
1648 return errorSyntax(USAGE_CLOSEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1649 else
1650 return errorSyntax(USAGE_CLOSEMEDIUM, "error: %Rrs", c);
1651 }
1652 }
1653
1654 /* check for required options */
1655 if (cmd == CMD_NONE)
1656 cmd = CMD_DISK;
1657 if (!pszFilenameOrUuid)
1658 return errorSyntax(USAGE_CLOSEMEDIUM, "Medium name or UUID required");
1659
1660 ComPtr<IMedium> pMedium;
1661 if (cmd == CMD_DISK)
1662 rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1663 AccessMode_ReadWrite, pMedium,
1664 false /* fForceNewUuidOnOpen */, false /* fSilent */);
1665 else if (cmd == CMD_DVD)
1666 rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
1667 AccessMode_ReadOnly, pMedium,
1668 false /* fForceNewUuidOnOpen */, false /* fSilent */);
1669 else if (cmd == CMD_FLOPPY)
1670 rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
1671 AccessMode_ReadWrite, pMedium,
1672 false /* fForceNewUuidOnOpen */, false /* fSilent */);
1673
1674 if (SUCCEEDED(rc) && pMedium)
1675 {
1676 if (fDelete)
1677 {
1678 ComPtr<IProgress> pProgress;
1679 CHECK_ERROR(pMedium, DeleteStorage(pProgress.asOutParam()));
1680 if (SUCCEEDED(rc))
1681 {
1682 rc = showProgress(pProgress);
1683 CHECK_PROGRESS_ERROR(pProgress, ("Failed to delete medium"));
1684 }
1685 else
1686 RTMsgError("Failed to delete medium. Error code %Rrc", rc);
1687 }
1688 CHECK_ERROR(pMedium, Close());
1689 }
1690
1691 return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1692}
1693
1694RTEXITCODE handleMediumProperty(HandlerArg *a)
1695{
1696 HRESULT rc = S_OK;
1697 const char *pszCmd = NULL;
1698 enum {
1699 CMD_NONE,
1700 CMD_DISK,
1701 CMD_DVD,
1702 CMD_FLOPPY
1703 } cmd = CMD_NONE;
1704 const char *pszAction = NULL;
1705 const char *pszFilenameOrUuid = NULL;
1706 const char *pszProperty = NULL;
1707 ComPtr<IMedium> pMedium;
1708
1709 pszCmd = (a->argc > 0) ? a->argv[0] : "";
1710 if ( !RTStrICmp(pszCmd, "disk")
1711 || !RTStrICmp(pszCmd, "dvd")
1712 || !RTStrICmp(pszCmd, "floppy"))
1713 {
1714 if (!RTStrICmp(pszCmd, "disk"))
1715 cmd = CMD_DISK;
1716 else if (!RTStrICmp(pszCmd, "dvd"))
1717 cmd = CMD_DVD;
1718 else if (!RTStrICmp(pszCmd, "floppy"))
1719 cmd = CMD_FLOPPY;
1720 else
1721 {
1722 AssertMsgFailed(("unexpected parameter %s\n", pszCmd));
1723 cmd = CMD_DISK;
1724 }
1725 a->argv++;
1726 a->argc--;
1727 }
1728 else
1729 {
1730 pszCmd = NULL;
1731 cmd = CMD_DISK;
1732 }
1733
1734 if (a->argc == 0)
1735 return errorSyntax(USAGE_MEDIUMPROPERTY, "Missing action");
1736
1737 pszAction = a->argv[0];
1738 if ( RTStrICmp(pszAction, "set")
1739 && RTStrICmp(pszAction, "get")
1740 && RTStrICmp(pszAction, "delete"))
1741 return errorSyntax(USAGE_MEDIUMPROPERTY, "Invalid action given: %s", pszAction);
1742
1743 if ( ( !RTStrICmp(pszAction, "set")
1744 && a->argc != 4)
1745 || ( RTStrICmp(pszAction, "set")
1746 && a->argc != 3))
1747 return errorSyntax(USAGE_MEDIUMPROPERTY, "Invalid number of arguments given for action: %s", pszAction);
1748
1749 pszFilenameOrUuid = a->argv[1];
1750 pszProperty = a->argv[2];
1751
1752 if (cmd == CMD_DISK)
1753 rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1754 AccessMode_ReadWrite, pMedium,
1755 false /* fForceNewUuidOnOpen */, false /* fSilent */);
1756 else if (cmd == CMD_DVD)
1757 rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
1758 AccessMode_ReadOnly, pMedium,
1759 false /* fForceNewUuidOnOpen */, false /* fSilent */);
1760 else if (cmd == CMD_FLOPPY)
1761 rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
1762 AccessMode_ReadWrite, pMedium,
1763 false /* fForceNewUuidOnOpen */, false /* fSilent */);
1764 if (SUCCEEDED(rc) && !pMedium.isNull())
1765 {
1766 if (!RTStrICmp(pszAction, "set"))
1767 {
1768 const char *pszValue = a->argv[3];
1769 CHECK_ERROR(pMedium, SetProperty(Bstr(pszProperty).raw(), Bstr(pszValue).raw()));
1770 }
1771 else if (!RTStrICmp(pszAction, "get"))
1772 {
1773 Bstr strVal;
1774 CHECK_ERROR(pMedium, GetProperty(Bstr(pszProperty).raw(), strVal.asOutParam()));
1775 if (SUCCEEDED(rc))
1776 RTPrintf("%s=%ls\n", pszProperty, strVal.raw());
1777 }
1778 else if (!RTStrICmp(pszAction, "delete"))
1779 {
1780 CHECK_ERROR(pMedium, SetProperty(Bstr(pszProperty).raw(), Bstr().raw()));
1781 /** @todo */
1782 }
1783 }
1784
1785 return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1786}
1787
1788static const RTGETOPTDEF g_aEncryptMediumOptions[] =
1789{
1790 { "--newpassword", 'n', RTGETOPT_REQ_STRING },
1791 { "--oldpassword", 'o', RTGETOPT_REQ_STRING },
1792 { "--cipher", 'c', RTGETOPT_REQ_STRING },
1793 { "--newpasswordid", 'i', RTGETOPT_REQ_STRING }
1794};
1795
1796RTEXITCODE handleEncryptMedium(HandlerArg *a)
1797{
1798 HRESULT rc;
1799 ComPtr<IMedium> hardDisk;
1800 const char *pszPasswordNew = NULL;
1801 const char *pszPasswordOld = NULL;
1802 const char *pszCipher = NULL;
1803 const char *pszFilenameOrUuid = NULL;
1804 const char *pszNewPasswordId = NULL;
1805 Utf8Str strPasswordNew;
1806 Utf8Str strPasswordOld;
1807
1808 int c;
1809 RTGETOPTUNION ValueUnion;
1810 RTGETOPTSTATE GetState;
1811 // start at 0 because main() has hacked both the argc and argv given to us
1812 RTGetOptInit(&GetState, a->argc, a->argv, g_aEncryptMediumOptions, RT_ELEMENTS(g_aEncryptMediumOptions),
1813 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1814 while ((c = RTGetOpt(&GetState, &ValueUnion)))
1815 {
1816 switch (c)
1817 {
1818 case 'n': // --newpassword
1819 pszPasswordNew = ValueUnion.psz;
1820 break;
1821
1822 case 'o': // --oldpassword
1823 pszPasswordOld = ValueUnion.psz;
1824 break;
1825
1826 case 'c': // --cipher
1827 pszCipher = ValueUnion.psz;
1828 break;
1829
1830 case 'i': // --newpasswordid
1831 pszNewPasswordId = ValueUnion.psz;
1832 break;
1833
1834 case VINF_GETOPT_NOT_OPTION:
1835 if (!pszFilenameOrUuid)
1836 pszFilenameOrUuid = ValueUnion.psz;
1837 else
1838 return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
1839 break;
1840
1841 default:
1842 if (c > 0)
1843 {
1844 if (RT_C_IS_PRINT(c))
1845 return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid option -%c", c);
1846 else
1847 return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid option case %i", c);
1848 }
1849 else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1850 return errorSyntax(USAGE_ENCRYPTMEDIUM, "unknown option: %s\n", ValueUnion.psz);
1851 else if (ValueUnion.pDef)
1852 return errorSyntax(USAGE_ENCRYPTMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1853 else
1854 return errorSyntax(USAGE_ENCRYPTMEDIUM, "error: %Rrs", c);
1855 }
1856 }
1857
1858 if (!pszFilenameOrUuid)
1859 return errorSyntax(USAGE_ENCRYPTMEDIUM, "Disk name or UUID required");
1860
1861 if (!pszPasswordNew && !pszPasswordOld)
1862 return errorSyntax(USAGE_ENCRYPTMEDIUM, "No password specified");
1863
1864 if ( (pszPasswordNew && !pszNewPasswordId)
1865 || (!pszPasswordNew && pszNewPasswordId))
1866 return errorSyntax(USAGE_ENCRYPTMEDIUM, "A new password must always have a valid identifier set at the same time");
1867
1868 if (pszPasswordNew)
1869 {
1870 if (!RTStrCmp(pszPasswordNew, "-"))
1871 {
1872 /* Get password from console. */
1873 RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordNew, "Enter new password:");
1874 if (rcExit == RTEXITCODE_FAILURE)
1875 return rcExit;
1876 }
1877 else
1878 {
1879 RTEXITCODE rcExit = readPasswordFile(pszPasswordNew, &strPasswordNew);
1880 if (rcExit == RTEXITCODE_FAILURE)
1881 {
1882 RTMsgError("Failed to read new password from file");
1883 return rcExit;
1884 }
1885 }
1886 }
1887
1888 if (pszPasswordOld)
1889 {
1890 if (!RTStrCmp(pszPasswordOld, "-"))
1891 {
1892 /* Get password from console. */
1893 RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordOld, "Enter old password:");
1894 if (rcExit == RTEXITCODE_FAILURE)
1895 return rcExit;
1896 }
1897 else
1898 {
1899 RTEXITCODE rcExit = readPasswordFile(pszPasswordOld, &strPasswordOld);
1900 if (rcExit == RTEXITCODE_FAILURE)
1901 {
1902 RTMsgError("Failed to read old password from file");
1903 return rcExit;
1904 }
1905 }
1906 }
1907
1908 /* Always open the medium if necessary, there is no other way. */
1909 rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1910 AccessMode_ReadWrite, hardDisk,
1911 false /* fForceNewUuidOnOpen */, false /* fSilent */);
1912 if (FAILED(rc))
1913 return RTEXITCODE_FAILURE;
1914 if (hardDisk.isNull())
1915 return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid hard disk reference, avoiding crash");
1916
1917 ComPtr<IProgress> progress;
1918 CHECK_ERROR(hardDisk, ChangeEncryption(Bstr(strPasswordOld).raw(), Bstr(pszCipher).raw(),
1919 Bstr(strPasswordNew).raw(), Bstr(pszNewPasswordId).raw(),
1920 progress.asOutParam()));
1921 if (SUCCEEDED(rc))
1922 rc = showProgress(progress);
1923 if (FAILED(rc))
1924 {
1925 if (rc == E_NOTIMPL)
1926 RTMsgError("Encrypt hard disk operation is not implemented!");
1927 else if (rc == VBOX_E_NOT_SUPPORTED)
1928 RTMsgError("Encrypt hard disk operation for this cipher is not implemented yet!");
1929 else if (!progress.isNull())
1930 CHECK_PROGRESS_ERROR(progress, ("Failed to encrypt hard disk"));
1931 else
1932 RTMsgError("Failed to encrypt hard disk!");
1933 }
1934
1935 return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1936}
1937
1938RTEXITCODE handleCheckMediumPassword(HandlerArg *a)
1939{
1940 HRESULT rc;
1941 ComPtr<IMedium> hardDisk;
1942 const char *pszFilenameOrUuid = NULL;
1943 Utf8Str strPassword;
1944
1945 if (a->argc != 2)
1946 return errorSyntax(USAGE_MEDIUMENCCHKPWD, "Invalid number of arguments: %d", a->argc);
1947
1948 pszFilenameOrUuid = a->argv[0];
1949
1950 if (!RTStrCmp(a->argv[1], "-"))
1951 {
1952 /* Get password from console. */
1953 RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, "Enter password:");
1954 if (rcExit == RTEXITCODE_FAILURE)
1955 return rcExit;
1956 }
1957 else
1958 {
1959 RTEXITCODE rcExit = readPasswordFile(a->argv[1], &strPassword);
1960 if (rcExit == RTEXITCODE_FAILURE)
1961 {
1962 RTMsgError("Failed to read password from file");
1963 return rcExit;
1964 }
1965 }
1966
1967 /* Always open the medium if necessary, there is no other way. */
1968 rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1969 AccessMode_ReadWrite, hardDisk,
1970 false /* fForceNewUuidOnOpen */, false /* fSilent */);
1971 if (FAILED(rc))
1972 return RTEXITCODE_FAILURE;
1973 if (hardDisk.isNull())
1974 return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid hard disk reference, avoiding crash");
1975
1976 CHECK_ERROR(hardDisk, CheckEncryptionPassword(Bstr(strPassword).raw()));
1977 if (SUCCEEDED(rc))
1978 RTPrintf("The given password is correct\n");
1979 return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1980}
1981
1982
1983/*********************************************************************************************************************************
1984* The mediumio command *
1985*********************************************************************************************************************************/
1986
1987/**
1988 * Common MediumIO options.
1989 */
1990typedef struct MEDIUMIOCOMMONOPT
1991{
1992 const char *pszFilenameOrUuid;
1993 DeviceType_T enmDeviceType;
1994 const char *pszPasswordFile;
1995} MEDIUMIOCOMMONOPT;
1996typedef MEDIUMIOCOMMONOPT *PMEDIUMIOCOMMONOPT;
1997typedef MEDIUMIOCOMMONOPT const *PCMEDIUMIOCOMMONOPT;
1998
1999/* For RTGETOPTDEF array initializer. */
2000#define MEDIUMIOCOMMONOPT_DEFS() \
2001 { "--disk", 'd', RTGETOPT_REQ_STRING }, \
2002 { "--harddisk", 'd', RTGETOPT_REQ_STRING }, \
2003 { "disk", 'd', RTGETOPT_REQ_STRING }, \
2004 { "harddisk", 'd', RTGETOPT_REQ_STRING }, \
2005 { "--dvd", 'D', RTGETOPT_REQ_STRING }, \
2006 { "--iso", 'D', RTGETOPT_REQ_STRING }, \
2007 { "dvd", 'D', RTGETOPT_REQ_STRING }, \
2008 { "iso", 'D', RTGETOPT_REQ_STRING }, \
2009 { "--floppy", 'f', RTGETOPT_REQ_STRING }, \
2010 { "floppy", 'f', RTGETOPT_REQ_STRING }, \
2011 { "--password-file", 'P', RTGETOPT_REQ_STRING }
2012
2013/* For option switch. */
2014#define MEDIUMIOCOMMONOPT_CASES(a_pCommonOpts) \
2015 case 'd': \
2016 (a_pCommonOpts)->enmDeviceType = DeviceType_HardDisk; \
2017 (a_pCommonOpts)->pszFilenameOrUuid = ValueUnion.psz; \
2018 break; \
2019 case 'D': \
2020 (a_pCommonOpts)->enmDeviceType = DeviceType_DVD; \
2021 (a_pCommonOpts)->pszFilenameOrUuid = ValueUnion.psz; \
2022 break; \
2023 case 'f': \
2024 (a_pCommonOpts)->enmDeviceType = DeviceType_Floppy; \
2025 (a_pCommonOpts)->pszFilenameOrUuid = ValueUnion.psz; \
2026 break; \
2027 case 'P': \
2028 (a_pCommonOpts)->pszPasswordFile = ValueUnion.psz; \
2029 break
2030
2031
2032/**
2033 * Worker for mediumio operations that returns a IMediumIO for the specified
2034 * medium.
2035 *
2036 * @returns Exit code.
2037 * @param pHandler The handler state structure (for IVirtualBox).
2038 * @param pCommonOpts Common mediumio options.
2039 * @param fWritable Whether to open writable (true) or read only
2040 * (false).
2041 * @param rPtrMediumIO Where to return the IMediumIO pointer.
2042 * @param pcbMedium Where to return the meidum size. Optional.
2043 */
2044static RTEXITCODE mediumIOOpenMediumForIO(HandlerArg *pHandler, PCMEDIUMIOCOMMONOPT pCommonOpts, bool fWritable,
2045 ComPtr<IMediumIO> &rPtrMediumIO, uint64_t *pcbMedium = NULL)
2046{
2047 /* Clear returns. */
2048 if (pcbMedium)
2049 *pcbMedium = 0;
2050 rPtrMediumIO.setNull();
2051
2052 /*
2053 * Make sure a medium was specified already.
2054 */
2055 if (pCommonOpts->enmDeviceType == DeviceType_Null)
2056 return errorSyntax("No medium specified!");
2057
2058 /*
2059 * Read the password.
2060 */
2061 Bstr bstrPassword;
2062 if (pCommonOpts->pszPasswordFile)
2063 {
2064 Utf8Str strPassword;
2065 RTEXITCODE rcExit;
2066 if (pCommonOpts->pszPasswordFile[0] == '-' && pCommonOpts->pszPasswordFile[1] == '\0')
2067 rcExit = readPasswordFromConsole(&strPassword, "Enter encryption password:");
2068 else
2069 rcExit = readPasswordFile(pCommonOpts->pszPasswordFile, &strPassword);
2070 if (rcExit != RTEXITCODE_SUCCESS)
2071 return rcExit;
2072 bstrPassword = strPassword;
2073 strPassword.assign(strPassword.length(), '*');
2074 }
2075
2076 /*
2077 * Open the medium and then get I/O access to it.
2078 */
2079 ComPtr<IMedium> ptrMedium;
2080 HRESULT hrc = openMedium(pHandler, pCommonOpts->pszFilenameOrUuid, pCommonOpts->enmDeviceType,
2081 fWritable ? AccessMode_ReadWrite : AccessMode_ReadOnly,
2082 ptrMedium, false /* fForceNewUuidOnOpen */, false /* fSilent */);
2083 if (SUCCEEDED(hrc))
2084 {
2085 CHECK_ERROR2I_STMT(ptrMedium, OpenForIO(fWritable, bstrPassword.raw(), rPtrMediumIO.asOutParam()), hrc = hrcCheck);
2086
2087 /*
2088 * If the size is requested get it after we've opened it.
2089 */
2090 if (pcbMedium && SUCCEEDED(hrc))
2091 {
2092 LONG64 cbLogical = 0;
2093 CHECK_ERROR2I_STMT(ptrMedium, COMGETTER(LogicalSize)(&cbLogical), hrc = hrcCheck);
2094 *pcbMedium = cbLogical;
2095 if (!SUCCEEDED(hrc))
2096 rPtrMediumIO.setNull();
2097 }
2098 }
2099
2100 if (bstrPassword.isNotEmpty())
2101 memset(bstrPassword.mutableRaw(), '*', bstrPassword.length() * sizeof(RTUTF16));
2102 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2103}
2104
2105
2106/**
2107 * mediumio formatfat
2108 */
2109static RTEXITCODE handleMediumIOFormatFat(HandlerArg *a, int iFirst, PMEDIUMIOCOMMONOPT pCommonOpts)
2110{
2111 /*
2112 * Parse the options.
2113 */
2114 bool fQuick = false;
2115 static const RTGETOPTDEF s_aOptions[] =
2116 {
2117 MEDIUMIOCOMMONOPT_DEFS(),
2118 { "--quick", 'q', RTGETOPT_REQ_NOTHING },
2119 };
2120
2121 RTGETOPTSTATE GetState;
2122 int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2123 AssertRC(rc);
2124 RTGETOPTUNION ValueUnion;
2125 while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
2126 {
2127 switch (rc)
2128 {
2129 MEDIUMIOCOMMONOPT_CASES(pCommonOpts);
2130
2131 case 'q':
2132 fQuick = true;
2133 break;
2134
2135 default:
2136 return errorGetOpt(rc, &ValueUnion);
2137 }
2138 }
2139
2140 /*
2141 * Open the medium for I/O and format it.
2142 */
2143 ComPtr<IMediumIO> ptrMediumIO;
2144 RTEXITCODE rcExit = mediumIOOpenMediumForIO(a, pCommonOpts, true /*fWritable*/, ptrMediumIO);
2145 if (rcExit != RTEXITCODE_SUCCESS)
2146 return rcExit;
2147 CHECK_ERROR2I_RET(ptrMediumIO, FormatFAT(fQuick), RTEXITCODE_FAILURE);
2148 return RTEXITCODE_SUCCESS;
2149}
2150
2151/**
2152 * mediumio cat
2153 */
2154static RTEXITCODE handleMediumIOCat(HandlerArg *a, int iFirst, PMEDIUMIOCOMMONOPT pCommonOpts)
2155{
2156 /*
2157 * Parse the options.
2158 */
2159 static const RTGETOPTDEF s_aOptions[] =
2160 {
2161 MEDIUMIOCOMMONOPT_DEFS(),
2162 { "--hex", 'H', RTGETOPT_REQ_NOTHING },
2163 { "--offset", 'o', RTGETOPT_REQ_UINT64 },
2164 { "--output", 'O', RTGETOPT_REQ_STRING },
2165 { "--size", 's', RTGETOPT_REQ_UINT64 },
2166 };
2167 bool fHex = false;
2168 uint64_t off = 0;
2169 const char *pszOutput = NULL;
2170 uint64_t cb = UINT64_MAX;
2171
2172 RTGETOPTSTATE GetState;
2173 int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2174 AssertRC(rc);
2175 RTGETOPTUNION ValueUnion;
2176 while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
2177 {
2178 switch (rc)
2179 {
2180 MEDIUMIOCOMMONOPT_CASES(pCommonOpts);
2181
2182 case 'H':
2183 fHex = true;
2184 break;
2185
2186 case 'o':
2187 off = ValueUnion.u64;
2188 break;
2189
2190 case 'O':
2191 pszOutput = ValueUnion.psz;
2192 break;
2193
2194 case 's':
2195 cb = ValueUnion.u64;
2196 break;
2197
2198 default:
2199 return errorGetOpt(rc, &ValueUnion);
2200 }
2201 }
2202
2203 /*
2204 * Open the medium for I/O.
2205 */
2206 ComPtr<IMediumIO> ptrMediumIO;
2207 uint64_t cbMedium;
2208 RTEXITCODE rcExit = mediumIOOpenMediumForIO(a, pCommonOpts, false /*fWritable*/, ptrMediumIO, &cbMedium);
2209 if (rcExit == RTEXITCODE_SUCCESS)
2210 {
2211 /*
2212 * Do we have an output file or do we write to stdout?
2213 */
2214 PRTSTREAM pOut = NULL;
2215 if (pszOutput && (pszOutput[0] != '-' || pszOutput[1] != '\0'))
2216 {
2217 int vrc = RTStrmOpen(pszOutput, fHex ? "wt" : "wb", &pOut);
2218 if (RT_FAILURE(vrc))
2219 rcExit = RTMsgErrorExitFailure("Error opening '%s' for writing: %Rrc", pszOutput, vrc);
2220 }
2221 else
2222 {
2223 pOut = g_pStdOut;
2224 if (!fHex)
2225 RTStrmSetMode(pOut, true, -1);
2226 }
2227
2228 if (rcExit == RTEXITCODE_SUCCESS)
2229 {
2230 /*
2231 * Adjust 'cb' now that we've got the medium size.
2232 */
2233 if (off >= cbMedium)
2234 {
2235 RTMsgWarning("Specified offset (%#RX64) is beyond the end of the medium (%#RX64)", off, cbMedium);
2236 cb = 0;
2237 }
2238 else if ( cb > cbMedium
2239 || cb + off > cbMedium)
2240 cb = cbMedium - off;
2241
2242 /*
2243 * Hex dump preps. (The duplication detection is making ASSUMPTIONS about
2244 * all the reads being a multiple of cchWidth, except for the final one.)
2245 */
2246 char abHexBuf[16] = { 0 };
2247 size_t cbHexBuf = 0;
2248 unsigned const cchWidth = RT_ELEMENTS(abHexBuf);
2249 uint64_t const offEndDupCheck = cb - cchWidth;
2250 uint64_t cDuplicates = 0;
2251
2252 /*
2253 * Do the reading.
2254 */
2255 while (cb > 0)
2256 {
2257 char szLine[32 + cchWidth * 4 + 32];
2258
2259 /* Do the reading. */
2260 uint32_t const cbToRead = (uint32_t)RT_MIN(cb, _128K);
2261 SafeArray<BYTE> SafeArrayBuf;
2262 HRESULT hrc = ptrMediumIO->Read(off, cbToRead, ComSafeArrayAsOutParam(SafeArrayBuf));
2263 if (FAILED(hrc))
2264 {
2265 RTStrPrintf(szLine, sizeof(szLine), "Read(%zu bytes at %#RX64)", cbToRead, off);
2266 com::GlueHandleComError(ptrMediumIO, szLine, hrc, __FILE__, __LINE__);
2267 break;
2268 }
2269
2270 /* Output the data. */
2271 size_t const cbReturned = SafeArrayBuf.size();
2272 if (cbReturned)
2273 {
2274 BYTE const *pbBuf = SafeArrayBuf.raw();
2275 int vrc = VINF_SUCCESS;
2276 if (!fHex)
2277 vrc = RTStrmWrite(pOut, pbBuf, cbReturned);
2278 else
2279 {
2280 /* hexdump -C */
2281 uint64_t offHex = off;
2282 uint64_t const offHexEnd = off + cbReturned;
2283 while (offHex < offHexEnd)
2284 {
2285 if ( offHex >= offEndDupCheck
2286 || cbHexBuf == 0
2287 || memcmp(pbBuf, abHexBuf, cchWidth) != 0
2288 || ( cDuplicates == 0
2289 && ( offHex + cchWidth >= offEndDupCheck
2290 || memcmp(pbBuf + cchWidth, pbBuf, cchWidth) != 0)) )
2291 {
2292 if (cDuplicates > 0)
2293 {
2294 RTStrmPrintf(pOut, "********** <ditto x %RU64>\n", cDuplicates);
2295 cDuplicates = 0;
2296 }
2297
2298 size_t cch = RTStrPrintf(szLine, sizeof(szLine), "%012RX64:", offHex);
2299 unsigned i;
2300 for (i = 0; i < cchWidth && offHex + i < offHexEnd; i++)
2301 {
2302 static const char s_szHexDigits[17] = "0123456789abcdef";
2303 szLine[cch++] = (i & 7) || i == 0 ? ' ' : '-';
2304 uint8_t const u8 = pbBuf[i];
2305 szLine[cch++] = s_szHexDigits[u8 >> 4];
2306 szLine[cch++] = s_szHexDigits[u8 & 0xf];
2307 }
2308 while (i++ < cchWidth)
2309 {
2310 szLine[cch++] = ' ';
2311 szLine[cch++] = ' ';
2312 szLine[cch++] = ' ';
2313 }
2314 szLine[cch++] = ' ';
2315
2316 for (i = 0; i < cchWidth && offHex + i < offHexEnd; i++)
2317 {
2318 uint8_t const u8 = pbBuf[i];
2319 szLine[cch++] = u8 < 127 && u8 >= 32 ? u8 : '.';
2320 }
2321 szLine[cch++] = '\n';
2322 szLine[cch] = '\0';
2323
2324 vrc = RTStrmWrite(pOut, szLine, cch);
2325 if (RT_FAILURE(vrc))
2326 break;
2327
2328
2329 /* copy bytes over to the duplication detection buffer. */
2330 cbHexBuf = (size_t)RT_MIN(cchWidth, offHexEnd - offHex);
2331 memcpy(abHexBuf, pbBuf, cbHexBuf);
2332 }
2333 else
2334 cDuplicates++;
2335
2336 /* Advance to next line. */
2337 pbBuf += cchWidth;
2338 offHex += cchWidth;
2339 }
2340 }
2341 if (RT_FAILURE(vrc))
2342 {
2343 rcExit = RTMsgErrorExitFailure("Error writing to '%s': %Rrc", pszOutput, vrc);
2344 break;
2345 }
2346 }
2347
2348 /* Advance. */
2349 if (cbReturned != cbToRead)
2350 {
2351 rcExit = RTMsgErrorExitFailure("Expected read() at offset %RU64 (%#RX64) to return %#zx bytes, only got %#zx!\n",
2352 off, off, cbReturned, cbToRead);
2353 break;
2354 }
2355 off += cbReturned;
2356 cb -= cbReturned;
2357 }
2358
2359 /*
2360 * Close output.
2361 */
2362 if (pOut != g_pStdOut)
2363 {
2364 int vrc = RTStrmClose(pOut);
2365 if (RT_FAILURE(vrc))
2366 rcExit = RTMsgErrorExitFailure("Error closing '%s': %Rrc", pszOutput, vrc);
2367 }
2368 else if (!fHex)
2369 RTStrmSetMode(pOut, false, -1);
2370 }
2371 }
2372 return rcExit;
2373}
2374
2375/**
2376 * mediumio stream
2377 */
2378static RTEXITCODE handleMediumIOStream(HandlerArg *a, int iFirst, PMEDIUMIOCOMMONOPT pCommonOpts)
2379{
2380 /*
2381 * Parse the options.
2382 */
2383 static const RTGETOPTDEF s_aOptions[] =
2384 {
2385 MEDIUMIOCOMMONOPT_DEFS(),
2386 { "--output", 'O', RTGETOPT_REQ_STRING },
2387 { "--format", 'F', RTGETOPT_REQ_STRING },
2388 { "--variant", 'v', RTGETOPT_REQ_STRING }
2389 };
2390 const char *pszOutput = NULL;
2391 MediumVariant_T enmMediumVariant = MediumVariant_Standard;
2392 Bstr strFormat;
2393
2394 RTGETOPTSTATE GetState;
2395 int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2396 AssertRC(rc);
2397 RTGETOPTUNION ValueUnion;
2398 while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
2399 {
2400 switch (rc)
2401 {
2402 MEDIUMIOCOMMONOPT_CASES(pCommonOpts);
2403
2404 case 'O':
2405 pszOutput = ValueUnion.psz;
2406 break;
2407 case 'F':
2408 strFormat = ValueUnion.psz;
2409 break;
2410 case 'v': // --variant
2411 {
2412 int vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
2413 if (RT_FAILURE(vrc))
2414 return errorArgument("Invalid medium variant '%s'", ValueUnion.psz);
2415 break;
2416 }
2417
2418 default:
2419 return errorGetOpt(rc, &ValueUnion);
2420 }
2421 }
2422
2423 /*
2424 * Open the medium for I/O.
2425 */
2426 ComPtr<IMediumIO> ptrMediumIO;
2427 uint64_t cbMedium;
2428 RTEXITCODE rcExit = mediumIOOpenMediumForIO(a, pCommonOpts, false /*fWritable*/, ptrMediumIO, &cbMedium);
2429 if (rcExit == RTEXITCODE_SUCCESS)
2430 {
2431 /*
2432 * Do we have an output file or do we write to stdout?
2433 */
2434 PRTSTREAM pOut = NULL;
2435 if (pszOutput && (pszOutput[0] != '-' || pszOutput[1] != '\0'))
2436 {
2437 int vrc = RTStrmOpen(pszOutput, "wb", &pOut);
2438 if (RT_FAILURE(vrc))
2439 rcExit = RTMsgErrorExitFailure("Error opening '%s' for writing: %Rrc", pszOutput, vrc);
2440 }
2441 else
2442 {
2443 pOut = g_pStdOut;
2444 RTStrmSetMode(pOut, true, -1);
2445 }
2446
2447 if (rcExit == RTEXITCODE_SUCCESS)
2448 {
2449 ComPtr<IDataStream> ptrDataStream;
2450 ComPtr<IProgress> ptrProgress;
2451
2452 com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8);
2453
2454 for (ULONG i = 0; i < l_variants.size(); ++i)
2455 {
2456 ULONG temp = enmMediumVariant;
2457 temp &= 1<<i;
2458 l_variants [i] = (MediumVariant_T)temp;
2459 }
2460
2461 HRESULT hrc = ptrMediumIO->ConvertToStream(strFormat.raw(), ComSafeArrayAsInParam(l_variants), 10 * _1M, ptrDataStream.asOutParam(), ptrProgress.asOutParam());
2462 if (hrc == S_OK)
2463 {
2464 /* Read until we reached the end of the stream. */
2465 for (;;)
2466 {
2467 SafeArray<BYTE> SafeArrayBuf;
2468
2469 hrc = ptrDataStream->Read(_64K, 0 /*Infinite wait*/, ComSafeArrayAsOutParam(SafeArrayBuf));
2470 if ( FAILED(hrc)
2471 || SafeArrayBuf.size() == 0)
2472 break;
2473
2474 /* Output the data. */
2475 size_t const cbReturned = SafeArrayBuf.size();
2476 if (cbReturned)
2477 {
2478 BYTE const *pbBuf = SafeArrayBuf.raw();
2479 int vrc = VINF_SUCCESS;
2480 vrc = RTStrmWrite(pOut, pbBuf, cbReturned);
2481 if (RT_FAILURE(vrc))
2482 {
2483 rcExit = RTMsgErrorExitFailure("Error writing to '%s': %Rrc", pszOutput, vrc);
2484 break;
2485 }
2486 }
2487
2488 /** @todo Check progress. */
2489 }
2490 }
2491 else
2492 {
2493 com::GlueHandleComError(ptrMediumIO, "ConvertToStream()", hrc, __FILE__, __LINE__);
2494 rcExit = RTEXITCODE_FAILURE;
2495 }
2496
2497 /*
2498 * Close output.
2499 */
2500 if (pOut != g_pStdOut)
2501 {
2502 int vrc = RTStrmClose(pOut);
2503 if (RT_FAILURE(vrc))
2504 rcExit = RTMsgErrorExitFailure("Error closing '%s': %Rrc", pszOutput, vrc);
2505 }
2506 else
2507 RTStrmSetMode(pOut, false, -1);
2508 }
2509 }
2510 return rcExit;
2511}
2512
2513
2514RTEXITCODE handleMediumIO(HandlerArg *a)
2515{
2516 /*
2517 * Parse image-option and sub-command.
2518 */
2519 static const RTGETOPTDEF s_aOptions[] =
2520 {
2521 MEDIUMIOCOMMONOPT_DEFS(),
2522 /* sub-commands */
2523 { "formatfat", 1000, RTGETOPT_REQ_NOTHING },
2524 { "cat", 1001, RTGETOPT_REQ_NOTHING },
2525 { "stream", 1002, RTGETOPT_REQ_NOTHING },
2526 };
2527 MEDIUMIOCOMMONOPT CommonOpts = { NULL, DeviceType_Null, NULL };
2528
2529 RTGETOPTSTATE GetState;
2530 int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0);
2531 AssertRC(rc);
2532 RTGETOPTUNION ValueUnion;
2533 while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
2534 {
2535 switch (rc)
2536 {
2537 MEDIUMIOCOMMONOPT_CASES(&CommonOpts);
2538
2539 /* Sub-commands: */
2540 case 1000:
2541 setCurrentSubcommand(HELP_SCOPE_MEDIUMIO_FORMATFAT);
2542 return handleMediumIOFormatFat(a, GetState.iNext, &CommonOpts);
2543 case 1001:
2544 setCurrentSubcommand(HELP_SCOPE_MEDIUMIO_CAT);
2545 return handleMediumIOCat(a, GetState.iNext, &CommonOpts);
2546 case 1002:
2547 setCurrentSubcommand(HELP_SCOPE_MEDIUMIO_STREAM);
2548 return handleMediumIOStream(a, GetState.iNext, &CommonOpts);
2549
2550 case VINF_GETOPT_NOT_OPTION:
2551 return errorUnknownSubcommand(ValueUnion.psz);
2552
2553 default:
2554 return errorGetOpt(rc, &ValueUnion);
2555 }
2556 }
2557 return errorNoSubcommand();
2558}
2559
2560#endif /* !VBOX_ONLY_DOCS */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette