VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

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

Last change on this file since 77910 was 77910, checked in by vboxsync, 5 years ago
Main: bugref:7929: Added ability to change the priority of the VM process
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 135.9 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use