VirtualBox

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

Last change on this file since 43421 was 43023, checked in by vboxsync, 12 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use