VirtualBox

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

Last change on this file since 76678 was 76678, checked in by vboxsync, 5 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use