VirtualBox

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

Last change on this file since 53404 was 52312, checked in by vboxsync, 10 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette