VirtualBox

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

Last change on this file since 33084 was 33020, checked in by vboxsync, 15 years ago

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

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