VirtualBox

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

Last change on this file since 73768 was 73768, checked in by vboxsync, 6 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use