VirtualBox

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

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

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