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
RevLine 
[16491]1/* $Id: VBoxManageModifyVM.cpp 43023 2012-08-28 06:43:23Z vboxsync $ */
[16485]2/** @file
[18780]3 * VBoxManage - Implementation of modifyvm command.
[16485]4 */
5
6/*
[40324]7 * Copyright (C) 2006-2012 Oracle Corporation
[16485]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>
[17238]23#include <VBox/com/array.h>
[16485]24#include <VBox/com/ErrorInfo.h>
[20928]25#include <VBox/com/errorprint.h>
[16485]26#include <VBox/com/EventQueue.h>
27
28#include <VBox/com/VirtualBox.h>
29#endif /* !VBOX_ONLY_DOCS */
30
31#include <iprt/cidr.h>
[40714]32#include <iprt/ctype.h>
33#include <iprt/file.h>
[16485]34#include <iprt/param.h>
35#include <iprt/path.h>
36#include <iprt/stream.h>
37#include <iprt/string.h>
[23706]38#include <iprt/getopt.h>
[16485]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
[23801]49enum
[23706]50{
[23801]51 MODIFYVM_NAME = 1000,
[42176]52 MODIFYVM_GROUPS,
[23801]53 MODIFYVM_OSTYPE,
54 MODIFYVM_MEMORY,
[29465]55 MODIFYVM_PAGEFUSION,
[23801]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,
[27166]65 MODIFYVM_LARGEPAGES,
[23801]66 MODIFYVM_VTXVPID,
67 MODIFYVM_CPUS,
[25901]68 MODIFYVM_CPUHOTPLUG,
69 MODIFYVM_PLUGCPU,
70 MODIFYVM_UNPLUGCPU,
[24321]71 MODIFYVM_SETCPUID,
72 MODIFYVM_DELCPUID,
73 MODIFYVM_DELALLCPUID,
[23801]74 MODIFYVM_MONITORCOUNT,
75 MODIFYVM_ACCELERATE3D,
[26675]76#ifdef VBOX_WITH_VIDEOHWACCEL
[23801]77 MODIFYVM_ACCELERATE2DVIDEO,
[26675]78#endif
[23801]79 MODIFYVM_BIOSLOGOFADEIN,
80 MODIFYVM_BIOSLOGOFADEOUT,
81 MODIFYVM_BIOSLOGODISPLAYTIME,
82 MODIFYVM_BIOSLOGOIMAGEPATH,
83 MODIFYVM_BIOSBOOTMENU,
84 MODIFYVM_BIOSSYSTEMTIMEOFFSET,
85 MODIFYVM_BIOSPXEDEBUG,
86 MODIFYVM_BOOT,
[23807]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
[23801]100 MODIFYVM_NICTRACEFILE,
101 MODIFYVM_NICTRACE,
[37200]102 MODIFYVM_NICPROPERTY,
[23801]103 MODIFYVM_NICTYPE,
104 MODIFYVM_NICSPEED,
[28106]105 MODIFYVM_NICBOOTPRIO,
[36082]106 MODIFYVM_NICPROMISC,
[36275]107 MODIFYVM_NICBWGROUP,
[23801]108 MODIFYVM_NIC,
109 MODIFYVM_CABLECONNECTED,
110 MODIFYVM_BRIDGEADAPTER,
111 MODIFYVM_HOSTONLYADAPTER,
112 MODIFYVM_INTNET,
113 MODIFYVM_NATNET,
[37200]114 MODIFYVM_GENERICDRV,
[27857]115 MODIFYVM_NATBINDIP,
116 MODIFYVM_NATSETTINGS,
117 MODIFYVM_NATPF,
[28787]118 MODIFYVM_NATALIASMODE,
[27857]119 MODIFYVM_NATTFTPPREFIX,
120 MODIFYVM_NATTFTPFILE,
121 MODIFYVM_NATTFTPSERVER,
122 MODIFYVM_NATDNSPASSDOMAIN,
123 MODIFYVM_NATDNSPROXY,
124 MODIFYVM_NATDNSHOSTRESOLVER,
[23801]125 MODIFYVM_MACADDRESS,
[26936]126 MODIFYVM_HIDPTR,
127 MODIFYVM_HIDKBD,
[23801]128 MODIFYVM_UARTMODE,
129 MODIFYVM_UART,
[40324]130#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS)
131 MODIFYVM_LPTMODE,
132 MODIFYVM_LPT,
133#endif
[23801]134 MODIFYVM_GUESTMEMORYBALLOON,
135 MODIFYVM_AUDIOCONTROLLER,
136 MODIFYVM_AUDIO,
137 MODIFYVM_CLIPBOARD,
[42261]138 MODIFYVM_DRAGANDDROP,
[33386]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 */
[33590]147 MODIFYVM_VRDEPROPERTY,
[35105]148 MODIFYVM_VRDEPORT,
149 MODIFYVM_VRDEADDRESS,
[33386]150 MODIFYVM_VRDEAUTHTYPE,
[34574]151 MODIFYVM_VRDEAUTHLIBRARY,
[33386]152 MODIFYVM_VRDEMULTICON,
153 MODIFYVM_VRDEREUSECON,
154 MODIFYVM_VRDEVIDEOCHANNEL,
155 MODIFYVM_VRDEVIDEOCHANNELQUALITY,
[34244]156 MODIFYVM_VRDE_EXTPACK,
[33386]157 MODIFYVM_VRDE,
[25672]158 MODIFYVM_RTCUSEUTC,
[23801]159 MODIFYVM_USBEHCI,
160 MODIFYVM_USB,
161 MODIFYVM_SNAPSHOTFOLDER,
162 MODIFYVM_TELEPORTER_ENABLED,
163 MODIFYVM_TELEPORTER_PORT,
164 MODIFYVM_TELEPORTER_ADDRESS,
[24136]165 MODIFYVM_TELEPORTER_PASSWORD,
[40729]166 MODIFYVM_TELEPORTER_PASSWORD_FILE,
[40418]167 MODIFYVM_TRACING_ENABLED,
168 MODIFYVM_TRACING_CONFIG,
169 MODIFYVM_TRACING_ALLOW_VM_ACCESS,
[26548]170 MODIFYVM_HARDWARE_UUID,
[27325]171 MODIFYVM_HPET,
172 MODIFYVM_IOCACHE,
[31976]173 MODIFYVM_IOCACHESIZE,
174 MODIFYVM_FAULT_TOLERANCE,
175 MODIFYVM_FAULT_TOLERANCE_ADDRESS,
176 MODIFYVM_FAULT_TOLERANCE_PORT,
177 MODIFYVM_FAULT_TOLERANCE_PASSWORD,
[32885]178 MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL,
[33020]179 MODIFYVM_CPU_EXECTUION_CAP,
[41915]180 MODIFYVM_AUTOSTART_ENABLED,
181 MODIFYVM_AUTOSTART_DELAY,
182 MODIFYVM_AUTOSTOP_TYPE,
[36630]183#ifdef VBOX_WITH_PCI_PASSTHROUGH
184 MODIFYVM_ATTACH_PCI,
185 MODIFYVM_DETACH_PCI,
186#endif
[41371]187#ifdef VBOX_WITH_USB_CARDREADER
188 MODIFYVM_USBCARDREADER,
189#endif
[42838]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
[23706]197};
198
199static const RTGETOPTDEF g_aModifyVMOptions[] =
200{
[23801]201 { "--name", MODIFYVM_NAME, RTGETOPT_REQ_STRING },
[42176]202 { "--groups", MODIFYVM_GROUPS, RTGETOPT_REQ_STRING },
[23801]203 { "--ostype", MODIFYVM_OSTYPE, RTGETOPT_REQ_STRING },
204 { "--memory", MODIFYVM_MEMORY, RTGETOPT_REQ_UINT32 },
[29465]205 { "--pagefusion", MODIFYVM_PAGEFUSION, RTGETOPT_REQ_BOOL_ONOFF },
[23801]206 { "--vram", MODIFYVM_VRAM, RTGETOPT_REQ_UINT32 },
207 { "--firmware", MODIFYVM_FIRMWARE, RTGETOPT_REQ_STRING },
[24143]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 },
[27166]215 { "--largepages", MODIFYVM_LARGEPAGES, RTGETOPT_REQ_BOOL_ONOFF },
[24143]216 { "--vtxvpid", MODIFYVM_VTXVPID, RTGETOPT_REQ_BOOL_ONOFF },
[24321]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},
[23801]220 { "--cpus", MODIFYVM_CPUS, RTGETOPT_REQ_UINT32 },
[25901]221 { "--cpuhotplug", MODIFYVM_CPUHOTPLUG, RTGETOPT_REQ_BOOL_ONOFF },
222 { "--plugcpu", MODIFYVM_PLUGCPU, RTGETOPT_REQ_UINT32 },
223 { "--unplugcpu", MODIFYVM_UNPLUGCPU, RTGETOPT_REQ_UINT32 },
[32885]224 { "--cpuexecutioncap", MODIFYVM_CPU_EXECTUION_CAP, RTGETOPT_REQ_UINT32 },
[25672]225 { "--rtcuseutc", MODIFYVM_RTCUSEUTC, RTGETOPT_REQ_BOOL_ONOFF },
[23801]226 { "--monitorcount", MODIFYVM_MONITORCOUNT, RTGETOPT_REQ_UINT32 },
[24143]227 { "--accelerate3d", MODIFYVM_ACCELERATE3D, RTGETOPT_REQ_BOOL_ONOFF },
[26675]228#ifdef VBOX_WITH_VIDEOHWACCEL
[24143]229 { "--accelerate2dvideo", MODIFYVM_ACCELERATE2DVIDEO, RTGETOPT_REQ_BOOL_ONOFF },
[26675]230#endif
[24143]231 { "--bioslogofadein", MODIFYVM_BIOSLOGOFADEIN, RTGETOPT_REQ_BOOL_ONOFF },
232 { "--bioslogofadeout", MODIFYVM_BIOSLOGOFADEOUT, RTGETOPT_REQ_BOOL_ONOFF },
[25325]233 { "--bioslogodisplaytime", MODIFYVM_BIOSLOGODISPLAYTIME, RTGETOPT_REQ_UINT32 },
[23801]234 { "--bioslogoimagepath", MODIFYVM_BIOSLOGOIMAGEPATH, RTGETOPT_REQ_STRING },
235 { "--biosbootmenu", MODIFYVM_BIOSBOOTMENU, RTGETOPT_REQ_STRING },
[24979]236 { "--biossystemtimeoffset", MODIFYVM_BIOSSYSTEMTIMEOFFSET, RTGETOPT_REQ_INT64 },
[24143]237 { "--biospxedebug", MODIFYVM_BIOSPXEDEBUG, RTGETOPT_REQ_BOOL_ONOFF },
[23801]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 },
[24143]253 { "--nictrace", MODIFYVM_NICTRACE, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
[37200]254 { "--nicproperty", MODIFYVM_NICPROPERTY, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
[23801]255 { "--nictype", MODIFYVM_NICTYPE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
256 { "--nicspeed", MODIFYVM_NICSPEED, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
[28106]257 { "--nicbootprio", MODIFYVM_NICBOOTPRIO, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
[36082]258 { "--nicpromisc", MODIFYVM_NICPROMISC, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
[36275]259 { "--nicbandwidthgroup", MODIFYVM_NICBWGROUP, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
[23801]260 { "--nic", MODIFYVM_NIC, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
[24143]261 { "--cableconnected", MODIFYVM_CABLECONNECTED, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
[23801]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 },
[37200]266 { "--nicgenericdrv", MODIFYVM_GENERICDRV, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
[27857]267 { "--natbindip", MODIFYVM_NATBINDIP, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
[28041]268 { "--natsettings", MODIFYVM_NATSETTINGS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
[27857]269 { "--natpf", MODIFYVM_NATPF, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
[28787]270 { "--nataliasmode", MODIFYVM_NATALIASMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
[27857]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 },
[23801]277 { "--macaddress", MODIFYVM_MACADDRESS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
[26936]278 { "--mouse", MODIFYVM_HIDPTR, RTGETOPT_REQ_STRING },
279 { "--keyboard", MODIFYVM_HIDKBD, RTGETOPT_REQ_STRING },
[23801]280 { "--uartmode", MODIFYVM_UARTMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
281 { "--uart", MODIFYVM_UART, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
[40324]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
[23801]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 },
[42261]290 { "--draganddrop", MODIFYVM_DRAGANDDROP, RTGETOPT_REQ_STRING },
[33386]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 */
[35146]297 { "--vrdpvideochannelquality", MODIFYVM_VRDPVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING }, /* deprecated */
[33386]298 { "--vrdp", MODIFYVM_VRDP, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
[33590]299 { "--vrdeproperty", MODIFYVM_VRDEPROPERTY, RTGETOPT_REQ_STRING },
[35105]300 { "--vrdeport", MODIFYVM_VRDEPORT, RTGETOPT_REQ_STRING },
301 { "--vrdeaddress", MODIFYVM_VRDEADDRESS, RTGETOPT_REQ_STRING },
[33386]302 { "--vrdeauthtype", MODIFYVM_VRDEAUTHTYPE, RTGETOPT_REQ_STRING },
[34574]303 { "--vrdeauthlibrary", MODIFYVM_VRDEAUTHLIBRARY, RTGETOPT_REQ_STRING },
[33386]304 { "--vrdemulticon", MODIFYVM_VRDEMULTICON, RTGETOPT_REQ_BOOL_ONOFF },
305 { "--vrdereusecon", MODIFYVM_VRDEREUSECON, RTGETOPT_REQ_BOOL_ONOFF },
306 { "--vrdevideochannel", MODIFYVM_VRDEVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF },
[35146]307 { "--vrdevideochannelquality", MODIFYVM_VRDEVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING },
[34244]308 { "--vrdeextpack", MODIFYVM_VRDE_EXTPACK, RTGETOPT_REQ_STRING },
[33386]309 { "--vrde", MODIFYVM_VRDE, RTGETOPT_REQ_BOOL_ONOFF },
[24143]310 { "--usbehci", MODIFYVM_USBEHCI, RTGETOPT_REQ_BOOL_ONOFF },
311 { "--usb", MODIFYVM_USB, RTGETOPT_REQ_BOOL_ONOFF },
[23801]312 { "--snapshotfolder", MODIFYVM_SNAPSHOTFOLDER, RTGETOPT_REQ_STRING },
[24864]313 { "--teleporter", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
314 { "--teleporterenabled", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
[23801]315 { "--teleporterport", MODIFYVM_TELEPORTER_PORT, RTGETOPT_REQ_UINT32 },
316 { "--teleporteraddress", MODIFYVM_TELEPORTER_ADDRESS, RTGETOPT_REQ_STRING },
317 { "--teleporterpassword", MODIFYVM_TELEPORTER_PASSWORD, RTGETOPT_REQ_STRING },
[40729]318 { "--teleporterpasswordfile", MODIFYVM_TELEPORTER_PASSWORD_FILE, RTGETOPT_REQ_STRING },
[40418]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 },
[24136]322 { "--hardwareuuid", MODIFYVM_HARDWARE_UUID, RTGETOPT_REQ_STRING },
[26548]323 { "--hpet", MODIFYVM_HPET, RTGETOPT_REQ_BOOL_ONOFF },
[27325]324 { "--iocache", MODIFYVM_IOCACHE, RTGETOPT_REQ_BOOL_ONOFF },
325 { "--iocachesize", MODIFYVM_IOCACHESIZE, RTGETOPT_REQ_UINT32 },
[31976]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 },
[33020]331 { "--chipset", MODIFYVM_CHIPSET, RTGETOPT_REQ_STRING },
[42838]332#ifdef VBOX_WITH_VPX
[42861]333 { "--vcpenabled", MODIFYVM_VCP, RTGETOPT_REQ_BOOL_ONOFF },
334 { "--vcpfile", MODIFYVM_VCP_FILENAME, RTGETOPT_REQ_STRING },
[42838]335 { "--vcpwidth", MODIFYVM_VCP_WIDTH, RTGETOPT_REQ_UINT32 },
336 { "--vcpheight", MODIFYVM_VCP_HEIGHT, RTGETOPT_REQ_UINT32 },
337#endif
[41915]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 },
[36630]341#ifdef VBOX_WITH_PCI_PASSTHROUGH
[37817]342 { "--pciattach", MODIFYVM_ATTACH_PCI, RTGETOPT_REQ_STRING },
343 { "--pcidetach", MODIFYVM_DETACH_PCI, RTGETOPT_REQ_STRING },
[36630]344#endif
[41371]345#ifdef VBOX_WITH_USB_CARDREADER
346 { "--usbcardreader", MODIFYVM_USBCARDREADER, RTGETOPT_REQ_BOOL_ONOFF },
347#endif
[23706]348};
349
[33386]350static void vrdeWarningDeprecatedOption(const char *pszOption)
351{
352 RTStrmPrintf(g_pStdErr, "Warning: '--vrdp%s' is deprecated. Use '--vrde%s'.\n", pszOption, pszOption);
353}
354
[36630]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};
[37200]361
[36630]362 rc = RTStrToUInt8Ex(pszNext, &pszNext, 16, &aVals[0]);
363 if (RT_FAILURE(rc) || pszNext == NULL || *pszNext != ':')
364 return -1;
[37200]365
[36630]366 rc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[1]);
367 if (RT_FAILURE(rc) || pszNext == NULL || *pszNext != '.')
368 return -1;
[33386]369
[36630]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
[42176]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
[16485]395int handleModifyVM(HandlerArg *a)
396{
[23706]397 int c;
[16485]398 HRESULT rc;
399 Bstr name;
[23873]400 RTGETOPTUNION ValueUnion;
401 RTGETOPTSTATE GetOptState;
[23706]402 ComPtr <IMachine> machine;
403 ComPtr <IBIOSSettings> biosSettings;
[16485]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 */
[33294]411 CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
412 machine.asOutParam()), 1);
[16485]413
[35761]414
415 /* Get the number of network adapters */
416 ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, machine);
417
[16485]418 /* open a session for the VM */
[31019]419 CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), 1);
[16485]420
[23706]421 /* get the mutable session machine */
[42381]422 CHECK_ERROR_RET(a->session, COMGETTER(Machine)(machine.asOutParam()), 1);
[23706]423 machine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
424
[23934]425 RTGetOptInit(&GetOptState, a->argc, a->argv, g_aModifyVMOptions,
[26517]426 RT_ELEMENTS(g_aModifyVMOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
[23706]427
428 while ( SUCCEEDED (rc)
[23873]429 && (c = RTGetOpt(&GetOptState, &ValueUnion)))
[16485]430 {
[23706]431 switch (c)
[16485]432 {
[23801]433 case MODIFYVM_NAME:
[16485]434 {
[32718]435 CHECK_ERROR(machine, COMSETTER(Name)(Bstr(ValueUnion.psz).raw()));
[23706]436 break;
[16485]437 }
[42176]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 }
[23801]445 case MODIFYVM_OSTYPE:
[16485]446 {
[24135]447 ComPtr<IGuestOSType> guestOSType;
[32718]448 CHECK_ERROR(a->virtualBox, GetGuestOSType(Bstr(ValueUnion.psz).raw(),
449 guestOSType.asOutParam()));
[24135]450 if (SUCCEEDED(rc) && guestOSType)
[23706]451 {
[32718]452 CHECK_ERROR(machine, COMSETTER(OSTypeId)(Bstr(ValueUnion.psz).raw()));
[23706]453 }
[24135]454 else
455 {
[31539]456 errorArgument("Invalid guest OS type '%s'", Utf8Str(ValueUnion.psz).c_str());
[24135]457 rc = E_FAIL;
458 }
[16485]459 break;
460 }
[23706]461
[23801]462 case MODIFYVM_MEMORY:
[16485]463 {
[24137]464 CHECK_ERROR(machine, COMSETTER(MemorySize)(ValueUnion.u32));
[23706]465 break;
[16485]466 }
[23706]467
[29465]468 case MODIFYVM_PAGEFUSION:
469 {
470 CHECK_ERROR(machine, COMSETTER(PageFusionEnabled)(ValueUnion.f));
471 break;
472 }
473
[23801]474 case MODIFYVM_VRAM:
[16485]475 {
[24137]476 CHECK_ERROR(machine, COMSETTER(VRAMSize)(ValueUnion.u32));
[23706]477 break;
[16485]478 }
[23706]479
[23801]480 case MODIFYVM_FIRMWARE:
[16485]481 {
[24858]482 if (!strcmp(ValueUnion.psz, "efi"))
[23706]483 {
[24135]484 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI));
[23706]485 }
[24858]486 else if (!strcmp(ValueUnion.psz, "efi32"))
487 {
488 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI32));
489 }
[24599]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 }
[24135]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 }
[16485]507 break;
508 }
[23706]509
[23801]510 case MODIFYVM_ACPI:
[16485]511 {
[24143]512 CHECK_ERROR(biosSettings, COMSETTER(ACPIEnabled)(ValueUnion.f));
[23706]513 break;
[16485]514 }
[23706]515
[23801]516 case MODIFYVM_IOAPIC:
[16485]517 {
[24143]518 CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(ValueUnion.f));
[23706]519 break;
[16485]520 }
[23706]521
[23801]522 case MODIFYVM_PAE:
[16485]523 {
[27537]524 CHECK_ERROR(machine, SetCPUProperty(CPUPropertyType_PAE, ValueUnion.f));
[16485]525 break;
526 }
[23706]527
[23801]528 case MODIFYVM_SYNTHCPU:
[23750]529 {
[27537]530 CHECK_ERROR(machine, SetCPUProperty(CPUPropertyType_Synthetic, ValueUnion.f));
[23750]531 break;
532 }
533
[23801]534 case MODIFYVM_HWVIRTEX:
[16485]535 {
[24143]536 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_Enabled, ValueUnion.f));
[23706]537 break;
[16485]538 }
[23706]539
[23801]540 case MODIFYVM_HWVIRTEXEXCLUSIVE:
[23733]541 {
[24143]542 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_Exclusive, ValueUnion.f));
[23733]543 break;
544 }
545
[24321]546 case MODIFYVM_SETCPUID:
[24305]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 }
[27537]560 CHECK_ERROR(machine, SetCPUIDLeaf(id, aValue[0], aValue[1], aValue[2], aValue[3]));
[24305]561 break;
562 }
563
[24321]564 case MODIFYVM_DELCPUID:
565 {
[27537]566 CHECK_ERROR(machine, RemoveCPUIDLeaf(ValueUnion.u32));
[24321]567 break;
568 }
569
570 case MODIFYVM_DELALLCPUID:
571 {
[27537]572 CHECK_ERROR(machine, RemoveAllCPUIDLeaves());
[24321]573 break;
574 }
575
[23801]576 case MODIFYVM_NESTEDPAGING:
[16485]577 {
[24143]578 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, ValueUnion.f));
[23706]579 break;
[16485]580 }
[23706]581
[27166]582 case MODIFYVM_LARGEPAGES:
583 {
584 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_LargePages, ValueUnion.f));
585 break;
586 }
587
[23801]588 case MODIFYVM_VTXVPID:
[16485]589 {
[24143]590 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_VPID, ValueUnion.f));
[16485]591 break;
592 }
[23706]593
[23801]594 case MODIFYVM_CPUS:
[16485]595 {
[24137]596 CHECK_ERROR(machine, COMSETTER(CPUCount)(ValueUnion.u32));
[23706]597 break;
[16485]598 }
[23706]599
[25672]600 case MODIFYVM_RTCUSEUTC:
601 {
602 CHECK_ERROR(machine, COMSETTER(RTCUseUTC)(ValueUnion.f));
603 break;
604 }
605
[25901]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
[32885]624 case MODIFYVM_CPU_EXECTUION_CAP:
625 {
626 CHECK_ERROR(machine, COMSETTER(CPUExecutionCap)(ValueUnion.u32));
[32913]627 break;
[32885]628 }
629
[23801]630 case MODIFYVM_MONITORCOUNT:
[16485]631 {
[24137]632 CHECK_ERROR(machine, COMSETTER(MonitorCount)(ValueUnion.u32));
[23706]633 break;
[16485]634 }
[23706]635
[23801]636 case MODIFYVM_ACCELERATE3D:
[16485]637 {
[24143]638 CHECK_ERROR(machine, COMSETTER(Accelerate3DEnabled)(ValueUnion.f));
[16485]639 break;
640 }
[23706]641
[24135]642#ifdef VBOX_WITH_VIDEOHWACCEL
[23801]643 case MODIFYVM_ACCELERATE2DVIDEO:
[16485]644 {
[24143]645 CHECK_ERROR(machine, COMSETTER(Accelerate2DVideoEnabled)(ValueUnion.f));
[16485]646 break;
647 }
[24135]648#endif
[23706]649
[23801]650 case MODIFYVM_BIOSLOGOFADEIN:
[16485]651 {
[24143]652 CHECK_ERROR(biosSettings, COMSETTER(LogoFadeIn)(ValueUnion.f));
[16485]653 break;
654 }
[23706]655
[23801]656 case MODIFYVM_BIOSLOGOFADEOUT:
[16485]657 {
[24143]658 CHECK_ERROR(biosSettings, COMSETTER(LogoFadeOut)(ValueUnion.f));
[16485]659 break;
660 }
[23706]661
[23801]662 case MODIFYVM_BIOSLOGODISPLAYTIME:
[22145]663 {
[25325]664 CHECK_ERROR(biosSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u32));
[22145]665 break;
666 }
[23706]667
[23801]668 case MODIFYVM_BIOSLOGOIMAGEPATH:
[23179]669 {
[32718]670 CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz).raw()));
[23179]671 break;
672 }
[23706]673
[23801]674 case MODIFYVM_BIOSBOOTMENU:
[16485]675 {
[24135]676 if (!strcmp(ValueUnion.psz, "disabled"))
[23706]677 {
[24135]678 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_Disabled));
[23706]679 }
[24135]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 }
[16485]693 break;
694 }
[23706]695
[23801]696 case MODIFYVM_BIOSSYSTEMTIMEOFFSET:
[16485]697 {
[24979]698 CHECK_ERROR(biosSettings, COMSETTER(TimeOffset)(ValueUnion.i64));
[16485]699 break;
700 }
[23706]701
[23801]702 case MODIFYVM_BIOSPXEDEBUG:
[16485]703 {
[24143]704 CHECK_ERROR(biosSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f));
[16485]705 break;
706 }
707
[23801]708 case MODIFYVM_BOOT:
[16485]709 {
[23873]710 if (!strcmp(ValueUnion.psz, "none"))
[23706]711 {
[23934]712 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Null));
[23706]713 }
[23873]714 else if (!strcmp(ValueUnion.psz, "floppy"))
[23706]715 {
[23934]716 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Floppy));
[23706]717 }
[23873]718 else if (!strcmp(ValueUnion.psz, "dvd"))
[23706]719 {
[23934]720 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_DVD));
[23706]721 }
[23873]722 else if (!strcmp(ValueUnion.psz, "disk"))
[23706]723 {
[23934]724 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_HardDisk));
[23706]725 }
[23873]726 else if (!strcmp(ValueUnion.psz, "net"))
[23706]727 {
[23934]728 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Network));
[23706]729 }
730 else
[23873]731 return errorArgument("Invalid boot device '%s'", ValueUnion.psz);
[16485]732 break;
733 }
[23706]734
[23807]735 case MODIFYVM_HDA: // deprecated
[31568]736 case MODIFYVM_HDB: // deprecated
737 case MODIFYVM_HDD: // deprecated
738 case MODIFYVM_SATAPORT: // deprecated
[16485]739 {
[31575]740 uint32_t u1 = 0, u2 = 0;
[31568]741 Bstr bstrController = L"IDE Controller";
742
743 switch (c)
[16485]744 {
[31568]745 case MODIFYVM_HDA: // deprecated
746 u1 = 0;
747 break;
[23706]748
[31568]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;
[16485]763 }
[23706]764
[23873]765 if (!strcmp(ValueUnion.psz, "none"))
[16485]766 {
[32718]767 machine->DetachDevice(bstrController.raw(), u1, u2);
[23706]768 }
769 else
770 {
771 ComPtr<IMedium> hardDisk;
[35239]772 rc = findOrOpenMedium(a, ValueUnion.psz, DeviceType_HardDisk,
[41347]773 AccessMode_ReadWrite, hardDisk,
774 false /* fForceNewUuidOnOpen */, NULL);
[31562]775 if (FAILED(rc))
[35239]776 break;
[23706]777 if (hardDisk)
778 {
[32718]779 CHECK_ERROR(machine, AttachDevice(bstrController.raw(),
780 u1, u2,
781 DeviceType_HardDisk,
782 hardDisk));
[23706]783 }
784 else
785 rc = E_FAIL;
[16485]786 }
[23706]787 break;
788 }
789
[23807]790 case MODIFYVM_IDECONTROLLER: // deprecated
[23706]791 {
792 ComPtr<IStorageController> storageController;
[32718]793 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("IDE Controller").raw(),
[23706]794 storageController.asOutParam()));
795
[23873]796 if (!RTStrICmp(ValueUnion.psz, "PIIX3"))
[16485]797 {
[23706]798 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX3));
[16485]799 }
[23873]800 else if (!RTStrICmp(ValueUnion.psz, "PIIX4"))
[23706]801 {
802 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX4));
803 }
[23873]804 else if (!RTStrICmp(ValueUnion.psz, "ICH6"))
[23706]805 {
806 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_ICH6));
807 }
[16485]808 else
[23706]809 {
[23873]810 errorArgument("Invalid --idecontroller argument '%s'", ValueUnion.psz);
[16485]811 rc = E_FAIL;
[23706]812 }
813 break;
[16485]814 }
[23706]815
[23807]816 case MODIFYVM_SATAPORTCOUNT: // deprecated
[16485]817 {
[23706]818 ComPtr<IStorageController> SataCtl;
[32718]819 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA").raw(),
820 SataCtl.asOutParam()));
[23706]821
[23873]822 if (SUCCEEDED(rc) && ValueUnion.u32 > 0)
823 CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32));
[23706]824 break;
825 }
826
[23807]827 case MODIFYVM_SATA: // deprecated
[23706]828 {
[23873]829 if (!strcmp(ValueUnion.psz, "on") || !strcmp(ValueUnion.psz, "enable"))
[16485]830 {
[23706]831 ComPtr<IStorageController> ctl;
[32718]832 CHECK_ERROR(machine, AddStorageController(Bstr("SATA").raw(),
833 StorageBus_SATA,
834 ctl.asOutParam()));
[23934]835 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
[16485]836 }
[23873]837 else if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
[32718]838 CHECK_ERROR(machine, RemoveStorageController(Bstr("SATA").raw()));
[16485]839 else
[23873]840 return errorArgument("Invalid --usb argument '%s'", ValueUnion.psz);
[23706]841 break;
[16485]842 }
843
[23807]844 case MODIFYVM_SCSIPORT: // deprecated
[16485]845 {
[23873]846 if (!strcmp(ValueUnion.psz, "none"))
[16485]847 {
[32718]848 rc = machine->DetachDevice(Bstr("LsiLogic").raw(),
849 GetOptState.uIndex, 0);
[23706]850 if (FAILED(rc))
[32718]851 CHECK_ERROR(machine, DetachDevice(Bstr("BusLogic").raw(),
852 GetOptState.uIndex, 0));
[23706]853 }
854 else
855 {
856 ComPtr<IMedium> hardDisk;
[35239]857 rc = findOrOpenMedium(a, ValueUnion.psz, DeviceType_HardDisk,
[41347]858 AccessMode_ReadWrite, hardDisk,
859 false /* fForceNewUuidOnOpen */, NULL);
[31562]860 if (FAILED(rc))
[35239]861 break;
[23706]862 if (hardDisk)
[16485]863 {
[32718]864 rc = machine->AttachDevice(Bstr("LsiLogic").raw(),
865 GetOptState.uIndex, 0,
866 DeviceType_HardDisk,
867 hardDisk);
[23706]868 if (FAILED(rc))
[23934]869 CHECK_ERROR(machine,
[32718]870 AttachDevice(Bstr("BusLogic").raw(),
871 GetOptState.uIndex, 0,
872 DeviceType_HardDisk,
873 hardDisk));
[23706]874 }
875 else
[16485]876 rc = E_FAIL;
877 }
[23706]878 break;
[16485]879 }
[23706]880
[23807]881 case MODIFYVM_SCSITYPE: // deprecated
[16485]882 {
[23706]883 ComPtr<IStorageController> ctl;
884
[23873]885 if (!RTStrICmp(ValueUnion.psz, "LsiLogic"))
[16485]886 {
[32718]887 rc = machine->RemoveStorageController(Bstr("BusLogic").raw());
[23706]888 if (FAILED(rc))
[32718]889 CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic").raw()));
[23706]890
[23934]891 CHECK_ERROR(machine,
[32718]892 AddStorageController(Bstr("LsiLogic").raw(),
[23706]893 StorageBus_SCSI,
894 ctl.asOutParam()));
895
896 if (SUCCEEDED(rc))
[23934]897 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
[16485]898 }
[23873]899 else if (!RTStrICmp(ValueUnion.psz, "BusLogic"))
[16485]900 {
[32718]901 rc = machine->RemoveStorageController(Bstr("LsiLogic").raw());
[23706]902 if (FAILED(rc))
[32718]903 CHECK_ERROR(machine, RemoveStorageController(Bstr("BusLogic").raw()));
[23706]904
[23934]905 CHECK_ERROR(machine,
[32718]906 AddStorageController(Bstr("BusLogic").raw(),
[23706]907 StorageBus_SCSI,
908 ctl.asOutParam()));
909
910 if (SUCCEEDED(rc))
[23934]911 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
[16485]912 }
[23706]913 else
[23873]914 return errorArgument("Invalid --scsitype argument '%s'", ValueUnion.psz);
[23706]915 break;
[23223]916 }
[16485]917
[23807]918 case MODIFYVM_SCSI: // deprecated
[23706]919 {
[23873]920 if (!strcmp(ValueUnion.psz, "on") || !strcmp(ValueUnion.psz, "enable"))
[23706]921 {
922 ComPtr<IStorageController> ctl;
[16485]923
[32718]924 CHECK_ERROR(machine, AddStorageController(Bstr("BusLogic").raw(),
925 StorageBus_SCSI,
926 ctl.asOutParam()));
[23706]927 if (SUCCEEDED(rc))
[23934]928 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
[23706]929 }
[23873]930 else if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
[23706]931 {
[32718]932 rc = machine->RemoveStorageController(Bstr("BusLogic").raw());
[23706]933 if (FAILED(rc))
[32718]934 CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic").raw()));
[23706]935 }
936 break;
937 }
[17669]938
[23807]939 case MODIFYVM_DVDPASSTHROUGH: // deprecated
[16485]940 {
[32718]941 CHECK_ERROR(machine, PassthroughDevice(Bstr("IDE Controller").raw(),
942 1, 0,
943 !strcmp(ValueUnion.psz, "on")));
[16485]944 break;
945 }
946
[23807]947 case MODIFYVM_DVD: // deprecated
[16485]948 {
[23706]949 ComPtr<IMedium> dvdMedium;
[16485]950
951 /* unmount? */
[23873]952 if (!strcmp(ValueUnion.psz, "none"))
[16485]953 {
[23223]954 /* nothing to do, NULL object will cause unmount */
[16485]955 }
956 /* host drive? */
[23873]957 else if (!strncmp(ValueUnion.psz, "host:", 5))
[16485]958 {
959 ComPtr<IHost> host;
[23934]960 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
[32718]961 rc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5).raw(),
962 dvdMedium.asOutParam());
[23706]963 if (!dvdMedium)
[16485]964 {
[23706]965 /* 2nd try: try with the real name, important on Linux+libhal */
966 char szPathReal[RTPATH_MAX];
[23873]967 if (RT_FAILURE(RTPathReal(ValueUnion.psz + 5, szPathReal, sizeof(szPathReal))))
[23706]968 {
[23873]969 errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
[23706]970 rc = E_FAIL;
971 break;
972 }
[32718]973 rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
974 dvdMedium.asOutParam());
[23706]975 if (!dvdMedium)
976 {
[23873]977 errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
[23706]978 rc = E_FAIL;
979 break;
980 }
[16485]981 }
982 }
983 else
984 {
[35239]985 rc = findOrOpenMedium(a, ValueUnion.psz, DeviceType_DVD,
[41347]986 AccessMode_ReadOnly, dvdMedium,
987 false /* fForceNewUuidOnOpen */, NULL);
[35239]988 if (FAILED(rc))
989 break;
[23706]990 if (!dvdMedium)
[16485]991 {
992 rc = E_FAIL;
993 break;
994 }
995 }
[23706]996
[32718]997 CHECK_ERROR(machine, MountMedium(Bstr("IDE Controller").raw(),
[33140]998 1, 0,
999 dvdMedium,
[32718]1000 FALSE /* aForce */));
[23706]1001 break;
[16485]1002 }
1003
[23807]1004 case MODIFYVM_FLOPPY: // deprecated
[16485]1005 {
[23706]1006 ComPtr<IMedium> floppyMedium;
1007 ComPtr<IMediumAttachment> floppyAttachment;
[32718]1008 machine->GetMediumAttachment(Bstr("Floppy Controller").raw(),
1009 0, 0, floppyAttachment.asOutParam());
[23706]1010
[16485]1011 /* disable? */
[23873]1012 if (!strcmp(ValueUnion.psz, "disabled"))
[16485]1013 {
[23706]1014 /* disable the controller */
1015 if (floppyAttachment)
[32718]1016 CHECK_ERROR(machine, DetachDevice(Bstr("Floppy Controller").raw(),
1017 0, 0));
[16485]1018 }
[23706]1019 else
[16485]1020 {
[23706]1021 /* enable the controller */
1022 if (!floppyAttachment)
[42538]1023 CHECK_ERROR(machine, AttachDeviceWithoutMedium(Bstr("Floppy Controller").raw(),
1024 0, 0,
1025 DeviceType_Floppy));
[23706]1026
1027 /* unmount? */
[23873]1028 if ( !strcmp(ValueUnion.psz, "none")
1029 || !strcmp(ValueUnion.psz, "empty")) // deprecated
[23706]1030 {
1031 /* nothing to do, NULL object will cause unmount */
1032 }
1033 /* host drive? */
[23873]1034 else if (!strncmp(ValueUnion.psz, "host:", 5))
[23706]1035 {
1036 ComPtr<IHost> host;
1037 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
[32718]1038 rc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5).raw(),
1039 floppyMedium.asOutParam());
[23706]1040 if (!floppyMedium)
1041 {
[23873]1042 errorArgument("Invalid host floppy drive name \"%s\"", ValueUnion.psz + 5);
[23706]1043 rc = E_FAIL;
1044 break;
1045 }
1046 }
1047 else
1048 {
[35239]1049 rc = findOrOpenMedium(a, ValueUnion.psz, DeviceType_Floppy,
[41347]1050 AccessMode_ReadWrite, floppyMedium,
1051 false /* fForceNewUuidOnOpen */, NULL);
[35239]1052 if (FAILED(rc))
1053 break;
[23706]1054 if (!floppyMedium)
1055 {
1056 rc = E_FAIL;
1057 break;
1058 }
1059 }
[32718]1060 CHECK_ERROR(machine, MountMedium(Bstr("Floppy Controller").raw(),
[33140]1061 0, 0,
1062 floppyMedium,
[32718]1063 FALSE /* aForce */));
[16485]1064 }
[23706]1065 break;
1066 }
1067
[23801]1068 case MODIFYVM_NICTRACEFILE:
[23706]1069 {
1070 ComPtr<INetworkAdapter> nic;
1071
[23934]1072 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
[23706]1073 ASSERT(nic);
1074
[32718]1075 CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz).raw()));
[23706]1076 break;
1077 }
1078
[23801]1079 case MODIFYVM_NICTRACE:
[23706]1080 {
1081 ComPtr<INetworkAdapter> nic;
1082
[23934]1083 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
[23706]1084 ASSERT(nic);
1085
[24143]1086 CHECK_ERROR(nic, COMSETTER(TraceEnabled)(ValueUnion.f));
[23706]1087 break;
1088 }
1089
[37200]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 }
[23801]1127 case MODIFYVM_NICTYPE:
[23706]1128 {
1129 ComPtr<INetworkAdapter> nic;
1130
[23934]1131 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
[23706]1132 ASSERT(nic);
1133
[23873]1134 if (!strcmp(ValueUnion.psz, "Am79C970A"))
[16485]1135 {
[23934]1136 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C970A));
[16485]1137 }
[23873]1138 else if (!strcmp(ValueUnion.psz, "Am79C973"))
[16485]1139 {
[23934]1140 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C973));
[16485]1141 }
[23706]1142#ifdef VBOX_WITH_E1000
[23873]1143 else if (!strcmp(ValueUnion.psz, "82540EM"))
[16485]1144 {
[23934]1145 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82540EM));
[16485]1146 }
[23873]1147 else if (!strcmp(ValueUnion.psz, "82543GC"))
[20501]1148 {
[23934]1149 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82543GC));
[20501]1150 }
[23873]1151 else if (!strcmp(ValueUnion.psz, "82545EM"))
[16485]1152 {
[23934]1153 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82545EM));
[16485]1154 }
[23706]1155#endif
1156#ifdef VBOX_WITH_VIRTIO
[23873]1157 else if (!strcmp(ValueUnion.psz, "virtio"))
[23706]1158 {
[23934]1159 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Virtio));
[23706]1160 }
1161#endif /* VBOX_WITH_VIRTIO */
[16485]1162 else
1163 {
[25324]1164 errorArgument("Invalid NIC type '%s' specified for NIC %u", ValueUnion.psz, GetOptState.uIndex);
[16485]1165 rc = E_FAIL;
1166 }
[23706]1167 break;
[16485]1168 }
[23706]1169
[23801]1170 case MODIFYVM_NICSPEED:
[16485]1171 {
[23706]1172 ComPtr<INetworkAdapter> nic;
1173
[23934]1174 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
[23706]1175 ASSERT(nic);
1176
[23934]1177 CHECK_ERROR(nic, COMSETTER(LineSpeed)(ValueUnion.u32));
[16485]1178 break;
1179 }
1180
[28106]1181 case MODIFYVM_NICBOOTPRIO:
1182 {
1183 ComPtr<INetworkAdapter> nic;
[28434]1184
[28106]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
[36082]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
[36275]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
[23801]1259 case MODIFYVM_NIC:
[23706]1260 {
1261 ComPtr<INetworkAdapter> nic;
[16485]1262
[23934]1263 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
[23706]1264 ASSERT(nic);
1265
[23873]1266 if (!strcmp(ValueUnion.psz, "none"))
[16485]1267 {
[23934]1268 CHECK_ERROR(nic, COMSETTER(Enabled)(FALSE));
[16485]1269 }
[23873]1270 else if (!strcmp(ValueUnion.psz, "null"))
[16485]1271 {
[23934]1272 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
[37200]1273 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Null));
[16485]1274 }
[23873]1275 else if (!strcmp(ValueUnion.psz, "nat"))
[16485]1276 {
[23934]1277 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
[37200]1278 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NAT));
[16485]1279 }
[23873]1280 else if ( !strcmp(ValueUnion.psz, "bridged")
1281 || !strcmp(ValueUnion.psz, "hostif")) /* backward compatibility */
[16485]1282 {
[23934]1283 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
[37200]1284 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged));
[16485]1285 }
[23873]1286 else if (!strcmp(ValueUnion.psz, "intnet"))
[16485]1287 {
[23934]1288 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
[37200]1289 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Internal));
[16485]1290 }
[23873]1291 else if (!strcmp(ValueUnion.psz, "hostonly"))
[16509]1292 {
[17281]1293
[23934]1294 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
[37200]1295 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly));
[16509]1296 }
[37200]1297 else if (!strcmp(ValueUnion.psz, "generic"))
[29117]1298 {
1299
1300 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
[37200]1301 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Generic));
[29117]1302 }
[16485]1303 else
1304 {
[25324]1305 errorArgument("Invalid type '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
[16485]1306 rc = E_FAIL;
1307 }
[23706]1308 break;
[16485]1309 }
1310
[23801]1311 case MODIFYVM_CABLECONNECTED:
[16485]1312 {
[23706]1313 ComPtr<INetworkAdapter> nic;
1314
[23934]1315 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
[23706]1316 ASSERT(nic);
1317
[24143]1318 CHECK_ERROR(nic, COMSETTER(CableConnected)(ValueUnion.f));
[23706]1319 break;
1320 }
1321
[23801]1322 case MODIFYVM_BRIDGEADAPTER:
[23706]1323 {
1324 ComPtr<INetworkAdapter> nic;
1325
[23934]1326 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
[23706]1327 ASSERT(nic);
1328
1329 /* remove it? */
[23873]1330 if (!strcmp(ValueUnion.psz, "none"))
[16485]1331 {
[37202]1332 CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr().raw()));
[16485]1333 }
1334 else
1335 {
[37200]1336 CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr(ValueUnion.psz).raw()));
[16485]1337 }
[23706]1338 break;
[16485]1339 }
1340
[37200]1341 case MODIFYVM_HOSTONLYADAPTER:
[16485]1342 {
[23706]1343 ComPtr<INetworkAdapter> nic;
1344
[23934]1345 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
[23706]1346 ASSERT(nic);
1347
1348 /* remove it? */
[23873]1349 if (!strcmp(ValueUnion.psz, "none"))
[16485]1350 {
[37202]1351 CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr().raw()));
[16485]1352 }
1353 else
1354 {
[37200]1355 CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr(ValueUnion.psz).raw()));
[16485]1356 }
[23706]1357 break;
[16485]1358 }
1359
[37200]1360 case MODIFYVM_INTNET:
[29117]1361 {
1362 ComPtr<INetworkAdapter> nic;
1363
1364 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1365 ASSERT(nic);
1366
[32718]1367 /* remove it? */
[37200]1368 if (!strcmp(ValueUnion.psz, "none"))
[29117]1369 {
[37202]1370 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr().raw()));
[29117]1371 }
1372 else
1373 {
[37200]1374 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz).raw()));
[29117]1375 }
1376 break;
1377 }
[37200]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
[23801]1390 case MODIFYVM_NATNET:
[16485]1391 {
[23706]1392 ComPtr<INetworkAdapter> nic;
[42551]1393 ComPtr<INATEngine> engine;
[16485]1394
[23934]1395 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
[23706]1396 ASSERT(nic);
1397
[42551]1398 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
[28139]1399
1400 const char *psz = ValueUnion.psz;
1401 if (!strcmp("default", psz))
1402 psz = "";
1403
[42551]1404 CHECK_ERROR(engine, COMSETTER(Network)(Bstr(psz).raw()));
[23706]1405 break;
[16485]1406 }
1407
[27857]1408 case MODIFYVM_NATBINDIP:
1409 {
1410 ComPtr<INetworkAdapter> nic;
[42551]1411 ComPtr<INATEngine> engine;
[27857]1412
1413 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1414 ASSERT(nic);
1415
[42551]1416 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1417 CHECK_ERROR(engine, COMSETTER(HostIP)(Bstr(ValueUnion.psz).raw()));
[27857]1418 break;
1419 }
1420
[27925]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
[27857]1437 case MODIFYVM_NATSETTINGS:
1438 {
1439 ComPtr<INetworkAdapter> nic;
[42551]1440 ComPtr<INATEngine> engine;
[27857]1441 char *strMtu;
1442 char *strSockSnd;
1443 char *strSockRcv;
1444 char *strTcpSnd;
1445 char *strTcpRcv;
[27976]1446 char *strRaw = RTStrDup(ValueUnion.psz);
[27857]1447 char *ch = strRaw;
[28588]1448 strMtu = RTStrStrip(ch);
[27857]1449 ITERATE_TO_NEXT_TERM(ch);
[28588]1450 strSockSnd = RTStrStrip(ch);
[27857]1451 ITERATE_TO_NEXT_TERM(ch);
[28588]1452 strSockRcv = RTStrStrip(ch);
[27857]1453 ITERATE_TO_NEXT_TERM(ch);
[28588]1454 strTcpSnd = RTStrStrip(ch);
[27857]1455 ITERATE_TO_NEXT_TERM(ch);
[28588]1456 strTcpRcv = RTStrStrip(ch);
[27857]1457
1458 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1459 ASSERT(nic);
1460
[42551]1461 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1462 CHECK_ERROR(engine, SetNetworkSettings(RTStrToUInt32(strMtu), RTStrToUInt32(strSockSnd), RTStrToUInt32(strSockRcv),
[27857]1463 RTStrToUInt32(strTcpSnd), RTStrToUInt32(strTcpRcv)));
1464 break;
1465 }
1466
1467
1468 case MODIFYVM_NATPF:
1469 {
1470 ComPtr<INetworkAdapter> nic;
[42551]1471 ComPtr<INATEngine> engine;
[27857]1472
1473 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1474 ASSERT(nic);
1475
[42551]1476 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
[27857]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;
[27976]1486 char *strRaw = RTStrDup(ValueUnion.psz);
[27857]1487 char *ch = strRaw;
[28588]1488 strName = RTStrStrip(ch);
[27857]1489 ITERATE_TO_NEXT_TERM(ch);
[28588]1490 strProto = RTStrStrip(ch);
[27857]1491 ITERATE_TO_NEXT_TERM(ch);
[28588]1492 strHostIp = RTStrStrip(ch);
[27857]1493 ITERATE_TO_NEXT_TERM(ch);
[28588]1494 strHostPort = RTStrStrip(ch);
[27857]1495 ITERATE_TO_NEXT_TERM(ch);
[28588]1496 strGuestIp = RTStrStrip(ch);
[27857]1497 ITERATE_TO_NEXT_TERM(ch);
[28588]1498 strGuestPort = RTStrStrip(ch);
[27876]1499 NATProtocol_T proto;
[27857]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 }
[42551]1510 CHECK_ERROR(engine, AddRedirect(Bstr(strName).raw(), proto,
[32718]1511 Bstr(strHostIp).raw(),
1512 RTStrToUInt16(strHostPort),
1513 Bstr(strGuestIp).raw(),
1514 RTStrToUInt16(strGuestPort)));
[27857]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");
[42551]1523 CHECK_ERROR(engine, RemoveRedirect(Bstr(ValueUnion.psz).raw()));
[27857]1524 }
1525 break;
1526 }
1527 #undef ITERATE_TO_NEXT_TERM
[28787]1528 case MODIFYVM_NATALIASMODE:
1529 {
1530 ComPtr<INetworkAdapter> nic;
[42551]1531 ComPtr<INATEngine> engine;
[28787]1532 uint32_t aliasMode = 0;
[27976]1533
[28787]1534 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1535 ASSERT(nic);
1536
[42551]1537 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
[28787]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 }
[42551]1559 CHECK_ERROR(engine, COMSETTER(AliasMode)(aliasMode));
[28787]1560 break;
1561 }
1562
[27857]1563 case MODIFYVM_NATTFTPPREFIX:
1564 {
1565 ComPtr<INetworkAdapter> nic;
[42551]1566 ComPtr<INATEngine> engine;
[27857]1567
1568 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1569 ASSERT(nic);
1570
[42551]1571 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1572 CHECK_ERROR(engine, COMSETTER(TFTPPrefix)(Bstr(ValueUnion.psz).raw()));
[27857]1573 break;
1574 }
1575
1576 case MODIFYVM_NATTFTPFILE:
1577 {
1578 ComPtr<INetworkAdapter> nic;
[42551]1579 ComPtr<INATEngine> engine;
[27857]1580
1581 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1582 ASSERT(nic);
1583
[42551]1584 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1585 CHECK_ERROR(engine, COMSETTER(TFTPBootFile)(Bstr(ValueUnion.psz).raw()));
[27857]1586 break;
1587 }
1588
1589 case MODIFYVM_NATTFTPSERVER:
1590 {
1591 ComPtr<INetworkAdapter> nic;
[42551]1592 ComPtr<INATEngine> engine;
[27857]1593
1594 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1595 ASSERT(nic);
1596
[42551]1597 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1598 CHECK_ERROR(engine, COMSETTER(TFTPNextServer)(Bstr(ValueUnion.psz).raw()));
[27857]1599 break;
1600 }
1601 case MODIFYVM_NATDNSPASSDOMAIN:
1602 {
1603 ComPtr<INetworkAdapter> nic;
[42551]1604 ComPtr<INATEngine> engine;
[27857]1605
1606 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1607 ASSERT(nic);
1608
[42551]1609 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1610 CHECK_ERROR(engine, COMSETTER(DNSPassDomain)(ValueUnion.f));
[27857]1611 break;
1612 }
1613
1614 case MODIFYVM_NATDNSPROXY:
1615 {
1616 ComPtr<INetworkAdapter> nic;
[42551]1617 ComPtr<INATEngine> engine;
[27857]1618
1619 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1620 ASSERT(nic);
1621
[42551]1622 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1623 CHECK_ERROR(engine, COMSETTER(DNSProxy)(ValueUnion.f));
[27857]1624 break;
1625 }
1626
1627 case MODIFYVM_NATDNSHOSTRESOLVER:
1628 {
1629 ComPtr<INetworkAdapter> nic;
[42551]1630 ComPtr<INATEngine> engine;
[27857]1631
1632 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1633 ASSERT(nic);
1634
[42551]1635 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1636 CHECK_ERROR(engine, COMSETTER(DNSUseHostResolver)(ValueUnion.f));
[27857]1637 break;
1638 }
[23801]1639 case MODIFYVM_MACADDRESS:
[16485]1640 {
[23706]1641 ComPtr<INetworkAdapter> nic;
1642
[23934]1643 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
[23706]1644 ASSERT(nic);
1645
1646 /* generate one? */
[23873]1647 if (!strcmp(ValueUnion.psz, "auto"))
[16485]1648 {
[37202]1649 CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr().raw()));
[16485]1650 }
1651 else
1652 {
[32718]1653 CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz).raw()));
[16485]1654 }
[23706]1655 break;
[16485]1656 }
1657
[26936]1658 case MODIFYVM_HIDPTR:
1659 {
[26971]1660 bool fEnableUsb = false;
[26936]1661 if (!strcmp(ValueUnion.psz, "ps2"))
1662 {
[42551]1663 CHECK_ERROR(machine, COMSETTER(PointingHIDType)(PointingHIDType_PS2Mouse));
[26936]1664 }
1665 else if (!strcmp(ValueUnion.psz, "usb"))
1666 {
[42551]1667 CHECK_ERROR(machine, COMSETTER(PointingHIDType)(PointingHIDType_USBMouse));
[26971]1668 if (SUCCEEDED(rc))
1669 fEnableUsb = true;
[26936]1670 }
1671 else if (!strcmp(ValueUnion.psz, "usbtablet"))
1672 {
[42551]1673 CHECK_ERROR(machine, COMSETTER(PointingHIDType)(PointingHIDType_USBTablet));
[26971]1674 if (SUCCEEDED(rc))
1675 fEnableUsb = true;
[26936]1676 }
1677 else
1678 {
1679 errorArgument("Invalid type '%s' specfied for pointing device", ValueUnion.psz);
1680 rc = E_FAIL;
1681 }
[26971]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 }
[26936]1697 break;
1698 }
1699
1700 case MODIFYVM_HIDKBD:
1701 {
[26971]1702 bool fEnableUsb = false;
[26936]1703 if (!strcmp(ValueUnion.psz, "ps2"))
1704 {
[42551]1705 CHECK_ERROR(machine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_PS2Keyboard));
[26936]1706 }
1707 else if (!strcmp(ValueUnion.psz, "usb"))
1708 {
[42551]1709 CHECK_ERROR(machine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_USBKeyboard));
[26971]1710 if (SUCCEEDED(rc))
1711 fEnableUsb = true;
[26936]1712 }
1713 else
1714 {
1715 errorArgument("Invalid type '%s' specfied for keyboard", ValueUnion.psz);
1716 rc = E_FAIL;
1717 }
[26971]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 }
[26936]1733 break;
1734 }
1735
[23801]1736 case MODIFYVM_UARTMODE:
[16485]1737 {
[23706]1738 ComPtr<ISerialPort> uart;
1739 char *pszIRQ = NULL;
1740
[23934]1741 CHECK_ERROR_BREAK(machine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
[23706]1742 ASSERT(uart);
1743
[23873]1744 if (!strcmp(ValueUnion.psz, "disconnected"))
[16485]1745 {
[23934]1746 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected));
[16485]1747 }
[23873]1748 else if ( !strcmp(ValueUnion.psz, "server")
1749 || !strcmp(ValueUnion.psz, "client")
1750 || !strcmp(ValueUnion.psz, "file"))
[16485]1751 {
[23873]1752 const char *pszMode = ValueUnion.psz;
[23706]1753
[23873]1754 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
1755 if (RT_FAILURE(vrc))
[23706]1756 return errorSyntax(USAGE_MODIFYVM,
1757 "Missing or Invalid argument to '%s'",
[23873]1758 GetOptState.pDef->pszLong);
[23706]1759
[32718]1760 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
[23706]1761
[23873]1762 if (!strcmp(pszMode, "server"))
[23706]1763 {
[23934]1764 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
1765 CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
[23706]1766 }
[23873]1767 else if (!strcmp(pszMode, "client"))
[23706]1768 {
[23934]1769 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
1770 CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
[23706]1771 }
[23873]1772 else if (!strcmp(pszMode, "file"))
[23706]1773 {
[23934]1774 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile));
[23706]1775 }
[16485]1776 }
1777 else
1778 {
[32718]1779 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
[23934]1780 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice));
[16485]1781 }
[23706]1782 break;
[16485]1783 }
1784
[23801]1785 case MODIFYVM_UART:
[16485]1786 {
[23706]1787 ComPtr<ISerialPort> uart;
[16485]1788
[23934]1789 CHECK_ERROR_BREAK(machine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
[23706]1790 ASSERT(uart);
1791
[23873]1792 if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
[23934]1793 CHECK_ERROR(uart, COMSETTER(Enabled)(FALSE));
[16485]1794 else
1795 {
[23873]1796 const char *pszIOBase = ValueUnion.psz;
[23706]1797 uint32_t uVal = 0;
1798
[23873]1799 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_UART;
1800 if (RT_FAILURE(vrc))
[23706]1801 return errorSyntax(USAGE_MODIFYVM,
1802 "Missing or Invalid argument to '%s'",
[23873]1803 GetOptState.pDef->pszLong);
[23706]1804
[23934]1805 CHECK_ERROR(uart, COMSETTER(IRQ)(ValueUnion.u32));
[23706]1806
[23873]1807 vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
[23706]1808 if (vrc != VINF_SUCCESS || uVal == 0)
[23873]1809 return errorArgument("Error parsing UART I/O base '%s'", pszIOBase);
[23934]1810 CHECK_ERROR(uart, COMSETTER(IOBase)(uVal));
[23706]1811
[23934]1812 CHECK_ERROR(uart, COMSETTER(Enabled)(TRUE));
[16485]1813 }
[23706]1814 break;
[16485]1815 }
1816
[40324]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
[23801]1863 case MODIFYVM_GUESTMEMORYBALLOON:
[16485]1864 {
[24137]1865 CHECK_ERROR(machine, COMSETTER(MemoryBalloonSize)(ValueUnion.u32));
[23706]1866 break;
[16485]1867 }
1868
[23801]1869 case MODIFYVM_AUDIOCONTROLLER:
[16485]1870 {
[24135]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));
[30976]1879 else if (!strcmp(ValueUnion.psz, "hda"))
1880 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_HDA));
[24135]1881 else
[16485]1882 {
[24135]1883 errorArgument("Invalid --audiocontroller argument '%s'", ValueUnion.psz);
1884 rc = E_FAIL;
[16485]1885 }
[23706]1886 break;
[16485]1887 }
[23706]1888
[23801]1889 case MODIFYVM_AUDIO:
[16485]1890 {
[24135]1891 ComPtr<IAudioAdapter> audioAdapter;
1892 machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
1893 ASSERT(audioAdapter);
1894
1895 /* disable? */
1896 if (!strcmp(ValueUnion.psz, "none"))
[16485]1897 {
[24135]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 }
[23706]1905#ifdef RT_OS_WINDOWS
1906#ifdef VBOX_WITH_WINMM
[24135]1907 else if (!strcmp(ValueUnion.psz, "winmm"))
1908 {
1909 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WinMM));
1910 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1911 }
[23706]1912#endif
[24135]1913 else if (!strcmp(ValueUnion.psz, "dsound"))
1914 {
1915 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_DirectSound));
1916 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1917 }
[23706]1918#endif /* RT_OS_WINDOWS */
1919#ifdef RT_OS_LINUX
1920# ifdef VBOX_WITH_ALSA
[24135]1921 else if (!strcmp(ValueUnion.psz, "alsa"))
1922 {
1923 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_ALSA));
1924 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1925 }
[23706]1926# endif
1927# ifdef VBOX_WITH_PULSE
[24135]1928 else if (!strcmp(ValueUnion.psz, "pulse"))
1929 {
1930 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
1931 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1932 }
[23706]1933# endif
1934#endif /* !RT_OS_LINUX */
1935#ifdef RT_OS_SOLARIS
[24135]1936 else if (!strcmp(ValueUnion.psz, "solaudio"))
1937 {
1938 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_SolAudio));
1939 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1940 }
[23706]1941#endif /* !RT_OS_SOLARIS */
[25819]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 */
[23706]1956#ifdef RT_OS_DARWIN
[24135]1957 else if (!strcmp(ValueUnion.psz, "coreaudio"))
1958 {
1959 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_CoreAudio));
1960 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1961 }
[23706]1962
1963#endif /* !RT_OS_DARWIN */
[24863]1964# if defined(RT_OS_FREEBSD) || defined(RT_OS_LINUX) || defined(VBOX_WITH_SOLARIS_OSS)
[24856]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
[24135]1971 else
1972 {
1973 errorArgument("Invalid --audio argument '%s'", ValueUnion.psz);
1974 rc = E_FAIL;
[16485]1975 }
[23706]1976 break;
[16485]1977 }
1978
[23801]1979 case MODIFYVM_CLIPBOARD:
[16485]1980 {
[41925]1981 ClipboardMode_T mode;
[24135]1982 if (!strcmp(ValueUnion.psz, "disabled"))
[41925]1983 mode = ClipboardMode_Disabled;
[24135]1984 else if (!strcmp(ValueUnion.psz, "hosttoguest"))
[41925]1985 mode = ClipboardMode_HostToGuest;
[24135]1986 else if (!strcmp(ValueUnion.psz, "guesttohost"))
[41925]1987 mode = ClipboardMode_GuestToHost;
[24135]1988 else if (!strcmp(ValueUnion.psz, "bidirectional"))
[41925]1989 mode = ClipboardMode_Bidirectional;
[24135]1990 else
1991 {
1992 errorArgument("Invalid --clipboard argument '%s'", ValueUnion.psz);
1993 rc = E_FAIL;
1994 }
[41925]1995 if (SUCCEEDED(rc))
1996 {
1997 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(mode));
1998 }
[23706]1999 break;
2000 }
2001
[42261]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
[34244]2025 case MODIFYVM_VRDE_EXTPACK:
[33556]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);
[34244]2036 CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(bstr.raw()));
[33556]2037 }
2038 else
[37202]2039 CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(Bstr().raw()));
[33556]2040 }
2041 break;
2042 }
2043
[33590]2044 case MODIFYVM_VRDEPROPERTY:
[33386]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
[33590]2069 errorArgument("Invalid --vrdeproperty argument '%s'", ValueUnion.psz);
[33386]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
[23801]2084 case MODIFYVM_VRDPPORT:
[35105]2085 vrdeWarningDeprecatedOption("port");
2086
2087 case MODIFYVM_VRDEPORT:
[23706]2088 {
[33386]2089 ComPtr<IVRDEServer> vrdeServer;
2090 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2091 ASSERT(vrdeServer);
2092
[24135]2093 if (!strcmp(ValueUnion.psz, "default"))
[33386]2094 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr("0").raw()));
[24135]2095 else
[33386]2096 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr(ValueUnion.psz).raw()));
[23706]2097 break;
2098 }
2099
[23801]2100 case MODIFYVM_VRDPADDRESS:
[35105]2101 vrdeWarningDeprecatedOption("address");
2102
2103 case MODIFYVM_VRDEADDRESS:
[23706]2104 {
[33386]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()));
[23706]2110 break;
2111 }
2112
[23801]2113 case MODIFYVM_VRDPAUTHTYPE:
[33386]2114 vrdeWarningDeprecatedOption("authtype");
2115 case MODIFYVM_VRDEAUTHTYPE:
[23706]2116 {
[33386]2117 ComPtr<IVRDEServer> vrdeServer;
2118 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2119 ASSERT(vrdeServer);
[24135]2120
2121 if (!strcmp(ValueUnion.psz, "null"))
[16485]2122 {
[33386]2123 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Null));
[16485]2124 }
[24135]2125 else if (!strcmp(ValueUnion.psz, "external"))
2126 {
[33386]2127 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_External));
[24135]2128 }
2129 else if (!strcmp(ValueUnion.psz, "guest"))
2130 {
[33386]2131 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Guest));
[24135]2132 }
2133 else
2134 {
[34563]2135 errorArgument("Invalid --vrdeauthtype argument '%s'", ValueUnion.psz);
[24135]2136 rc = E_FAIL;
2137 }
[23706]2138 break;
2139 }
2140
[34574]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
[37202]2155 CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(Bstr().raw()));
[34574]2156 }
2157 break;
2158 }
2159
[23801]2160 case MODIFYVM_VRDPMULTICON:
[33386]2161 vrdeWarningDeprecatedOption("multicon");
2162 case MODIFYVM_VRDEMULTICON:
[23706]2163 {
[33386]2164 ComPtr<IVRDEServer> vrdeServer;
2165 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2166 ASSERT(vrdeServer);
[24135]2167
[33386]2168 CHECK_ERROR(vrdeServer, COMSETTER(AllowMultiConnection)(ValueUnion.f));
[23706]2169 break;
2170 }
2171
[23801]2172 case MODIFYVM_VRDPREUSECON:
[33386]2173 vrdeWarningDeprecatedOption("reusecon");
2174 case MODIFYVM_VRDEREUSECON:
[23706]2175 {
[33386]2176 ComPtr<IVRDEServer> vrdeServer;
2177 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2178 ASSERT(vrdeServer);
[24135]2179
[33386]2180 CHECK_ERROR(vrdeServer, COMSETTER(ReuseSingleConnection)(ValueUnion.f));
[23706]2181 break;
[16485]2182 }
2183
[28836]2184 case MODIFYVM_VRDPVIDEOCHANNEL:
[33386]2185 vrdeWarningDeprecatedOption("videochannel");
2186 case MODIFYVM_VRDEVIDEOCHANNEL:
[28836]2187 {
[33386]2188 ComPtr<IVRDEServer> vrdeServer;
2189 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2190 ASSERT(vrdeServer);
[28836]2191
[35146]2192 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Enabled").raw(),
2193 ValueUnion.f? Bstr("true").raw(): Bstr("false").raw()));
[28836]2194 break;
2195 }
2196
2197 case MODIFYVM_VRDPVIDEOCHANNELQUALITY:
[33386]2198 vrdeWarningDeprecatedOption("videochannelquality");
2199 case MODIFYVM_VRDEVIDEOCHANNELQUALITY:
[28836]2200 {
[33386]2201 ComPtr<IVRDEServer> vrdeServer;
2202 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2203 ASSERT(vrdeServer);
[28836]2204
[35146]2205 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Quality").raw(),
2206 Bstr(ValueUnion.psz).raw()));
[28836]2207 break;
2208 }
2209
[23801]2210 case MODIFYVM_VRDP:
[33386]2211 vrdeWarningDeprecatedOption("");
2212 case MODIFYVM_VRDE:
[16485]2213 {
[33386]2214 ComPtr<IVRDEServer> vrdeServer;
2215 machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2216 ASSERT(vrdeServer);
[24135]2217
[33386]2218 CHECK_ERROR(vrdeServer, COMSETTER(Enabled)(ValueUnion.f));
[23706]2219 break;
[16485]2220 }
2221
[23801]2222 case MODIFYVM_USBEHCI:
[16485]2223 {
[24135]2224 ComPtr<IUSBController> UsbCtl;
2225 CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
2226 if (SUCCEEDED(rc))
[42551]2227 CHECK_ERROR(UsbCtl, COMSETTER(EnabledEHCI)(ValueUnion.f));
[23706]2228 break;
[16485]2229 }
2230
[23801]2231 case MODIFYVM_USB:
[16485]2232 {
[24135]2233 ComPtr<IUSBController> UsbCtl;
2234 CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
2235 if (SUCCEEDED(rc))
[24143]2236 CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(ValueUnion.f));
[23706]2237 break;
[16485]2238 }
2239
[23801]2240 case MODIFYVM_SNAPSHOTFOLDER:
[17669]2241 {
[24135]2242 if (!strcmp(ValueUnion.psz, "default"))
[37202]2243 CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(Bstr().raw()));
[24135]2244 else
[32718]2245 CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz).raw()));
[23706]2246 break;
2247 }
2248
[23801]2249 case MODIFYVM_TELEPORTER_ENABLED:
[23706]2250 {
[24143]2251 CHECK_ERROR(machine, COMSETTER(TeleporterEnabled)(ValueUnion.f));
[23706]2252 break;
[17669]2253 }
[23706]2254
[23801]2255 case MODIFYVM_TELEPORTER_PORT:
[17939]2256 {
[24137]2257 CHECK_ERROR(machine, COMSETTER(TeleporterPort)(ValueUnion.u32));
[23706]2258 break;
[17939]2259 }
[17669]2260
[23801]2261 case MODIFYVM_TELEPORTER_ADDRESS:
[17669]2262 {
[32718]2263 CHECK_ERROR(machine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz).raw()));
[23706]2264 break;
[17669]2265 }
[23706]2266
[23801]2267 case MODIFYVM_TELEPORTER_PASSWORD:
2268 {
[32718]2269 CHECK_ERROR(machine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz).raw()));
[23801]2270 break;
2271 }
2272
[40729]2273 case MODIFYVM_TELEPORTER_PASSWORD_FILE:
[40714]2274 {
[42445]2275 Utf8Str password;
2276 RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &password);
2277 if (rcExit != RTEXITCODE_SUCCESS)
2278 rc = E_FAIL;
[40724]2279 else
[42445]2280 CHECK_ERROR(machine, COMSETTER(TeleporterPassword)(Bstr(password).raw()));
[40714]2281 break;
2282 }
2283
[40418]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
[31976]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 {
[32718]2323 CHECK_ERROR(machine, COMSETTER(FaultToleranceAddress)(Bstr(ValueUnion.psz).raw()));
[31976]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 {
[32718]2335 CHECK_ERROR(machine, COMSETTER(FaultTolerancePassword)(Bstr(ValueUnion.psz).raw()));
[31976]2336 break;
2337 }
2338
2339 case MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL:
2340 {
2341 CHECK_ERROR(machine, COMSETTER(FaultToleranceSyncInterval)(ValueUnion.u32));
2342 break;
2343 }
2344
[24136]2345 case MODIFYVM_HARDWARE_UUID:
2346 {
[32718]2347 CHECK_ERROR(machine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz).raw()));
[24136]2348 break;
2349 }
2350
[26548]2351 case MODIFYVM_HPET:
2352 {
[42551]2353 CHECK_ERROR(machine, COMSETTER(HPETEnabled)(ValueUnion.f));
[26548]2354 break;
2355 }
2356
[27325]2357 case MODIFYVM_IOCACHE:
2358 {
[42551]2359 CHECK_ERROR(machine, COMSETTER(IOCacheEnabled)(ValueUnion.f));
[27325]2360 break;
2361 }
2362
2363 case MODIFYVM_IOCACHESIZE:
2364 {
[42551]2365 CHECK_ERROR(machine, COMSETTER(IOCacheSize)(ValueUnion.u32));
[27325]2366 break;
2367 }
2368
[33020]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));
[33600]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 }
[33020]2385 }
2386 else
2387 {
2388 errorArgument("Invalid --chipset argument '%s' (valid: piix3,ich9)", ValueUnion.psz);
2389 rc = E_FAIL;
2390 }
2391 break;
2392 }
[42838]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 {
[42861]2401 Bstr bstr(ValueUnion.psz);
2402 CHECK_ERROR(machine, COMSETTER(VideoCaptureFile)(bstr.raw()));
[42838]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
[41915]2416 case MODIFYVM_AUTOSTART_ENABLED:
2417 {
2418 CHECK_ERROR(machine, COMSETTER(AutostartEnabled)(ValueUnion.f));
2419 break;
2420 }
2421
2422 case MODIFYVM_AUTOSTART_DELAY:
2423 {
[41916]2424 CHECK_ERROR(machine, COMSETTER(AutostartDelay)(ValueUnion.u32));
2425 break;
2426 }
2427
2428 case MODIFYVM_AUTOSTOP_TYPE:
2429 {
[41915]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 }
[36630]2450#ifdef VBOX_WITH_PCI_PASSTHROUGH
2451 case MODIFYVM_ATTACH_PCI:
2452 {
2453 const char* pAt = strchr(ValueUnion.psz, '@');
2454 int32_t iHostAddr, iGuestAddr;
[33020]2455
[36630]2456 iHostAddr = parsePci(ValueUnion.psz);
2457 iGuestAddr = pAt != NULL ? parsePci(pAt + 1) : iHostAddr;
[37200]2458
[36630]2459 if (iHostAddr == -1 || iGuestAddr == -1)
2460 {
[37817]2461 errorArgument("Invalid --pciattach argument '%s' (valid: 'HB:HD.HF@GB:GD.GF' or just 'HB:HD.HF')", ValueUnion.psz);
[36630]2462 rc = E_FAIL;
2463 }
2464 else
2465 {
[42551]2466 CHECK_ERROR(machine, AttachHostPCIDevice(iHostAddr, iGuestAddr, TRUE));
[36630]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 {
[37817]2478 errorArgument("Invalid --pcidetach argument '%s' (valid: 'HB:HD.HF')", ValueUnion.psz);
[36630]2479 rc = E_FAIL;
2480 }
2481 else
2482 {
[42551]2483 CHECK_ERROR(machine, DetachHostPCIDevice(iHostAddr));
[36630]2484 }
2485
2486 break;
2487 }
2488#endif
[41371]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
[23706]2497 default:
2498 {
[23873]2499 errorGetOpt(USAGE_MODIFYVM, c, &ValueUnion);
[23706]2500 rc = E_FAIL;
2501 break;
2502 }
[17669]2503 }
[23706]2504 }
[17669]2505
[23706]2506 /* commit changes */
2507 if (SUCCEEDED(rc))
[23934]2508 CHECK_ERROR(machine, SaveSettings());
[23667]2509
[16485]2510 /* it's important to always close sessions */
[31070]2511 a->session->UnlockMachine();
[16485]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