VirtualBox

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

Last change on this file since 46545 was 46290, checked in by vboxsync, 12 years ago

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