VirtualBox

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

Last change on this file since 33356 was 33294, checked in by vboxsync, 15 years ago

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