VirtualBox

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

Last change on this file since 67954 was 66830, checked in by vboxsync, 7 years ago

VBoxManage: Adjustments for Visual C++ v12 / Visual Studio 2013. Dropped warning 4748.

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