VirtualBox

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

Last change on this file since 27987 was 27976, checked in by vboxsync, 15 years ago

*: scm cleans up whitespace and adds a new line at the end of ApplianceimplPrivate.h.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 78.9 KB
Line 
1/* $Id: VBoxManageModifyVM.cpp 27976 2010-04-04 14:16:32Z 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_LARGEPAGES,
72 MODIFYVM_VTXVPID,
73 MODIFYVM_CPUS,
74 MODIFYVM_CPUHOTPLUG,
75 MODIFYVM_PLUGCPU,
76 MODIFYVM_UNPLUGCPU,
77 MODIFYVM_SETCPUID,
78 MODIFYVM_DELCPUID,
79 MODIFYVM_DELALLCPUID,
80 MODIFYVM_MONITORCOUNT,
81 MODIFYVM_ACCELERATE3D,
82#ifdef VBOX_WITH_VIDEOHWACCEL
83 MODIFYVM_ACCELERATE2DVIDEO,
84#endif
85 MODIFYVM_BIOSLOGOFADEIN,
86 MODIFYVM_BIOSLOGOFADEOUT,
87 MODIFYVM_BIOSLOGODISPLAYTIME,
88 MODIFYVM_BIOSLOGOIMAGEPATH,
89 MODIFYVM_BIOSBOOTMENU,
90 MODIFYVM_BIOSSYSTEMTIMEOFFSET,
91 MODIFYVM_BIOSPXEDEBUG,
92 MODIFYVM_BOOT,
93 MODIFYVM_HDA, // deprecated
94 MODIFYVM_HDB, // deprecated
95 MODIFYVM_HDD, // deprecated
96 MODIFYVM_IDECONTROLLER, // deprecated
97 MODIFYVM_SATAIDEEMULATION, // deprecated
98 MODIFYVM_SATAPORTCOUNT, // deprecated
99 MODIFYVM_SATAPORT, // deprecated
100 MODIFYVM_SATA, // deprecated
101 MODIFYVM_SCSIPORT, // deprecated
102 MODIFYVM_SCSITYPE, // deprecated
103 MODIFYVM_SCSI, // deprecated
104 MODIFYVM_DVDPASSTHROUGH, // deprecated
105 MODIFYVM_DVD, // deprecated
106 MODIFYVM_FLOPPY, // deprecated
107 MODIFYVM_NICTRACEFILE,
108 MODIFYVM_NICTRACE,
109 MODIFYVM_NICTYPE,
110 MODIFYVM_NICSPEED,
111 MODIFYVM_NIC,
112 MODIFYVM_CABLECONNECTED,
113 MODIFYVM_BRIDGEADAPTER,
114 MODIFYVM_HOSTONLYADAPTER,
115 MODIFYVM_INTNET,
116 MODIFYVM_NATNET,
117 MODIFYVM_NATBINDIP,
118 MODIFYVM_NATSETTINGS,
119 MODIFYVM_NATPF,
120 MODIFYVM_NATTFTPPREFIX,
121 MODIFYVM_NATTFTPFILE,
122 MODIFYVM_NATTFTPSERVER,
123 MODIFYVM_NATDNSPASSDOMAIN,
124 MODIFYVM_NATDNSPROXY,
125 MODIFYVM_NATDNSHOSTRESOLVER,
126 MODIFYVM_MACADDRESS,
127 MODIFYVM_HIDPTR,
128 MODIFYVM_HIDKBD,
129 MODIFYVM_UARTMODE,
130 MODIFYVM_UART,
131 MODIFYVM_GUESTMEMORYBALLOON,
132 MODIFYVM_AUDIOCONTROLLER,
133 MODIFYVM_AUDIO,
134 MODIFYVM_CLIPBOARD,
135#ifdef VBOX_WITH_VRDP
136 MODIFYVM_VRDPPORT,
137 MODIFYVM_VRDPADDRESS,
138 MODIFYVM_VRDPAUTHTYPE,
139 MODIFYVM_VRDPMULTICON,
140 MODIFYVM_VRDPREUSECON,
141 MODIFYVM_VRDP,
142#endif
143 MODIFYVM_RTCUSEUTC,
144 MODIFYVM_USBEHCI,
145 MODIFYVM_USB,
146 MODIFYVM_SNAPSHOTFOLDER,
147 MODIFYVM_TELEPORTER_ENABLED,
148 MODIFYVM_TELEPORTER_PORT,
149 MODIFYVM_TELEPORTER_ADDRESS,
150 MODIFYVM_TELEPORTER_PASSWORD,
151 MODIFYVM_HARDWARE_UUID,
152 MODIFYVM_HPET,
153 MODIFYVM_IOMGR,
154 MODIFYVM_IOBACKEND,
155 MODIFYVM_IOCACHE,
156 MODIFYVM_IOCACHESIZE,
157 MODIFYVM_IOBANDWIDTHMAX
158};
159
160static const RTGETOPTDEF g_aModifyVMOptions[] =
161{
162 { "--name", MODIFYVM_NAME, RTGETOPT_REQ_STRING },
163 { "--ostype", MODIFYVM_OSTYPE, RTGETOPT_REQ_STRING },
164 { "--memory", MODIFYVM_MEMORY, RTGETOPT_REQ_UINT32 },
165 { "--vram", MODIFYVM_VRAM, RTGETOPT_REQ_UINT32 },
166 { "--firmware", MODIFYVM_FIRMWARE, RTGETOPT_REQ_STRING },
167 { "--acpi", MODIFYVM_ACPI, RTGETOPT_REQ_BOOL_ONOFF },
168 { "--ioapic", MODIFYVM_IOAPIC, RTGETOPT_REQ_BOOL_ONOFF },
169 { "--pae", MODIFYVM_PAE, RTGETOPT_REQ_BOOL_ONOFF },
170 { "--synthcpu", MODIFYVM_SYNTHCPU, RTGETOPT_REQ_BOOL_ONOFF },
171 { "--hwvirtex", MODIFYVM_HWVIRTEX, RTGETOPT_REQ_BOOL_ONOFF },
172 { "--hwvirtexexcl", MODIFYVM_HWVIRTEXEXCLUSIVE, RTGETOPT_REQ_BOOL_ONOFF },
173 { "--nestedpaging", MODIFYVM_NESTEDPAGING, RTGETOPT_REQ_BOOL_ONOFF },
174 { "--largepages", MODIFYVM_LARGEPAGES, RTGETOPT_REQ_BOOL_ONOFF },
175 { "--vtxvpid", MODIFYVM_VTXVPID, RTGETOPT_REQ_BOOL_ONOFF },
176 { "--cpuidset", MODIFYVM_SETCPUID, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX},
177 { "--cpuidremove", MODIFYVM_DELCPUID, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX},
178 { "--cpuidremoveall", MODIFYVM_DELALLCPUID, RTGETOPT_REQ_NOTHING},
179 { "--cpus", MODIFYVM_CPUS, RTGETOPT_REQ_UINT32 },
180 { "--cpuhotplug", MODIFYVM_CPUHOTPLUG, RTGETOPT_REQ_BOOL_ONOFF },
181 { "--plugcpu", MODIFYVM_PLUGCPU, RTGETOPT_REQ_UINT32 },
182 { "--unplugcpu", MODIFYVM_UNPLUGCPU, RTGETOPT_REQ_UINT32 },
183 { "--rtcuseutc", MODIFYVM_RTCUSEUTC, RTGETOPT_REQ_BOOL_ONOFF },
184 { "--monitorcount", MODIFYVM_MONITORCOUNT, RTGETOPT_REQ_UINT32 },
185 { "--accelerate3d", MODIFYVM_ACCELERATE3D, RTGETOPT_REQ_BOOL_ONOFF },
186#ifdef VBOX_WITH_VIDEOHWACCEL
187 { "--accelerate2dvideo", MODIFYVM_ACCELERATE2DVIDEO, RTGETOPT_REQ_BOOL_ONOFF },
188#endif
189 { "--bioslogofadein", MODIFYVM_BIOSLOGOFADEIN, RTGETOPT_REQ_BOOL_ONOFF },
190 { "--bioslogofadeout", MODIFYVM_BIOSLOGOFADEOUT, RTGETOPT_REQ_BOOL_ONOFF },
191 { "--bioslogodisplaytime", MODIFYVM_BIOSLOGODISPLAYTIME, RTGETOPT_REQ_UINT32 },
192 { "--bioslogoimagepath", MODIFYVM_BIOSLOGOIMAGEPATH, RTGETOPT_REQ_STRING },
193 { "--biosbootmenu", MODIFYVM_BIOSBOOTMENU, RTGETOPT_REQ_STRING },
194 { "--biossystemtimeoffset", MODIFYVM_BIOSSYSTEMTIMEOFFSET, RTGETOPT_REQ_INT64 },
195 { "--biospxedebug", MODIFYVM_BIOSPXEDEBUG, RTGETOPT_REQ_BOOL_ONOFF },
196 { "--boot", MODIFYVM_BOOT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
197 { "--hda", MODIFYVM_HDA, RTGETOPT_REQ_STRING },
198 { "--hdb", MODIFYVM_HDB, RTGETOPT_REQ_STRING },
199 { "--hdd", MODIFYVM_HDD, RTGETOPT_REQ_STRING },
200 { "--idecontroller", MODIFYVM_IDECONTROLLER, RTGETOPT_REQ_STRING },
201 { "--sataideemulation", MODIFYVM_SATAIDEEMULATION, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
202 { "--sataportcount", MODIFYVM_SATAPORTCOUNT, RTGETOPT_REQ_UINT32 },
203 { "--sataport", MODIFYVM_SATAPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
204 { "--sata", MODIFYVM_SATA, RTGETOPT_REQ_STRING },
205 { "--scsiport", MODIFYVM_SCSIPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
206 { "--scsitype", MODIFYVM_SCSITYPE, RTGETOPT_REQ_STRING },
207 { "--scsi", MODIFYVM_SCSI, RTGETOPT_REQ_STRING },
208 { "--dvdpassthrough", MODIFYVM_DVDPASSTHROUGH, RTGETOPT_REQ_STRING },
209 { "--dvd", MODIFYVM_DVD, RTGETOPT_REQ_STRING },
210 { "--floppy", MODIFYVM_FLOPPY, RTGETOPT_REQ_STRING },
211 { "--nictracefile", MODIFYVM_NICTRACEFILE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
212 { "--nictrace", MODIFYVM_NICTRACE, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
213 { "--nictype", MODIFYVM_NICTYPE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
214 { "--nicspeed", MODIFYVM_NICSPEED, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
215 { "--nic", MODIFYVM_NIC, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
216 { "--cableconnected", MODIFYVM_CABLECONNECTED, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
217 { "--bridgeadapter", MODIFYVM_BRIDGEADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
218 { "--hostonlyadapter", MODIFYVM_HOSTONLYADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
219 { "--intnet", MODIFYVM_INTNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
220 { "--natnet", MODIFYVM_NATNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
221 { "--natbindip", MODIFYVM_NATBINDIP, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
222 { "--natsettings", MODIFYVM_NATSETTINGS, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
223 { "--natpf", MODIFYVM_NATPF, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
224 { "--nattftpprefix", MODIFYVM_NATTFTPPREFIX, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
225 { "--nattftpfile", MODIFYVM_NATTFTPFILE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
226 { "--nattftpserver", MODIFYVM_NATTFTPSERVER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
227 { "--natdnspassdomain", MODIFYVM_NATDNSPASSDOMAIN, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
228 { "--natdnsproxy", MODIFYVM_NATDNSPROXY, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
229 { "--natdnshostresolver", MODIFYVM_NATDNSHOSTRESOLVER, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
230 { "--macaddress", MODIFYVM_MACADDRESS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
231 { "--mouse", MODIFYVM_HIDPTR, RTGETOPT_REQ_STRING },
232 { "--keyboard", MODIFYVM_HIDKBD, RTGETOPT_REQ_STRING },
233 { "--uartmode", MODIFYVM_UARTMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
234 { "--uart", MODIFYVM_UART, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
235 { "--guestmemoryballoon", MODIFYVM_GUESTMEMORYBALLOON, RTGETOPT_REQ_UINT32 },
236 { "--audiocontroller", MODIFYVM_AUDIOCONTROLLER, RTGETOPT_REQ_STRING },
237 { "--audio", MODIFYVM_AUDIO, RTGETOPT_REQ_STRING },
238 { "--clipboard", MODIFYVM_CLIPBOARD, RTGETOPT_REQ_STRING },
239#ifdef VBOX_WITH_VRDP
240 { "--vrdpport", MODIFYVM_VRDPPORT, RTGETOPT_REQ_STRING },
241 { "--vrdpaddress", MODIFYVM_VRDPADDRESS, RTGETOPT_REQ_STRING },
242 { "--vrdpauthtype", MODIFYVM_VRDPAUTHTYPE, RTGETOPT_REQ_STRING },
243 { "--vrdpmulticon", MODIFYVM_VRDPMULTICON, RTGETOPT_REQ_BOOL_ONOFF },
244 { "--vrdpreusecon", MODIFYVM_VRDPREUSECON, RTGETOPT_REQ_BOOL_ONOFF },
245 { "--vrdp", MODIFYVM_VRDP, RTGETOPT_REQ_BOOL_ONOFF },
246#endif
247 { "--usbehci", MODIFYVM_USBEHCI, RTGETOPT_REQ_BOOL_ONOFF },
248 { "--usb", MODIFYVM_USB, RTGETOPT_REQ_BOOL_ONOFF },
249 { "--snapshotfolder", MODIFYVM_SNAPSHOTFOLDER, RTGETOPT_REQ_STRING },
250 { "--teleporter", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
251 { "--teleporterenabled", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
252 { "--teleporterport", MODIFYVM_TELEPORTER_PORT, RTGETOPT_REQ_UINT32 },
253 { "--teleporteraddress", MODIFYVM_TELEPORTER_ADDRESS, RTGETOPT_REQ_STRING },
254 { "--teleporterpassword", MODIFYVM_TELEPORTER_PASSWORD, RTGETOPT_REQ_STRING },
255 { "--hardwareuuid", MODIFYVM_HARDWARE_UUID, RTGETOPT_REQ_STRING },
256 { "--hpet", MODIFYVM_HPET, RTGETOPT_REQ_BOOL_ONOFF },
257 { "--iomgr", MODIFYVM_IOMGR, RTGETOPT_REQ_STRING },
258 { "--iobackend", MODIFYVM_IOBACKEND, RTGETOPT_REQ_STRING },
259 { "--iocache", MODIFYVM_IOCACHE, RTGETOPT_REQ_BOOL_ONOFF },
260 { "--iocachesize", MODIFYVM_IOCACHESIZE, RTGETOPT_REQ_UINT32 },
261 { "--iobandwidthmax", MODIFYVM_IOBANDWIDTHMAX, RTGETOPT_REQ_UINT32 },
262};
263
264int handleModifyVM(HandlerArg *a)
265{
266 int c;
267 HRESULT rc;
268 Bstr name;
269 Bstr machineuuid (a->argv[0]);
270 RTGETOPTUNION ValueUnion;
271 RTGETOPTSTATE GetOptState;
272 ComPtr <IMachine> machine;
273 ComPtr <IBIOSSettings> biosSettings;
274
275 /* VM ID + at least one parameter. Parameter arguments are checked
276 * individually. */
277 if (a->argc < 2)
278 return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
279
280 /* Get the number of network adapters */
281 ULONG NetworkAdapterCount = 0;
282 {
283 ComPtr <ISystemProperties> info;
284 CHECK_ERROR_RET(a->virtualBox, COMGETTER(SystemProperties)(info.asOutParam()), 1);
285 CHECK_ERROR_RET(info, COMGETTER(NetworkAdapterCount)(&NetworkAdapterCount), 1);
286 }
287 ULONG SerialPortCount = 0;
288 {
289 ComPtr <ISystemProperties> info;
290 CHECK_ERROR_RET(a->virtualBox, COMGETTER(SystemProperties)(info.asOutParam()), 1);
291 CHECK_ERROR_RET(info, COMGETTER(SerialPortCount)(&SerialPortCount), 1);
292 }
293
294 /* try to find the given machine */
295 if (!Guid(machineuuid).isEmpty())
296 {
297 CHECK_ERROR_RET(a->virtualBox, GetMachine(machineuuid, machine.asOutParam()), 1);
298 }
299 else
300 {
301 CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()), 1);
302 machine->COMGETTER(Id)(machineuuid.asOutParam());
303 }
304
305 /* open a session for the VM */
306 CHECK_ERROR_RET(a->virtualBox, OpenSession(a->session, machineuuid), 1);
307
308 /* get the mutable session machine */
309 a->session->COMGETTER(Machine)(machine.asOutParam());
310 machine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
311
312 RTGetOptInit(&GetOptState, a->argc, a->argv, g_aModifyVMOptions,
313 RT_ELEMENTS(g_aModifyVMOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
314
315 while ( SUCCEEDED (rc)
316 && (c = RTGetOpt(&GetOptState, &ValueUnion)))
317 {
318 switch (c)
319 {
320 case MODIFYVM_NAME:
321 {
322 CHECK_ERROR(machine, COMSETTER(Name)(Bstr(ValueUnion.psz)));
323 break;
324 }
325 case MODIFYVM_OSTYPE:
326 {
327 ComPtr<IGuestOSType> guestOSType;
328 CHECK_ERROR(a->virtualBox, GetGuestOSType(Bstr(ValueUnion.psz), guestOSType.asOutParam()));
329 if (SUCCEEDED(rc) && guestOSType)
330 {
331 CHECK_ERROR(machine, COMSETTER(OSTypeId)(Bstr(ValueUnion.psz)));
332 }
333 else
334 {
335 errorArgument("Invalid guest OS type '%s'", Utf8Str(ValueUnion.psz).raw());
336 rc = E_FAIL;
337 }
338 break;
339 }
340
341 case MODIFYVM_MEMORY:
342 {
343 CHECK_ERROR(machine, COMSETTER(MemorySize)(ValueUnion.u32));
344 break;
345 }
346
347 case MODIFYVM_VRAM:
348 {
349 CHECK_ERROR(machine, COMSETTER(VRAMSize)(ValueUnion.u32));
350 break;
351 }
352
353 case MODIFYVM_FIRMWARE:
354 {
355 if (!strcmp(ValueUnion.psz, "efi"))
356 {
357 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI));
358 }
359 else if (!strcmp(ValueUnion.psz, "efi32"))
360 {
361 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI32));
362 }
363 else if (!strcmp(ValueUnion.psz, "efi64"))
364 {
365 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI64));
366 }
367 else if (!strcmp(ValueUnion.psz, "efidual"))
368 {
369 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFIDUAL));
370 }
371 else if (!strcmp(ValueUnion.psz, "bios"))
372 {
373 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_BIOS));
374 }
375 else
376 {
377 errorArgument("Invalid --firmware argument '%s'", ValueUnion.psz);
378 rc = E_FAIL;
379 }
380 break;
381 }
382
383 case MODIFYVM_ACPI:
384 {
385 CHECK_ERROR(biosSettings, COMSETTER(ACPIEnabled)(ValueUnion.f));
386 break;
387 }
388
389 case MODIFYVM_IOAPIC:
390 {
391 CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(ValueUnion.f));
392 break;
393 }
394
395 case MODIFYVM_PAE:
396 {
397 CHECK_ERROR(machine, SetCPUProperty(CPUPropertyType_PAE, ValueUnion.f));
398 break;
399 }
400
401 case MODIFYVM_SYNTHCPU:
402 {
403 CHECK_ERROR(machine, SetCPUProperty(CPUPropertyType_Synthetic, ValueUnion.f));
404 break;
405 }
406
407 case MODIFYVM_HWVIRTEX:
408 {
409 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_Enabled, ValueUnion.f));
410 break;
411 }
412
413 case MODIFYVM_HWVIRTEXEXCLUSIVE:
414 {
415 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_Exclusive, ValueUnion.f));
416 break;
417 }
418
419 case MODIFYVM_SETCPUID:
420 {
421 uint32_t id = ValueUnion.u32;
422 uint32_t aValue[4];
423
424 for (unsigned i = 0 ; i < 4 ; i++)
425 {
426 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX);
427 if (RT_FAILURE(vrc))
428 return errorSyntax(USAGE_MODIFYVM,
429 "Missing or Invalid argument to '%s'",
430 GetOptState.pDef->pszLong);
431 aValue[i] = ValueUnion.u32;
432 }
433 CHECK_ERROR(machine, SetCPUIDLeaf(id, aValue[0], aValue[1], aValue[2], aValue[3]));
434 break;
435 }
436
437 case MODIFYVM_DELCPUID:
438 {
439 CHECK_ERROR(machine, RemoveCPUIDLeaf(ValueUnion.u32));
440 break;
441 }
442
443 case MODIFYVM_DELALLCPUID:
444 {
445 CHECK_ERROR(machine, RemoveAllCPUIDLeaves());
446 break;
447 }
448
449 case MODIFYVM_NESTEDPAGING:
450 {
451 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, ValueUnion.f));
452 break;
453 }
454
455 case MODIFYVM_LARGEPAGES:
456 {
457 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_LargePages, ValueUnion.f));
458 break;
459 }
460
461 case MODIFYVM_VTXVPID:
462 {
463 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_VPID, ValueUnion.f));
464 break;
465 }
466
467 case MODIFYVM_CPUS:
468 {
469 CHECK_ERROR(machine, COMSETTER(CPUCount)(ValueUnion.u32));
470 break;
471 }
472
473 case MODIFYVM_RTCUSEUTC:
474 {
475 CHECK_ERROR(machine, COMSETTER(RTCUseUTC)(ValueUnion.f));
476 break;
477 }
478
479 case MODIFYVM_CPUHOTPLUG:
480 {
481 CHECK_ERROR(machine, COMSETTER(CPUHotPlugEnabled)(ValueUnion.f));
482 break;
483 }
484
485 case MODIFYVM_PLUGCPU:
486 {
487 CHECK_ERROR(machine, HotPlugCPU(ValueUnion.u32));
488 break;
489 }
490
491 case MODIFYVM_UNPLUGCPU:
492 {
493 CHECK_ERROR(machine, HotUnplugCPU(ValueUnion.u32));
494 break;
495 }
496
497 case MODIFYVM_MONITORCOUNT:
498 {
499 CHECK_ERROR(machine, COMSETTER(MonitorCount)(ValueUnion.u32));
500 break;
501 }
502
503 case MODIFYVM_ACCELERATE3D:
504 {
505 CHECK_ERROR(machine, COMSETTER(Accelerate3DEnabled)(ValueUnion.f));
506 break;
507 }
508
509#ifdef VBOX_WITH_VIDEOHWACCEL
510 case MODIFYVM_ACCELERATE2DVIDEO:
511 {
512 CHECK_ERROR(machine, COMSETTER(Accelerate2DVideoEnabled)(ValueUnion.f));
513 break;
514 }
515#endif
516
517 case MODIFYVM_BIOSLOGOFADEIN:
518 {
519 CHECK_ERROR(biosSettings, COMSETTER(LogoFadeIn)(ValueUnion.f));
520 break;
521 }
522
523 case MODIFYVM_BIOSLOGOFADEOUT:
524 {
525 CHECK_ERROR(biosSettings, COMSETTER(LogoFadeOut)(ValueUnion.f));
526 break;
527 }
528
529 case MODIFYVM_BIOSLOGODISPLAYTIME:
530 {
531 CHECK_ERROR(biosSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u32));
532 break;
533 }
534
535 case MODIFYVM_BIOSLOGOIMAGEPATH:
536 {
537 CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz)));
538 break;
539 }
540
541 case MODIFYVM_BIOSBOOTMENU:
542 {
543 if (!strcmp(ValueUnion.psz, "disabled"))
544 {
545 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_Disabled));
546 }
547 else if (!strcmp(ValueUnion.psz, "menuonly"))
548 {
549 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MenuOnly));
550 }
551 else if (!strcmp(ValueUnion.psz, "messageandmenu"))
552 {
553 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MessageAndMenu));
554 }
555 else
556 {
557 errorArgument("Invalid --biosbootmenu argument '%s'", ValueUnion.psz);
558 rc = E_FAIL;
559 }
560 break;
561 }
562
563 case MODIFYVM_BIOSSYSTEMTIMEOFFSET:
564 {
565 CHECK_ERROR(biosSettings, COMSETTER(TimeOffset)(ValueUnion.i64));
566 break;
567 }
568
569 case MODIFYVM_BIOSPXEDEBUG:
570 {
571 CHECK_ERROR(biosSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f));
572 break;
573 }
574
575 case MODIFYVM_BOOT:
576 {
577 if (!strcmp(ValueUnion.psz, "none"))
578 {
579 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Null));
580 }
581 else if (!strcmp(ValueUnion.psz, "floppy"))
582 {
583 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Floppy));
584 }
585 else if (!strcmp(ValueUnion.psz, "dvd"))
586 {
587 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_DVD));
588 }
589 else if (!strcmp(ValueUnion.psz, "disk"))
590 {
591 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_HardDisk));
592 }
593 else if (!strcmp(ValueUnion.psz, "net"))
594 {
595 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Network));
596 }
597 else
598 return errorArgument("Invalid boot device '%s'", ValueUnion.psz);
599 break;
600 }
601
602 case MODIFYVM_HDA: // deprecated
603 {
604 if (!strcmp(ValueUnion.psz, "none"))
605 {
606 machine->DetachDevice(Bstr("IDE Controller"), 0, 0);
607 }
608 else
609 {
610 /* first guess is that it's a UUID */
611 Bstr uuid(ValueUnion.psz);
612 ComPtr<IMedium> hardDisk;
613 rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
614 /* not successful? Then it must be a filename */
615 if (!hardDisk)
616 {
617 rc = a->virtualBox->FindHardDisk(Bstr(ValueUnion.psz), hardDisk.asOutParam());
618 if (FAILED(rc))
619 {
620 /* open the new hard disk object */
621 CHECK_ERROR(a->virtualBox,
622 OpenHardDisk(Bstr(ValueUnion.psz),
623 AccessMode_ReadWrite, false, Bstr(""),
624 false, Bstr(""), hardDisk.asOutParam()));
625 }
626 }
627 if (hardDisk)
628 {
629 hardDisk->COMGETTER(Id)(uuid.asOutParam());
630 CHECK_ERROR(machine, AttachDevice(Bstr("IDE Controller"), 0, 0, DeviceType_HardDisk, uuid));
631 }
632 else
633 rc = E_FAIL;
634 }
635 break;
636 }
637
638 case MODIFYVM_HDB: // deprecated
639 {
640 if (!strcmp(ValueUnion.psz, "none"))
641 {
642 machine->DetachDevice(Bstr("IDE Controller"), 0, 1);
643 }
644 else
645 {
646 /* first guess is that it's a UUID */
647 Bstr uuid(ValueUnion.psz);
648 ComPtr<IMedium> hardDisk;
649 rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
650 /* not successful? Then it must be a filename */
651 if (!hardDisk)
652 {
653 rc = a->virtualBox->FindHardDisk(Bstr(ValueUnion.psz), hardDisk.asOutParam());
654 if (FAILED(rc))
655 {
656 /* open the new hard disk object */
657 CHECK_ERROR(a->virtualBox,
658 OpenHardDisk(Bstr(ValueUnion.psz),
659 AccessMode_ReadWrite, false, Bstr(""),
660 false, Bstr(""), hardDisk.asOutParam()));
661 }
662 }
663 if (hardDisk)
664 {
665 hardDisk->COMGETTER(Id)(uuid.asOutParam());
666 CHECK_ERROR(machine, AttachDevice(Bstr("IDE Controller"), 0, 1, DeviceType_HardDisk, uuid));
667 }
668 else
669 rc = E_FAIL;
670 }
671 break;
672 }
673
674 case MODIFYVM_HDD: // deprecated
675 {
676 if (!strcmp(ValueUnion.psz, "none"))
677 {
678 machine->DetachDevice(Bstr("IDE Controller"), 1, 1);
679 }
680 else
681 {
682 /* first guess is that it's a UUID */
683 Bstr uuid(ValueUnion.psz);
684 ComPtr<IMedium> hardDisk;
685 rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
686 /* not successful? Then it must be a filename */
687 if (!hardDisk)
688 {
689 rc = a->virtualBox->FindHardDisk(Bstr(ValueUnion.psz), hardDisk.asOutParam());
690 if (FAILED(rc))
691 {
692 /* open the new hard disk object */
693 CHECK_ERROR(a->virtualBox,
694 OpenHardDisk(Bstr(ValueUnion.psz),
695 AccessMode_ReadWrite, false, Bstr(""),
696 false, Bstr(""), hardDisk.asOutParam()));
697 }
698 }
699 if (hardDisk)
700 {
701 hardDisk->COMGETTER(Id)(uuid.asOutParam());
702 CHECK_ERROR(machine, AttachDevice(Bstr("IDE Controller"), 1, 1, DeviceType_HardDisk, uuid));
703 }
704 else
705 rc = E_FAIL;
706 }
707 break;
708 }
709
710 case MODIFYVM_IDECONTROLLER: // deprecated
711 {
712 ComPtr<IStorageController> storageController;
713 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("IDE Controller"),
714 storageController.asOutParam()));
715
716 if (!RTStrICmp(ValueUnion.psz, "PIIX3"))
717 {
718 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX3));
719 }
720 else if (!RTStrICmp(ValueUnion.psz, "PIIX4"))
721 {
722 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX4));
723 }
724 else if (!RTStrICmp(ValueUnion.psz, "ICH6"))
725 {
726 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_ICH6));
727 }
728 else
729 {
730 errorArgument("Invalid --idecontroller argument '%s'", ValueUnion.psz);
731 rc = E_FAIL;
732 }
733 break;
734 }
735
736 case MODIFYVM_SATAIDEEMULATION: // deprecated
737 {
738 ComPtr<IStorageController> SataCtl;
739 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA"), SataCtl.asOutParam()));
740
741 if (SUCCEEDED(rc))
742 CHECK_ERROR(SataCtl, SetIDEEmulationPort(GetOptState.uIndex, ValueUnion.u32));
743 break;
744 }
745
746 case MODIFYVM_SATAPORTCOUNT: // deprecated
747 {
748 ComPtr<IStorageController> SataCtl;
749 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA"), SataCtl.asOutParam()));
750
751 if (SUCCEEDED(rc) && ValueUnion.u32 > 0)
752 CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32));
753 break;
754 }
755
756 case MODIFYVM_SATAPORT: // deprecated
757 {
758 if (!strcmp(ValueUnion.psz, "none"))
759 {
760 machine->DetachDevice(Bstr("SATA"), GetOptState.uIndex, 0);
761 }
762 else
763 {
764 /* first guess is that it's a UUID */
765 Bstr uuid(ValueUnion.psz);
766 ComPtr<IMedium> hardDisk;
767 rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
768 /* not successful? Then it must be a filename */
769 if (!hardDisk)
770 {
771 rc = a->virtualBox->FindHardDisk(Bstr(ValueUnion.psz), hardDisk.asOutParam());
772 if (FAILED(rc))
773 {
774 /* open the new hard disk object */
775 CHECK_ERROR(a->virtualBox,
776 OpenHardDisk(Bstr(ValueUnion.psz), AccessMode_ReadWrite,
777 false, Bstr(""), false,
778 Bstr(""), hardDisk.asOutParam()));
779 }
780 }
781 if (hardDisk)
782 {
783 hardDisk->COMGETTER(Id)(uuid.asOutParam());
784 CHECK_ERROR(machine,
785 AttachDevice(Bstr("SATA"), GetOptState.uIndex,
786 0, DeviceType_HardDisk, uuid));
787 }
788 else
789 rc = E_FAIL;
790 }
791 break;
792 }
793
794 case MODIFYVM_SATA: // deprecated
795 {
796 if (!strcmp(ValueUnion.psz, "on") || !strcmp(ValueUnion.psz, "enable"))
797 {
798 ComPtr<IStorageController> ctl;
799 CHECK_ERROR(machine, AddStorageController(Bstr("SATA"), StorageBus_SATA, ctl.asOutParam()));
800 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
801 }
802 else if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
803 CHECK_ERROR(machine, RemoveStorageController(Bstr("SATA")));
804 else
805 return errorArgument("Invalid --usb argument '%s'", ValueUnion.psz);
806 break;
807 }
808
809 case MODIFYVM_SCSIPORT: // deprecated
810 {
811 if (!strcmp(ValueUnion.psz, "none"))
812 {
813 rc = machine->DetachDevice(Bstr("LsiLogic"), GetOptState.uIndex, 0);
814 if (FAILED(rc))
815 CHECK_ERROR(machine, DetachDevice(Bstr("BusLogic"), GetOptState.uIndex, 0));
816 }
817 else
818 {
819 /* first guess is that it's a UUID */
820 Bstr uuid(ValueUnion.psz);
821 ComPtr<IMedium> hardDisk;
822 rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
823 /* not successful? Then it must be a filename */
824 if (!hardDisk)
825 {
826 rc = a->virtualBox->FindHardDisk(Bstr(ValueUnion.psz), hardDisk.asOutParam());
827 if (FAILED(rc))
828 {
829 /* open the new hard disk object */
830 CHECK_ERROR(a->virtualBox,
831 OpenHardDisk(Bstr(ValueUnion.psz),
832 AccessMode_ReadWrite, false, Bstr(""),
833 false, Bstr(""), hardDisk.asOutParam()));
834 }
835 }
836 if (hardDisk)
837 {
838 hardDisk->COMGETTER(Id)(uuid.asOutParam());
839 rc = machine->AttachDevice(Bstr("LsiLogic"), GetOptState.uIndex, 0, DeviceType_HardDisk, uuid);
840 if (FAILED(rc))
841 CHECK_ERROR(machine,
842 AttachDevice(Bstr("BusLogic"),
843 GetOptState.uIndex, 0,
844 DeviceType_HardDisk, uuid));
845 }
846 else
847 rc = E_FAIL;
848 }
849 break;
850 }
851
852 case MODIFYVM_SCSITYPE: // deprecated
853 {
854 ComPtr<IStorageController> ctl;
855
856 if (!RTStrICmp(ValueUnion.psz, "LsiLogic"))
857 {
858 rc = machine->RemoveStorageController(Bstr("BusLogic"));
859 if (FAILED(rc))
860 CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic")));
861
862 CHECK_ERROR(machine,
863 AddStorageController(Bstr("LsiLogic"),
864 StorageBus_SCSI,
865 ctl.asOutParam()));
866
867 if (SUCCEEDED(rc))
868 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
869 }
870 else if (!RTStrICmp(ValueUnion.psz, "BusLogic"))
871 {
872 rc = machine->RemoveStorageController(Bstr("LsiLogic"));
873 if (FAILED(rc))
874 CHECK_ERROR(machine, RemoveStorageController(Bstr("BusLogic")));
875
876 CHECK_ERROR(machine,
877 AddStorageController(Bstr("BusLogic"),
878 StorageBus_SCSI,
879 ctl.asOutParam()));
880
881 if (SUCCEEDED(rc))
882 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
883 }
884 else
885 return errorArgument("Invalid --scsitype argument '%s'", ValueUnion.psz);
886 break;
887 }
888
889 case MODIFYVM_SCSI: // deprecated
890 {
891 if (!strcmp(ValueUnion.psz, "on") || !strcmp(ValueUnion.psz, "enable"))
892 {
893 ComPtr<IStorageController> ctl;
894
895 CHECK_ERROR(machine, AddStorageController(Bstr("BusLogic"), StorageBus_SCSI, ctl.asOutParam()));
896 if (SUCCEEDED(rc))
897 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
898 }
899 else if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
900 {
901 rc = machine->RemoveStorageController(Bstr("BusLogic"));
902 if (FAILED(rc))
903 CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic")));
904 }
905 break;
906 }
907
908 case MODIFYVM_DVDPASSTHROUGH: // deprecated
909 {
910 CHECK_ERROR(machine, PassthroughDevice(Bstr("IDE Controller"), 1, 0, !strcmp(ValueUnion.psz, "on")));
911 break;
912 }
913
914 case MODIFYVM_DVD: // deprecated
915 {
916 ComPtr<IMedium> dvdMedium;
917 Bstr uuid(ValueUnion.psz);
918
919 /* unmount? */
920 if (!strcmp(ValueUnion.psz, "none"))
921 {
922 /* nothing to do, NULL object will cause unmount */
923 }
924 /* host drive? */
925 else if (!strncmp(ValueUnion.psz, "host:", 5))
926 {
927 ComPtr<IHost> host;
928 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
929 rc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5), dvdMedium.asOutParam());
930 if (!dvdMedium)
931 {
932 /* 2nd try: try with the real name, important on Linux+libhal */
933 char szPathReal[RTPATH_MAX];
934 if (RT_FAILURE(RTPathReal(ValueUnion.psz + 5, szPathReal, sizeof(szPathReal))))
935 {
936 errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
937 rc = E_FAIL;
938 break;
939 }
940 rc = host->FindHostDVDDrive(Bstr(szPathReal), dvdMedium.asOutParam());
941 if (!dvdMedium)
942 {
943 errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
944 rc = E_FAIL;
945 break;
946 }
947 }
948 }
949 else
950 {
951 /* first assume it's a UUID */
952 rc = a->virtualBox->GetDVDImage(uuid, dvdMedium.asOutParam());
953 if (FAILED(rc) || !dvdMedium)
954 {
955 /* must be a filename, check if it's in the collection */
956 rc = a->virtualBox->FindDVDImage(Bstr(ValueUnion.psz), dvdMedium.asOutParam());
957 /* not registered, do that on the fly */
958 if (!dvdMedium)
959 {
960 Bstr emptyUUID;
961 CHECK_ERROR(a->virtualBox, OpenDVDImage(Bstr(ValueUnion.psz),
962 emptyUUID, dvdMedium.asOutParam()));
963 }
964 }
965 if (!dvdMedium)
966 {
967 rc = E_FAIL;
968 break;
969 }
970 }
971
972 /** @todo generalize this, allow arbitrary number of DVD drives
973 * and as a consequence multiple attachments and different
974 * storage controllers. */
975 if (dvdMedium)
976 dvdMedium->COMGETTER(Id)(uuid.asOutParam());
977 CHECK_ERROR(machine, MountMedium(Bstr("IDE Controller"), 1, 0, uuid, FALSE /* aForce */));
978 break;
979 }
980
981 case MODIFYVM_FLOPPY: // deprecated
982 {
983 Bstr uuid(ValueUnion.psz);
984 ComPtr<IMedium> floppyMedium;
985 ComPtr<IMediumAttachment> floppyAttachment;
986 machine->GetMediumAttachment(Bstr("Floppy Controller"), 0, 0, floppyAttachment.asOutParam());
987
988 /* disable? */
989 if (!strcmp(ValueUnion.psz, "disabled"))
990 {
991 /* disable the controller */
992 if (floppyAttachment)
993 CHECK_ERROR(machine, DetachDevice(Bstr("Floppy Controller"), 0, 0));
994 }
995 else
996 {
997 /* enable the controller */
998 if (!floppyAttachment)
999 CHECK_ERROR(machine, AttachDevice(Bstr("Floppy Controller"), 0, 0, DeviceType_Floppy, NULL));
1000
1001 /* unmount? */
1002 if ( !strcmp(ValueUnion.psz, "none")
1003 || !strcmp(ValueUnion.psz, "empty")) // deprecated
1004 {
1005 /* nothing to do, NULL object will cause unmount */
1006 }
1007 /* host drive? */
1008 else if (!strncmp(ValueUnion.psz, "host:", 5))
1009 {
1010 ComPtr<IHost> host;
1011 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1012 rc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5), floppyMedium.asOutParam());
1013 if (!floppyMedium)
1014 {
1015 errorArgument("Invalid host floppy drive name \"%s\"", ValueUnion.psz + 5);
1016 rc = E_FAIL;
1017 break;
1018 }
1019 }
1020 else
1021 {
1022 /* first assume it's a UUID */
1023 rc = a->virtualBox->GetFloppyImage(uuid, floppyMedium.asOutParam());
1024 if (FAILED(rc) || !floppyMedium)
1025 {
1026 /* must be a filename, check if it's in the collection */
1027 rc = a->virtualBox->FindFloppyImage(Bstr(ValueUnion.psz), floppyMedium.asOutParam());
1028 /* not registered, do that on the fly */
1029 if (!floppyMedium)
1030 {
1031 Bstr emptyUUID;
1032 CHECK_ERROR(a->virtualBox,
1033 OpenFloppyImage(Bstr(ValueUnion.psz),
1034 emptyUUID,
1035 floppyMedium.asOutParam()));
1036 }
1037 }
1038 if (!floppyMedium)
1039 {
1040 rc = E_FAIL;
1041 break;
1042 }
1043 }
1044 floppyMedium->COMGETTER(Id)(uuid.asOutParam());
1045 CHECK_ERROR(machine, MountMedium(Bstr("Floppy Controller"), 0, 0, uuid, FALSE /* aForce */));
1046 }
1047 break;
1048 }
1049
1050 case MODIFYVM_NICTRACEFILE:
1051 {
1052 ComPtr<INetworkAdapter> nic;
1053
1054 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1055 ASSERT(nic);
1056
1057 CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz)));
1058 break;
1059 }
1060
1061 case MODIFYVM_NICTRACE:
1062 {
1063 ComPtr<INetworkAdapter> nic;
1064
1065 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1066 ASSERT(nic);
1067
1068 CHECK_ERROR(nic, COMSETTER(TraceEnabled)(ValueUnion.f));
1069 break;
1070 }
1071
1072 case MODIFYVM_NICTYPE:
1073 {
1074 ComPtr<INetworkAdapter> nic;
1075
1076 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1077 ASSERT(nic);
1078
1079 if (!strcmp(ValueUnion.psz, "Am79C970A"))
1080 {
1081 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C970A));
1082 }
1083 else if (!strcmp(ValueUnion.psz, "Am79C973"))
1084 {
1085 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C973));
1086 }
1087#ifdef VBOX_WITH_E1000
1088 else if (!strcmp(ValueUnion.psz, "82540EM"))
1089 {
1090 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82540EM));
1091 }
1092 else if (!strcmp(ValueUnion.psz, "82543GC"))
1093 {
1094 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82543GC));
1095 }
1096 else if (!strcmp(ValueUnion.psz, "82545EM"))
1097 {
1098 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82545EM));
1099 }
1100#endif
1101#ifdef VBOX_WITH_VIRTIO
1102 else if (!strcmp(ValueUnion.psz, "virtio"))
1103 {
1104 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Virtio));
1105 }
1106#endif /* VBOX_WITH_VIRTIO */
1107 else
1108 {
1109 errorArgument("Invalid NIC type '%s' specified for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1110 rc = E_FAIL;
1111 }
1112 break;
1113 }
1114
1115 case MODIFYVM_NICSPEED:
1116 {
1117 ComPtr<INetworkAdapter> nic;
1118
1119 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1120 ASSERT(nic);
1121
1122 CHECK_ERROR(nic, COMSETTER(LineSpeed)(ValueUnion.u32));
1123 break;
1124 }
1125
1126 case MODIFYVM_NIC:
1127 {
1128 ComPtr<INetworkAdapter> nic;
1129
1130 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1131 ASSERT(nic);
1132
1133 if (!strcmp(ValueUnion.psz, "none"))
1134 {
1135 CHECK_ERROR(nic, COMSETTER(Enabled)(FALSE));
1136 }
1137 else if (!strcmp(ValueUnion.psz, "null"))
1138 {
1139 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1140 CHECK_ERROR(nic, Detach());
1141 }
1142 else if (!strcmp(ValueUnion.psz, "nat"))
1143 {
1144 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1145 CHECK_ERROR(nic, AttachToNAT());
1146 }
1147 else if ( !strcmp(ValueUnion.psz, "bridged")
1148 || !strcmp(ValueUnion.psz, "hostif")) /* backward compatibility */
1149 {
1150 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1151 CHECK_ERROR(nic, AttachToBridgedInterface());
1152 }
1153 else if (!strcmp(ValueUnion.psz, "intnet"))
1154 {
1155 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1156 CHECK_ERROR(nic, AttachToInternalNetwork());
1157 }
1158#if defined(VBOX_WITH_NETFLT)
1159 else if (!strcmp(ValueUnion.psz, "hostonly"))
1160 {
1161
1162 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1163 CHECK_ERROR(nic, AttachToHostOnlyInterface());
1164 }
1165#endif
1166 else
1167 {
1168 errorArgument("Invalid type '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1169 rc = E_FAIL;
1170 }
1171 break;
1172 }
1173
1174 case MODIFYVM_CABLECONNECTED:
1175 {
1176 ComPtr<INetworkAdapter> nic;
1177
1178 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1179 ASSERT(nic);
1180
1181 CHECK_ERROR(nic, COMSETTER(CableConnected)(ValueUnion.f));
1182 break;
1183 }
1184
1185 case MODIFYVM_BRIDGEADAPTER:
1186 case MODIFYVM_HOSTONLYADAPTER:
1187 {
1188 ComPtr<INetworkAdapter> nic;
1189
1190 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1191 ASSERT(nic);
1192
1193 /* remove it? */
1194 if (!strcmp(ValueUnion.psz, "none"))
1195 {
1196 CHECK_ERROR(nic, COMSETTER(HostInterface)(NULL));
1197 }
1198 else
1199 {
1200 CHECK_ERROR(nic, COMSETTER(HostInterface)(Bstr(ValueUnion.psz)));
1201 }
1202 break;
1203 }
1204
1205 case MODIFYVM_INTNET:
1206 {
1207 ComPtr<INetworkAdapter> nic;
1208
1209 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1210 ASSERT(nic);
1211
1212 /* remove it? */
1213 if (!strcmp(ValueUnion.psz, "none"))
1214 {
1215 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(NULL));
1216 }
1217 else
1218 {
1219 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz)));
1220 }
1221 break;
1222 }
1223
1224 case MODIFYVM_NATNET:
1225 {
1226 ComPtr<INetworkAdapter> nic;
1227 ComPtr<INATEngine> driver;
1228
1229 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1230 ASSERT(nic);
1231
1232 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1233 CHECK_ERROR(driver, COMSETTER(Network)(Bstr(ValueUnion.psz)));
1234 break;
1235 }
1236
1237 case MODIFYVM_NATBINDIP:
1238 {
1239 ComPtr<INetworkAdapter> nic;
1240 ComPtr<INATEngine> driver;
1241
1242 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1243 ASSERT(nic);
1244
1245 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1246 CHECK_ERROR(driver, COMSETTER(HostIP)(Bstr(ValueUnion.psz)));
1247 break;
1248 }
1249
1250#define ITERATE_TO_NEXT_TERM(ch) \
1251 do { \
1252 while (*ch != ',') \
1253 { \
1254 if (*ch == 0) \
1255 { \
1256 return errorSyntax(USAGE_MODIFYVM, \
1257 "Missing or Invalid argument to '%s'", \
1258 GetOptState.pDef->pszLong); \
1259 } \
1260 ch++; \
1261 } \
1262 *ch = '\0'; \
1263 ch++; \
1264 } while(0)
1265
1266 case MODIFYVM_NATSETTINGS:
1267 {
1268 ComPtr<INetworkAdapter> nic;
1269 ComPtr<INATEngine> driver;
1270 char *strMtu;
1271 char *strSockSnd;
1272 char *strSockRcv;
1273 char *strTcpSnd;
1274 char *strTcpRcv;
1275 char *strRaw = RTStrDup(ValueUnion.psz);
1276 char *ch = strRaw;
1277 strMtu = ch;
1278 ITERATE_TO_NEXT_TERM(ch);
1279 strSockSnd = ch;
1280 ITERATE_TO_NEXT_TERM(ch);
1281 strSockRcv = ch;
1282 ITERATE_TO_NEXT_TERM(ch);
1283 strTcpSnd = ch;
1284 ITERATE_TO_NEXT_TERM(ch);
1285 strTcpRcv = ch;
1286
1287 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1288 ASSERT(nic);
1289
1290 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1291 CHECK_ERROR(driver, SetNetworkSettings(RTStrToUInt32(strMtu), RTStrToUInt32(strSockSnd), RTStrToUInt32(strSockRcv),
1292 RTStrToUInt32(strTcpSnd), RTStrToUInt32(strTcpRcv)));
1293 break;
1294 }
1295
1296
1297 case MODIFYVM_NATPF:
1298 {
1299 ComPtr<INetworkAdapter> nic;
1300 ComPtr<INATEngine> driver;
1301
1302 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1303 ASSERT(nic);
1304
1305 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1306 /* format name:proto:hostip:hostport:guestip:guestport*/
1307 if (RTStrCmp(ValueUnion.psz, "delete") != 0)
1308 {
1309 char *strName;
1310 char *strProto;
1311 char *strHostIp;
1312 char *strHostPort;
1313 char *strGuestIp;
1314 char *strGuestPort;
1315 char *strRaw = RTStrDup(ValueUnion.psz);
1316 char *ch = strRaw;
1317 strName = ch;
1318 ITERATE_TO_NEXT_TERM(ch);
1319 strProto = ch;
1320 ITERATE_TO_NEXT_TERM(ch);
1321 strHostIp = ch;
1322 ITERATE_TO_NEXT_TERM(ch);
1323 strHostPort = ch;
1324 ITERATE_TO_NEXT_TERM(ch);
1325 strGuestIp = ch;
1326 ITERATE_TO_NEXT_TERM(ch);
1327 strGuestPort = ch;
1328 NATProtocol_T proto;
1329 if (RTStrICmp(strProto, "udp") == 0)
1330 proto = NATProtocol_UDP;
1331 else if (RTStrICmp(strProto, "tcp") == 0)
1332 proto = NATProtocol_TCP;
1333 else
1334 {
1335 errorArgument("Invalid proto '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1336 rc = E_FAIL;
1337 break;
1338 }
1339 CHECK_ERROR(driver, AddRedirect(Bstr(strName), proto, Bstr(strHostIp),
1340 RTStrToUInt16(strHostPort), Bstr(strGuestIp), RTStrToUInt16(strGuestPort)));
1341 }
1342 else
1343 {
1344 /* delete NAT Rule operation */
1345 int vrc;
1346 vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
1347 if (RT_FAILURE(vrc))
1348 return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
1349 CHECK_ERROR(driver, RemoveRedirect(Bstr(ValueUnion.psz)));
1350 }
1351 break;
1352 }
1353 #undef ITERATE_TO_NEXT_TERM
1354
1355 case MODIFYVM_NATTFTPPREFIX:
1356 {
1357 ComPtr<INetworkAdapter> nic;
1358 ComPtr<INATEngine> driver;
1359
1360 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1361 ASSERT(nic);
1362
1363 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1364 CHECK_ERROR(driver, COMSETTER(TftpPrefix)(Bstr(ValueUnion.psz)));
1365 break;
1366 }
1367
1368 case MODIFYVM_NATTFTPFILE:
1369 {
1370 ComPtr<INetworkAdapter> nic;
1371 ComPtr<INATEngine> driver;
1372
1373 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1374 ASSERT(nic);
1375
1376 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1377 CHECK_ERROR(driver, COMSETTER(TftpBootFile)(Bstr(ValueUnion.psz)));
1378 break;
1379 }
1380
1381 case MODIFYVM_NATTFTPSERVER:
1382 {
1383 ComPtr<INetworkAdapter> nic;
1384 ComPtr<INATEngine> driver;
1385
1386 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1387 ASSERT(nic);
1388
1389 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1390 CHECK_ERROR(driver, COMSETTER(TftpNextServer)(Bstr(ValueUnion.psz)));
1391 break;
1392 }
1393 case MODIFYVM_NATDNSPASSDOMAIN:
1394 {
1395 ComPtr<INetworkAdapter> nic;
1396 ComPtr<INATEngine> driver;
1397
1398 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1399 ASSERT(nic);
1400
1401 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1402 CHECK_ERROR(driver, COMSETTER(DnsPassDomain)(ValueUnion.f));
1403 break;
1404 }
1405
1406 case MODIFYVM_NATDNSPROXY:
1407 {
1408 ComPtr<INetworkAdapter> nic;
1409 ComPtr<INATEngine> driver;
1410
1411 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1412 ASSERT(nic);
1413
1414 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1415 CHECK_ERROR(driver, COMSETTER(DnsProxy)(ValueUnion.f));
1416 break;
1417 }
1418
1419 case MODIFYVM_NATDNSHOSTRESOLVER:
1420 {
1421 ComPtr<INetworkAdapter> nic;
1422 ComPtr<INATEngine> driver;
1423
1424 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1425 ASSERT(nic);
1426
1427 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1428 CHECK_ERROR(driver, COMSETTER(DnsUseHostResolver)(ValueUnion.f));
1429 break;
1430 }
1431 case MODIFYVM_MACADDRESS:
1432 {
1433 ComPtr<INetworkAdapter> nic;
1434
1435 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1436 ASSERT(nic);
1437
1438 /* generate one? */
1439 if (!strcmp(ValueUnion.psz, "auto"))
1440 {
1441 CHECK_ERROR(nic, COMSETTER(MACAddress)(NULL));
1442 }
1443 else
1444 {
1445 CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz)));
1446 }
1447 break;
1448 }
1449
1450 case MODIFYVM_HIDPTR:
1451 {
1452 bool fEnableUsb = false;
1453 if (!strcmp(ValueUnion.psz, "ps2"))
1454 {
1455 CHECK_ERROR(machine, COMSETTER(PointingHidType)(PointingHidType_PS2Mouse));
1456 }
1457 else if (!strcmp(ValueUnion.psz, "usb"))
1458 {
1459 CHECK_ERROR(machine, COMSETTER(PointingHidType)(PointingHidType_USBMouse));
1460 if (SUCCEEDED(rc))
1461 fEnableUsb = true;
1462 }
1463 else if (!strcmp(ValueUnion.psz, "usbtablet"))
1464 {
1465 CHECK_ERROR(machine, COMSETTER(PointingHidType)(PointingHidType_USBTablet));
1466 if (SUCCEEDED(rc))
1467 fEnableUsb = true;
1468 }
1469 else
1470 {
1471 errorArgument("Invalid type '%s' specfied for pointing device", ValueUnion.psz);
1472 rc = E_FAIL;
1473 }
1474 if (fEnableUsb)
1475 {
1476 /* Make sure the OHCI controller is enabled. */
1477 ComPtr<IUSBController> UsbCtl;
1478 rc = machine->COMGETTER(USBController)(UsbCtl.asOutParam());
1479 if (SUCCEEDED(rc))
1480 {
1481 BOOL fEnabled;
1482 rc = UsbCtl->COMGETTER(Enabled)(&fEnabled);
1483 if (FAILED(rc))
1484 fEnabled = false;
1485 if (!fEnabled)
1486 CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(true));
1487 }
1488 }
1489 break;
1490 }
1491
1492 case MODIFYVM_HIDKBD:
1493 {
1494 bool fEnableUsb = false;
1495 if (!strcmp(ValueUnion.psz, "ps2"))
1496 {
1497 CHECK_ERROR(machine, COMSETTER(KeyboardHidType)(KeyboardHidType_PS2Keyboard));
1498 }
1499 else if (!strcmp(ValueUnion.psz, "usb"))
1500 {
1501 CHECK_ERROR(machine, COMSETTER(KeyboardHidType)(KeyboardHidType_USBKeyboard));
1502 if (SUCCEEDED(rc))
1503 fEnableUsb = true;
1504 }
1505 else
1506 {
1507 errorArgument("Invalid type '%s' specfied for keyboard", ValueUnion.psz);
1508 rc = E_FAIL;
1509 }
1510 if (fEnableUsb)
1511 {
1512 /* Make sure the OHCI controller is enabled. */
1513 ComPtr<IUSBController> UsbCtl;
1514 rc = machine->COMGETTER(USBController)(UsbCtl.asOutParam());
1515 if (SUCCEEDED(rc))
1516 {
1517 BOOL fEnabled;
1518 rc = UsbCtl->COMGETTER(Enabled)(&fEnabled);
1519 if (FAILED(rc))
1520 fEnabled = false;
1521 if (!fEnabled)
1522 CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(true));
1523 }
1524 }
1525 break;
1526 }
1527
1528 case MODIFYVM_UARTMODE:
1529 {
1530 ComPtr<ISerialPort> uart;
1531 char *pszIRQ = NULL;
1532
1533 CHECK_ERROR_BREAK(machine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
1534 ASSERT(uart);
1535
1536 if (!strcmp(ValueUnion.psz, "disconnected"))
1537 {
1538 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected));
1539 }
1540 else if ( !strcmp(ValueUnion.psz, "server")
1541 || !strcmp(ValueUnion.psz, "client")
1542 || !strcmp(ValueUnion.psz, "file"))
1543 {
1544 const char *pszMode = ValueUnion.psz;
1545
1546 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
1547 if (RT_FAILURE(vrc))
1548 return errorSyntax(USAGE_MODIFYVM,
1549 "Missing or Invalid argument to '%s'",
1550 GetOptState.pDef->pszLong);
1551
1552 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz)));
1553
1554 if (!strcmp(pszMode, "server"))
1555 {
1556 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
1557 CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
1558 }
1559 else if (!strcmp(pszMode, "client"))
1560 {
1561 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
1562 CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
1563 }
1564 else if (!strcmp(pszMode, "file"))
1565 {
1566 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile));
1567 }
1568 }
1569 else
1570 {
1571 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz)));
1572 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice));
1573 }
1574 break;
1575 }
1576
1577 case MODIFYVM_UART:
1578 {
1579 ComPtr<ISerialPort> uart;
1580
1581 CHECK_ERROR_BREAK(machine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
1582 ASSERT(uart);
1583
1584 if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
1585 CHECK_ERROR(uart, COMSETTER(Enabled)(FALSE));
1586 else
1587 {
1588 const char *pszIOBase = ValueUnion.psz;
1589 uint32_t uVal = 0;
1590
1591 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_UART;
1592 if (RT_FAILURE(vrc))
1593 return errorSyntax(USAGE_MODIFYVM,
1594 "Missing or Invalid argument to '%s'",
1595 GetOptState.pDef->pszLong);
1596
1597 CHECK_ERROR(uart, COMSETTER(IRQ)(ValueUnion.u32));
1598
1599 vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
1600 if (vrc != VINF_SUCCESS || uVal == 0)
1601 return errorArgument("Error parsing UART I/O base '%s'", pszIOBase);
1602 CHECK_ERROR(uart, COMSETTER(IOBase)(uVal));
1603
1604 CHECK_ERROR(uart, COMSETTER(Enabled)(TRUE));
1605 }
1606 break;
1607 }
1608
1609 case MODIFYVM_GUESTMEMORYBALLOON:
1610 {
1611 CHECK_ERROR(machine, COMSETTER(MemoryBalloonSize)(ValueUnion.u32));
1612 break;
1613 }
1614
1615 case MODIFYVM_AUDIOCONTROLLER:
1616 {
1617 ComPtr<IAudioAdapter> audioAdapter;
1618 machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
1619 ASSERT(audioAdapter);
1620
1621 if (!strcmp(ValueUnion.psz, "sb16"))
1622 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_SB16));
1623 else if (!strcmp(ValueUnion.psz, "ac97"))
1624 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_AC97));
1625 else
1626 {
1627 errorArgument("Invalid --audiocontroller argument '%s'", ValueUnion.psz);
1628 rc = E_FAIL;
1629 }
1630 break;
1631 }
1632
1633 case MODIFYVM_AUDIO:
1634 {
1635 ComPtr<IAudioAdapter> audioAdapter;
1636 machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
1637 ASSERT(audioAdapter);
1638
1639 /* disable? */
1640 if (!strcmp(ValueUnion.psz, "none"))
1641 {
1642 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(false));
1643 }
1644 else if (!strcmp(ValueUnion.psz, "null"))
1645 {
1646 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Null));
1647 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1648 }
1649#ifdef RT_OS_WINDOWS
1650#ifdef VBOX_WITH_WINMM
1651 else if (!strcmp(ValueUnion.psz, "winmm"))
1652 {
1653 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WinMM));
1654 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1655 }
1656#endif
1657 else if (!strcmp(ValueUnion.psz, "dsound"))
1658 {
1659 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_DirectSound));
1660 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1661 }
1662#endif /* RT_OS_WINDOWS */
1663#ifdef RT_OS_LINUX
1664# ifdef VBOX_WITH_ALSA
1665 else if (!strcmp(ValueUnion.psz, "alsa"))
1666 {
1667 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_ALSA));
1668 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1669 }
1670# endif
1671# ifdef VBOX_WITH_PULSE
1672 else if (!strcmp(ValueUnion.psz, "pulse"))
1673 {
1674 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
1675 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1676 }
1677# endif
1678#endif /* !RT_OS_LINUX */
1679#ifdef RT_OS_SOLARIS
1680 else if (!strcmp(ValueUnion.psz, "solaudio"))
1681 {
1682 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_SolAudio));
1683 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1684 }
1685#endif /* !RT_OS_SOLARIS */
1686#ifdef RT_OS_FREEBSD
1687 else if (!strcmp(ValueUnion.psz, "oss"))
1688 {
1689 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS));
1690 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1691 }
1692# ifdef VBOX_WITH_PULSE
1693 else if (!strcmp(ValueUnion.psz, "pulse"))
1694 {
1695 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
1696 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1697 }
1698# endif
1699#endif /* !RT_OS_FREEBSD */
1700#ifdef RT_OS_DARWIN
1701 else if (!strcmp(ValueUnion.psz, "coreaudio"))
1702 {
1703 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_CoreAudio));
1704 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1705 }
1706
1707#endif /* !RT_OS_DARWIN */
1708# if defined(RT_OS_FREEBSD) || defined(RT_OS_LINUX) || defined(VBOX_WITH_SOLARIS_OSS)
1709 else if (!strcmp(ValueUnion.psz, "oss"))
1710 {
1711 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS));
1712 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1713 }
1714# endif
1715 else
1716 {
1717 errorArgument("Invalid --audio argument '%s'", ValueUnion.psz);
1718 rc = E_FAIL;
1719 }
1720 break;
1721 }
1722
1723 case MODIFYVM_CLIPBOARD:
1724 {
1725 if (!strcmp(ValueUnion.psz, "disabled"))
1726 {
1727 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_Disabled));
1728 }
1729 else if (!strcmp(ValueUnion.psz, "hosttoguest"))
1730 {
1731 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_HostToGuest));
1732 }
1733 else if (!strcmp(ValueUnion.psz, "guesttohost"))
1734 {
1735 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_GuestToHost));
1736 }
1737 else if (!strcmp(ValueUnion.psz, "bidirectional"))
1738 {
1739 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_Bidirectional));
1740 }
1741 else
1742 {
1743 errorArgument("Invalid --clipboard argument '%s'", ValueUnion.psz);
1744 rc = E_FAIL;
1745 }
1746 break;
1747 }
1748
1749#ifdef VBOX_WITH_VRDP
1750 case MODIFYVM_VRDPPORT:
1751 {
1752 ComPtr<IVRDPServer> vrdpServer;
1753 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1754 ASSERT(vrdpServer);
1755
1756 if (!strcmp(ValueUnion.psz, "default"))
1757 CHECK_ERROR(vrdpServer, COMSETTER(Ports)(Bstr("0")));
1758 else
1759 CHECK_ERROR(vrdpServer, COMSETTER(Ports)(Bstr(ValueUnion.psz)));
1760 break;
1761 }
1762
1763 case MODIFYVM_VRDPADDRESS:
1764 {
1765 ComPtr<IVRDPServer> vrdpServer;
1766 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1767 ASSERT(vrdpServer);
1768
1769 CHECK_ERROR(vrdpServer, COMSETTER(NetAddress)(Bstr(ValueUnion.psz)));
1770 break;
1771 }
1772
1773 case MODIFYVM_VRDPAUTHTYPE:
1774 {
1775 ComPtr<IVRDPServer> vrdpServer;
1776 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1777 ASSERT(vrdpServer);
1778
1779 if (!strcmp(ValueUnion.psz, "null"))
1780 {
1781 CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_Null));
1782 }
1783 else if (!strcmp(ValueUnion.psz, "external"))
1784 {
1785 CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_External));
1786 }
1787 else if (!strcmp(ValueUnion.psz, "guest"))
1788 {
1789 CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_Guest));
1790 }
1791 else
1792 {
1793 errorArgument("Invalid --vrdpauthtype argument '%s'", ValueUnion.psz);
1794 rc = E_FAIL;
1795 }
1796 break;
1797 }
1798
1799 case MODIFYVM_VRDPMULTICON:
1800 {
1801 ComPtr<IVRDPServer> vrdpServer;
1802 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1803 ASSERT(vrdpServer);
1804
1805 CHECK_ERROR(vrdpServer, COMSETTER(AllowMultiConnection)(ValueUnion.f));
1806 break;
1807 }
1808
1809 case MODIFYVM_VRDPREUSECON:
1810 {
1811 ComPtr<IVRDPServer> vrdpServer;
1812 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1813 ASSERT(vrdpServer);
1814
1815 CHECK_ERROR(vrdpServer, COMSETTER(ReuseSingleConnection)(ValueUnion.f));
1816 break;
1817 }
1818
1819 case MODIFYVM_VRDP:
1820 {
1821 ComPtr<IVRDPServer> vrdpServer;
1822 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1823 ASSERT(vrdpServer);
1824
1825 CHECK_ERROR(vrdpServer, COMSETTER(Enabled)(ValueUnion.f));
1826 break;
1827 }
1828#endif /* VBOX_WITH_VRDP */
1829
1830 case MODIFYVM_USBEHCI:
1831 {
1832 ComPtr<IUSBController> UsbCtl;
1833 CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
1834 if (SUCCEEDED(rc))
1835 CHECK_ERROR(UsbCtl, COMSETTER(EnabledEhci)(ValueUnion.f));
1836 break;
1837 }
1838
1839 case MODIFYVM_USB:
1840 {
1841 ComPtr<IUSBController> UsbCtl;
1842 CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
1843 if (SUCCEEDED(rc))
1844 CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(ValueUnion.f));
1845 break;
1846 }
1847
1848 case MODIFYVM_SNAPSHOTFOLDER:
1849 {
1850 if (!strcmp(ValueUnion.psz, "default"))
1851 CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(NULL));
1852 else
1853 CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz)));
1854 break;
1855 }
1856
1857 case MODIFYVM_TELEPORTER_ENABLED:
1858 {
1859 CHECK_ERROR(machine, COMSETTER(TeleporterEnabled)(ValueUnion.f));
1860 break;
1861 }
1862
1863 case MODIFYVM_TELEPORTER_PORT:
1864 {
1865 CHECK_ERROR(machine, COMSETTER(TeleporterPort)(ValueUnion.u32));
1866 break;
1867 }
1868
1869 case MODIFYVM_TELEPORTER_ADDRESS:
1870 {
1871 CHECK_ERROR(machine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz)));
1872 break;
1873 }
1874
1875 case MODIFYVM_TELEPORTER_PASSWORD:
1876 {
1877 CHECK_ERROR(machine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz)));
1878 break;
1879 }
1880
1881 case MODIFYVM_HARDWARE_UUID:
1882 {
1883 CHECK_ERROR(machine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz)));
1884 break;
1885 }
1886
1887 case MODIFYVM_HPET:
1888 {
1889 CHECK_ERROR(machine, COMSETTER(HpetEnabled)(ValueUnion.f));
1890 break;
1891 }
1892
1893 case MODIFYVM_IOMGR:
1894 {
1895 if (!strcmp(ValueUnion.psz, "simple"))
1896 CHECK_ERROR(machine, COMSETTER(IoMgr)(IoMgrType_Simple));
1897 else if (!strcmp(ValueUnion.psz, "async"))
1898 CHECK_ERROR(machine, COMSETTER(IoMgr)(IoMgrType_Async));
1899 else
1900 {
1901 errorArgument("Invalid --iomgr argument '%s'", ValueUnion.psz);
1902 rc = E_FAIL;
1903 }
1904 break;
1905 }
1906
1907 case MODIFYVM_IOBACKEND:
1908 {
1909 if (!strcmp(ValueUnion.psz, "buffered"))
1910 CHECK_ERROR(machine, COMSETTER(IoBackend)(IoBackendType_Buffered));
1911 else if (!strcmp(ValueUnion.psz, "unbuffered"))
1912 CHECK_ERROR(machine, COMSETTER(IoBackend)(IoBackendType_Unbuffered));
1913 else
1914 {
1915 errorArgument("Invalid --iobackend argument '%s'", ValueUnion.psz);
1916 rc = E_FAIL;
1917 }
1918 break;
1919 }
1920
1921 case MODIFYVM_IOCACHE:
1922 {
1923 CHECK_ERROR(machine, COMSETTER(IoCacheEnabled)(ValueUnion.f));
1924 break;
1925 }
1926
1927 case MODIFYVM_IOCACHESIZE:
1928 {
1929 CHECK_ERROR(machine, COMSETTER(IoCacheSize)(ValueUnion.u32));
1930 break;
1931 }
1932
1933 case MODIFYVM_IOBANDWIDTHMAX:
1934 {
1935 CHECK_ERROR(machine, COMSETTER(IoBandwidthMax)(ValueUnion.u32));
1936 break;
1937 }
1938
1939 default:
1940 {
1941 errorGetOpt(USAGE_MODIFYVM, c, &ValueUnion);
1942 rc = E_FAIL;
1943 break;
1944 }
1945 }
1946 }
1947
1948 /* commit changes */
1949 if (SUCCEEDED(rc))
1950 CHECK_ERROR(machine, SaveSettings());
1951
1952 /* it's important to always close sessions */
1953 a->session->Close();
1954
1955 return SUCCEEDED(rc) ? 0 : 1;
1956}
1957
1958#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