VirtualBox

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

Last change on this file since 50776 was 50721, checked in by vboxsync, 11 years ago

Updated USB configuration.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 110.9 KB
Line 
1/* $Id: VBoxManageModifyVM.cpp 50721 2014-03-06 21:40:39Z vboxsync $ */
2/** @file
3 * VBoxManage - Implementation of modifyvm command.
4 */
5
6/*
7 * Copyright (C) 2006-2013 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/VirtualBox.h>
27#endif /* !VBOX_ONLY_DOCS */
28
29#include <iprt/cidr.h>
30#include <iprt/ctype.h>
31#include <iprt/file.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#include "VBoxManage.h"
39
40#ifndef VBOX_ONLY_DOCS
41using namespace com;
42/** @todo refine this after HDD changes; MSC 8.0/64 has trouble with handleModifyVM. */
43#if defined(_MSC_VER)
44# pragma optimize("g", off)
45#endif
46
47enum
48{
49 MODIFYVM_NAME = 1000,
50 MODIFYVM_GROUPS,
51 MODIFYVM_DESCRIPTION,
52 MODIFYVM_OSTYPE,
53 MODIFYVM_ICONFILE,
54 MODIFYVM_MEMORY,
55 MODIFYVM_PAGEFUSION,
56 MODIFYVM_VRAM,
57 MODIFYVM_FIRMWARE,
58 MODIFYVM_ACPI,
59 MODIFYVM_IOAPIC,
60 MODIFYVM_PAE,
61 MODIFYVM_LONGMODE,
62 MODIFYVM_SYNTHCPU,
63 MODIFYVM_TFRESET,
64 MODIFYVM_HWVIRTEX,
65 MODIFYVM_NESTEDPAGING,
66 MODIFYVM_LARGEPAGES,
67 MODIFYVM_VTXVPID,
68 MODIFYVM_VTXUX,
69 MODIFYVM_CPUS,
70 MODIFYVM_CPUHOTPLUG,
71 MODIFYVM_PLUGCPU,
72 MODIFYVM_UNPLUGCPU,
73 MODIFYVM_SETCPUID,
74 MODIFYVM_DELCPUID,
75 MODIFYVM_DELALLCPUID,
76 MODIFYVM_GRAPHICSCONTROLLER,
77 MODIFYVM_MONITORCOUNT,
78 MODIFYVM_ACCELERATE3D,
79#ifdef VBOX_WITH_VIDEOHWACCEL
80 MODIFYVM_ACCELERATE2DVIDEO,
81#endif
82 MODIFYVM_BIOSLOGOFADEIN,
83 MODIFYVM_BIOSLOGOFADEOUT,
84 MODIFYVM_BIOSLOGODISPLAYTIME,
85 MODIFYVM_BIOSLOGOIMAGEPATH,
86 MODIFYVM_BIOSBOOTMENU,
87 MODIFYVM_BIOSSYSTEMTIMEOFFSET,
88 MODIFYVM_BIOSPXEDEBUG,
89 MODIFYVM_BOOT,
90 MODIFYVM_HDA, // deprecated
91 MODIFYVM_HDB, // deprecated
92 MODIFYVM_HDD, // deprecated
93 MODIFYVM_IDECONTROLLER, // deprecated
94 MODIFYVM_SATAPORTCOUNT, // deprecated
95 MODIFYVM_SATAPORT, // deprecated
96 MODIFYVM_SATA, // deprecated
97 MODIFYVM_SCSIPORT, // deprecated
98 MODIFYVM_SCSITYPE, // deprecated
99 MODIFYVM_SCSI, // deprecated
100 MODIFYVM_DVDPASSTHROUGH, // deprecated
101 MODIFYVM_DVD, // deprecated
102 MODIFYVM_FLOPPY, // deprecated
103 MODIFYVM_NICTRACEFILE,
104 MODIFYVM_NICTRACE,
105 MODIFYVM_NICPROPERTY,
106 MODIFYVM_NICTYPE,
107 MODIFYVM_NICSPEED,
108 MODIFYVM_NICBOOTPRIO,
109 MODIFYVM_NICPROMISC,
110 MODIFYVM_NICBWGROUP,
111 MODIFYVM_NIC,
112 MODIFYVM_CABLECONNECTED,
113 MODIFYVM_BRIDGEADAPTER,
114 MODIFYVM_HOSTONLYADAPTER,
115 MODIFYVM_INTNET,
116 MODIFYVM_GENERICDRV,
117 MODIFYVM_NATNETWORKNAME,
118 MODIFYVM_NATNET,
119 MODIFYVM_NATBINDIP,
120 MODIFYVM_NATSETTINGS,
121 MODIFYVM_NATPF,
122 MODIFYVM_NATALIASMODE,
123 MODIFYVM_NATTFTPPREFIX,
124 MODIFYVM_NATTFTPFILE,
125 MODIFYVM_NATTFTPSERVER,
126 MODIFYVM_NATDNSPASSDOMAIN,
127 MODIFYVM_NATDNSPROXY,
128 MODIFYVM_NATDNSHOSTRESOLVER,
129 MODIFYVM_MACADDRESS,
130 MODIFYVM_HIDPTR,
131 MODIFYVM_HIDKBD,
132 MODIFYVM_UARTMODE,
133 MODIFYVM_UART,
134#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS)
135 MODIFYVM_LPTMODE,
136 MODIFYVM_LPT,
137#endif
138 MODIFYVM_GUESTMEMORYBALLOON,
139 MODIFYVM_AUDIOCONTROLLER,
140 MODIFYVM_AUDIO,
141 MODIFYVM_CLIPBOARD,
142 MODIFYVM_DRAGANDDROP,
143 MODIFYVM_VRDPPORT, /* VRDE: deprecated */
144 MODIFYVM_VRDPADDRESS, /* VRDE: deprecated */
145 MODIFYVM_VRDPAUTHTYPE, /* VRDE: deprecated */
146 MODIFYVM_VRDPMULTICON, /* VRDE: deprecated */
147 MODIFYVM_VRDPREUSECON, /* VRDE: deprecated */
148 MODIFYVM_VRDPVIDEOCHANNEL, /* VRDE: deprecated */
149 MODIFYVM_VRDPVIDEOCHANNELQUALITY, /* VRDE: deprecated */
150 MODIFYVM_VRDP, /* VRDE: deprecated */
151 MODIFYVM_VRDEPROPERTY,
152 MODIFYVM_VRDEPORT,
153 MODIFYVM_VRDEADDRESS,
154 MODIFYVM_VRDEAUTHTYPE,
155 MODIFYVM_VRDEAUTHLIBRARY,
156 MODIFYVM_VRDEMULTICON,
157 MODIFYVM_VRDEREUSECON,
158 MODIFYVM_VRDEVIDEOCHANNEL,
159 MODIFYVM_VRDEVIDEOCHANNELQUALITY,
160 MODIFYVM_VRDE_EXTPACK,
161 MODIFYVM_VRDE,
162 MODIFYVM_RTCUSEUTC,
163 MODIFYVM_USBXHCI,
164 MODIFYVM_USBEHCI,
165 MODIFYVM_USB,
166 MODIFYVM_SNAPSHOTFOLDER,
167 MODIFYVM_TELEPORTER_ENABLED,
168 MODIFYVM_TELEPORTER_PORT,
169 MODIFYVM_TELEPORTER_ADDRESS,
170 MODIFYVM_TELEPORTER_PASSWORD,
171 MODIFYVM_TELEPORTER_PASSWORD_FILE,
172 MODIFYVM_TRACING_ENABLED,
173 MODIFYVM_TRACING_CONFIG,
174 MODIFYVM_TRACING_ALLOW_VM_ACCESS,
175 MODIFYVM_HARDWARE_UUID,
176 MODIFYVM_HPET,
177 MODIFYVM_IOCACHE,
178 MODIFYVM_IOCACHESIZE,
179 MODIFYVM_FAULT_TOLERANCE,
180 MODIFYVM_FAULT_TOLERANCE_ADDRESS,
181 MODIFYVM_FAULT_TOLERANCE_PORT,
182 MODIFYVM_FAULT_TOLERANCE_PASSWORD,
183 MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL,
184 MODIFYVM_CPU_EXECTUION_CAP,
185 MODIFYVM_AUTOSTART_ENABLED,
186 MODIFYVM_AUTOSTART_DELAY,
187 MODIFYVM_AUTOSTOP_TYPE,
188#ifdef VBOX_WITH_PCI_PASSTHROUGH
189 MODIFYVM_ATTACH_PCI,
190 MODIFYVM_DETACH_PCI,
191#endif
192#ifdef VBOX_WITH_USB_CARDREADER
193 MODIFYVM_USBCARDREADER,
194#endif
195#ifdef VBOX_WITH_VPX
196 MODIFYVM_VCP,
197 MODIFYVM_VCP_SCREENS,
198 MODIFYVM_VCP_FILENAME,
199 MODIFYVM_VCP_WIDTH,
200 MODIFYVM_VCP_HEIGHT,
201 MODIFYVM_VCP_RATE,
202 MODIFYVM_VCP_FPS,
203#endif
204 MODIFYVM_CHIPSET,
205 MODIFYVM_DEFAULTFRONTEND
206};
207
208static const RTGETOPTDEF g_aModifyVMOptions[] =
209{
210 { "--name", MODIFYVM_NAME, RTGETOPT_REQ_STRING },
211 { "--groups", MODIFYVM_GROUPS, RTGETOPT_REQ_STRING },
212 { "--description", MODIFYVM_DESCRIPTION, RTGETOPT_REQ_STRING },
213 { "--ostype", MODIFYVM_OSTYPE, RTGETOPT_REQ_STRING },
214 { "--iconfile", MODIFYVM_ICONFILE, RTGETOPT_REQ_STRING },
215 { "--memory", MODIFYVM_MEMORY, RTGETOPT_REQ_UINT32 },
216 { "--pagefusion", MODIFYVM_PAGEFUSION, RTGETOPT_REQ_BOOL_ONOFF },
217 { "--vram", MODIFYVM_VRAM, RTGETOPT_REQ_UINT32 },
218 { "--firmware", MODIFYVM_FIRMWARE, RTGETOPT_REQ_STRING },
219 { "--acpi", MODIFYVM_ACPI, RTGETOPT_REQ_BOOL_ONOFF },
220 { "--ioapic", MODIFYVM_IOAPIC, RTGETOPT_REQ_BOOL_ONOFF },
221 { "--pae", MODIFYVM_PAE, RTGETOPT_REQ_BOOL_ONOFF },
222 { "--longmode", MODIFYVM_LONGMODE, RTGETOPT_REQ_BOOL_ONOFF },
223 { "--synthcpu", MODIFYVM_SYNTHCPU, RTGETOPT_REQ_BOOL_ONOFF },
224 { "--triplefaultreset", MODIFYVM_TFRESET, RTGETOPT_REQ_BOOL_ONOFF },
225 { "--hwvirtex", MODIFYVM_HWVIRTEX, RTGETOPT_REQ_BOOL_ONOFF },
226 { "--nestedpaging", MODIFYVM_NESTEDPAGING, RTGETOPT_REQ_BOOL_ONOFF },
227 { "--largepages", MODIFYVM_LARGEPAGES, RTGETOPT_REQ_BOOL_ONOFF },
228 { "--vtxvpid", MODIFYVM_VTXVPID, RTGETOPT_REQ_BOOL_ONOFF },
229 { "--vtxux", MODIFYVM_VTXUX, RTGETOPT_REQ_BOOL_ONOFF },
230 { "--cpuidset", MODIFYVM_SETCPUID, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX},
231 { "--cpuidremove", MODIFYVM_DELCPUID, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX},
232 { "--cpuidremoveall", MODIFYVM_DELALLCPUID, RTGETOPT_REQ_NOTHING},
233 { "--cpus", MODIFYVM_CPUS, RTGETOPT_REQ_UINT32 },
234 { "--cpuhotplug", MODIFYVM_CPUHOTPLUG, RTGETOPT_REQ_BOOL_ONOFF },
235 { "--plugcpu", MODIFYVM_PLUGCPU, RTGETOPT_REQ_UINT32 },
236 { "--unplugcpu", MODIFYVM_UNPLUGCPU, RTGETOPT_REQ_UINT32 },
237 { "--cpuexecutioncap", MODIFYVM_CPU_EXECTUION_CAP, RTGETOPT_REQ_UINT32 },
238 { "--rtcuseutc", MODIFYVM_RTCUSEUTC, RTGETOPT_REQ_BOOL_ONOFF },
239 { "--graphicscontroller", MODIFYVM_GRAPHICSCONTROLLER, RTGETOPT_REQ_STRING },
240 { "--monitorcount", MODIFYVM_MONITORCOUNT, RTGETOPT_REQ_UINT32 },
241 { "--accelerate3d", MODIFYVM_ACCELERATE3D, RTGETOPT_REQ_BOOL_ONOFF },
242#ifdef VBOX_WITH_VIDEOHWACCEL
243 { "--accelerate2dvideo", MODIFYVM_ACCELERATE2DVIDEO, RTGETOPT_REQ_BOOL_ONOFF },
244#endif
245 { "--bioslogofadein", MODIFYVM_BIOSLOGOFADEIN, RTGETOPT_REQ_BOOL_ONOFF },
246 { "--bioslogofadeout", MODIFYVM_BIOSLOGOFADEOUT, RTGETOPT_REQ_BOOL_ONOFF },
247 { "--bioslogodisplaytime", MODIFYVM_BIOSLOGODISPLAYTIME, RTGETOPT_REQ_UINT32 },
248 { "--bioslogoimagepath", MODIFYVM_BIOSLOGOIMAGEPATH, RTGETOPT_REQ_STRING },
249 { "--biosbootmenu", MODIFYVM_BIOSBOOTMENU, RTGETOPT_REQ_STRING },
250 { "--biossystemtimeoffset", MODIFYVM_BIOSSYSTEMTIMEOFFSET, RTGETOPT_REQ_INT64 },
251 { "--biospxedebug", MODIFYVM_BIOSPXEDEBUG, RTGETOPT_REQ_BOOL_ONOFF },
252 { "--boot", MODIFYVM_BOOT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
253 { "--hda", MODIFYVM_HDA, RTGETOPT_REQ_STRING },
254 { "--hdb", MODIFYVM_HDB, RTGETOPT_REQ_STRING },
255 { "--hdd", MODIFYVM_HDD, RTGETOPT_REQ_STRING },
256 { "--idecontroller", MODIFYVM_IDECONTROLLER, RTGETOPT_REQ_STRING },
257 { "--sataportcount", MODIFYVM_SATAPORTCOUNT, RTGETOPT_REQ_UINT32 },
258 { "--sataport", MODIFYVM_SATAPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
259 { "--sata", MODIFYVM_SATA, RTGETOPT_REQ_STRING },
260 { "--scsiport", MODIFYVM_SCSIPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
261 { "--scsitype", MODIFYVM_SCSITYPE, RTGETOPT_REQ_STRING },
262 { "--scsi", MODIFYVM_SCSI, RTGETOPT_REQ_STRING },
263 { "--dvdpassthrough", MODIFYVM_DVDPASSTHROUGH, RTGETOPT_REQ_STRING },
264 { "--dvd", MODIFYVM_DVD, RTGETOPT_REQ_STRING },
265 { "--floppy", MODIFYVM_FLOPPY, RTGETOPT_REQ_STRING },
266 { "--nictracefile", MODIFYVM_NICTRACEFILE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
267 { "--nictrace", MODIFYVM_NICTRACE, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
268 { "--nicproperty", MODIFYVM_NICPROPERTY, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
269 { "--nictype", MODIFYVM_NICTYPE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
270 { "--nicspeed", MODIFYVM_NICSPEED, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
271 { "--nicbootprio", MODIFYVM_NICBOOTPRIO, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
272 { "--nicpromisc", MODIFYVM_NICPROMISC, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
273 { "--nicbandwidthgroup", MODIFYVM_NICBWGROUP, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
274 { "--nic", MODIFYVM_NIC, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
275 { "--cableconnected", MODIFYVM_CABLECONNECTED, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
276 { "--bridgeadapter", MODIFYVM_BRIDGEADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
277 { "--hostonlyadapter", MODIFYVM_HOSTONLYADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
278 { "--intnet", MODIFYVM_INTNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
279 { "--nicgenericdrv", MODIFYVM_GENERICDRV, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
280 { "--nat-network", MODIFYVM_NATNETWORKNAME, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
281 { "--natnetwork", MODIFYVM_NATNETWORKNAME, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
282 { "--natnet", MODIFYVM_NATNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
283 { "--natbindip", MODIFYVM_NATBINDIP, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
284 { "--natsettings", MODIFYVM_NATSETTINGS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
285 { "--natpf", MODIFYVM_NATPF, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
286 { "--nataliasmode", MODIFYVM_NATALIASMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
287 { "--nattftpprefix", MODIFYVM_NATTFTPPREFIX, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
288 { "--nattftpfile", MODIFYVM_NATTFTPFILE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
289 { "--nattftpserver", MODIFYVM_NATTFTPSERVER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
290 { "--natdnspassdomain", MODIFYVM_NATDNSPASSDOMAIN, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
291 { "--natdnsproxy", MODIFYVM_NATDNSPROXY, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
292 { "--natdnshostresolver", MODIFYVM_NATDNSHOSTRESOLVER, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
293 { "--macaddress", MODIFYVM_MACADDRESS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
294 { "--mouse", MODIFYVM_HIDPTR, RTGETOPT_REQ_STRING },
295 { "--keyboard", MODIFYVM_HIDKBD, RTGETOPT_REQ_STRING },
296 { "--uartmode", MODIFYVM_UARTMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
297 { "--uart", MODIFYVM_UART, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
298#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS)
299 { "--lptmode", MODIFYVM_LPTMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
300 { "--lpt", MODIFYVM_LPT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
301#endif
302 { "--guestmemoryballoon", MODIFYVM_GUESTMEMORYBALLOON, RTGETOPT_REQ_UINT32 },
303 { "--audiocontroller", MODIFYVM_AUDIOCONTROLLER, RTGETOPT_REQ_STRING },
304 { "--audio", MODIFYVM_AUDIO, RTGETOPT_REQ_STRING },
305 { "--clipboard", MODIFYVM_CLIPBOARD, RTGETOPT_REQ_STRING },
306 { "--draganddrop", MODIFYVM_DRAGANDDROP, RTGETOPT_REQ_STRING },
307 { "--vrdpport", MODIFYVM_VRDPPORT, RTGETOPT_REQ_STRING }, /* deprecated */
308 { "--vrdpaddress", MODIFYVM_VRDPADDRESS, RTGETOPT_REQ_STRING }, /* deprecated */
309 { "--vrdpauthtype", MODIFYVM_VRDPAUTHTYPE, RTGETOPT_REQ_STRING }, /* deprecated */
310 { "--vrdpmulticon", MODIFYVM_VRDPMULTICON, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
311 { "--vrdpreusecon", MODIFYVM_VRDPREUSECON, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
312 { "--vrdpvideochannel", MODIFYVM_VRDPVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
313 { "--vrdpvideochannelquality", MODIFYVM_VRDPVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING }, /* deprecated */
314 { "--vrdp", MODIFYVM_VRDP, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
315 { "--vrdeproperty", MODIFYVM_VRDEPROPERTY, RTGETOPT_REQ_STRING },
316 { "--vrdeport", MODIFYVM_VRDEPORT, RTGETOPT_REQ_STRING },
317 { "--vrdeaddress", MODIFYVM_VRDEADDRESS, RTGETOPT_REQ_STRING },
318 { "--vrdeauthtype", MODIFYVM_VRDEAUTHTYPE, RTGETOPT_REQ_STRING },
319 { "--vrdeauthlibrary", MODIFYVM_VRDEAUTHLIBRARY, RTGETOPT_REQ_STRING },
320 { "--vrdemulticon", MODIFYVM_VRDEMULTICON, RTGETOPT_REQ_BOOL_ONOFF },
321 { "--vrdereusecon", MODIFYVM_VRDEREUSECON, RTGETOPT_REQ_BOOL_ONOFF },
322 { "--vrdevideochannel", MODIFYVM_VRDEVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF },
323 { "--vrdevideochannelquality", MODIFYVM_VRDEVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING },
324 { "--vrdeextpack", MODIFYVM_VRDE_EXTPACK, RTGETOPT_REQ_STRING },
325 { "--vrde", MODIFYVM_VRDE, RTGETOPT_REQ_BOOL_ONOFF },
326 { "--usbxhci", MODIFYVM_USBXHCI, RTGETOPT_REQ_BOOL_ONOFF },
327 { "--usbehci", MODIFYVM_USBEHCI, RTGETOPT_REQ_BOOL_ONOFF },
328 { "--usb", MODIFYVM_USB, RTGETOPT_REQ_BOOL_ONOFF },
329 { "--snapshotfolder", MODIFYVM_SNAPSHOTFOLDER, RTGETOPT_REQ_STRING },
330 { "--teleporter", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
331 { "--teleporterenabled", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
332 { "--teleporterport", MODIFYVM_TELEPORTER_PORT, RTGETOPT_REQ_UINT32 },
333 { "--teleporteraddress", MODIFYVM_TELEPORTER_ADDRESS, RTGETOPT_REQ_STRING },
334 { "--teleporterpassword", MODIFYVM_TELEPORTER_PASSWORD, RTGETOPT_REQ_STRING },
335 { "--teleporterpasswordfile", MODIFYVM_TELEPORTER_PASSWORD_FILE, RTGETOPT_REQ_STRING },
336 { "--tracing-enabled", MODIFYVM_TRACING_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
337 { "--tracing-config", MODIFYVM_TRACING_CONFIG, RTGETOPT_REQ_STRING },
338 { "--tracing-allow-vm-access", MODIFYVM_TRACING_ALLOW_VM_ACCESS, RTGETOPT_REQ_BOOL_ONOFF },
339 { "--hardwareuuid", MODIFYVM_HARDWARE_UUID, RTGETOPT_REQ_STRING },
340 { "--hpet", MODIFYVM_HPET, RTGETOPT_REQ_BOOL_ONOFF },
341 { "--iocache", MODIFYVM_IOCACHE, RTGETOPT_REQ_BOOL_ONOFF },
342 { "--iocachesize", MODIFYVM_IOCACHESIZE, RTGETOPT_REQ_UINT32 },
343 { "--faulttolerance", MODIFYVM_FAULT_TOLERANCE, RTGETOPT_REQ_STRING },
344 { "--faulttoleranceaddress", MODIFYVM_FAULT_TOLERANCE_ADDRESS, RTGETOPT_REQ_STRING },
345 { "--faulttoleranceport", MODIFYVM_FAULT_TOLERANCE_PORT, RTGETOPT_REQ_UINT32 },
346 { "--faulttolerancepassword", MODIFYVM_FAULT_TOLERANCE_PASSWORD, RTGETOPT_REQ_STRING },
347 { "--faulttolerancesyncinterval", MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL, RTGETOPT_REQ_UINT32 },
348 { "--chipset", MODIFYVM_CHIPSET, RTGETOPT_REQ_STRING },
349#ifdef VBOX_WITH_VPX
350 { "--vcpenabled", MODIFYVM_VCP, RTGETOPT_REQ_BOOL_ONOFF },
351 { "--vcpscreens", MODIFYVM_VCP_SCREENS, RTGETOPT_REQ_STRING },
352 { "--vcpfile", MODIFYVM_VCP_FILENAME, RTGETOPT_REQ_STRING },
353 { "--vcpwidth", MODIFYVM_VCP_WIDTH, RTGETOPT_REQ_UINT32 },
354 { "--vcpheight", MODIFYVM_VCP_HEIGHT, RTGETOPT_REQ_UINT32 },
355 { "--vcprate", MODIFYVM_VCP_RATE, RTGETOPT_REQ_UINT32 },
356 { "--vcpfps", MODIFYVM_VCP_FPS, RTGETOPT_REQ_UINT32 },
357#endif
358 { "--autostart-enabled", MODIFYVM_AUTOSTART_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
359 { "--autostart-delay", MODIFYVM_AUTOSTART_DELAY, RTGETOPT_REQ_UINT32 },
360 { "--autostop-type", MODIFYVM_AUTOSTOP_TYPE, RTGETOPT_REQ_STRING },
361#ifdef VBOX_WITH_PCI_PASSTHROUGH
362 { "--pciattach", MODIFYVM_ATTACH_PCI, RTGETOPT_REQ_STRING },
363 { "--pcidetach", MODIFYVM_DETACH_PCI, RTGETOPT_REQ_STRING },
364#endif
365#ifdef VBOX_WITH_USB_CARDREADER
366 { "--usbcardreader", MODIFYVM_USBCARDREADER, RTGETOPT_REQ_BOOL_ONOFF },
367#endif
368 { "--defaultfrontend", MODIFYVM_DEFAULTFRONTEND, RTGETOPT_REQ_STRING },
369};
370
371static void vrdeWarningDeprecatedOption(const char *pszOption)
372{
373 RTStrmPrintf(g_pStdErr, "Warning: '--vrdp%s' is deprecated. Use '--vrde%s'.\n", pszOption, pszOption);
374}
375
376/** Parse PCI address in format 01:02.03 and convert it to the numeric representation. */
377static int32_t parsePci(const char* szPciAddr)
378{
379 char* pszNext = (char*)szPciAddr;
380 int rc;
381 uint8_t aVals[3] = {0, 0, 0};
382
383 rc = RTStrToUInt8Ex(pszNext, &pszNext, 16, &aVals[0]);
384 if (RT_FAILURE(rc) || pszNext == NULL || *pszNext != ':')
385 return -1;
386
387 rc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[1]);
388 if (RT_FAILURE(rc) || pszNext == NULL || *pszNext != '.')
389 return -1;
390
391 rc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[2]);
392 if (RT_FAILURE(rc) || pszNext == NULL)
393 return -1;
394
395 return (aVals[0] << 8) | (aVals[1] << 3) | (aVals[2] << 0);
396}
397
398void parseGroups(const char *pcszGroups, com::SafeArray<BSTR> *pGroups)
399{
400 while (pcszGroups)
401 {
402 char *pComma = RTStrStr(pcszGroups, ",");
403 if (pComma)
404 {
405 Bstr(pcszGroups, pComma - pcszGroups).detachTo(pGroups->appendedRaw());
406 pcszGroups = pComma + 1;
407 }
408 else
409 {
410 Bstr(pcszGroups).detachTo(pGroups->appendedRaw());
411 pcszGroups = NULL;
412 }
413 }
414}
415
416int parseScreens(const char *pcszScreens, com::SafeArray<BOOL> *pScreens)
417{
418 while (pcszScreens && *pcszScreens)
419 {
420 char *pszNext;
421 uint32_t iScreen;
422 int rc = RTStrToUInt32Ex(pcszScreens, &pszNext, 0, &iScreen);
423 if (RT_FAILURE(rc))
424 return 1;
425 if (iScreen >= pScreens->size())
426 return 1;
427 if (pszNext && *pszNext)
428 {
429 pszNext = RTStrStripL(pszNext);
430 if (*pszNext != ',')
431 return 1;
432 pszNext++;
433 }
434 (*pScreens)[iScreen] = true;
435 pcszScreens = pszNext;
436 }
437 return 0;
438}
439
440int handleModifyVM(HandlerArg *a)
441{
442 int c;
443 HRESULT rc;
444 Bstr name;
445 RTGETOPTUNION ValueUnion;
446 RTGETOPTSTATE GetOptState;
447 ComPtr<IMachine> machine;
448 ComPtr<IBIOSSettings> biosSettings;
449
450 /* VM ID + at least one parameter. Parameter arguments are checked
451 * individually. */
452 if (a->argc < 2)
453 return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
454
455 /* try to find the given machine */
456 CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
457 machine.asOutParam()), 1);
458
459
460 /* Get the number of network adapters */
461 ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, machine);
462
463 /* open a session for the VM */
464 CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), 1);
465
466 /* get the mutable session machine */
467 CHECK_ERROR_RET(a->session, COMGETTER(Machine)(machine.asOutParam()), 1);
468 machine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
469
470 RTGetOptInit(&GetOptState, a->argc, a->argv, g_aModifyVMOptions,
471 RT_ELEMENTS(g_aModifyVMOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
472
473 while ( SUCCEEDED (rc)
474 && (c = RTGetOpt(&GetOptState, &ValueUnion)))
475 {
476 switch (c)
477 {
478 case MODIFYVM_NAME:
479 {
480 CHECK_ERROR(machine, COMSETTER(Name)(Bstr(ValueUnion.psz).raw()));
481 break;
482 }
483 case MODIFYVM_GROUPS:
484 {
485 com::SafeArray<BSTR> groups;
486 parseGroups(ValueUnion.psz, &groups);
487 CHECK_ERROR(machine, COMSETTER(Groups)(ComSafeArrayAsInParam(groups)));
488 break;
489 }
490 case MODIFYVM_DESCRIPTION:
491 {
492 CHECK_ERROR(machine, COMSETTER(Description)(Bstr(ValueUnion.psz).raw()));
493 break;
494 }
495 case MODIFYVM_OSTYPE:
496 {
497 ComPtr<IGuestOSType> guestOSType;
498 CHECK_ERROR(a->virtualBox, GetGuestOSType(Bstr(ValueUnion.psz).raw(),
499 guestOSType.asOutParam()));
500 if (SUCCEEDED(rc) && guestOSType)
501 {
502 CHECK_ERROR(machine, COMSETTER(OSTypeId)(Bstr(ValueUnion.psz).raw()));
503 }
504 else
505 {
506 errorArgument("Invalid guest OS type '%s'", ValueUnion.psz);
507 rc = E_FAIL;
508 }
509 break;
510 }
511
512 case MODIFYVM_ICONFILE:
513 {
514 RTFILE iconFile;
515 int vrc = RTFileOpen(&iconFile, ValueUnion.psz, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
516 if (RT_FAILURE(vrc))
517 {
518 RTMsgError("Cannot open file \"%s\": %Rrc", ValueUnion.psz, vrc);
519 rc = E_FAIL;
520 break;
521 }
522 uint64_t cbSize;
523 vrc = RTFileGetSize(iconFile, &cbSize);
524 if (RT_FAILURE(vrc))
525 {
526 RTMsgError("Cannot get size of file \"%s\": %Rrc", ValueUnion.psz, vrc);
527 rc = E_FAIL;
528 break;
529 }
530 if (cbSize > _256K)
531 {
532 RTMsgError("File \"%s\" is bigger than 256KByte", ValueUnion.psz);
533 rc = E_FAIL;
534 break;
535 }
536 SafeArray<BYTE> icon((size_t)cbSize);
537 rc = RTFileRead(iconFile, icon.raw(), (size_t)cbSize, NULL);
538 if (RT_FAILURE(vrc))
539 {
540 RTMsgError("Cannot read contents of file \"%s\": %Rrc", ValueUnion.psz, vrc);
541 rc = E_FAIL;
542 break;
543 }
544 RTFileClose(iconFile);
545 CHECK_ERROR(machine, COMSETTER(Icon)(ComSafeArrayAsInParam(icon)));
546 break;
547 }
548
549 case MODIFYVM_MEMORY:
550 {
551 CHECK_ERROR(machine, COMSETTER(MemorySize)(ValueUnion.u32));
552 break;
553 }
554
555 case MODIFYVM_PAGEFUSION:
556 {
557 CHECK_ERROR(machine, COMSETTER(PageFusionEnabled)(ValueUnion.f));
558 break;
559 }
560
561 case MODIFYVM_VRAM:
562 {
563 CHECK_ERROR(machine, COMSETTER(VRAMSize)(ValueUnion.u32));
564 break;
565 }
566
567 case MODIFYVM_FIRMWARE:
568 {
569 if (!RTStrICmp(ValueUnion.psz, "efi"))
570 {
571 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI));
572 }
573 else if (!RTStrICmp(ValueUnion.psz, "efi32"))
574 {
575 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI32));
576 }
577 else if (!RTStrICmp(ValueUnion.psz, "efi64"))
578 {
579 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI64));
580 }
581 else if (!RTStrICmp(ValueUnion.psz, "efidual"))
582 {
583 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFIDUAL));
584 }
585 else if (!RTStrICmp(ValueUnion.psz, "bios"))
586 {
587 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_BIOS));
588 }
589 else
590 {
591 errorArgument("Invalid --firmware argument '%s'", ValueUnion.psz);
592 rc = E_FAIL;
593 }
594 break;
595 }
596
597 case MODIFYVM_ACPI:
598 {
599 CHECK_ERROR(biosSettings, COMSETTER(ACPIEnabled)(ValueUnion.f));
600 break;
601 }
602
603 case MODIFYVM_IOAPIC:
604 {
605 CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(ValueUnion.f));
606 break;
607 }
608
609 case MODIFYVM_PAE:
610 {
611 CHECK_ERROR(machine, SetCPUProperty(CPUPropertyType_PAE, ValueUnion.f));
612 break;
613 }
614
615 case MODIFYVM_LONGMODE:
616 {
617 CHECK_ERROR(machine, SetCPUProperty(CPUPropertyType_LongMode, ValueUnion.f));
618 break;
619 }
620
621 case MODIFYVM_SYNTHCPU:
622 {
623 CHECK_ERROR(machine, SetCPUProperty(CPUPropertyType_Synthetic, ValueUnion.f));
624 break;
625 }
626
627 case MODIFYVM_TFRESET:
628 {
629 CHECK_ERROR(machine, SetCPUProperty(CPUPropertyType_TripleFaultReset, ValueUnion.f));
630 break;
631 }
632
633 case MODIFYVM_HWVIRTEX:
634 {
635 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_Enabled, ValueUnion.f));
636 break;
637 }
638
639 case MODIFYVM_SETCPUID:
640 {
641 uint32_t id = ValueUnion.u32;
642 uint32_t aValue[4];
643
644 for (unsigned i = 0 ; i < 4 ; i++)
645 {
646 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX);
647 if (RT_FAILURE(vrc))
648 return errorSyntax(USAGE_MODIFYVM,
649 "Missing or Invalid argument to '%s'",
650 GetOptState.pDef->pszLong);
651 aValue[i] = ValueUnion.u32;
652 }
653 CHECK_ERROR(machine, SetCPUIDLeaf(id, aValue[0], aValue[1], aValue[2], aValue[3]));
654 break;
655 }
656
657 case MODIFYVM_DELCPUID:
658 {
659 CHECK_ERROR(machine, RemoveCPUIDLeaf(ValueUnion.u32));
660 break;
661 }
662
663 case MODIFYVM_DELALLCPUID:
664 {
665 CHECK_ERROR(machine, RemoveAllCPUIDLeaves());
666 break;
667 }
668
669 case MODIFYVM_NESTEDPAGING:
670 {
671 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, ValueUnion.f));
672 break;
673 }
674
675 case MODIFYVM_LARGEPAGES:
676 {
677 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_LargePages, ValueUnion.f));
678 break;
679 }
680
681 case MODIFYVM_VTXVPID:
682 {
683 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_VPID, ValueUnion.f));
684 break;
685 }
686
687 case MODIFYVM_VTXUX:
688 {
689 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, ValueUnion.f));
690 break;
691 }
692
693 case MODIFYVM_CPUS:
694 {
695 CHECK_ERROR(machine, COMSETTER(CPUCount)(ValueUnion.u32));
696 break;
697 }
698
699 case MODIFYVM_RTCUSEUTC:
700 {
701 CHECK_ERROR(machine, COMSETTER(RTCUseUTC)(ValueUnion.f));
702 break;
703 }
704
705 case MODIFYVM_CPUHOTPLUG:
706 {
707 CHECK_ERROR(machine, COMSETTER(CPUHotPlugEnabled)(ValueUnion.f));
708 break;
709 }
710
711 case MODIFYVM_PLUGCPU:
712 {
713 CHECK_ERROR(machine, HotPlugCPU(ValueUnion.u32));
714 break;
715 }
716
717 case MODIFYVM_UNPLUGCPU:
718 {
719 CHECK_ERROR(machine, HotUnplugCPU(ValueUnion.u32));
720 break;
721 }
722
723 case MODIFYVM_CPU_EXECTUION_CAP:
724 {
725 CHECK_ERROR(machine, COMSETTER(CPUExecutionCap)(ValueUnion.u32));
726 break;
727 }
728
729 case MODIFYVM_GRAPHICSCONTROLLER:
730 {
731 if ( !RTStrICmp(ValueUnion.psz, "none")
732 || !RTStrICmp(ValueUnion.psz, "disabled"))
733 CHECK_ERROR(machine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_Null));
734 else if ( !RTStrICmp(ValueUnion.psz, "vboxvga")
735 || !RTStrICmp(ValueUnion.psz, "vbox")
736 || !RTStrICmp(ValueUnion.psz, "vga")
737 || !RTStrICmp(ValueUnion.psz, "vesa"))
738 CHECK_ERROR(machine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VBoxVGA));
739#ifdef VBOX_WITH_VMSVGA
740 else if ( !RTStrICmp(ValueUnion.psz, "vmsvga")
741 || !RTStrICmp(ValueUnion.psz, "vmware"))
742 CHECK_ERROR(machine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VMSVGA));
743#endif
744 else
745 {
746 errorArgument("Invalid --graphicscontroller argument '%s'", ValueUnion.psz);
747 rc = E_FAIL;
748 }
749 break;
750 }
751
752 case MODIFYVM_MONITORCOUNT:
753 {
754 CHECK_ERROR(machine, COMSETTER(MonitorCount)(ValueUnion.u32));
755 break;
756 }
757
758 case MODIFYVM_ACCELERATE3D:
759 {
760 CHECK_ERROR(machine, COMSETTER(Accelerate3DEnabled)(ValueUnion.f));
761 break;
762 }
763
764#ifdef VBOX_WITH_VIDEOHWACCEL
765 case MODIFYVM_ACCELERATE2DVIDEO:
766 {
767 CHECK_ERROR(machine, COMSETTER(Accelerate2DVideoEnabled)(ValueUnion.f));
768 break;
769 }
770#endif
771
772 case MODIFYVM_BIOSLOGOFADEIN:
773 {
774 CHECK_ERROR(biosSettings, COMSETTER(LogoFadeIn)(ValueUnion.f));
775 break;
776 }
777
778 case MODIFYVM_BIOSLOGOFADEOUT:
779 {
780 CHECK_ERROR(biosSettings, COMSETTER(LogoFadeOut)(ValueUnion.f));
781 break;
782 }
783
784 case MODIFYVM_BIOSLOGODISPLAYTIME:
785 {
786 CHECK_ERROR(biosSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u32));
787 break;
788 }
789
790 case MODIFYVM_BIOSLOGOIMAGEPATH:
791 {
792 CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz).raw()));
793 break;
794 }
795
796 case MODIFYVM_BIOSBOOTMENU:
797 {
798 if (!RTStrICmp(ValueUnion.psz, "disabled"))
799 {
800 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_Disabled));
801 }
802 else if (!RTStrICmp(ValueUnion.psz, "menuonly"))
803 {
804 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MenuOnly));
805 }
806 else if (!RTStrICmp(ValueUnion.psz, "messageandmenu"))
807 {
808 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MessageAndMenu));
809 }
810 else
811 {
812 errorArgument("Invalid --biosbootmenu argument '%s'", ValueUnion.psz);
813 rc = E_FAIL;
814 }
815 break;
816 }
817
818 case MODIFYVM_BIOSSYSTEMTIMEOFFSET:
819 {
820 CHECK_ERROR(biosSettings, COMSETTER(TimeOffset)(ValueUnion.i64));
821 break;
822 }
823
824 case MODIFYVM_BIOSPXEDEBUG:
825 {
826 CHECK_ERROR(biosSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f));
827 break;
828 }
829
830 case MODIFYVM_BOOT:
831 {
832 if (!RTStrICmp(ValueUnion.psz, "none"))
833 {
834 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Null));
835 }
836 else if (!RTStrICmp(ValueUnion.psz, "floppy"))
837 {
838 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Floppy));
839 }
840 else if (!RTStrICmp(ValueUnion.psz, "dvd"))
841 {
842 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_DVD));
843 }
844 else if (!RTStrICmp(ValueUnion.psz, "disk"))
845 {
846 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_HardDisk));
847 }
848 else if (!RTStrICmp(ValueUnion.psz, "net"))
849 {
850 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Network));
851 }
852 else
853 return errorArgument("Invalid boot device '%s'", ValueUnion.psz);
854 break;
855 }
856
857 case MODIFYVM_HDA: // deprecated
858 case MODIFYVM_HDB: // deprecated
859 case MODIFYVM_HDD: // deprecated
860 case MODIFYVM_SATAPORT: // deprecated
861 {
862 uint32_t u1 = 0, u2 = 0;
863 Bstr bstrController = L"IDE Controller";
864
865 switch (c)
866 {
867 case MODIFYVM_HDA: // deprecated
868 u1 = 0;
869 break;
870
871 case MODIFYVM_HDB: // deprecated
872 u1 = 0;
873 u2 = 1;
874 break;
875
876 case MODIFYVM_HDD: // deprecated
877 u1 = 1;
878 u2 = 1;
879 break;
880
881 case MODIFYVM_SATAPORT: // deprecated
882 u1 = GetOptState.uIndex;
883 bstrController = L"SATA";
884 break;
885 }
886
887 if (!RTStrICmp(ValueUnion.psz, "none"))
888 {
889 machine->DetachDevice(bstrController.raw(), u1, u2);
890 }
891 else
892 {
893 ComPtr<IMedium> hardDisk;
894 rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
895 AccessMode_ReadWrite, hardDisk,
896 false /* fForceNewUuidOnOpen */,
897 false /* fSilent */);
898 if (FAILED(rc))
899 break;
900 if (hardDisk)
901 {
902 CHECK_ERROR(machine, AttachDevice(bstrController.raw(),
903 u1, u2,
904 DeviceType_HardDisk,
905 hardDisk));
906 }
907 else
908 rc = E_FAIL;
909 }
910 break;
911 }
912
913 case MODIFYVM_IDECONTROLLER: // deprecated
914 {
915 ComPtr<IStorageController> storageController;
916 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("IDE Controller").raw(),
917 storageController.asOutParam()));
918
919 if (!RTStrICmp(ValueUnion.psz, "PIIX3"))
920 {
921 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX3));
922 }
923 else if (!RTStrICmp(ValueUnion.psz, "PIIX4"))
924 {
925 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX4));
926 }
927 else if (!RTStrICmp(ValueUnion.psz, "ICH6"))
928 {
929 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_ICH6));
930 }
931 else
932 {
933 errorArgument("Invalid --idecontroller argument '%s'", ValueUnion.psz);
934 rc = E_FAIL;
935 }
936 break;
937 }
938
939 case MODIFYVM_SATAPORTCOUNT: // deprecated
940 {
941 ComPtr<IStorageController> SataCtl;
942 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA").raw(),
943 SataCtl.asOutParam()));
944
945 if (SUCCEEDED(rc) && ValueUnion.u32 > 0)
946 CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32));
947 break;
948 }
949
950 case MODIFYVM_SATA: // deprecated
951 {
952 if (!RTStrICmp(ValueUnion.psz, "on") || !RTStrICmp(ValueUnion.psz, "enable"))
953 {
954 ComPtr<IStorageController> ctl;
955 CHECK_ERROR(machine, AddStorageController(Bstr("SATA").raw(),
956 StorageBus_SATA,
957 ctl.asOutParam()));
958 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
959 }
960 else if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
961 CHECK_ERROR(machine, RemoveStorageController(Bstr("SATA").raw()));
962 else
963 return errorArgument("Invalid --usb argument '%s'", ValueUnion.psz);
964 break;
965 }
966
967 case MODIFYVM_SCSIPORT: // deprecated
968 {
969 if (!RTStrICmp(ValueUnion.psz, "none"))
970 {
971 rc = machine->DetachDevice(Bstr("LsiLogic").raw(),
972 GetOptState.uIndex, 0);
973 if (FAILED(rc))
974 CHECK_ERROR(machine, DetachDevice(Bstr("BusLogic").raw(),
975 GetOptState.uIndex, 0));
976 }
977 else
978 {
979 ComPtr<IMedium> hardDisk;
980 rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
981 AccessMode_ReadWrite, hardDisk,
982 false /* fForceNewUuidOnOpen */,
983 false /* fSilent */);
984 if (FAILED(rc))
985 break;
986 if (hardDisk)
987 {
988 rc = machine->AttachDevice(Bstr("LsiLogic").raw(),
989 GetOptState.uIndex, 0,
990 DeviceType_HardDisk,
991 hardDisk);
992 if (FAILED(rc))
993 CHECK_ERROR(machine,
994 AttachDevice(Bstr("BusLogic").raw(),
995 GetOptState.uIndex, 0,
996 DeviceType_HardDisk,
997 hardDisk));
998 }
999 else
1000 rc = E_FAIL;
1001 }
1002 break;
1003 }
1004
1005 case MODIFYVM_SCSITYPE: // deprecated
1006 {
1007 ComPtr<IStorageController> ctl;
1008
1009 if (!RTStrICmp(ValueUnion.psz, "LsiLogic"))
1010 {
1011 rc = machine->RemoveStorageController(Bstr("BusLogic").raw());
1012 if (FAILED(rc))
1013 CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic").raw()));
1014
1015 CHECK_ERROR(machine,
1016 AddStorageController(Bstr("LsiLogic").raw(),
1017 StorageBus_SCSI,
1018 ctl.asOutParam()));
1019
1020 if (SUCCEEDED(rc))
1021 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
1022 }
1023 else if (!RTStrICmp(ValueUnion.psz, "BusLogic"))
1024 {
1025 rc = machine->RemoveStorageController(Bstr("LsiLogic").raw());
1026 if (FAILED(rc))
1027 CHECK_ERROR(machine, RemoveStorageController(Bstr("BusLogic").raw()));
1028
1029 CHECK_ERROR(machine,
1030 AddStorageController(Bstr("BusLogic").raw(),
1031 StorageBus_SCSI,
1032 ctl.asOutParam()));
1033
1034 if (SUCCEEDED(rc))
1035 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
1036 }
1037 else
1038 return errorArgument("Invalid --scsitype argument '%s'", ValueUnion.psz);
1039 break;
1040 }
1041
1042 case MODIFYVM_SCSI: // deprecated
1043 {
1044 if (!RTStrICmp(ValueUnion.psz, "on") || !RTStrICmp(ValueUnion.psz, "enable"))
1045 {
1046 ComPtr<IStorageController> ctl;
1047
1048 CHECK_ERROR(machine, AddStorageController(Bstr("BusLogic").raw(),
1049 StorageBus_SCSI,
1050 ctl.asOutParam()));
1051 if (SUCCEEDED(rc))
1052 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
1053 }
1054 else if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
1055 {
1056 rc = machine->RemoveStorageController(Bstr("BusLogic").raw());
1057 if (FAILED(rc))
1058 CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic").raw()));
1059 }
1060 break;
1061 }
1062
1063 case MODIFYVM_DVDPASSTHROUGH: // deprecated
1064 {
1065 CHECK_ERROR(machine, PassthroughDevice(Bstr("IDE Controller").raw(),
1066 1, 0,
1067 !RTStrICmp(ValueUnion.psz, "on")));
1068 break;
1069 }
1070
1071 case MODIFYVM_DVD: // deprecated
1072 {
1073 ComPtr<IMedium> dvdMedium;
1074
1075 /* unmount? */
1076 if (!RTStrICmp(ValueUnion.psz, "none"))
1077 {
1078 /* nothing to do, NULL object will cause unmount */
1079 }
1080 /* host drive? */
1081 else if (!RTStrNICmp(ValueUnion.psz, "host:", 5))
1082 {
1083 ComPtr<IHost> host;
1084 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1085 rc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5).raw(),
1086 dvdMedium.asOutParam());
1087 if (!dvdMedium)
1088 {
1089 /* 2nd try: try with the real name, important on Linux+libhal */
1090 char szPathReal[RTPATH_MAX];
1091 if (RT_FAILURE(RTPathReal(ValueUnion.psz + 5, szPathReal, sizeof(szPathReal))))
1092 {
1093 errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
1094 rc = E_FAIL;
1095 break;
1096 }
1097 rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
1098 dvdMedium.asOutParam());
1099 if (!dvdMedium)
1100 {
1101 errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
1102 rc = E_FAIL;
1103 break;
1104 }
1105 }
1106 }
1107 else
1108 {
1109 rc = openMedium(a, ValueUnion.psz, DeviceType_DVD,
1110 AccessMode_ReadOnly, dvdMedium,
1111 false /* fForceNewUuidOnOpen */,
1112 false /* fSilent */);
1113 if (FAILED(rc))
1114 break;
1115 if (!dvdMedium)
1116 {
1117 rc = E_FAIL;
1118 break;
1119 }
1120 }
1121
1122 CHECK_ERROR(machine, MountMedium(Bstr("IDE Controller").raw(),
1123 1, 0,
1124 dvdMedium,
1125 FALSE /* aForce */));
1126 break;
1127 }
1128
1129 case MODIFYVM_FLOPPY: // deprecated
1130 {
1131 ComPtr<IMedium> floppyMedium;
1132 ComPtr<IMediumAttachment> floppyAttachment;
1133 machine->GetMediumAttachment(Bstr("Floppy Controller").raw(),
1134 0, 0, floppyAttachment.asOutParam());
1135
1136 /* disable? */
1137 if (!RTStrICmp(ValueUnion.psz, "disabled"))
1138 {
1139 /* disable the controller */
1140 if (floppyAttachment)
1141 CHECK_ERROR(machine, DetachDevice(Bstr("Floppy Controller").raw(),
1142 0, 0));
1143 }
1144 else
1145 {
1146 /* enable the controller */
1147 if (!floppyAttachment)
1148 CHECK_ERROR(machine, AttachDeviceWithoutMedium(Bstr("Floppy Controller").raw(),
1149 0, 0,
1150 DeviceType_Floppy));
1151
1152 /* unmount? */
1153 if ( !RTStrICmp(ValueUnion.psz, "none")
1154 || !RTStrICmp(ValueUnion.psz, "empty")) // deprecated
1155 {
1156 /* nothing to do, NULL object will cause unmount */
1157 }
1158 /* host drive? */
1159 else if (!RTStrNICmp(ValueUnion.psz, "host:", 5))
1160 {
1161 ComPtr<IHost> host;
1162 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1163 rc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5).raw(),
1164 floppyMedium.asOutParam());
1165 if (!floppyMedium)
1166 {
1167 errorArgument("Invalid host floppy drive name \"%s\"", ValueUnion.psz + 5);
1168 rc = E_FAIL;
1169 break;
1170 }
1171 }
1172 else
1173 {
1174 rc = openMedium(a, ValueUnion.psz, DeviceType_Floppy,
1175 AccessMode_ReadWrite, floppyMedium,
1176 false /* fForceNewUuidOnOpen */,
1177 false /* fSilent */);
1178 if (FAILED(rc))
1179 break;
1180 if (!floppyMedium)
1181 {
1182 rc = E_FAIL;
1183 break;
1184 }
1185 }
1186 CHECK_ERROR(machine, MountMedium(Bstr("Floppy Controller").raw(),
1187 0, 0,
1188 floppyMedium,
1189 FALSE /* aForce */));
1190 }
1191 break;
1192 }
1193
1194 case MODIFYVM_NICTRACEFILE:
1195 {
1196 ComPtr<INetworkAdapter> nic;
1197
1198 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1199 ASSERT(nic);
1200
1201 CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz).raw()));
1202 break;
1203 }
1204
1205 case MODIFYVM_NICTRACE:
1206 {
1207 ComPtr<INetworkAdapter> nic;
1208
1209 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1210 ASSERT(nic);
1211
1212 CHECK_ERROR(nic, COMSETTER(TraceEnabled)(ValueUnion.f));
1213 break;
1214 }
1215
1216 case MODIFYVM_NICPROPERTY:
1217 {
1218 ComPtr<INetworkAdapter> nic;
1219
1220 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1221 ASSERT(nic);
1222
1223 if (nic)
1224 {
1225 /* Parse 'name=value' */
1226 char *pszProperty = RTStrDup(ValueUnion.psz);
1227 if (pszProperty)
1228 {
1229 char *pDelimiter = strchr(pszProperty, '=');
1230 if (pDelimiter)
1231 {
1232 *pDelimiter = '\0';
1233
1234 Bstr bstrName = pszProperty;
1235 Bstr bstrValue = &pDelimiter[1];
1236 CHECK_ERROR(nic, SetProperty(bstrName.raw(), bstrValue.raw()));
1237 }
1238 else
1239 {
1240 errorArgument("Invalid --nicproperty%d argument '%s'", GetOptState.uIndex, ValueUnion.psz);
1241 rc = E_FAIL;
1242 }
1243 RTStrFree(pszProperty);
1244 }
1245 else
1246 {
1247 RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for --nicproperty%d '%s'\n", GetOptState.uIndex, ValueUnion.psz);
1248 rc = E_FAIL;
1249 }
1250 }
1251 break;
1252 }
1253 case MODIFYVM_NICTYPE:
1254 {
1255 ComPtr<INetworkAdapter> nic;
1256
1257 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1258 ASSERT(nic);
1259
1260 if (!RTStrICmp(ValueUnion.psz, "Am79C970A"))
1261 {
1262 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C970A));
1263 }
1264 else if (!RTStrICmp(ValueUnion.psz, "Am79C973"))
1265 {
1266 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C973));
1267 }
1268#ifdef VBOX_WITH_E1000
1269 else if (!RTStrICmp(ValueUnion.psz, "82540EM"))
1270 {
1271 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82540EM));
1272 }
1273 else if (!RTStrICmp(ValueUnion.psz, "82543GC"))
1274 {
1275 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82543GC));
1276 }
1277 else if (!RTStrICmp(ValueUnion.psz, "82545EM"))
1278 {
1279 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82545EM));
1280 }
1281#endif
1282#ifdef VBOX_WITH_VIRTIO
1283 else if (!RTStrICmp(ValueUnion.psz, "virtio"))
1284 {
1285 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Virtio));
1286 }
1287#endif /* VBOX_WITH_VIRTIO */
1288 else
1289 {
1290 errorArgument("Invalid NIC type '%s' specified for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1291 rc = E_FAIL;
1292 }
1293 break;
1294 }
1295
1296 case MODIFYVM_NICSPEED:
1297 {
1298 ComPtr<INetworkAdapter> nic;
1299
1300 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1301 ASSERT(nic);
1302
1303 CHECK_ERROR(nic, COMSETTER(LineSpeed)(ValueUnion.u32));
1304 break;
1305 }
1306
1307 case MODIFYVM_NICBOOTPRIO:
1308 {
1309 ComPtr<INetworkAdapter> nic;
1310
1311 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1312 ASSERT(nic);
1313
1314 /* Somewhat arbitrary limitation - we can pass a list of up to 4 PCI devices
1315 * to the PXE ROM, hence only boot priorities 1-4 are allowed (in addition to
1316 * 0 for the default lowest priority).
1317 */
1318 if (ValueUnion.u32 > 4)
1319 {
1320 errorArgument("Invalid boot priority '%u' specfied for NIC %u", ValueUnion.u32, GetOptState.uIndex);
1321 rc = E_FAIL;
1322 }
1323 else
1324 {
1325 CHECK_ERROR(nic, COMSETTER(BootPriority)(ValueUnion.u32));
1326 }
1327 break;
1328 }
1329
1330 case MODIFYVM_NICPROMISC:
1331 {
1332 NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
1333 if (!RTStrICmp(ValueUnion.psz, "deny"))
1334 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_Deny;
1335 else if ( !RTStrICmp(ValueUnion.psz, "allow-vms")
1336 || !RTStrICmp(ValueUnion.psz, "allow-network"))
1337 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowNetwork;
1338 else if (!RTStrICmp(ValueUnion.psz, "allow-all"))
1339 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowAll;
1340 else
1341 {
1342 errorArgument("Unknown promiscuous mode policy '%s'", ValueUnion.psz);
1343 rc = E_INVALIDARG;
1344 break;
1345 }
1346
1347 ComPtr<INetworkAdapter> nic;
1348 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1349 ASSERT(nic);
1350
1351 CHECK_ERROR(nic, COMSETTER(PromiscModePolicy)(enmPromiscModePolicy));
1352 break;
1353 }
1354
1355 case MODIFYVM_NICBWGROUP:
1356 {
1357 ComPtr<INetworkAdapter> nic;
1358 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1359 ASSERT(nic);
1360
1361 if (!RTStrICmp(ValueUnion.psz, "none"))
1362 {
1363 /* Just remove the bandwidth group. */
1364 CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(NULL));
1365 }
1366 else
1367 {
1368 ComPtr<IBandwidthControl> bwCtrl;
1369 ComPtr<IBandwidthGroup> bwGroup;
1370
1371 CHECK_ERROR(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
1372
1373 if (SUCCEEDED(rc))
1374 {
1375 CHECK_ERROR(bwCtrl, GetBandwidthGroup(Bstr(ValueUnion.psz).raw(), bwGroup.asOutParam()));
1376 if (SUCCEEDED(rc))
1377 {
1378 CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(bwGroup));
1379 }
1380 }
1381 }
1382 break;
1383 }
1384
1385 case MODIFYVM_NIC:
1386 {
1387 ComPtr<INetworkAdapter> nic;
1388
1389 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1390 ASSERT(nic);
1391
1392 if (!RTStrICmp(ValueUnion.psz, "none"))
1393 {
1394 CHECK_ERROR(nic, COMSETTER(Enabled)(FALSE));
1395 }
1396 else if (!RTStrICmp(ValueUnion.psz, "null"))
1397 {
1398 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1399 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Null));
1400 }
1401 else if (!RTStrICmp(ValueUnion.psz, "nat"))
1402 {
1403 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1404 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NAT));
1405 }
1406 else if ( !RTStrICmp(ValueUnion.psz, "bridged")
1407 || !RTStrICmp(ValueUnion.psz, "hostif")) /* backward compatibility */
1408 {
1409 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1410 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged));
1411 }
1412 else if (!RTStrICmp(ValueUnion.psz, "intnet"))
1413 {
1414 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1415 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Internal));
1416 }
1417 else if (!RTStrICmp(ValueUnion.psz, "hostonly"))
1418 {
1419
1420 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1421 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly));
1422 }
1423 else if (!RTStrICmp(ValueUnion.psz, "generic"))
1424 {
1425
1426 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1427 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Generic));
1428 }
1429 else if (!RTStrICmp(ValueUnion.psz, "natnetwork"))
1430 {
1431
1432 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1433 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NATNetwork));
1434 }
1435 else
1436 {
1437 errorArgument("Invalid type '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1438 rc = E_FAIL;
1439 }
1440 break;
1441 }
1442
1443 case MODIFYVM_CABLECONNECTED:
1444 {
1445 ComPtr<INetworkAdapter> nic;
1446
1447 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1448 ASSERT(nic);
1449
1450 CHECK_ERROR(nic, COMSETTER(CableConnected)(ValueUnion.f));
1451 break;
1452 }
1453
1454 case MODIFYVM_BRIDGEADAPTER:
1455 {
1456 ComPtr<INetworkAdapter> nic;
1457
1458 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1459 ASSERT(nic);
1460
1461 /* remove it? */
1462 if (!RTStrICmp(ValueUnion.psz, "none"))
1463 {
1464 CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr().raw()));
1465 }
1466 else
1467 {
1468 CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr(ValueUnion.psz).raw()));
1469 }
1470 break;
1471 }
1472
1473 case MODIFYVM_HOSTONLYADAPTER:
1474 {
1475 ComPtr<INetworkAdapter> nic;
1476
1477 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1478 ASSERT(nic);
1479
1480 /* remove it? */
1481 if (!RTStrICmp(ValueUnion.psz, "none"))
1482 {
1483 CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr().raw()));
1484 }
1485 else
1486 {
1487 CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr(ValueUnion.psz).raw()));
1488 }
1489 break;
1490 }
1491
1492 case MODIFYVM_INTNET:
1493 {
1494 ComPtr<INetworkAdapter> nic;
1495
1496 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1497 ASSERT(nic);
1498
1499 /* remove it? */
1500 if (!RTStrICmp(ValueUnion.psz, "none"))
1501 {
1502 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr().raw()));
1503 }
1504 else
1505 {
1506 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz).raw()));
1507 }
1508 break;
1509 }
1510
1511 case MODIFYVM_GENERICDRV:
1512 {
1513 ComPtr<INetworkAdapter> nic;
1514
1515 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1516 ASSERT(nic);
1517
1518 CHECK_ERROR(nic, COMSETTER(GenericDriver)(Bstr(ValueUnion.psz).raw()));
1519 break;
1520 }
1521
1522 case MODIFYVM_NATNETWORKNAME:
1523 {
1524 ComPtr<INetworkAdapter> nic;
1525
1526 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1527 ASSERT(nic);
1528
1529 CHECK_ERROR(nic, COMSETTER(NATNetwork)(Bstr(ValueUnion.psz).raw()));
1530 break;
1531 }
1532
1533 case MODIFYVM_NATNET:
1534 {
1535 ComPtr<INetworkAdapter> nic;
1536 ComPtr<INATEngine> engine;
1537
1538 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1539 ASSERT(nic);
1540
1541 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1542
1543 const char *psz = ValueUnion.psz;
1544 if (!RTStrICmp("default", psz))
1545 psz = "";
1546
1547 CHECK_ERROR(engine, COMSETTER(Network)(Bstr(psz).raw()));
1548 break;
1549 }
1550
1551 case MODIFYVM_NATBINDIP:
1552 {
1553 ComPtr<INetworkAdapter> nic;
1554 ComPtr<INATEngine> engine;
1555
1556 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1557 ASSERT(nic);
1558
1559 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1560 CHECK_ERROR(engine, COMSETTER(HostIP)(Bstr(ValueUnion.psz).raw()));
1561 break;
1562 }
1563
1564#define ITERATE_TO_NEXT_TERM(ch) \
1565 do { \
1566 while (*ch != ',') \
1567 { \
1568 if (*ch == 0) \
1569 { \
1570 return errorSyntax(USAGE_MODIFYVM, \
1571 "Missing or Invalid argument to '%s'", \
1572 GetOptState.pDef->pszLong); \
1573 } \
1574 ch++; \
1575 } \
1576 *ch = '\0'; \
1577 ch++; \
1578 } while(0)
1579
1580 case MODIFYVM_NATSETTINGS:
1581 {
1582 ComPtr<INetworkAdapter> nic;
1583 ComPtr<INATEngine> engine;
1584 char *strMtu;
1585 char *strSockSnd;
1586 char *strSockRcv;
1587 char *strTcpSnd;
1588 char *strTcpRcv;
1589 char *strRaw = RTStrDup(ValueUnion.psz);
1590 char *ch = strRaw;
1591 strMtu = RTStrStrip(ch);
1592 ITERATE_TO_NEXT_TERM(ch);
1593 strSockSnd = RTStrStrip(ch);
1594 ITERATE_TO_NEXT_TERM(ch);
1595 strSockRcv = RTStrStrip(ch);
1596 ITERATE_TO_NEXT_TERM(ch);
1597 strTcpSnd = RTStrStrip(ch);
1598 ITERATE_TO_NEXT_TERM(ch);
1599 strTcpRcv = RTStrStrip(ch);
1600
1601 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1602 ASSERT(nic);
1603
1604 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1605 CHECK_ERROR(engine, SetNetworkSettings(RTStrToUInt32(strMtu), RTStrToUInt32(strSockSnd), RTStrToUInt32(strSockRcv),
1606 RTStrToUInt32(strTcpSnd), RTStrToUInt32(strTcpRcv)));
1607 break;
1608 }
1609
1610
1611 case MODIFYVM_NATPF:
1612 {
1613 ComPtr<INetworkAdapter> nic;
1614 ComPtr<INATEngine> engine;
1615
1616 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1617 ASSERT(nic);
1618
1619 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1620 /* format name:proto:hostip:hostport:guestip:guestport*/
1621 if (RTStrCmp(ValueUnion.psz, "delete") != 0)
1622 {
1623 char *strName;
1624 char *strProto;
1625 char *strHostIp;
1626 char *strHostPort;
1627 char *strGuestIp;
1628 char *strGuestPort;
1629 char *strRaw = RTStrDup(ValueUnion.psz);
1630 char *ch = strRaw;
1631 strName = RTStrStrip(ch);
1632 ITERATE_TO_NEXT_TERM(ch);
1633 strProto = RTStrStrip(ch);
1634 ITERATE_TO_NEXT_TERM(ch);
1635 strHostIp = RTStrStrip(ch);
1636 ITERATE_TO_NEXT_TERM(ch);
1637 strHostPort = RTStrStrip(ch);
1638 ITERATE_TO_NEXT_TERM(ch);
1639 strGuestIp = RTStrStrip(ch);
1640 ITERATE_TO_NEXT_TERM(ch);
1641 strGuestPort = RTStrStrip(ch);
1642 NATProtocol_T proto;
1643 if (RTStrICmp(strProto, "udp") == 0)
1644 proto = NATProtocol_UDP;
1645 else if (RTStrICmp(strProto, "tcp") == 0)
1646 proto = NATProtocol_TCP;
1647 else
1648 {
1649 errorArgument("Invalid proto '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1650 rc = E_FAIL;
1651 break;
1652 }
1653 CHECK_ERROR(engine, AddRedirect(Bstr(strName).raw(), proto,
1654 Bstr(strHostIp).raw(),
1655 RTStrToUInt16(strHostPort),
1656 Bstr(strGuestIp).raw(),
1657 RTStrToUInt16(strGuestPort)));
1658 }
1659 else
1660 {
1661 /* delete NAT Rule operation */
1662 int vrc;
1663 vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
1664 if (RT_FAILURE(vrc))
1665 return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
1666 CHECK_ERROR(engine, RemoveRedirect(Bstr(ValueUnion.psz).raw()));
1667 }
1668 break;
1669 }
1670 #undef ITERATE_TO_NEXT_TERM
1671 case MODIFYVM_NATALIASMODE:
1672 {
1673 ComPtr<INetworkAdapter> nic;
1674 ComPtr<INATEngine> engine;
1675 uint32_t aliasMode = 0;
1676
1677 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1678 ASSERT(nic);
1679
1680 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1681 if (RTStrCmp(ValueUnion.psz, "default") == 0)
1682 {
1683 aliasMode = 0;
1684 }
1685 else
1686 {
1687 char *token = (char *)ValueUnion.psz;
1688 while(token)
1689 {
1690 if (RTStrNCmp(token, "log", 3) == 0)
1691 aliasMode |= 0x1;
1692 else if (RTStrNCmp(token, "proxyonly", 9) == 0)
1693 aliasMode |= 0x2;
1694 else if (RTStrNCmp(token, "sameports", 9) == 0)
1695 aliasMode |= 0x4;
1696 token = RTStrStr(token, ",");
1697 if (token == NULL)
1698 break;
1699 token++;
1700 }
1701 }
1702 CHECK_ERROR(engine, COMSETTER(AliasMode)(aliasMode));
1703 break;
1704 }
1705
1706 case MODIFYVM_NATTFTPPREFIX:
1707 {
1708 ComPtr<INetworkAdapter> nic;
1709 ComPtr<INATEngine> engine;
1710
1711 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1712 ASSERT(nic);
1713
1714 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1715 CHECK_ERROR(engine, COMSETTER(TFTPPrefix)(Bstr(ValueUnion.psz).raw()));
1716 break;
1717 }
1718
1719 case MODIFYVM_NATTFTPFILE:
1720 {
1721 ComPtr<INetworkAdapter> nic;
1722 ComPtr<INATEngine> engine;
1723
1724 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1725 ASSERT(nic);
1726
1727 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1728 CHECK_ERROR(engine, COMSETTER(TFTPBootFile)(Bstr(ValueUnion.psz).raw()));
1729 break;
1730 }
1731
1732 case MODIFYVM_NATTFTPSERVER:
1733 {
1734 ComPtr<INetworkAdapter> nic;
1735 ComPtr<INATEngine> engine;
1736
1737 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1738 ASSERT(nic);
1739
1740 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1741 CHECK_ERROR(engine, COMSETTER(TFTPNextServer)(Bstr(ValueUnion.psz).raw()));
1742 break;
1743 }
1744 case MODIFYVM_NATDNSPASSDOMAIN:
1745 {
1746 ComPtr<INetworkAdapter> nic;
1747 ComPtr<INATEngine> engine;
1748
1749 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1750 ASSERT(nic);
1751
1752 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1753 CHECK_ERROR(engine, COMSETTER(DNSPassDomain)(ValueUnion.f));
1754 break;
1755 }
1756
1757 case MODIFYVM_NATDNSPROXY:
1758 {
1759 ComPtr<INetworkAdapter> nic;
1760 ComPtr<INATEngine> engine;
1761
1762 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1763 ASSERT(nic);
1764
1765 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1766 CHECK_ERROR(engine, COMSETTER(DNSProxy)(ValueUnion.f));
1767 break;
1768 }
1769
1770 case MODIFYVM_NATDNSHOSTRESOLVER:
1771 {
1772 ComPtr<INetworkAdapter> nic;
1773 ComPtr<INATEngine> engine;
1774
1775 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1776 ASSERT(nic);
1777
1778 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1779 CHECK_ERROR(engine, COMSETTER(DNSUseHostResolver)(ValueUnion.f));
1780 break;
1781 }
1782 case MODIFYVM_MACADDRESS:
1783 {
1784 ComPtr<INetworkAdapter> nic;
1785
1786 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1787 ASSERT(nic);
1788
1789 /* generate one? */
1790 if (!RTStrICmp(ValueUnion.psz, "auto"))
1791 {
1792 CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr().raw()));
1793 }
1794 else
1795 {
1796 CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz).raw()));
1797 }
1798 break;
1799 }
1800
1801 case MODIFYVM_HIDPTR:
1802 {
1803 bool fEnableUsb = false;
1804 if (!RTStrICmp(ValueUnion.psz, "ps2"))
1805 {
1806 CHECK_ERROR(machine, COMSETTER(PointingHIDType)(PointingHIDType_PS2Mouse));
1807 }
1808 else if (!RTStrICmp(ValueUnion.psz, "usb"))
1809 {
1810 CHECK_ERROR(machine, COMSETTER(PointingHIDType)(PointingHIDType_USBMouse));
1811 if (SUCCEEDED(rc))
1812 fEnableUsb = true;
1813 }
1814 else if (!RTStrICmp(ValueUnion.psz, "usbtablet"))
1815 {
1816 CHECK_ERROR(machine, COMSETTER(PointingHIDType)(PointingHIDType_USBTablet));
1817 if (SUCCEEDED(rc))
1818 fEnableUsb = true;
1819 }
1820 else if (!RTStrICmp(ValueUnion.psz, "usbmultitouch"))
1821 {
1822 CHECK_ERROR(machine, COMSETTER(PointingHIDType)(PointingHIDType_USBMultiTouch));
1823 if (SUCCEEDED(rc))
1824 fEnableUsb = true;
1825 }
1826 else
1827 {
1828 errorArgument("Invalid type '%s' specfied for pointing device", ValueUnion.psz);
1829 rc = E_FAIL;
1830 }
1831 if (fEnableUsb)
1832 {
1833 /* Make sure the OHCI controller is enabled. */
1834 ULONG cOhciCtrls = 0;
1835 rc = machine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
1836 if ( SUCCEEDED(rc)
1837 && !cOhciCtrls)
1838 {
1839 ComPtr<IUSBController> UsbCtl;
1840 CHECK_ERROR(machine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
1841 UsbCtl.asOutParam()));
1842 }
1843 }
1844 break;
1845 }
1846
1847 case MODIFYVM_HIDKBD:
1848 {
1849 bool fEnableUsb = false;
1850 if (!RTStrICmp(ValueUnion.psz, "ps2"))
1851 {
1852 CHECK_ERROR(machine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_PS2Keyboard));
1853 }
1854 else if (!RTStrICmp(ValueUnion.psz, "usb"))
1855 {
1856 CHECK_ERROR(machine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_USBKeyboard));
1857 if (SUCCEEDED(rc))
1858 fEnableUsb = true;
1859 }
1860 else
1861 {
1862 errorArgument("Invalid type '%s' specfied for keyboard", ValueUnion.psz);
1863 rc = E_FAIL;
1864 }
1865 if (fEnableUsb)
1866 {
1867 /* Make sure the OHCI controller is enabled. */
1868 ULONG cOhciCtrls = 0;
1869 rc = machine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
1870 if ( SUCCEEDED(rc)
1871 && !cOhciCtrls)
1872 {
1873 ComPtr<IUSBController> UsbCtl;
1874 CHECK_ERROR(machine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
1875 UsbCtl.asOutParam()));
1876 }
1877 }
1878 break;
1879 }
1880
1881 case MODIFYVM_UARTMODE:
1882 {
1883 ComPtr<ISerialPort> uart;
1884 char *pszIRQ = NULL;
1885
1886 CHECK_ERROR_BREAK(machine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
1887 ASSERT(uart);
1888
1889 if (!RTStrICmp(ValueUnion.psz, "disconnected"))
1890 {
1891 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected));
1892 }
1893 else if ( !RTStrICmp(ValueUnion.psz, "server")
1894 || !RTStrICmp(ValueUnion.psz, "client")
1895 || !RTStrICmp(ValueUnion.psz, "file"))
1896 {
1897 const char *pszMode = ValueUnion.psz;
1898
1899 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
1900 if (RT_FAILURE(vrc))
1901 return errorSyntax(USAGE_MODIFYVM,
1902 "Missing or Invalid argument to '%s'",
1903 GetOptState.pDef->pszLong);
1904
1905 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
1906
1907 if (!RTStrICmp(pszMode, "server"))
1908 {
1909 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
1910 CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
1911 }
1912 else if (!RTStrICmp(pszMode, "client"))
1913 {
1914 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
1915 CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
1916 }
1917 else if (!RTStrICmp(pszMode, "file"))
1918 {
1919 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile));
1920 }
1921 }
1922 else
1923 {
1924 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
1925 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice));
1926 }
1927 break;
1928 }
1929
1930 case MODIFYVM_UART:
1931 {
1932 ComPtr<ISerialPort> uart;
1933
1934 CHECK_ERROR_BREAK(machine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
1935 ASSERT(uart);
1936
1937 if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
1938 CHECK_ERROR(uart, COMSETTER(Enabled)(FALSE));
1939 else
1940 {
1941 const char *pszIOBase = ValueUnion.psz;
1942 uint32_t uVal = 0;
1943
1944 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_UART;
1945 if (RT_FAILURE(vrc))
1946 return errorSyntax(USAGE_MODIFYVM,
1947 "Missing or Invalid argument to '%s'",
1948 GetOptState.pDef->pszLong);
1949
1950 CHECK_ERROR(uart, COMSETTER(IRQ)(ValueUnion.u32));
1951
1952 vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
1953 if (vrc != VINF_SUCCESS || uVal == 0)
1954 return errorArgument("Error parsing UART I/O base '%s'", pszIOBase);
1955 CHECK_ERROR(uart, COMSETTER(IOBase)(uVal));
1956
1957 CHECK_ERROR(uart, COMSETTER(Enabled)(TRUE));
1958 }
1959 break;
1960 }
1961
1962#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS)
1963 case MODIFYVM_LPTMODE:
1964 {
1965 ComPtr<IParallelPort> lpt;
1966 char *pszIRQ = NULL;
1967
1968 CHECK_ERROR_BREAK(machine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam()));
1969 ASSERT(lpt);
1970
1971 CHECK_ERROR(lpt, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
1972 break;
1973 }
1974
1975 case MODIFYVM_LPT:
1976 {
1977 ComPtr<IParallelPort> lpt;
1978
1979 CHECK_ERROR_BREAK(machine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam()));
1980 ASSERT(lpt);
1981
1982 if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
1983 CHECK_ERROR(lpt, COMSETTER(Enabled)(FALSE));
1984 else
1985 {
1986 const char *pszIOBase = ValueUnion.psz;
1987 uint32_t uVal = 0;
1988
1989 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_LPT;
1990 if (RT_FAILURE(vrc))
1991 return errorSyntax(USAGE_MODIFYVM,
1992 "Missing or Invalid argument to '%s'",
1993 GetOptState.pDef->pszLong);
1994
1995 CHECK_ERROR(lpt, COMSETTER(IRQ)(ValueUnion.u32));
1996
1997 vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
1998 if (vrc != VINF_SUCCESS || uVal == 0)
1999 return errorArgument("Error parsing LPT I/O base '%s'", pszIOBase);
2000 CHECK_ERROR(lpt, COMSETTER(IOBase)(uVal));
2001
2002 CHECK_ERROR(lpt, COMSETTER(Enabled)(TRUE));
2003 }
2004 break;
2005 }
2006#endif
2007
2008 case MODIFYVM_GUESTMEMORYBALLOON:
2009 {
2010 CHECK_ERROR(machine, COMSETTER(MemoryBalloonSize)(ValueUnion.u32));
2011 break;
2012 }
2013
2014 case MODIFYVM_AUDIOCONTROLLER:
2015 {
2016 ComPtr<IAudioAdapter> audioAdapter;
2017 machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2018 ASSERT(audioAdapter);
2019
2020 if (!RTStrICmp(ValueUnion.psz, "sb16"))
2021 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_SB16));
2022 else if (!RTStrICmp(ValueUnion.psz, "ac97"))
2023 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_AC97));
2024 else if (!RTStrICmp(ValueUnion.psz, "hda"))
2025 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_HDA));
2026 else
2027 {
2028 errorArgument("Invalid --audiocontroller argument '%s'", ValueUnion.psz);
2029 rc = E_FAIL;
2030 }
2031 break;
2032 }
2033
2034 case MODIFYVM_AUDIO:
2035 {
2036 ComPtr<IAudioAdapter> audioAdapter;
2037 machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2038 ASSERT(audioAdapter);
2039
2040 /* disable? */
2041 if (!RTStrICmp(ValueUnion.psz, "none"))
2042 {
2043 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(false));
2044 }
2045 else if (!RTStrICmp(ValueUnion.psz, "null"))
2046 {
2047 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Null));
2048 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2049 }
2050#ifdef RT_OS_WINDOWS
2051#ifdef VBOX_WITH_WINMM
2052 else if (!RTStrICmp(ValueUnion.psz, "winmm"))
2053 {
2054 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WinMM));
2055 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2056 }
2057#endif
2058 else if (!RTStrICmp(ValueUnion.psz, "dsound"))
2059 {
2060 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_DirectSound));
2061 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2062 }
2063#endif /* RT_OS_WINDOWS */
2064#ifdef RT_OS_LINUX
2065# ifdef VBOX_WITH_ALSA
2066 else if (!RTStrICmp(ValueUnion.psz, "alsa"))
2067 {
2068 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_ALSA));
2069 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2070 }
2071# endif
2072# ifdef VBOX_WITH_PULSE
2073 else if (!RTStrICmp(ValueUnion.psz, "pulse"))
2074 {
2075 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
2076 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2077 }
2078# endif
2079#endif /* !RT_OS_LINUX */
2080#ifdef RT_OS_SOLARIS
2081 else if (!RTStrICmp(ValueUnion.psz, "solaudio"))
2082 {
2083 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_SolAudio));
2084 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2085 }
2086#endif /* !RT_OS_SOLARIS */
2087#ifdef RT_OS_FREEBSD
2088 else if (!RTStrICmp(ValueUnion.psz, "oss"))
2089 {
2090 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS));
2091 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2092 }
2093# ifdef VBOX_WITH_PULSE
2094 else if (!RTStrICmp(ValueUnion.psz, "pulse"))
2095 {
2096 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
2097 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2098 }
2099# endif
2100#endif /* !RT_OS_FREEBSD */
2101#ifdef RT_OS_DARWIN
2102 else if (!RTStrICmp(ValueUnion.psz, "coreaudio"))
2103 {
2104 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_CoreAudio));
2105 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2106 }
2107
2108#endif /* !RT_OS_DARWIN */
2109# if defined(RT_OS_FREEBSD) || defined(RT_OS_LINUX) || defined(VBOX_WITH_SOLARIS_OSS)
2110 else if (!RTStrICmp(ValueUnion.psz, "oss"))
2111 {
2112 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS));
2113 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2114 }
2115# endif
2116 else
2117 {
2118 errorArgument("Invalid --audio argument '%s'", ValueUnion.psz);
2119 rc = E_FAIL;
2120 }
2121 break;
2122 }
2123
2124 case MODIFYVM_CLIPBOARD:
2125 {
2126 ClipboardMode_T mode;
2127 if (!RTStrICmp(ValueUnion.psz, "disabled"))
2128 mode = ClipboardMode_Disabled;
2129 else if (!RTStrICmp(ValueUnion.psz, "hosttoguest"))
2130 mode = ClipboardMode_HostToGuest;
2131 else if (!RTStrICmp(ValueUnion.psz, "guesttohost"))
2132 mode = ClipboardMode_GuestToHost;
2133 else if (!RTStrICmp(ValueUnion.psz, "bidirectional"))
2134 mode = ClipboardMode_Bidirectional;
2135 else
2136 {
2137 errorArgument("Invalid --clipboard argument '%s'", ValueUnion.psz);
2138 rc = E_FAIL;
2139 }
2140 if (SUCCEEDED(rc))
2141 {
2142 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(mode));
2143 }
2144 break;
2145 }
2146
2147 case MODIFYVM_DRAGANDDROP:
2148 {
2149 DragAndDropMode_T mode;
2150 if (!RTStrICmp(ValueUnion.psz, "disabled"))
2151 mode = DragAndDropMode_Disabled;
2152 else if (!RTStrICmp(ValueUnion.psz, "hosttoguest"))
2153 mode = DragAndDropMode_HostToGuest;
2154 else if (!RTStrICmp(ValueUnion.psz, "guesttohost"))
2155 mode = DragAndDropMode_GuestToHost;
2156 else if (!RTStrICmp(ValueUnion.psz, "bidirectional"))
2157 mode = DragAndDropMode_Bidirectional;
2158 else
2159 {
2160 errorArgument("Invalid --draganddrop argument '%s'", ValueUnion.psz);
2161 rc = E_FAIL;
2162 }
2163 if (SUCCEEDED(rc))
2164 {
2165 CHECK_ERROR(machine, COMSETTER(DragAndDropMode)(mode));
2166 }
2167 break;
2168 }
2169
2170 case MODIFYVM_VRDE_EXTPACK:
2171 {
2172 ComPtr<IVRDEServer> vrdeServer;
2173 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2174 ASSERT(vrdeServer);
2175
2176 if (vrdeServer)
2177 {
2178 if (RTStrICmp(ValueUnion.psz, "default") != 0)
2179 {
2180 Bstr bstr(ValueUnion.psz);
2181 CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(bstr.raw()));
2182 }
2183 else
2184 CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(Bstr().raw()));
2185 }
2186 break;
2187 }
2188
2189 case MODIFYVM_VRDEPROPERTY:
2190 {
2191 ComPtr<IVRDEServer> vrdeServer;
2192 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2193 ASSERT(vrdeServer);
2194
2195 if (vrdeServer)
2196 {
2197 /* Parse 'name=value' */
2198 char *pszProperty = RTStrDup(ValueUnion.psz);
2199 if (pszProperty)
2200 {
2201 char *pDelimiter = strchr(pszProperty, '=');
2202 if (pDelimiter)
2203 {
2204 *pDelimiter = '\0';
2205
2206 Bstr bstrName = pszProperty;
2207 Bstr bstrValue = &pDelimiter[1];
2208 CHECK_ERROR(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw()));
2209 }
2210 else
2211 {
2212 RTStrFree(pszProperty);
2213
2214 errorArgument("Invalid --vrdeproperty argument '%s'", ValueUnion.psz);
2215 rc = E_FAIL;
2216 break;
2217 }
2218 RTStrFree(pszProperty);
2219 }
2220 else
2221 {
2222 RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for VRDE property '%s'\n", ValueUnion.psz);
2223 rc = E_FAIL;
2224 }
2225 }
2226 break;
2227 }
2228
2229 case MODIFYVM_VRDPPORT:
2230 vrdeWarningDeprecatedOption("port");
2231
2232 case MODIFYVM_VRDEPORT:
2233 {
2234 ComPtr<IVRDEServer> vrdeServer;
2235 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2236 ASSERT(vrdeServer);
2237
2238 if (!RTStrICmp(ValueUnion.psz, "default"))
2239 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr("0").raw()));
2240 else
2241 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr(ValueUnion.psz).raw()));
2242 break;
2243 }
2244
2245 case MODIFYVM_VRDPADDRESS:
2246 vrdeWarningDeprecatedOption("address");
2247
2248 case MODIFYVM_VRDEADDRESS:
2249 {
2250 ComPtr<IVRDEServer> vrdeServer;
2251 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2252 ASSERT(vrdeServer);
2253
2254 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Address").raw(), Bstr(ValueUnion.psz).raw()));
2255 break;
2256 }
2257
2258 case MODIFYVM_VRDPAUTHTYPE:
2259 vrdeWarningDeprecatedOption("authtype");
2260 case MODIFYVM_VRDEAUTHTYPE:
2261 {
2262 ComPtr<IVRDEServer> vrdeServer;
2263 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2264 ASSERT(vrdeServer);
2265
2266 if (!RTStrICmp(ValueUnion.psz, "null"))
2267 {
2268 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Null));
2269 }
2270 else if (!RTStrICmp(ValueUnion.psz, "external"))
2271 {
2272 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_External));
2273 }
2274 else if (!RTStrICmp(ValueUnion.psz, "guest"))
2275 {
2276 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Guest));
2277 }
2278 else
2279 {
2280 errorArgument("Invalid --vrdeauthtype argument '%s'", ValueUnion.psz);
2281 rc = E_FAIL;
2282 }
2283 break;
2284 }
2285
2286 case MODIFYVM_VRDEAUTHLIBRARY:
2287 {
2288 ComPtr<IVRDEServer> vrdeServer;
2289 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2290 ASSERT(vrdeServer);
2291
2292 if (vrdeServer)
2293 {
2294 if (RTStrICmp(ValueUnion.psz, "default") != 0)
2295 {
2296 Bstr bstr(ValueUnion.psz);
2297 CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(bstr.raw()));
2298 }
2299 else
2300 CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(Bstr().raw()));
2301 }
2302 break;
2303 }
2304
2305 case MODIFYVM_VRDPMULTICON:
2306 vrdeWarningDeprecatedOption("multicon");
2307 case MODIFYVM_VRDEMULTICON:
2308 {
2309 ComPtr<IVRDEServer> vrdeServer;
2310 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2311 ASSERT(vrdeServer);
2312
2313 CHECK_ERROR(vrdeServer, COMSETTER(AllowMultiConnection)(ValueUnion.f));
2314 break;
2315 }
2316
2317 case MODIFYVM_VRDPREUSECON:
2318 vrdeWarningDeprecatedOption("reusecon");
2319 case MODIFYVM_VRDEREUSECON:
2320 {
2321 ComPtr<IVRDEServer> vrdeServer;
2322 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2323 ASSERT(vrdeServer);
2324
2325 CHECK_ERROR(vrdeServer, COMSETTER(ReuseSingleConnection)(ValueUnion.f));
2326 break;
2327 }
2328
2329 case MODIFYVM_VRDPVIDEOCHANNEL:
2330 vrdeWarningDeprecatedOption("videochannel");
2331 case MODIFYVM_VRDEVIDEOCHANNEL:
2332 {
2333 ComPtr<IVRDEServer> vrdeServer;
2334 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2335 ASSERT(vrdeServer);
2336
2337 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Enabled").raw(),
2338 ValueUnion.f? Bstr("true").raw(): Bstr("false").raw()));
2339 break;
2340 }
2341
2342 case MODIFYVM_VRDPVIDEOCHANNELQUALITY:
2343 vrdeWarningDeprecatedOption("videochannelquality");
2344 case MODIFYVM_VRDEVIDEOCHANNELQUALITY:
2345 {
2346 ComPtr<IVRDEServer> vrdeServer;
2347 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2348 ASSERT(vrdeServer);
2349
2350 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Quality").raw(),
2351 Bstr(ValueUnion.psz).raw()));
2352 break;
2353 }
2354
2355 case MODIFYVM_VRDP:
2356 vrdeWarningDeprecatedOption("");
2357 case MODIFYVM_VRDE:
2358 {
2359 ComPtr<IVRDEServer> vrdeServer;
2360 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2361 ASSERT(vrdeServer);
2362
2363 CHECK_ERROR(vrdeServer, COMSETTER(Enabled)(ValueUnion.f));
2364 break;
2365 }
2366
2367 case MODIFYVM_USBXHCI:
2368 {
2369 ULONG cXhciCtrls = 0;
2370 rc = machine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
2371 if (SUCCEEDED(rc))
2372 {
2373 if (!cXhciCtrls && ValueUnion.f)
2374 {
2375 ComPtr<IUSBController> UsbCtl;
2376 CHECK_ERROR(machine, AddUSBController(Bstr("XHCI").raw(), USBControllerType_XHCI,
2377 UsbCtl.asOutParam()));
2378 }
2379 else if (cXhciCtrls && !ValueUnion.f)
2380 CHECK_ERROR(machine, RemoveUSBController(Bstr("XHCI").raw()));
2381 }
2382 break;
2383 }
2384
2385 case MODIFYVM_USBEHCI:
2386 {
2387 ULONG cEhciCtrls = 0;
2388 rc = machine->GetUSBControllerCountByType(USBControllerType_EHCI, &cEhciCtrls);
2389 if (SUCCEEDED(rc))
2390 {
2391 if (!cEhciCtrls && ValueUnion.f)
2392 {
2393 ComPtr<IUSBController> UsbCtl;
2394 CHECK_ERROR(machine, AddUSBController(Bstr("EHCI").raw(), USBControllerType_EHCI,
2395 UsbCtl.asOutParam()));
2396 }
2397 else if (cEhciCtrls && !ValueUnion.f)
2398 CHECK_ERROR(machine, RemoveUSBController(Bstr("EHCI").raw()));
2399 }
2400 break;
2401 }
2402
2403 case MODIFYVM_USB:
2404 {
2405 ULONG cOhciCtrls = 0;
2406 rc = machine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
2407 if (SUCCEEDED(rc))
2408 {
2409 if (!cOhciCtrls && ValueUnion.f)
2410 {
2411 ComPtr<IUSBController> UsbCtl;
2412 CHECK_ERROR(machine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
2413 UsbCtl.asOutParam()));
2414 }
2415 else if (cOhciCtrls && !ValueUnion.f)
2416 CHECK_ERROR(machine, RemoveUSBController(Bstr("OHCI").raw()));
2417 }
2418 break;
2419 }
2420
2421 case MODIFYVM_SNAPSHOTFOLDER:
2422 {
2423 if (!RTStrICmp(ValueUnion.psz, "default"))
2424 CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(Bstr().raw()));
2425 else
2426 CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz).raw()));
2427 break;
2428 }
2429
2430 case MODIFYVM_TELEPORTER_ENABLED:
2431 {
2432 CHECK_ERROR(machine, COMSETTER(TeleporterEnabled)(ValueUnion.f));
2433 break;
2434 }
2435
2436 case MODIFYVM_TELEPORTER_PORT:
2437 {
2438 CHECK_ERROR(machine, COMSETTER(TeleporterPort)(ValueUnion.u32));
2439 break;
2440 }
2441
2442 case MODIFYVM_TELEPORTER_ADDRESS:
2443 {
2444 CHECK_ERROR(machine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz).raw()));
2445 break;
2446 }
2447
2448 case MODIFYVM_TELEPORTER_PASSWORD:
2449 {
2450 CHECK_ERROR(machine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz).raw()));
2451 break;
2452 }
2453
2454 case MODIFYVM_TELEPORTER_PASSWORD_FILE:
2455 {
2456 Utf8Str password;
2457 RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &password);
2458 if (rcExit != RTEXITCODE_SUCCESS)
2459 rc = E_FAIL;
2460 else
2461 CHECK_ERROR(machine, COMSETTER(TeleporterPassword)(Bstr(password).raw()));
2462 break;
2463 }
2464
2465 case MODIFYVM_TRACING_ENABLED:
2466 {
2467 CHECK_ERROR(machine, COMSETTER(TracingEnabled)(ValueUnion.f));
2468 break;
2469 }
2470
2471 case MODIFYVM_TRACING_CONFIG:
2472 {
2473 CHECK_ERROR(machine, COMSETTER(TracingConfig)(Bstr(ValueUnion.psz).raw()));
2474 break;
2475 }
2476
2477 case MODIFYVM_TRACING_ALLOW_VM_ACCESS:
2478 {
2479 CHECK_ERROR(machine, COMSETTER(AllowTracingToAccessVM)(ValueUnion.f));
2480 break;
2481 }
2482
2483 case MODIFYVM_FAULT_TOLERANCE:
2484 {
2485 if (!RTStrICmp(ValueUnion.psz, "master"))
2486 {
2487 CHECK_ERROR(machine, COMSETTER(FaultToleranceState(FaultToleranceState_Master)));
2488 }
2489 else
2490 if (!RTStrICmp(ValueUnion.psz, "standby"))
2491 {
2492 CHECK_ERROR(machine, COMSETTER(FaultToleranceState(FaultToleranceState_Standby)));
2493 }
2494 else
2495 {
2496 errorArgument("Invalid --faulttolerance argument '%s'", ValueUnion.psz);
2497 rc = E_FAIL;
2498 }
2499 break;
2500 }
2501
2502 case MODIFYVM_FAULT_TOLERANCE_ADDRESS:
2503 {
2504 CHECK_ERROR(machine, COMSETTER(FaultToleranceAddress)(Bstr(ValueUnion.psz).raw()));
2505 break;
2506 }
2507
2508 case MODIFYVM_FAULT_TOLERANCE_PORT:
2509 {
2510 CHECK_ERROR(machine, COMSETTER(FaultTolerancePort)(ValueUnion.u32));
2511 break;
2512 }
2513
2514 case MODIFYVM_FAULT_TOLERANCE_PASSWORD:
2515 {
2516 CHECK_ERROR(machine, COMSETTER(FaultTolerancePassword)(Bstr(ValueUnion.psz).raw()));
2517 break;
2518 }
2519
2520 case MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL:
2521 {
2522 CHECK_ERROR(machine, COMSETTER(FaultToleranceSyncInterval)(ValueUnion.u32));
2523 break;
2524 }
2525
2526 case MODIFYVM_HARDWARE_UUID:
2527 {
2528 CHECK_ERROR(machine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz).raw()));
2529 break;
2530 }
2531
2532 case MODIFYVM_HPET:
2533 {
2534 CHECK_ERROR(machine, COMSETTER(HPETEnabled)(ValueUnion.f));
2535 break;
2536 }
2537
2538 case MODIFYVM_IOCACHE:
2539 {
2540 CHECK_ERROR(machine, COMSETTER(IOCacheEnabled)(ValueUnion.f));
2541 break;
2542 }
2543
2544 case MODIFYVM_IOCACHESIZE:
2545 {
2546 CHECK_ERROR(machine, COMSETTER(IOCacheSize)(ValueUnion.u32));
2547 break;
2548 }
2549
2550 case MODIFYVM_CHIPSET:
2551 {
2552 if (!RTStrICmp(ValueUnion.psz, "piix3"))
2553 {
2554 CHECK_ERROR(machine, COMSETTER(ChipsetType)(ChipsetType_PIIX3));
2555 }
2556 else if (!RTStrICmp(ValueUnion.psz, "ich9"))
2557 {
2558 CHECK_ERROR(machine, COMSETTER(ChipsetType)(ChipsetType_ICH9));
2559 BOOL fIoApic = FALSE;
2560 CHECK_ERROR(biosSettings, COMGETTER(IOAPICEnabled)(&fIoApic));
2561 if (!fIoApic)
2562 {
2563 RTStrmPrintf(g_pStdErr, "*** I/O APIC must be enabled for ICH9, enabling. ***\n");
2564 CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(TRUE));
2565 }
2566 }
2567 else
2568 {
2569 errorArgument("Invalid --chipset argument '%s' (valid: piix3,ich9)", ValueUnion.psz);
2570 rc = E_FAIL;
2571 }
2572 break;
2573 }
2574#ifdef VBOX_WITH_VPX
2575 case MODIFYVM_VCP:
2576 {
2577 CHECK_ERROR(machine, COMSETTER(VideoCaptureEnabled)(ValueUnion.f));
2578 break;
2579 }
2580 case MODIFYVM_VCP_SCREENS:
2581 {
2582 ULONG cMonitors = 64;
2583 CHECK_ERROR(machine, COMGETTER(MonitorCount)(&cMonitors));
2584 com::SafeArray<BOOL> screens(cMonitors);
2585 if (parseScreens(ValueUnion.psz, &screens))
2586 {
2587 errorArgument("Invalid list of screens specified\n");
2588 rc = E_FAIL;
2589 break;
2590 }
2591 CHECK_ERROR(machine, COMSETTER(VideoCaptureScreens)(ComSafeArrayAsInParam(screens)));
2592 break;
2593 }
2594 case MODIFYVM_VCP_FILENAME:
2595 {
2596 Bstr bstr;
2597 /* empty string will fall through, leaving bstr empty */
2598 if (*ValueUnion.psz)
2599 {
2600 char szVCFileAbs[RTPATH_MAX] = "";
2601 int vrc = RTPathAbs(ValueUnion.psz, szVCFileAbs, sizeof(szVCFileAbs));
2602 if (RT_FAILURE(vrc))
2603 {
2604 errorArgument("Cannot convert filename \"%s\" to absolute path\n", ValueUnion.psz);
2605 rc = E_FAIL;
2606 break;
2607 }
2608 bstr = szVCFileAbs;
2609 }
2610 CHECK_ERROR(machine, COMSETTER(VideoCaptureFile)(bstr.raw()));
2611 break;
2612 }
2613 case MODIFYVM_VCP_WIDTH:
2614 {
2615 CHECK_ERROR(machine, COMSETTER(VideoCaptureWidth)(ValueUnion.u32));
2616 break;
2617 }
2618 case MODIFYVM_VCP_HEIGHT:
2619 {
2620 CHECK_ERROR(machine, COMSETTER(VideoCaptureHeight)(ValueUnion.u32));
2621 break;
2622 }
2623 case MODIFYVM_VCP_RATE:
2624 {
2625 CHECK_ERROR(machine, COMSETTER(VideoCaptureRate)(ValueUnion.u32));
2626 break;
2627 }
2628 case MODIFYVM_VCP_FPS:
2629 {
2630 CHECK_ERROR(machine, COMSETTER(VideoCaptureFPS)(ValueUnion.u32));
2631 break;
2632 }
2633#endif
2634 case MODIFYVM_AUTOSTART_ENABLED:
2635 {
2636 CHECK_ERROR(machine, COMSETTER(AutostartEnabled)(ValueUnion.f));
2637 break;
2638 }
2639
2640 case MODIFYVM_AUTOSTART_DELAY:
2641 {
2642 CHECK_ERROR(machine, COMSETTER(AutostartDelay)(ValueUnion.u32));
2643 break;
2644 }
2645
2646 case MODIFYVM_AUTOSTOP_TYPE:
2647 {
2648 AutostopType_T enmAutostopType = AutostopType_Disabled;
2649
2650 if (!RTStrICmp(ValueUnion.psz, "disabled"))
2651 enmAutostopType = AutostopType_Disabled;
2652 else if (!RTStrICmp(ValueUnion.psz, "savestate"))
2653 enmAutostopType = AutostopType_SaveState;
2654 else if (!RTStrICmp(ValueUnion.psz, "poweroff"))
2655 enmAutostopType = AutostopType_PowerOff;
2656 else if (!RTStrICmp(ValueUnion.psz, "acpishutdown"))
2657 enmAutostopType = AutostopType_AcpiShutdown;
2658 else
2659 {
2660 errorArgument("Invalid --autostop-type argument '%s' (valid: disabled, savestate, poweroff, acpishutdown)", ValueUnion.psz);
2661 rc = E_FAIL;
2662 }
2663
2664 if (SUCCEEDED(rc))
2665 CHECK_ERROR(machine, COMSETTER(AutostopType)(enmAutostopType));
2666 break;
2667 }
2668#ifdef VBOX_WITH_PCI_PASSTHROUGH
2669 case MODIFYVM_ATTACH_PCI:
2670 {
2671 const char* pAt = strchr(ValueUnion.psz, '@');
2672 int32_t iHostAddr, iGuestAddr;
2673
2674 iHostAddr = parsePci(ValueUnion.psz);
2675 iGuestAddr = pAt != NULL ? parsePci(pAt + 1) : iHostAddr;
2676
2677 if (iHostAddr == -1 || iGuestAddr == -1)
2678 {
2679 errorArgument("Invalid --pciattach argument '%s' (valid: 'HB:HD.HF@GB:GD.GF' or just 'HB:HD.HF')", ValueUnion.psz);
2680 rc = E_FAIL;
2681 }
2682 else
2683 {
2684 CHECK_ERROR(machine, AttachHostPCIDevice(iHostAddr, iGuestAddr, TRUE));
2685 }
2686
2687 break;
2688 }
2689 case MODIFYVM_DETACH_PCI:
2690 {
2691 int32_t iHostAddr;
2692
2693 iHostAddr = parsePci(ValueUnion.psz);
2694 if (iHostAddr == -1)
2695 {
2696 errorArgument("Invalid --pcidetach argument '%s' (valid: 'HB:HD.HF')", ValueUnion.psz);
2697 rc = E_FAIL;
2698 }
2699 else
2700 {
2701 CHECK_ERROR(machine, DetachHostPCIDevice(iHostAddr));
2702 }
2703
2704 break;
2705 }
2706#endif
2707
2708#ifdef VBOX_WITH_USB_CARDREADER
2709 case MODIFYVM_USBCARDREADER:
2710 {
2711 CHECK_ERROR(machine, COMSETTER(EmulatedUSBCardReaderEnabled)(ValueUnion.f));
2712 break;
2713 }
2714#endif /* VBOX_WITH_USB_CARDREADER */
2715
2716 case MODIFYVM_DEFAULTFRONTEND:
2717 {
2718 Bstr bstr(ValueUnion.psz);
2719 if (bstr == "default")
2720 bstr = Bstr::Empty;
2721 CHECK_ERROR(machine, COMSETTER(DefaultFrontend)(bstr.raw()));
2722 break;
2723 }
2724
2725 default:
2726 {
2727 errorGetOpt(USAGE_MODIFYVM, c, &ValueUnion);
2728 rc = E_FAIL;
2729 break;
2730 }
2731 }
2732 }
2733
2734 /* commit changes */
2735 if (SUCCEEDED(rc))
2736 CHECK_ERROR(machine, SaveSettings());
2737
2738 /* it's important to always close sessions */
2739 a->session->UnlockMachine();
2740
2741 return SUCCEEDED(rc) ? 0 : 1;
2742}
2743
2744#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