VirtualBox

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

Last change on this file since 32947 was 32913, checked in by vboxsync, 15 years ago

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