VirtualBox

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

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

VBoxManage: --biossystemtimeoffset can be negative
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 67.3 KB
Line 
1/* $Id: VBoxManageModifyVM.cpp 24979 2009-11-26 08:36:53Z vboxsync $ */
2/** @file
3 * VBoxManage - Implementation of modifyvm command.
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/*******************************************************************************
23* Header Files *
24*******************************************************************************/
25#ifndef VBOX_ONLY_DOCS
26#include <VBox/com/com.h>
27#include <VBox/com/array.h>
28#include <VBox/com/ErrorInfo.h>
29#include <VBox/com/errorprint.h>
30#include <VBox/com/EventQueue.h>
31
32#include <VBox/com/VirtualBox.h>
33
34#include <vector>
35#include <list>
36#endif /* !VBOX_ONLY_DOCS */
37
38#include <iprt/cidr.h>
39#include <iprt/param.h>
40#include <iprt/path.h>
41#include <iprt/stream.h>
42#include <iprt/string.h>
43#include <iprt/getopt.h>
44#include <VBox/log.h>
45
46#include "VBoxManage.h"
47
48#ifndef VBOX_ONLY_DOCS
49using namespace com;
50
51
52/** @todo refine this after HDD changes; MSC 8.0/64 has trouble with handleModifyVM. */
53#if defined(_MSC_VER)
54# pragma optimize("g", off)
55#endif
56
57enum
58{
59 MODIFYVM_NAME = 1000,
60 MODIFYVM_OSTYPE,
61 MODIFYVM_MEMORY,
62 MODIFYVM_VRAM,
63 MODIFYVM_FIRMWARE,
64 MODIFYVM_ACPI,
65 MODIFYVM_IOAPIC,
66 MODIFYVM_PAE,
67 MODIFYVM_SYNTHCPU,
68 MODIFYVM_HWVIRTEX,
69 MODIFYVM_HWVIRTEXEXCLUSIVE,
70 MODIFYVM_NESTEDPAGING,
71 MODIFYVM_VTXVPID,
72 MODIFYVM_CPUS,
73 MODIFYVM_SETCPUID,
74 MODIFYVM_DELCPUID,
75 MODIFYVM_DELALLCPUID,
76 MODIFYVM_MONITORCOUNT,
77 MODIFYVM_ACCELERATE3D,
78 MODIFYVM_ACCELERATE2DVIDEO,
79 MODIFYVM_BIOSLOGOFADEIN,
80 MODIFYVM_BIOSLOGOFADEOUT,
81 MODIFYVM_BIOSLOGODISPLAYTIME,
82 MODIFYVM_BIOSLOGOIMAGEPATH,
83 MODIFYVM_BIOSBOOTMENU,
84 MODIFYVM_BIOSSYSTEMTIMEOFFSET,
85 MODIFYVM_BIOSPXEDEBUG,
86 MODIFYVM_BOOT,
87 MODIFYVM_HDA, // deprecated
88 MODIFYVM_HDB, // deprecated
89 MODIFYVM_HDD, // deprecated
90 MODIFYVM_IDECONTROLLER, // deprecated
91 MODIFYVM_SATAIDEEMULATION, // deprecated
92 MODIFYVM_SATAPORTCOUNT, // deprecated
93 MODIFYVM_SATAPORT, // deprecated
94 MODIFYVM_SATA, // deprecated
95 MODIFYVM_SCSIPORT, // deprecated
96 MODIFYVM_SCSITYPE, // deprecated
97 MODIFYVM_SCSI, // deprecated
98 MODIFYVM_DVDPASSTHROUGH, // deprecated
99 MODIFYVM_DVD, // deprecated
100 MODIFYVM_FLOPPY, // deprecated
101 MODIFYVM_NICTRACEFILE,
102 MODIFYVM_NICTRACE,
103 MODIFYVM_NICTYPE,
104 MODIFYVM_NICSPEED,
105 MODIFYVM_NIC,
106 MODIFYVM_CABLECONNECTED,
107 MODIFYVM_BRIDGEADAPTER,
108 MODIFYVM_HOSTONLYADAPTER,
109 MODIFYVM_INTNET,
110 MODIFYVM_NATNET,
111 MODIFYVM_MACADDRESS,
112 MODIFYVM_UARTMODE,
113 MODIFYVM_UART,
114 MODIFYVM_GUESTSTATISTICSINTERVAL,
115 MODIFYVM_GUESTMEMORYBALLOON,
116 MODIFYVM_AUDIOCONTROLLER,
117 MODIFYVM_AUDIO,
118 MODIFYVM_CLIPBOARD,
119 MODIFYVM_VRDPPORT,
120 MODIFYVM_VRDPADDRESS,
121 MODIFYVM_VRDPAUTHTYPE,
122 MODIFYVM_VRDPMULTICON,
123 MODIFYVM_VRDPREUSECON,
124 MODIFYVM_VRDP,
125 MODIFYVM_USBEHCI,
126 MODIFYVM_USB,
127 MODIFYVM_SNAPSHOTFOLDER,
128 MODIFYVM_TELEPORTER_ENABLED,
129 MODIFYVM_TELEPORTER_PORT,
130 MODIFYVM_TELEPORTER_ADDRESS,
131 MODIFYVM_TELEPORTER_PASSWORD,
132 MODIFYVM_HARDWARE_UUID
133};
134
135static const RTGETOPTDEF g_aModifyVMOptions[] =
136{
137 { "--name", MODIFYVM_NAME, RTGETOPT_REQ_STRING },
138 { "--ostype", MODIFYVM_OSTYPE, RTGETOPT_REQ_STRING },
139 { "--memory", MODIFYVM_MEMORY, RTGETOPT_REQ_UINT32 },
140 { "--vram", MODIFYVM_VRAM, RTGETOPT_REQ_UINT32 },
141 { "--firmware", MODIFYVM_FIRMWARE, RTGETOPT_REQ_STRING },
142 { "--acpi", MODIFYVM_ACPI, RTGETOPT_REQ_BOOL_ONOFF },
143 { "--ioapic", MODIFYVM_IOAPIC, RTGETOPT_REQ_BOOL_ONOFF },
144 { "--pae", MODIFYVM_PAE, RTGETOPT_REQ_BOOL_ONOFF },
145 { "--synthcpu", MODIFYVM_SYNTHCPU, RTGETOPT_REQ_BOOL_ONOFF },
146 { "--hwvirtex", MODIFYVM_HWVIRTEX, RTGETOPT_REQ_BOOL_ONOFF },
147 { "--hwvirtexexcl", MODIFYVM_HWVIRTEXEXCLUSIVE, RTGETOPT_REQ_BOOL_ONOFF },
148 { "--nestedpaging", MODIFYVM_NESTEDPAGING, RTGETOPT_REQ_BOOL_ONOFF },
149 { "--vtxvpid", MODIFYVM_VTXVPID, RTGETOPT_REQ_BOOL_ONOFF },
150 { "--cpuidset", MODIFYVM_SETCPUID, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX},
151 { "--cpuidremove", MODIFYVM_DELCPUID, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX},
152 { "--cpuidremoveall", MODIFYVM_DELALLCPUID, RTGETOPT_REQ_NOTHING},
153 { "--cpus", MODIFYVM_CPUS, RTGETOPT_REQ_UINT32 },
154 { "--monitorcount", MODIFYVM_MONITORCOUNT, RTGETOPT_REQ_UINT32 },
155 { "--accelerate3d", MODIFYVM_ACCELERATE3D, RTGETOPT_REQ_BOOL_ONOFF },
156 { "--accelerate2dvideo", MODIFYVM_ACCELERATE2DVIDEO, RTGETOPT_REQ_BOOL_ONOFF },
157 { "--bioslogofadein", MODIFYVM_BIOSLOGOFADEIN, RTGETOPT_REQ_BOOL_ONOFF },
158 { "--bioslogofadeout", MODIFYVM_BIOSLOGOFADEOUT, RTGETOPT_REQ_BOOL_ONOFF },
159 { "--bioslogodisplaytime", MODIFYVM_BIOSLOGODISPLAYTIME, RTGETOPT_REQ_UINT64 },
160 { "--bioslogoimagepath", MODIFYVM_BIOSLOGOIMAGEPATH, RTGETOPT_REQ_STRING },
161 { "--biosbootmenu", MODIFYVM_BIOSBOOTMENU, RTGETOPT_REQ_STRING },
162 { "--biossystemtimeoffset", MODIFYVM_BIOSSYSTEMTIMEOFFSET, RTGETOPT_REQ_INT64 },
163 { "--biospxedebug", MODIFYVM_BIOSPXEDEBUG, RTGETOPT_REQ_BOOL_ONOFF },
164 { "--boot", MODIFYVM_BOOT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
165 { "--hda", MODIFYVM_HDA, RTGETOPT_REQ_STRING },
166 { "--hdb", MODIFYVM_HDB, RTGETOPT_REQ_STRING },
167 { "--hdd", MODIFYVM_HDD, RTGETOPT_REQ_STRING },
168 { "--idecontroller", MODIFYVM_IDECONTROLLER, RTGETOPT_REQ_STRING },
169 { "--sataideemulation", MODIFYVM_SATAIDEEMULATION, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
170 { "--sataportcount", MODIFYVM_SATAPORTCOUNT, RTGETOPT_REQ_UINT32 },
171 { "--sataport", MODIFYVM_SATAPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
172 { "--sata", MODIFYVM_SATA, RTGETOPT_REQ_STRING },
173 { "--scsiport", MODIFYVM_SCSIPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
174 { "--scsitype", MODIFYVM_SCSITYPE, RTGETOPT_REQ_STRING },
175 { "--scsi", MODIFYVM_SCSI, RTGETOPT_REQ_STRING },
176 { "--dvdpassthrough", MODIFYVM_DVDPASSTHROUGH, RTGETOPT_REQ_STRING },
177 { "--dvd", MODIFYVM_DVD, RTGETOPT_REQ_STRING },
178 { "--floppy", MODIFYVM_FLOPPY, RTGETOPT_REQ_STRING },
179 { "--nictracefile", MODIFYVM_NICTRACEFILE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
180 { "--nictrace", MODIFYVM_NICTRACE, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
181 { "--nictype", MODIFYVM_NICTYPE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
182 { "--nicspeed", MODIFYVM_NICSPEED, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
183 { "--nic", MODIFYVM_NIC, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
184 { "--cableconnected", MODIFYVM_CABLECONNECTED, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
185 { "--bridgeadapter", MODIFYVM_BRIDGEADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
186 { "--hostonlyadapter", MODIFYVM_HOSTONLYADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
187 { "--intnet", MODIFYVM_INTNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
188 { "--natnet", MODIFYVM_NATNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
189 { "--macaddress", MODIFYVM_MACADDRESS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
190 { "--uartmode", MODIFYVM_UARTMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
191 { "--uart", MODIFYVM_UART, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
192 { "--gueststatisticsinterval", MODIFYVM_GUESTSTATISTICSINTERVAL, RTGETOPT_REQ_UINT32 },
193 { "--guestmemoryballoon", MODIFYVM_GUESTMEMORYBALLOON, RTGETOPT_REQ_UINT32 },
194 { "--audiocontroller", MODIFYVM_AUDIOCONTROLLER, RTGETOPT_REQ_STRING },
195 { "--audio", MODIFYVM_AUDIO, RTGETOPT_REQ_STRING },
196 { "--clipboard", MODIFYVM_CLIPBOARD, RTGETOPT_REQ_STRING },
197 { "--vrdpport", MODIFYVM_VRDPPORT, RTGETOPT_REQ_STRING },
198 { "--vrdpaddress", MODIFYVM_VRDPADDRESS, RTGETOPT_REQ_STRING },
199 { "--vrdpauthtype", MODIFYVM_VRDPAUTHTYPE, RTGETOPT_REQ_STRING },
200 { "--vrdpmulticon", MODIFYVM_VRDPMULTICON, RTGETOPT_REQ_BOOL_ONOFF },
201 { "--vrdpreusecon", MODIFYVM_VRDPREUSECON, RTGETOPT_REQ_BOOL_ONOFF },
202 { "--vrdp", MODIFYVM_VRDP, RTGETOPT_REQ_BOOL_ONOFF },
203 { "--usbehci", MODIFYVM_USBEHCI, RTGETOPT_REQ_BOOL_ONOFF },
204 { "--usb", MODIFYVM_USB, RTGETOPT_REQ_BOOL_ONOFF },
205 { "--snapshotfolder", MODIFYVM_SNAPSHOTFOLDER, RTGETOPT_REQ_STRING },
206 { "--teleporter", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
207 { "--teleporterenabled", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
208 { "--teleporterport", MODIFYVM_TELEPORTER_PORT, RTGETOPT_REQ_UINT32 },
209 { "--teleporteraddress", MODIFYVM_TELEPORTER_ADDRESS, RTGETOPT_REQ_STRING },
210 { "--teleporterpassword", MODIFYVM_TELEPORTER_PASSWORD, RTGETOPT_REQ_STRING },
211 { "--hardwareuuid", MODIFYVM_HARDWARE_UUID, RTGETOPT_REQ_STRING },
212};
213
214int handleModifyVM(HandlerArg *a)
215{
216 int c;
217 HRESULT rc;
218 Bstr name;
219 Bstr machineuuid (a->argv[0]);
220 RTGETOPTUNION ValueUnion;
221 RTGETOPTSTATE GetOptState;
222 ComPtr <IMachine> machine;
223 ComPtr <IBIOSSettings> biosSettings;
224
225 /* VM ID + at least one parameter. Parameter arguments are checked
226 * individually. */
227 if (a->argc < 2)
228 return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
229
230 /* Get the number of network adapters */
231 ULONG NetworkAdapterCount = 0;
232 {
233 ComPtr <ISystemProperties> info;
234 CHECK_ERROR_RET(a->virtualBox, COMGETTER(SystemProperties)(info.asOutParam()), 1);
235 CHECK_ERROR_RET(info, COMGETTER(NetworkAdapterCount)(&NetworkAdapterCount), 1);
236 }
237 ULONG SerialPortCount = 0;
238 {
239 ComPtr <ISystemProperties> info;
240 CHECK_ERROR_RET(a->virtualBox, COMGETTER(SystemProperties)(info.asOutParam()), 1);
241 CHECK_ERROR_RET(info, COMGETTER(SerialPortCount)(&SerialPortCount), 1);
242 }
243
244 /* try to find the given machine */
245 if (!Guid(machineuuid).isEmpty())
246 {
247 CHECK_ERROR_RET(a->virtualBox, GetMachine(machineuuid, machine.asOutParam()), 1);
248 }
249 else
250 {
251 CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()), 1);
252 machine->COMGETTER(Id)(machineuuid.asOutParam());
253 }
254
255 /* open a session for the VM */
256 CHECK_ERROR_RET(a->virtualBox, OpenSession(a->session, machineuuid), 1);
257
258 /* get the mutable session machine */
259 a->session->COMGETTER(Machine)(machine.asOutParam());
260 machine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
261
262 RTGetOptInit(&GetOptState, a->argc, a->argv, g_aModifyVMOptions,
263 RT_ELEMENTS(g_aModifyVMOptions), 1, 0 /* fFlags */);
264
265 while ( SUCCEEDED (rc)
266 && (c = RTGetOpt(&GetOptState, &ValueUnion)))
267 {
268 switch (c)
269 {
270 case MODIFYVM_NAME:
271 {
272 CHECK_ERROR(machine, COMSETTER(Name)(Bstr(ValueUnion.psz)));
273 break;
274 }
275 case MODIFYVM_OSTYPE:
276 {
277 ComPtr<IGuestOSType> guestOSType;
278 CHECK_ERROR(a->virtualBox, GetGuestOSType(Bstr(ValueUnion.psz), guestOSType.asOutParam()));
279 if (SUCCEEDED(rc) && guestOSType)
280 {
281 CHECK_ERROR(machine, COMSETTER(OSTypeId)(Bstr(ValueUnion.psz)));
282 }
283 else
284 {
285 errorArgument("Invalid guest OS type '%s'", Utf8Str(ValueUnion.psz).raw());
286 rc = E_FAIL;
287 }
288 break;
289 }
290
291 case MODIFYVM_MEMORY:
292 {
293 CHECK_ERROR(machine, COMSETTER(MemorySize)(ValueUnion.u32));
294 break;
295 }
296
297 case MODIFYVM_VRAM:
298 {
299 CHECK_ERROR(machine, COMSETTER(VRAMSize)(ValueUnion.u32));
300 break;
301 }
302
303 case MODIFYVM_FIRMWARE:
304 {
305 if (!strcmp(ValueUnion.psz, "efi"))
306 {
307 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI));
308 }
309 else if (!strcmp(ValueUnion.psz, "efi32"))
310 {
311 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI32));
312 }
313 else if (!strcmp(ValueUnion.psz, "efi64"))
314 {
315 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI64));
316 }
317 else if (!strcmp(ValueUnion.psz, "efidual"))
318 {
319 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFIDUAL));
320 }
321 else if (!strcmp(ValueUnion.psz, "bios"))
322 {
323 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_BIOS));
324 }
325 else
326 {
327 errorArgument("Invalid --firmware argument '%s'", ValueUnion.psz);
328 rc = E_FAIL;
329 }
330 break;
331 }
332
333 case MODIFYVM_ACPI:
334 {
335 CHECK_ERROR(biosSettings, COMSETTER(ACPIEnabled)(ValueUnion.f));
336 break;
337 }
338
339 case MODIFYVM_IOAPIC:
340 {
341 CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(ValueUnion.f));
342 break;
343 }
344
345 case MODIFYVM_PAE:
346 {
347 CHECK_ERROR(machine, SetCpuProperty(CpuPropertyType_PAE, ValueUnion.f));
348 break;
349 }
350
351 case MODIFYVM_SYNTHCPU:
352 {
353 CHECK_ERROR(machine, SetCpuProperty(CpuPropertyType_Synthetic, ValueUnion.f));
354 break;
355 }
356
357 case MODIFYVM_HWVIRTEX:
358 {
359 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_Enabled, ValueUnion.f));
360 break;
361 }
362
363 case MODIFYVM_HWVIRTEXEXCLUSIVE:
364 {
365 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_Exclusive, ValueUnion.f));
366 break;
367 }
368
369 case MODIFYVM_SETCPUID:
370 {
371 uint32_t id = ValueUnion.u32;
372 uint32_t aValue[4];
373
374 for (unsigned i = 0 ; i < 4 ; i++)
375 {
376 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX);
377 if (RT_FAILURE(vrc))
378 return errorSyntax(USAGE_MODIFYVM,
379 "Missing or Invalid argument to '%s'",
380 GetOptState.pDef->pszLong);
381 aValue[i] = ValueUnion.u32;
382 }
383 CHECK_ERROR(machine, SetCpuIdLeaf(id, aValue[0], aValue[1], aValue[2], aValue[3]));
384 break;
385 }
386
387 case MODIFYVM_DELCPUID:
388 {
389 CHECK_ERROR(machine, RemoveCpuIdLeaf(ValueUnion.u32));
390 break;
391 }
392
393 case MODIFYVM_DELALLCPUID:
394 {
395 CHECK_ERROR(machine, RemoveAllCpuIdLeafs());
396 break;
397 }
398
399 case MODIFYVM_NESTEDPAGING:
400 {
401 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, ValueUnion.f));
402 break;
403 }
404
405 case MODIFYVM_VTXVPID:
406 {
407 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_VPID, ValueUnion.f));
408 break;
409 }
410
411 case MODIFYVM_CPUS:
412 {
413 CHECK_ERROR(machine, COMSETTER(CPUCount)(ValueUnion.u32));
414 break;
415 }
416
417 case MODIFYVM_MONITORCOUNT:
418 {
419 CHECK_ERROR(machine, COMSETTER(MonitorCount)(ValueUnion.u32));
420 break;
421 }
422
423 case MODIFYVM_ACCELERATE3D:
424 {
425 CHECK_ERROR(machine, COMSETTER(Accelerate3DEnabled)(ValueUnion.f));
426 break;
427 }
428
429#ifdef VBOX_WITH_VIDEOHWACCEL
430 case MODIFYVM_ACCELERATE2DVIDEO:
431 {
432 CHECK_ERROR(machine, COMSETTER(Accelerate2DVideoEnabled)(ValueUnion.f));
433 break;
434 }
435#endif
436
437 case MODIFYVM_BIOSLOGOFADEIN:
438 {
439 CHECK_ERROR(biosSettings, COMSETTER(LogoFadeIn)(ValueUnion.f));
440 break;
441 }
442
443 case MODIFYVM_BIOSLOGOFADEOUT:
444 {
445 CHECK_ERROR(biosSettings, COMSETTER(LogoFadeOut)(ValueUnion.f));
446 break;
447 }
448
449 case MODIFYVM_BIOSLOGODISPLAYTIME:
450 {
451 CHECK_ERROR(biosSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u64));
452 break;
453 }
454
455 case MODIFYVM_BIOSLOGOIMAGEPATH:
456 {
457 CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz)));
458 break;
459 }
460
461 case MODIFYVM_BIOSBOOTMENU:
462 {
463 if (!strcmp(ValueUnion.psz, "disabled"))
464 {
465 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_Disabled));
466 }
467 else if (!strcmp(ValueUnion.psz, "menuonly"))
468 {
469 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MenuOnly));
470 }
471 else if (!strcmp(ValueUnion.psz, "messageandmenu"))
472 {
473 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MessageAndMenu));
474 }
475 else
476 {
477 errorArgument("Invalid --biosbootmenu argument '%s'", ValueUnion.psz);
478 rc = E_FAIL;
479 }
480 break;
481 }
482
483 case MODIFYVM_BIOSSYSTEMTIMEOFFSET:
484 {
485 CHECK_ERROR(biosSettings, COMSETTER(TimeOffset)(ValueUnion.i64));
486 break;
487 }
488
489 case MODIFYVM_BIOSPXEDEBUG:
490 {
491 CHECK_ERROR(biosSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f));
492 break;
493 }
494
495 case MODIFYVM_BOOT:
496 {
497 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > 4))
498 return errorSyntax(USAGE_MODIFYVM,
499 "Missing or Invalid boot slot number in '%s'",
500 GetOptState.pDef->pszLong);
501
502 if (!strcmp(ValueUnion.psz, "none"))
503 {
504 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Null));
505 }
506 else if (!strcmp(ValueUnion.psz, "floppy"))
507 {
508 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Floppy));
509 }
510 else if (!strcmp(ValueUnion.psz, "dvd"))
511 {
512 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_DVD));
513 }
514 else if (!strcmp(ValueUnion.psz, "disk"))
515 {
516 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_HardDisk));
517 }
518 else if (!strcmp(ValueUnion.psz, "net"))
519 {
520 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Network));
521 }
522 else
523 return errorArgument("Invalid boot device '%s'", ValueUnion.psz);
524
525 break;
526 }
527
528 case MODIFYVM_HDA: // deprecated
529 {
530 if (!strcmp(ValueUnion.psz, "none"))
531 {
532 machine->DetachDevice(Bstr("IDE Controller"), 0, 0);
533 }
534 else
535 {
536 /* first guess is that it's a UUID */
537 Bstr uuid(ValueUnion.psz);
538 ComPtr<IMedium> hardDisk;
539 rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
540 /* not successful? Then it must be a filename */
541 if (!hardDisk)
542 {
543 rc = a->virtualBox->FindHardDisk(Bstr(ValueUnion.psz), hardDisk.asOutParam());
544 if (FAILED(rc))
545 {
546 /* open the new hard disk object */
547 CHECK_ERROR(a->virtualBox,
548 OpenHardDisk(Bstr(ValueUnion.psz),
549 AccessMode_ReadWrite, false, Bstr(""),
550 false, Bstr(""), hardDisk.asOutParam()));
551 }
552 }
553 if (hardDisk)
554 {
555 hardDisk->COMGETTER(Id)(uuid.asOutParam());
556 CHECK_ERROR(machine, AttachDevice(Bstr("IDE Controller"), 0, 0, DeviceType_HardDisk, uuid));
557 }
558 else
559 rc = E_FAIL;
560 }
561 break;
562 }
563
564 case MODIFYVM_HDB: // deprecated
565 {
566 if (!strcmp(ValueUnion.psz, "none"))
567 {
568 machine->DetachDevice(Bstr("IDE Controller"), 0, 1);
569 }
570 else
571 {
572 /* first guess is that it's a UUID */
573 Bstr uuid(ValueUnion.psz);
574 ComPtr<IMedium> hardDisk;
575 rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
576 /* not successful? Then it must be a filename */
577 if (!hardDisk)
578 {
579 rc = a->virtualBox->FindHardDisk(Bstr(ValueUnion.psz), hardDisk.asOutParam());
580 if (FAILED(rc))
581 {
582 /* open the new hard disk object */
583 CHECK_ERROR(a->virtualBox,
584 OpenHardDisk(Bstr(ValueUnion.psz),
585 AccessMode_ReadWrite, false, Bstr(""),
586 false, Bstr(""), hardDisk.asOutParam()));
587 }
588 }
589 if (hardDisk)
590 {
591 hardDisk->COMGETTER(Id)(uuid.asOutParam());
592 CHECK_ERROR(machine, AttachDevice(Bstr("IDE Controller"), 0, 1, DeviceType_HardDisk, uuid));
593 }
594 else
595 rc = E_FAIL;
596 }
597 break;
598 }
599
600 case MODIFYVM_HDD: // deprecated
601 {
602 if (!strcmp(ValueUnion.psz, "none"))
603 {
604 machine->DetachDevice(Bstr("IDE Controller"), 1, 1);
605 }
606 else
607 {
608 /* first guess is that it's a UUID */
609 Bstr uuid(ValueUnion.psz);
610 ComPtr<IMedium> hardDisk;
611 rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
612 /* not successful? Then it must be a filename */
613 if (!hardDisk)
614 {
615 rc = a->virtualBox->FindHardDisk(Bstr(ValueUnion.psz), hardDisk.asOutParam());
616 if (FAILED(rc))
617 {
618 /* open the new hard disk object */
619 CHECK_ERROR(a->virtualBox,
620 OpenHardDisk(Bstr(ValueUnion.psz),
621 AccessMode_ReadWrite, false, Bstr(""),
622 false, Bstr(""), hardDisk.asOutParam()));
623 }
624 }
625 if (hardDisk)
626 {
627 hardDisk->COMGETTER(Id)(uuid.asOutParam());
628 CHECK_ERROR(machine, AttachDevice(Bstr("IDE Controller"), 1, 1, DeviceType_HardDisk, uuid));
629 }
630 else
631 rc = E_FAIL;
632 }
633 break;
634 }
635
636 case MODIFYVM_IDECONTROLLER: // deprecated
637 {
638 ComPtr<IStorageController> storageController;
639 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("IDE Controller"),
640 storageController.asOutParam()));
641
642 if (!RTStrICmp(ValueUnion.psz, "PIIX3"))
643 {
644 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX3));
645 }
646 else if (!RTStrICmp(ValueUnion.psz, "PIIX4"))
647 {
648 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX4));
649 }
650 else if (!RTStrICmp(ValueUnion.psz, "ICH6"))
651 {
652 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_ICH6));
653 }
654 else
655 {
656 errorArgument("Invalid --idecontroller argument '%s'", ValueUnion.psz);
657 rc = E_FAIL;
658 }
659 break;
660 }
661
662 case MODIFYVM_SATAIDEEMULATION: // deprecated
663 {
664 ComPtr<IStorageController> SataCtl;
665 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA"), SataCtl.asOutParam()));
666
667 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > 4))
668 return errorSyntax(USAGE_MODIFYVM,
669 "Missing or Invalid SATA boot slot number in '%s'",
670 GetOptState.pDef->pszLong);
671
672 if ((ValueUnion.u32 < 1) && (ValueUnion.u32 > 30))
673 return errorSyntax(USAGE_MODIFYVM,
674 "Missing or Invalid SATA port number in '%s'",
675 GetOptState.pDef->pszLong);
676
677 if (SUCCEEDED(rc))
678 CHECK_ERROR(SataCtl, SetIDEEmulationPort(GetOptState.uIndex, ValueUnion.u32));
679
680 break;
681 }
682
683 case MODIFYVM_SATAPORTCOUNT: // deprecated
684 {
685 ComPtr<IStorageController> SataCtl;
686 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA"), SataCtl.asOutParam()));
687
688 if (SUCCEEDED(rc) && ValueUnion.u32 > 0)
689 CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32));
690
691 break;
692 }
693
694 case MODIFYVM_SATAPORT: // deprecated
695 {
696 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > 30))
697 return errorSyntax(USAGE_MODIFYVM,
698 "Missing or Invalid SATA port number in '%s'",
699 GetOptState.pDef->pszLong);
700
701 if (!strcmp(ValueUnion.psz, "none"))
702 {
703 machine->DetachDevice(Bstr("SATA"), GetOptState.uIndex, 0);
704 }
705 else
706 {
707 /* first guess is that it's a UUID */
708 Bstr uuid(ValueUnion.psz);
709 ComPtr<IMedium> hardDisk;
710 rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
711 /* not successful? Then it must be a filename */
712 if (!hardDisk)
713 {
714 rc = a->virtualBox->FindHardDisk(Bstr(ValueUnion.psz), hardDisk.asOutParam());
715 if (FAILED(rc))
716 {
717 /* open the new hard disk object */
718 CHECK_ERROR(a->virtualBox,
719 OpenHardDisk(Bstr(ValueUnion.psz), AccessMode_ReadWrite,
720 false, Bstr(""), false,
721 Bstr(""), hardDisk.asOutParam()));
722 }
723 }
724 if (hardDisk)
725 {
726 hardDisk->COMGETTER(Id)(uuid.asOutParam());
727 CHECK_ERROR(machine,
728 AttachDevice(Bstr("SATA"), GetOptState.uIndex,
729 0, DeviceType_HardDisk, uuid));
730 }
731 else
732 rc = E_FAIL;
733 }
734 break;
735 }
736
737 case MODIFYVM_SATA: // deprecated
738 {
739 if (!strcmp(ValueUnion.psz, "on") || !strcmp(ValueUnion.psz, "enable"))
740 {
741 ComPtr<IStorageController> ctl;
742 CHECK_ERROR(machine, AddStorageController(Bstr("SATA"), StorageBus_SATA, ctl.asOutParam()));
743 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
744 }
745 else if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
746 CHECK_ERROR(machine, RemoveStorageController(Bstr("SATA")));
747 else
748 return errorArgument("Invalid --usb argument '%s'", ValueUnion.psz);
749 break;
750 }
751
752 case MODIFYVM_SCSIPORT: // deprecated
753 {
754 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > 16))
755 return errorSyntax(USAGE_MODIFYVM,
756 "Missing or Invalid SCSI port number in '%s'",
757 GetOptState.pDef->pszLong);
758
759 if (!strcmp(ValueUnion.psz, "none"))
760 {
761 rc = machine->DetachDevice(Bstr("LsiLogic"), GetOptState.uIndex, 0);
762 if (FAILED(rc))
763 CHECK_ERROR(machine, DetachDevice(Bstr("BusLogic"), GetOptState.uIndex, 0));
764 }
765 else
766 {
767 /* first guess is that it's a UUID */
768 Bstr uuid(ValueUnion.psz);
769 ComPtr<IMedium> hardDisk;
770 rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
771 /* not successful? Then it must be a filename */
772 if (!hardDisk)
773 {
774 rc = a->virtualBox->FindHardDisk(Bstr(ValueUnion.psz), hardDisk.asOutParam());
775 if (FAILED(rc))
776 {
777 /* open the new hard disk object */
778 CHECK_ERROR(a->virtualBox,
779 OpenHardDisk(Bstr(ValueUnion.psz),
780 AccessMode_ReadWrite, false, Bstr(""),
781 false, Bstr(""), hardDisk.asOutParam()));
782 }
783 }
784 if (hardDisk)
785 {
786 hardDisk->COMGETTER(Id)(uuid.asOutParam());
787 rc = machine->AttachDevice(Bstr("LsiLogic"), GetOptState.uIndex, 0, DeviceType_HardDisk, uuid);
788 if (FAILED(rc))
789 CHECK_ERROR(machine,
790 AttachDevice(Bstr("BusLogic"),
791 GetOptState.uIndex, 0,
792 DeviceType_HardDisk, uuid));
793 }
794 else
795 rc = E_FAIL;
796 }
797 break;
798 }
799
800 case MODIFYVM_SCSITYPE: // deprecated
801 {
802 ComPtr<IStorageController> ctl;
803
804 if (!RTStrICmp(ValueUnion.psz, "LsiLogic"))
805 {
806 rc = machine->RemoveStorageController(Bstr("BusLogic"));
807 if (FAILED(rc))
808 CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic")));
809
810 CHECK_ERROR(machine,
811 AddStorageController(Bstr("LsiLogic"),
812 StorageBus_SCSI,
813 ctl.asOutParam()));
814
815 if (SUCCEEDED(rc))
816 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
817 }
818 else if (!RTStrICmp(ValueUnion.psz, "BusLogic"))
819 {
820 rc = machine->RemoveStorageController(Bstr("LsiLogic"));
821 if (FAILED(rc))
822 CHECK_ERROR(machine, RemoveStorageController(Bstr("BusLogic")));
823
824 CHECK_ERROR(machine,
825 AddStorageController(Bstr("BusLogic"),
826 StorageBus_SCSI,
827 ctl.asOutParam()));
828
829 if (SUCCEEDED(rc))
830 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
831 }
832 else
833 return errorArgument("Invalid --scsitype argument '%s'", ValueUnion.psz);
834 break;
835 }
836
837 case MODIFYVM_SCSI: // deprecated
838 {
839 if (!strcmp(ValueUnion.psz, "on") || !strcmp(ValueUnion.psz, "enable"))
840 {
841 ComPtr<IStorageController> ctl;
842
843 CHECK_ERROR(machine, AddStorageController(Bstr("BusLogic"), StorageBus_SCSI, ctl.asOutParam()));
844 if (SUCCEEDED(rc))
845 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
846 }
847 else if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
848 {
849 rc = machine->RemoveStorageController(Bstr("BusLogic"));
850 if (FAILED(rc))
851 CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic")));
852 }
853 break;
854 }
855
856 case MODIFYVM_DVDPASSTHROUGH: // deprecated
857 {
858 CHECK_ERROR(machine, PassthroughDevice(Bstr("IDE Controller"), 1, 0, !strcmp(ValueUnion.psz, "on")));
859 break;
860 }
861
862 case MODIFYVM_DVD: // deprecated
863 {
864 ComPtr<IMedium> dvdMedium;
865 Bstr uuid(ValueUnion.psz);
866
867 /* unmount? */
868 if (!strcmp(ValueUnion.psz, "none"))
869 {
870 /* nothing to do, NULL object will cause unmount */
871 }
872 /* host drive? */
873 else if (!strncmp(ValueUnion.psz, "host:", 5))
874 {
875 ComPtr<IHost> host;
876 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
877 rc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5), dvdMedium.asOutParam());
878 if (!dvdMedium)
879 {
880 /* 2nd try: try with the real name, important on Linux+libhal */
881 char szPathReal[RTPATH_MAX];
882 if (RT_FAILURE(RTPathReal(ValueUnion.psz + 5, szPathReal, sizeof(szPathReal))))
883 {
884 errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
885 rc = E_FAIL;
886 break;
887 }
888 rc = host->FindHostDVDDrive(Bstr(szPathReal), dvdMedium.asOutParam());
889 if (!dvdMedium)
890 {
891 errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
892 rc = E_FAIL;
893 break;
894 }
895 }
896 }
897 else
898 {
899 /* first assume it's a UUID */
900 rc = a->virtualBox->GetDVDImage(uuid, dvdMedium.asOutParam());
901 if (FAILED(rc) || !dvdMedium)
902 {
903 /* must be a filename, check if it's in the collection */
904 rc = a->virtualBox->FindDVDImage(Bstr(ValueUnion.psz), dvdMedium.asOutParam());
905 /* not registered, do that on the fly */
906 if (!dvdMedium)
907 {
908 Bstr emptyUUID;
909 CHECK_ERROR(a->virtualBox, OpenDVDImage(Bstr(ValueUnion.psz),
910 emptyUUID, dvdMedium.asOutParam()));
911 }
912 }
913 if (!dvdMedium)
914 {
915 rc = E_FAIL;
916 break;
917 }
918 }
919
920 /** @todo generalize this, allow arbitrary number of DVD drives
921 * and as a consequence multiple attachments and different
922 * storage controllers. */
923 if (dvdMedium)
924 dvdMedium->COMGETTER(Id)(uuid.asOutParam());
925 CHECK_ERROR(machine, MountMedium(Bstr("IDE Controller"), 1, 0, uuid, FALSE /* aForce */));
926 break;
927 }
928
929 case MODIFYVM_FLOPPY: // deprecated
930 {
931 Bstr uuid(ValueUnion.psz);
932 ComPtr<IMedium> floppyMedium;
933 ComPtr<IMediumAttachment> floppyAttachment;
934 machine->GetMediumAttachment(Bstr("Floppy Controller"), 0, 0, floppyAttachment.asOutParam());
935
936 /* disable? */
937 if (!strcmp(ValueUnion.psz, "disabled"))
938 {
939 /* disable the controller */
940 if (floppyAttachment)
941 CHECK_ERROR(machine, DetachDevice(Bstr("Floppy Controller"), 0, 0));
942 }
943 else
944 {
945 /* enable the controller */
946 if (!floppyAttachment)
947 CHECK_ERROR(machine, AttachDevice(Bstr("Floppy Controller"), 0, 0, DeviceType_Floppy, NULL));
948
949 /* unmount? */
950 if ( !strcmp(ValueUnion.psz, "none")
951 || !strcmp(ValueUnion.psz, "empty")) // deprecated
952 {
953 /* nothing to do, NULL object will cause unmount */
954 }
955 /* host drive? */
956 else if (!strncmp(ValueUnion.psz, "host:", 5))
957 {
958 ComPtr<IHost> host;
959 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
960 rc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5), floppyMedium.asOutParam());
961 if (!floppyMedium)
962 {
963 errorArgument("Invalid host floppy drive name \"%s\"", ValueUnion.psz + 5);
964 rc = E_FAIL;
965 break;
966 }
967 }
968 else
969 {
970 /* first assume it's a UUID */
971 rc = a->virtualBox->GetFloppyImage(uuid, floppyMedium.asOutParam());
972 if (FAILED(rc) || !floppyMedium)
973 {
974 /* must be a filename, check if it's in the collection */
975 rc = a->virtualBox->FindFloppyImage(Bstr(ValueUnion.psz), floppyMedium.asOutParam());
976 /* not registered, do that on the fly */
977 if (!floppyMedium)
978 {
979 Bstr emptyUUID;
980 CHECK_ERROR(a->virtualBox,
981 OpenFloppyImage(Bstr(ValueUnion.psz),
982 emptyUUID,
983 floppyMedium.asOutParam()));
984 }
985 }
986 if (!floppyMedium)
987 {
988 rc = E_FAIL;
989 break;
990 }
991 }
992 floppyMedium->COMGETTER(Id)(uuid.asOutParam());
993 CHECK_ERROR(machine, MountMedium(Bstr("Floppy Controller"), 0, 0, uuid, FALSE /* aForce */));
994 }
995 break;
996 }
997
998 case MODIFYVM_NICTRACEFILE:
999 {
1000 ComPtr<INetworkAdapter> nic;
1001
1002 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > NetworkAdapterCount))
1003 return errorSyntax(USAGE_MODIFYVM,
1004 "Missing or Invalid NIC slot number in '%s'",
1005 GetOptState.pDef->pszLong);
1006
1007 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1008 ASSERT(nic);
1009
1010 CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz)));
1011 break;
1012 }
1013
1014 case MODIFYVM_NICTRACE:
1015 {
1016 ComPtr<INetworkAdapter> nic;
1017
1018 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > NetworkAdapterCount))
1019 return errorSyntax(USAGE_MODIFYVM,
1020 "Missing or Invalid NIC slot number in '%s'",
1021 GetOptState.pDef->pszLong);
1022
1023 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1024 ASSERT(nic);
1025
1026 CHECK_ERROR(nic, COMSETTER(TraceEnabled)(ValueUnion.f));
1027 break;
1028 }
1029
1030 case MODIFYVM_NICTYPE:
1031 {
1032 ComPtr<INetworkAdapter> nic;
1033
1034 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > NetworkAdapterCount))
1035 return errorSyntax(USAGE_MODIFYVM,
1036 "Missing or Invalid NIC slot number in '%s'",
1037 GetOptState.pDef->pszLong);
1038
1039 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1040 ASSERT(nic);
1041
1042 if (!strcmp(ValueUnion.psz, "Am79C970A"))
1043 {
1044 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C970A));
1045 }
1046 else if (!strcmp(ValueUnion.psz, "Am79C973"))
1047 {
1048 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C973));
1049 }
1050#ifdef VBOX_WITH_E1000
1051 else if (!strcmp(ValueUnion.psz, "82540EM"))
1052 {
1053 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82540EM));
1054 }
1055 else if (!strcmp(ValueUnion.psz, "82543GC"))
1056 {
1057 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82543GC));
1058 }
1059 else if (!strcmp(ValueUnion.psz, "82545EM"))
1060 {
1061 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82545EM));
1062 }
1063#endif
1064#ifdef VBOX_WITH_VIRTIO
1065 else if (!strcmp(ValueUnion.psz, "virtio"))
1066 {
1067 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Virtio));
1068 }
1069#endif /* VBOX_WITH_VIRTIO */
1070 else
1071 {
1072 errorArgument("Invalid NIC type '%s' specified for NIC %lu", ValueUnion.psz, GetOptState.uIndex);
1073 rc = E_FAIL;
1074 }
1075 break;
1076 }
1077
1078 case MODIFYVM_NICSPEED:
1079 {
1080 ComPtr<INetworkAdapter> nic;
1081
1082 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > NetworkAdapterCount))
1083 return errorSyntax(USAGE_MODIFYVM,
1084 "Missing or Invalid NIC slot number in '%s'",
1085 GetOptState.pDef->pszLong);
1086
1087 if ((ValueUnion.u32 < 1000) && (ValueUnion.u32 > 4000000))
1088 {
1089 errorArgument("Invalid --nicspeed%lu argument '%u'", GetOptState.uIndex, ValueUnion.u32);
1090 rc = E_FAIL;
1091 break;
1092 }
1093
1094 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1095 ASSERT(nic);
1096
1097 CHECK_ERROR(nic, COMSETTER(LineSpeed)(ValueUnion.u32));
1098 break;
1099 }
1100
1101 case MODIFYVM_NIC:
1102 {
1103 ComPtr<INetworkAdapter> nic;
1104
1105 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > NetworkAdapterCount))
1106 return errorSyntax(USAGE_MODIFYVM,
1107 "Missing or Invalid NIC slot number in '%s'",
1108 GetOptState.pDef->pszLong);
1109
1110 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1111 ASSERT(nic);
1112
1113 if (!strcmp(ValueUnion.psz, "none"))
1114 {
1115 CHECK_ERROR(nic, COMSETTER(Enabled)(FALSE));
1116 }
1117 else if (!strcmp(ValueUnion.psz, "null"))
1118 {
1119 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1120 CHECK_ERROR(nic, Detach());
1121 }
1122 else if (!strcmp(ValueUnion.psz, "nat"))
1123 {
1124 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1125 CHECK_ERROR(nic, AttachToNAT());
1126 }
1127 else if ( !strcmp(ValueUnion.psz, "bridged")
1128 || !strcmp(ValueUnion.psz, "hostif")) /* backward compatibility */
1129 {
1130 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1131 CHECK_ERROR(nic, AttachToBridgedInterface());
1132 }
1133 else if (!strcmp(ValueUnion.psz, "intnet"))
1134 {
1135 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1136 CHECK_ERROR(nic, AttachToInternalNetwork());
1137 }
1138#if defined(VBOX_WITH_NETFLT)
1139 else if (!strcmp(ValueUnion.psz, "hostonly"))
1140 {
1141
1142 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1143 CHECK_ERROR(nic, AttachToHostOnlyInterface());
1144 }
1145#endif
1146 else
1147 {
1148 errorArgument("Invalid type '%s' specfied for NIC %lu", ValueUnion.psz, GetOptState.uIndex);
1149 rc = E_FAIL;
1150 }
1151 break;
1152 }
1153
1154 case MODIFYVM_CABLECONNECTED:
1155 {
1156 ComPtr<INetworkAdapter> nic;
1157
1158 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > NetworkAdapterCount))
1159 return errorSyntax(USAGE_MODIFYVM,
1160 "Missing or Invalid NIC slot number in '%s'",
1161 GetOptState.pDef->pszLong);
1162
1163 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1164 ASSERT(nic);
1165
1166 CHECK_ERROR(nic, COMSETTER(CableConnected)(ValueUnion.f));
1167 break;
1168 }
1169
1170 case MODIFYVM_BRIDGEADAPTER:
1171 case MODIFYVM_HOSTONLYADAPTER:
1172 {
1173 ComPtr<INetworkAdapter> nic;
1174
1175 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > NetworkAdapterCount))
1176 return errorSyntax(USAGE_MODIFYVM,
1177 "Missing or Invalid NIC slot number in '%s'",
1178 GetOptState.pDef->pszLong);
1179
1180 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1181 ASSERT(nic);
1182
1183 /* remove it? */
1184 if (!strcmp(ValueUnion.psz, "none"))
1185 {
1186 CHECK_ERROR(nic, COMSETTER(HostInterface)(NULL));
1187 }
1188 else
1189 {
1190 CHECK_ERROR(nic, COMSETTER(HostInterface)(Bstr(ValueUnion.psz)));
1191 }
1192 break;
1193 }
1194
1195 case MODIFYVM_INTNET:
1196 {
1197 ComPtr<INetworkAdapter> nic;
1198
1199 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > NetworkAdapterCount))
1200 return errorSyntax(USAGE_MODIFYVM,
1201 "Missing or Invalid NIC slot number in '%s'",
1202 GetOptState.pDef->pszLong);
1203
1204 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1205 ASSERT(nic);
1206
1207 /* remove it? */
1208 if (!strcmp(ValueUnion.psz, "none"))
1209 {
1210 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(NULL));
1211 }
1212 else
1213 {
1214 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz)));
1215 }
1216 break;
1217 }
1218
1219 case MODIFYVM_NATNET:
1220 {
1221 ComPtr<INetworkAdapter> nic;
1222
1223 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > NetworkAdapterCount))
1224 return errorSyntax(USAGE_MODIFYVM,
1225 "Missing or Invalid NIC slot number in '%s'",
1226 GetOptState.pDef->pszLong);
1227
1228 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1229 ASSERT(nic);
1230
1231 CHECK_ERROR(nic, COMSETTER(NATNetwork)(Bstr(ValueUnion.psz)));
1232
1233 break;
1234 }
1235
1236 case MODIFYVM_MACADDRESS:
1237 {
1238 ComPtr<INetworkAdapter> nic;
1239
1240 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > NetworkAdapterCount))
1241 return errorSyntax(USAGE_MODIFYVM,
1242 "Missing or Invalid NIC slot number in '%s'",
1243 GetOptState.pDef->pszLong);
1244
1245 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1246 ASSERT(nic);
1247
1248 /* generate one? */
1249 if (!strcmp(ValueUnion.psz, "auto"))
1250 {
1251 CHECK_ERROR(nic, COMSETTER(MACAddress)(NULL));
1252 }
1253 else
1254 {
1255 CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz)));
1256 }
1257 break;
1258 }
1259
1260 case MODIFYVM_UARTMODE:
1261 {
1262 ComPtr<ISerialPort> uart;
1263 char *pszIRQ = NULL;
1264
1265 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > SerialPortCount))
1266 return errorSyntax(USAGE_MODIFYVM,
1267 "Missing or Invalid Serial Port number in '%s'",
1268 GetOptState.pDef->pszLong);
1269
1270 CHECK_ERROR_BREAK(machine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
1271 ASSERT(uart);
1272
1273 if (!strcmp(ValueUnion.psz, "disconnected"))
1274 {
1275 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected));
1276 }
1277 else if ( !strcmp(ValueUnion.psz, "server")
1278 || !strcmp(ValueUnion.psz, "client")
1279 || !strcmp(ValueUnion.psz, "file"))
1280 {
1281 const char *pszMode = ValueUnion.psz;
1282
1283 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
1284 if (RT_FAILURE(vrc))
1285 return errorSyntax(USAGE_MODIFYVM,
1286 "Missing or Invalid argument to '%s'",
1287 GetOptState.pDef->pszLong);
1288
1289 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz)));
1290
1291 if (!strcmp(pszMode, "server"))
1292 {
1293 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
1294 CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
1295 }
1296 else if (!strcmp(pszMode, "client"))
1297 {
1298 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
1299 CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
1300 }
1301 else if (!strcmp(pszMode, "file"))
1302 {
1303 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile));
1304 }
1305 }
1306 else
1307 {
1308 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz)));
1309 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice));
1310 }
1311 break;
1312 }
1313
1314 case MODIFYVM_UART:
1315 {
1316 ComPtr<ISerialPort> uart;
1317
1318 if ((GetOptState.uIndex < 1) && (GetOptState.uIndex > SerialPortCount))
1319 return errorSyntax(USAGE_MODIFYVM,
1320 "Missing or Invalid Serial Port number in '%s'",
1321 GetOptState.pDef->pszLong);
1322
1323 CHECK_ERROR_BREAK(machine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
1324 ASSERT(uart);
1325
1326 if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
1327 CHECK_ERROR(uart, COMSETTER(Enabled)(FALSE));
1328 else
1329 {
1330 const char *pszIOBase = ValueUnion.psz;
1331 uint32_t uVal = 0;
1332
1333 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_UART;
1334 if (RT_FAILURE(vrc))
1335 return errorSyntax(USAGE_MODIFYVM,
1336 "Missing or Invalid argument to '%s'",
1337 GetOptState.pDef->pszLong);
1338
1339 CHECK_ERROR(uart, COMSETTER(IRQ)(ValueUnion.u32));
1340
1341 vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
1342 if (vrc != VINF_SUCCESS || uVal == 0)
1343 return errorArgument("Error parsing UART I/O base '%s'", pszIOBase);
1344 CHECK_ERROR(uart, COMSETTER(IOBase)(uVal));
1345
1346 CHECK_ERROR(uart, COMSETTER(Enabled)(TRUE));
1347 }
1348 break;
1349 }
1350
1351 case MODIFYVM_GUESTSTATISTICSINTERVAL:
1352 {
1353 CHECK_ERROR(machine, COMSETTER(StatisticsUpdateInterval)(ValueUnion.u32));
1354 break;
1355 }
1356
1357#ifdef VBOX_WITH_MEM_BALLOONING
1358 case MODIFYVM_GUESTMEMORYBALLOON:
1359 {
1360 CHECK_ERROR(machine, COMSETTER(MemoryBalloonSize)(ValueUnion.u32));
1361 break;
1362 }
1363#endif
1364
1365 case MODIFYVM_AUDIOCONTROLLER:
1366 {
1367 ComPtr<IAudioAdapter> audioAdapter;
1368 machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
1369 ASSERT(audioAdapter);
1370
1371 if (!strcmp(ValueUnion.psz, "sb16"))
1372 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_SB16));
1373 else if (!strcmp(ValueUnion.psz, "ac97"))
1374 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_AC97));
1375 else
1376 {
1377 errorArgument("Invalid --audiocontroller argument '%s'", ValueUnion.psz);
1378 rc = E_FAIL;
1379 }
1380 break;
1381 }
1382
1383 case MODIFYVM_AUDIO:
1384 {
1385 ComPtr<IAudioAdapter> audioAdapter;
1386 machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
1387 ASSERT(audioAdapter);
1388
1389 /* disable? */
1390 if (!strcmp(ValueUnion.psz, "none"))
1391 {
1392 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(false));
1393 }
1394 else if (!strcmp(ValueUnion.psz, "null"))
1395 {
1396 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Null));
1397 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1398 }
1399#ifdef RT_OS_WINDOWS
1400#ifdef VBOX_WITH_WINMM
1401 else if (!strcmp(ValueUnion.psz, "winmm"))
1402 {
1403 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WinMM));
1404 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1405 }
1406#endif
1407 else if (!strcmp(ValueUnion.psz, "dsound"))
1408 {
1409 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_DirectSound));
1410 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1411 }
1412#endif /* RT_OS_WINDOWS */
1413#ifdef RT_OS_LINUX
1414# ifdef VBOX_WITH_ALSA
1415 else if (!strcmp(ValueUnion.psz, "alsa"))
1416 {
1417 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_ALSA));
1418 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1419 }
1420# endif
1421# ifdef VBOX_WITH_PULSE
1422 else if (!strcmp(ValueUnion.psz, "pulse"))
1423 {
1424 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
1425 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1426 }
1427# endif
1428#endif /* !RT_OS_LINUX */
1429#ifdef RT_OS_SOLARIS
1430 else if (!strcmp(ValueUnion.psz, "solaudio"))
1431 {
1432 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_SolAudio));
1433 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1434 }
1435#endif /* !RT_OS_SOLARIS */
1436#ifdef RT_OS_DARWIN
1437 else if (!strcmp(ValueUnion.psz, "coreaudio"))
1438 {
1439 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_CoreAudio));
1440 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1441 }
1442
1443#endif /* !RT_OS_DARWIN */
1444# if defined(RT_OS_FREEBSD) || defined(RT_OS_LINUX) || defined(VBOX_WITH_SOLARIS_OSS)
1445 else if (!strcmp(ValueUnion.psz, "oss"))
1446 {
1447 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS));
1448 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1449 }
1450# endif
1451 else
1452 {
1453 errorArgument("Invalid --audio argument '%s'", ValueUnion.psz);
1454 rc = E_FAIL;
1455 }
1456 break;
1457 }
1458
1459 case MODIFYVM_CLIPBOARD:
1460 {
1461 if (!strcmp(ValueUnion.psz, "disabled"))
1462 {
1463 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_Disabled));
1464 }
1465 else if (!strcmp(ValueUnion.psz, "hosttoguest"))
1466 {
1467 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_HostToGuest));
1468 }
1469 else if (!strcmp(ValueUnion.psz, "guesttohost"))
1470 {
1471 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_GuestToHost));
1472 }
1473 else if (!strcmp(ValueUnion.psz, "bidirectional"))
1474 {
1475 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_Bidirectional));
1476 }
1477 else
1478 {
1479 errorArgument("Invalid --clipboard argument '%s'", ValueUnion.psz);
1480 rc = E_FAIL;
1481 }
1482 break;
1483 }
1484
1485#ifdef VBOX_WITH_VRDP
1486 case MODIFYVM_VRDPPORT:
1487 {
1488 ComPtr<IVRDPServer> vrdpServer;
1489 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1490 ASSERT(vrdpServer);
1491
1492 if (!strcmp(ValueUnion.psz, "default"))
1493 CHECK_ERROR(vrdpServer, COMSETTER(Ports)(Bstr("0")));
1494 else
1495 CHECK_ERROR(vrdpServer, COMSETTER(Ports)(Bstr(ValueUnion.psz)));
1496 break;
1497 }
1498
1499 case MODIFYVM_VRDPADDRESS:
1500 {
1501 ComPtr<IVRDPServer> vrdpServer;
1502 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1503 ASSERT(vrdpServer);
1504
1505 CHECK_ERROR(vrdpServer, COMSETTER(NetAddress)(Bstr(ValueUnion.psz)));
1506 break;
1507 }
1508
1509 case MODIFYVM_VRDPAUTHTYPE:
1510 {
1511 ComPtr<IVRDPServer> vrdpServer;
1512 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1513 ASSERT(vrdpServer);
1514
1515 if (!strcmp(ValueUnion.psz, "null"))
1516 {
1517 CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_Null));
1518 }
1519 else if (!strcmp(ValueUnion.psz, "external"))
1520 {
1521 CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_External));
1522 }
1523 else if (!strcmp(ValueUnion.psz, "guest"))
1524 {
1525 CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_Guest));
1526 }
1527 else
1528 {
1529 errorArgument("Invalid --vrdpauthtype argument '%s'", ValueUnion.psz);
1530 rc = E_FAIL;
1531 }
1532 break;
1533 }
1534
1535 case MODIFYVM_VRDPMULTICON:
1536 {
1537 ComPtr<IVRDPServer> vrdpServer;
1538 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1539 ASSERT(vrdpServer);
1540
1541 CHECK_ERROR(vrdpServer, COMSETTER(AllowMultiConnection)(ValueUnion.f));
1542 break;
1543 }
1544
1545 case MODIFYVM_VRDPREUSECON:
1546 {
1547 ComPtr<IVRDPServer> vrdpServer;
1548 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1549 ASSERT(vrdpServer);
1550
1551 CHECK_ERROR(vrdpServer, COMSETTER(ReuseSingleConnection)(ValueUnion.f));
1552 break;
1553 }
1554
1555 case MODIFYVM_VRDP:
1556 {
1557 ComPtr<IVRDPServer> vrdpServer;
1558 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1559 ASSERT(vrdpServer);
1560
1561 CHECK_ERROR(vrdpServer, COMSETTER(Enabled)(ValueUnion.f));
1562 break;
1563 }
1564#endif /* VBOX_WITH_VRDP */
1565
1566 case MODIFYVM_USBEHCI:
1567 {
1568 ComPtr<IUSBController> UsbCtl;
1569 CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
1570 if (SUCCEEDED(rc))
1571 CHECK_ERROR(UsbCtl, COMSETTER(EnabledEhci)(ValueUnion.f));
1572 break;
1573 }
1574
1575 case MODIFYVM_USB:
1576 {
1577 ComPtr<IUSBController> UsbCtl;
1578 CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
1579 if (SUCCEEDED(rc))
1580 CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(ValueUnion.f));
1581 break;
1582 }
1583
1584 case MODIFYVM_SNAPSHOTFOLDER:
1585 {
1586 if (!strcmp(ValueUnion.psz, "default"))
1587 CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(NULL));
1588 else
1589 CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz)));
1590 break;
1591 }
1592
1593 case MODIFYVM_TELEPORTER_ENABLED:
1594 {
1595 CHECK_ERROR(machine, COMSETTER(TeleporterEnabled)(ValueUnion.f));
1596 break;
1597 }
1598
1599 case MODIFYVM_TELEPORTER_PORT:
1600 {
1601 CHECK_ERROR(machine, COMSETTER(TeleporterPort)(ValueUnion.u32));
1602 break;
1603 }
1604
1605 case MODIFYVM_TELEPORTER_ADDRESS:
1606 {
1607 CHECK_ERROR(machine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz)));
1608 break;
1609 }
1610
1611 case MODIFYVM_TELEPORTER_PASSWORD:
1612 {
1613 CHECK_ERROR(machine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz)));
1614 break;
1615 }
1616
1617 case MODIFYVM_HARDWARE_UUID:
1618 {
1619 CHECK_ERROR(machine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz)));
1620 break;
1621 }
1622
1623 default:
1624 {
1625 errorGetOpt(USAGE_MODIFYVM, c, &ValueUnion);
1626 rc = E_FAIL;
1627 break;
1628 }
1629 }
1630 }
1631
1632 /* commit changes */
1633 if (SUCCEEDED(rc))
1634 CHECK_ERROR(machine, SaveSettings());
1635
1636 /* it's important to always close sessions */
1637 a->session->Close();
1638
1639 return SUCCEEDED(rc) ? 0 : 1;
1640}
1641
1642#endif /* !VBOX_ONLY_DOCS */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use