VirtualBox

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

Last change on this file since 42121 was 41925, checked in by vboxsync, 13 years ago

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