VirtualBox

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

Last change on this file since 32823 was 32718, checked in by vboxsync, 15 years ago

com/string: Remove bool conversion operator and other convenience error operators. They are hiding programming errors (like incorrect empty string checks, and in one case a free of the wrong pointer).
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 82.0 KB
Line 
1/* $Id: VBoxManageModifyVM.cpp 32718 2010-09-23 12:57:52Z vboxsync $ */
2/** @file
3 * VBoxManage - Implementation of modifyvm command.
4 */
5
6/*
7 * Copyright (C) 2006-2010 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/*******************************************************************************
19* Header Files *
20*******************************************************************************/
21#ifndef VBOX_ONLY_DOCS
22#include <VBox/com/com.h>
23#include <VBox/com/array.h>
24#include <VBox/com/ErrorInfo.h>
25#include <VBox/com/errorprint.h>
26#include <VBox/com/EventQueue.h>
27
28#include <VBox/com/VirtualBox.h>
29#endif /* !VBOX_ONLY_DOCS */
30
31#include <iprt/cidr.h>
32#include <iprt/param.h>
33#include <iprt/path.h>
34#include <iprt/stream.h>
35#include <iprt/string.h>
36#include <iprt/getopt.h>
37#include <VBox/log.h>
38
39#include "VBoxManage.h"
40
41#ifndef VBOX_ONLY_DOCS
42using namespace com;
43
44
45/** @todo refine this after HDD changes; MSC 8.0/64 has trouble with handleModifyVM. */
46#if defined(_MSC_VER)
47# pragma optimize("g", off)
48#endif
49
50enum
51{
52 MODIFYVM_NAME = 1000,
53 MODIFYVM_OSTYPE,
54 MODIFYVM_MEMORY,
55 MODIFYVM_PAGEFUSION,
56 MODIFYVM_VRAM,
57 MODIFYVM_FIRMWARE,
58 MODIFYVM_ACPI,
59 MODIFYVM_IOAPIC,
60 MODIFYVM_PAE,
61 MODIFYVM_SYNTHCPU,
62 MODIFYVM_HWVIRTEX,
63 MODIFYVM_HWVIRTEXEXCLUSIVE,
64 MODIFYVM_NESTEDPAGING,
65 MODIFYVM_LARGEPAGES,
66 MODIFYVM_VTXVPID,
67 MODIFYVM_CPUS,
68 MODIFYVM_CPUHOTPLUG,
69 MODIFYVM_PLUGCPU,
70 MODIFYVM_UNPLUGCPU,
71 MODIFYVM_SETCPUID,
72 MODIFYVM_DELCPUID,
73 MODIFYVM_DELALLCPUID,
74 MODIFYVM_MONITORCOUNT,
75 MODIFYVM_ACCELERATE3D,
76#ifdef VBOX_WITH_VIDEOHWACCEL
77 MODIFYVM_ACCELERATE2DVIDEO,
78#endif
79 MODIFYVM_BIOSLOGOFADEIN,
80 MODIFYVM_BIOSLOGOFADEOUT,
81 MODIFYVM_BIOSLOGODISPLAYTIME,
82 MODIFYVM_BIOSLOGOIMAGEPATH,
83 MODIFYVM_BIOSBOOTMENU,
84 MODIFYVM_BIOSSYSTEMTIMEOFFSET,
85 MODIFYVM_BIOSPXEDEBUG,
86 MODIFYVM_BOOT,
87 MODIFYVM_HDA, // deprecated
88 MODIFYVM_HDB, // deprecated
89 MODIFYVM_HDD, // deprecated
90 MODIFYVM_IDECONTROLLER, // deprecated
91 MODIFYVM_SATAIDEEMULATION, // deprecated
92 MODIFYVM_SATAPORTCOUNT, // deprecated
93 MODIFYVM_SATAPORT, // deprecated
94 MODIFYVM_SATA, // deprecated
95 MODIFYVM_SCSIPORT, // deprecated
96 MODIFYVM_SCSITYPE, // deprecated
97 MODIFYVM_SCSI, // deprecated
98 MODIFYVM_DVDPASSTHROUGH, // deprecated
99 MODIFYVM_DVD, // deprecated
100 MODIFYVM_FLOPPY, // deprecated
101 MODIFYVM_NICTRACEFILE,
102 MODIFYVM_NICTRACE,
103 MODIFYVM_NICTYPE,
104 MODIFYVM_NICSPEED,
105 MODIFYVM_NICBOOTPRIO,
106 MODIFYVM_NIC,
107 MODIFYVM_CABLECONNECTED,
108 MODIFYVM_BRIDGEADAPTER,
109 MODIFYVM_HOSTONLYADAPTER,
110 MODIFYVM_INTNET,
111 MODIFYVM_NATNET,
112#ifdef VBOX_WITH_VDE
113 MODIFYVM_VDENET,
114#endif
115 MODIFYVM_NATBINDIP,
116 MODIFYVM_NATSETTINGS,
117 MODIFYVM_NATPF,
118 MODIFYVM_NATALIASMODE,
119 MODIFYVM_NATTFTPPREFIX,
120 MODIFYVM_NATTFTPFILE,
121 MODIFYVM_NATTFTPSERVER,
122 MODIFYVM_NATDNSPASSDOMAIN,
123 MODIFYVM_NATDNSPROXY,
124 MODIFYVM_NATDNSHOSTRESOLVER,
125 MODIFYVM_MACADDRESS,
126 MODIFYVM_HIDPTR,
127 MODIFYVM_HIDKBD,
128 MODIFYVM_UARTMODE,
129 MODIFYVM_UART,
130 MODIFYVM_GUESTMEMORYBALLOON,
131 MODIFYVM_AUDIOCONTROLLER,
132 MODIFYVM_AUDIO,
133 MODIFYVM_CLIPBOARD,
134#ifdef VBOX_WITH_VRDP
135 MODIFYVM_VRDPPORT,
136 MODIFYVM_VRDPADDRESS,
137 MODIFYVM_VRDPAUTHTYPE,
138 MODIFYVM_VRDPMULTICON,
139 MODIFYVM_VRDPREUSECON,
140 MODIFYVM_VRDPVIDEOCHANNEL,
141 MODIFYVM_VRDPVIDEOCHANNELQUALITY,
142 MODIFYVM_VRDP,
143#endif
144 MODIFYVM_RTCUSEUTC,
145 MODIFYVM_USBEHCI,
146 MODIFYVM_USB,
147 MODIFYVM_SNAPSHOTFOLDER,
148 MODIFYVM_TELEPORTER_ENABLED,
149 MODIFYVM_TELEPORTER_PORT,
150 MODIFYVM_TELEPORTER_ADDRESS,
151 MODIFYVM_TELEPORTER_PASSWORD,
152 MODIFYVM_HARDWARE_UUID,
153 MODIFYVM_HPET,
154 MODIFYVM_IOCACHE,
155 MODIFYVM_IOCACHESIZE,
156 MODIFYVM_FAULT_TOLERANCE,
157 MODIFYVM_FAULT_TOLERANCE_ADDRESS,
158 MODIFYVM_FAULT_TOLERANCE_PORT,
159 MODIFYVM_FAULT_TOLERANCE_PASSWORD,
160 MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL
161};
162
163static const RTGETOPTDEF g_aModifyVMOptions[] =
164{
165 { "--name", MODIFYVM_NAME, RTGETOPT_REQ_STRING },
166 { "--ostype", MODIFYVM_OSTYPE, RTGETOPT_REQ_STRING },
167 { "--memory", MODIFYVM_MEMORY, RTGETOPT_REQ_UINT32 },
168 { "--pagefusion", MODIFYVM_PAGEFUSION, RTGETOPT_REQ_BOOL_ONOFF },
169 { "--vram", MODIFYVM_VRAM, RTGETOPT_REQ_UINT32 },
170 { "--firmware", MODIFYVM_FIRMWARE, RTGETOPT_REQ_STRING },
171 { "--acpi", MODIFYVM_ACPI, RTGETOPT_REQ_BOOL_ONOFF },
172 { "--ioapic", MODIFYVM_IOAPIC, RTGETOPT_REQ_BOOL_ONOFF },
173 { "--pae", MODIFYVM_PAE, RTGETOPT_REQ_BOOL_ONOFF },
174 { "--synthcpu", MODIFYVM_SYNTHCPU, RTGETOPT_REQ_BOOL_ONOFF },
175 { "--hwvirtex", MODIFYVM_HWVIRTEX, RTGETOPT_REQ_BOOL_ONOFF },
176 { "--hwvirtexexcl", MODIFYVM_HWVIRTEXEXCLUSIVE, RTGETOPT_REQ_BOOL_ONOFF },
177 { "--nestedpaging", MODIFYVM_NESTEDPAGING, RTGETOPT_REQ_BOOL_ONOFF },
178 { "--largepages", MODIFYVM_LARGEPAGES, RTGETOPT_REQ_BOOL_ONOFF },
179 { "--vtxvpid", MODIFYVM_VTXVPID, RTGETOPT_REQ_BOOL_ONOFF },
180 { "--cpuidset", MODIFYVM_SETCPUID, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX},
181 { "--cpuidremove", MODIFYVM_DELCPUID, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX},
182 { "--cpuidremoveall", MODIFYVM_DELALLCPUID, RTGETOPT_REQ_NOTHING},
183 { "--cpus", MODIFYVM_CPUS, RTGETOPT_REQ_UINT32 },
184 { "--cpuhotplug", MODIFYVM_CPUHOTPLUG, RTGETOPT_REQ_BOOL_ONOFF },
185 { "--plugcpu", MODIFYVM_PLUGCPU, RTGETOPT_REQ_UINT32 },
186 { "--unplugcpu", MODIFYVM_UNPLUGCPU, RTGETOPT_REQ_UINT32 },
187 { "--rtcuseutc", MODIFYVM_RTCUSEUTC, RTGETOPT_REQ_BOOL_ONOFF },
188 { "--monitorcount", MODIFYVM_MONITORCOUNT, RTGETOPT_REQ_UINT32 },
189 { "--accelerate3d", MODIFYVM_ACCELERATE3D, RTGETOPT_REQ_BOOL_ONOFF },
190#ifdef VBOX_WITH_VIDEOHWACCEL
191 { "--accelerate2dvideo", MODIFYVM_ACCELERATE2DVIDEO, RTGETOPT_REQ_BOOL_ONOFF },
192#endif
193 { "--bioslogofadein", MODIFYVM_BIOSLOGOFADEIN, RTGETOPT_REQ_BOOL_ONOFF },
194 { "--bioslogofadeout", MODIFYVM_BIOSLOGOFADEOUT, RTGETOPT_REQ_BOOL_ONOFF },
195 { "--bioslogodisplaytime", MODIFYVM_BIOSLOGODISPLAYTIME, RTGETOPT_REQ_UINT32 },
196 { "--bioslogoimagepath", MODIFYVM_BIOSLOGOIMAGEPATH, RTGETOPT_REQ_STRING },
197 { "--biosbootmenu", MODIFYVM_BIOSBOOTMENU, RTGETOPT_REQ_STRING },
198 { "--biossystemtimeoffset", MODIFYVM_BIOSSYSTEMTIMEOFFSET, RTGETOPT_REQ_INT64 },
199 { "--biospxedebug", MODIFYVM_BIOSPXEDEBUG, RTGETOPT_REQ_BOOL_ONOFF },
200 { "--boot", MODIFYVM_BOOT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
201 { "--hda", MODIFYVM_HDA, RTGETOPT_REQ_STRING },
202 { "--hdb", MODIFYVM_HDB, RTGETOPT_REQ_STRING },
203 { "--hdd", MODIFYVM_HDD, RTGETOPT_REQ_STRING },
204 { "--idecontroller", MODIFYVM_IDECONTROLLER, RTGETOPT_REQ_STRING },
205 { "--sataideemulation", MODIFYVM_SATAIDEEMULATION, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
206 { "--sataportcount", MODIFYVM_SATAPORTCOUNT, RTGETOPT_REQ_UINT32 },
207 { "--sataport", MODIFYVM_SATAPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
208 { "--sata", MODIFYVM_SATA, RTGETOPT_REQ_STRING },
209 { "--scsiport", MODIFYVM_SCSIPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
210 { "--scsitype", MODIFYVM_SCSITYPE, RTGETOPT_REQ_STRING },
211 { "--scsi", MODIFYVM_SCSI, RTGETOPT_REQ_STRING },
212 { "--dvdpassthrough", MODIFYVM_DVDPASSTHROUGH, RTGETOPT_REQ_STRING },
213 { "--dvd", MODIFYVM_DVD, RTGETOPT_REQ_STRING },
214 { "--floppy", MODIFYVM_FLOPPY, RTGETOPT_REQ_STRING },
215 { "--nictracefile", MODIFYVM_NICTRACEFILE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
216 { "--nictrace", MODIFYVM_NICTRACE, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
217 { "--nictype", MODIFYVM_NICTYPE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
218 { "--nicspeed", MODIFYVM_NICSPEED, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
219 { "--nicbootprio", MODIFYVM_NICBOOTPRIO, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
220 { "--nic", MODIFYVM_NIC, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
221 { "--cableconnected", MODIFYVM_CABLECONNECTED, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
222 { "--bridgeadapter", MODIFYVM_BRIDGEADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
223 { "--hostonlyadapter", MODIFYVM_HOSTONLYADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
224 { "--intnet", MODIFYVM_INTNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
225 { "--natnet", MODIFYVM_NATNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
226#ifdef VBOX_WITH_VDE
227 { "--vdenet", MODIFYVM_VDENET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
228#endif
229 { "--natbindip", MODIFYVM_NATBINDIP, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
230 { "--natsettings", MODIFYVM_NATSETTINGS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
231 { "--natpf", MODIFYVM_NATPF, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
232 { "--nataliasmode", MODIFYVM_NATALIASMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
233 { "--nattftpprefix", MODIFYVM_NATTFTPPREFIX, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
234 { "--nattftpfile", MODIFYVM_NATTFTPFILE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
235 { "--nattftpserver", MODIFYVM_NATTFTPSERVER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
236 { "--natdnspassdomain", MODIFYVM_NATDNSPASSDOMAIN, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
237 { "--natdnsproxy", MODIFYVM_NATDNSPROXY, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
238 { "--natdnshostresolver", MODIFYVM_NATDNSHOSTRESOLVER, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
239 { "--macaddress", MODIFYVM_MACADDRESS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
240 { "--mouse", MODIFYVM_HIDPTR, RTGETOPT_REQ_STRING },
241 { "--keyboard", MODIFYVM_HIDKBD, RTGETOPT_REQ_STRING },
242 { "--uartmode", MODIFYVM_UARTMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
243 { "--uart", MODIFYVM_UART, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
244 { "--guestmemoryballoon", MODIFYVM_GUESTMEMORYBALLOON, RTGETOPT_REQ_UINT32 },
245 { "--audiocontroller", MODIFYVM_AUDIOCONTROLLER, RTGETOPT_REQ_STRING },
246 { "--audio", MODIFYVM_AUDIO, RTGETOPT_REQ_STRING },
247 { "--clipboard", MODIFYVM_CLIPBOARD, RTGETOPT_REQ_STRING },
248#ifdef VBOX_WITH_VRDP
249 { "--vrdpport", MODIFYVM_VRDPPORT, RTGETOPT_REQ_STRING },
250 { "--vrdpaddress", MODIFYVM_VRDPADDRESS, RTGETOPT_REQ_STRING },
251 { "--vrdpauthtype", MODIFYVM_VRDPAUTHTYPE, RTGETOPT_REQ_STRING },
252 { "--vrdpmulticon", MODIFYVM_VRDPMULTICON, RTGETOPT_REQ_BOOL_ONOFF },
253 { "--vrdpreusecon", MODIFYVM_VRDPREUSECON, RTGETOPT_REQ_BOOL_ONOFF },
254 { "--vrdpvideochannel", MODIFYVM_VRDPVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF },
255 { "--vrdpvideochannelquality", MODIFYVM_VRDPVIDEOCHANNELQUALITY, RTGETOPT_REQ_UINT32 },
256 { "--vrdp", MODIFYVM_VRDP, RTGETOPT_REQ_BOOL_ONOFF },
257#endif
258 { "--usbehci", MODIFYVM_USBEHCI, RTGETOPT_REQ_BOOL_ONOFF },
259 { "--usb", MODIFYVM_USB, RTGETOPT_REQ_BOOL_ONOFF },
260 { "--snapshotfolder", MODIFYVM_SNAPSHOTFOLDER, RTGETOPT_REQ_STRING },
261 { "--teleporter", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
262 { "--teleporterenabled", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
263 { "--teleporterport", MODIFYVM_TELEPORTER_PORT, RTGETOPT_REQ_UINT32 },
264 { "--teleporteraddress", MODIFYVM_TELEPORTER_ADDRESS, RTGETOPT_REQ_STRING },
265 { "--teleporterpassword", MODIFYVM_TELEPORTER_PASSWORD, RTGETOPT_REQ_STRING },
266 { "--hardwareuuid", MODIFYVM_HARDWARE_UUID, RTGETOPT_REQ_STRING },
267 { "--hpet", MODIFYVM_HPET, RTGETOPT_REQ_BOOL_ONOFF },
268 { "--iocache", MODIFYVM_IOCACHE, RTGETOPT_REQ_BOOL_ONOFF },
269 { "--iocachesize", MODIFYVM_IOCACHESIZE, RTGETOPT_REQ_UINT32 },
270 { "--faulttolerance", MODIFYVM_FAULT_TOLERANCE, RTGETOPT_REQ_STRING },
271 { "--faulttoleranceaddress", MODIFYVM_FAULT_TOLERANCE_ADDRESS, RTGETOPT_REQ_STRING },
272 { "--faulttoleranceport", MODIFYVM_FAULT_TOLERANCE_PORT, RTGETOPT_REQ_UINT32 },
273 { "--faulttolerancepassword", MODIFYVM_FAULT_TOLERANCE_PASSWORD, RTGETOPT_REQ_STRING },
274 { "--faulttolerancesyncinterval", MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL, RTGETOPT_REQ_UINT32 },
275};
276
277int handleModifyVM(HandlerArg *a)
278{
279 int c;
280 HRESULT rc;
281 Bstr name;
282 Bstr machineuuid(a->argv[0]);
283 RTGETOPTUNION ValueUnion;
284 RTGETOPTSTATE GetOptState;
285 ComPtr <IMachine> machine;
286 ComPtr <IBIOSSettings> biosSettings;
287
288 /* VM ID + at least one parameter. Parameter arguments are checked
289 * individually. */
290 if (a->argc < 2)
291 return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
292
293 /* Get the number of network adapters */
294 ULONG NetworkAdapterCount = 0;
295 {
296 ComPtr <ISystemProperties> info;
297 CHECK_ERROR_RET(a->virtualBox, COMGETTER(SystemProperties)(info.asOutParam()), 1);
298 CHECK_ERROR_RET(info, COMGETTER(NetworkAdapterCount)(&NetworkAdapterCount), 1);
299 }
300 ULONG SerialPortCount = 0;
301 {
302 ComPtr <ISystemProperties> info;
303 CHECK_ERROR_RET(a->virtualBox, COMGETTER(SystemProperties)(info.asOutParam()), 1);
304 CHECK_ERROR_RET(info, COMGETTER(SerialPortCount)(&SerialPortCount), 1);
305 }
306
307 /* try to find the given machine */
308 if (!Guid(machineuuid).isEmpty())
309 {
310 CHECK_ERROR_RET(a->virtualBox, GetMachine(machineuuid.raw(),
311 machine.asOutParam()), 1);
312 }
313 else
314 {
315 CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
316 machine.asOutParam()), 1);
317 machine->COMGETTER(Id)(machineuuid.asOutParam());
318 }
319
320 /* open a session for the VM */
321 CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), 1);
322
323 /* get the mutable session machine */
324 a->session->COMGETTER(Machine)(machine.asOutParam());
325 machine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
326
327 RTGetOptInit(&GetOptState, a->argc, a->argv, g_aModifyVMOptions,
328 RT_ELEMENTS(g_aModifyVMOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
329
330 while ( SUCCEEDED (rc)
331 && (c = RTGetOpt(&GetOptState, &ValueUnion)))
332 {
333 switch (c)
334 {
335 case MODIFYVM_NAME:
336 {
337 CHECK_ERROR(machine, COMSETTER(Name)(Bstr(ValueUnion.psz).raw()));
338 break;
339 }
340 case MODIFYVM_OSTYPE:
341 {
342 ComPtr<IGuestOSType> guestOSType;
343 CHECK_ERROR(a->virtualBox, GetGuestOSType(Bstr(ValueUnion.psz).raw(),
344 guestOSType.asOutParam()));
345 if (SUCCEEDED(rc) && guestOSType)
346 {
347 CHECK_ERROR(machine, COMSETTER(OSTypeId)(Bstr(ValueUnion.psz).raw()));
348 }
349 else
350 {
351 errorArgument("Invalid guest OS type '%s'", Utf8Str(ValueUnion.psz).c_str());
352 rc = E_FAIL;
353 }
354 break;
355 }
356
357 case MODIFYVM_MEMORY:
358 {
359 CHECK_ERROR(machine, COMSETTER(MemorySize)(ValueUnion.u32));
360 break;
361 }
362
363 case MODIFYVM_PAGEFUSION:
364 {
365 CHECK_ERROR(machine, COMSETTER(PageFusionEnabled)(ValueUnion.f));
366 break;
367 }
368
369 case MODIFYVM_VRAM:
370 {
371 CHECK_ERROR(machine, COMSETTER(VRAMSize)(ValueUnion.u32));
372 break;
373 }
374
375 case MODIFYVM_FIRMWARE:
376 {
377 if (!strcmp(ValueUnion.psz, "efi"))
378 {
379 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI));
380 }
381 else if (!strcmp(ValueUnion.psz, "efi32"))
382 {
383 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI32));
384 }
385 else if (!strcmp(ValueUnion.psz, "efi64"))
386 {
387 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFI64));
388 }
389 else if (!strcmp(ValueUnion.psz, "efidual"))
390 {
391 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_EFIDUAL));
392 }
393 else if (!strcmp(ValueUnion.psz, "bios"))
394 {
395 CHECK_ERROR(machine, COMSETTER(FirmwareType)(FirmwareType_BIOS));
396 }
397 else
398 {
399 errorArgument("Invalid --firmware argument '%s'", ValueUnion.psz);
400 rc = E_FAIL;
401 }
402 break;
403 }
404
405 case MODIFYVM_ACPI:
406 {
407 CHECK_ERROR(biosSettings, COMSETTER(ACPIEnabled)(ValueUnion.f));
408 break;
409 }
410
411 case MODIFYVM_IOAPIC:
412 {
413 CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(ValueUnion.f));
414 break;
415 }
416
417 case MODIFYVM_PAE:
418 {
419 CHECK_ERROR(machine, SetCPUProperty(CPUPropertyType_PAE, ValueUnion.f));
420 break;
421 }
422
423 case MODIFYVM_SYNTHCPU:
424 {
425 CHECK_ERROR(machine, SetCPUProperty(CPUPropertyType_Synthetic, ValueUnion.f));
426 break;
427 }
428
429 case MODIFYVM_HWVIRTEX:
430 {
431 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_Enabled, ValueUnion.f));
432 break;
433 }
434
435 case MODIFYVM_HWVIRTEXEXCLUSIVE:
436 {
437 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_Exclusive, ValueUnion.f));
438 break;
439 }
440
441 case MODIFYVM_SETCPUID:
442 {
443 uint32_t id = ValueUnion.u32;
444 uint32_t aValue[4];
445
446 for (unsigned i = 0 ; i < 4 ; i++)
447 {
448 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX);
449 if (RT_FAILURE(vrc))
450 return errorSyntax(USAGE_MODIFYVM,
451 "Missing or Invalid argument to '%s'",
452 GetOptState.pDef->pszLong);
453 aValue[i] = ValueUnion.u32;
454 }
455 CHECK_ERROR(machine, SetCPUIDLeaf(id, aValue[0], aValue[1], aValue[2], aValue[3]));
456 break;
457 }
458
459 case MODIFYVM_DELCPUID:
460 {
461 CHECK_ERROR(machine, RemoveCPUIDLeaf(ValueUnion.u32));
462 break;
463 }
464
465 case MODIFYVM_DELALLCPUID:
466 {
467 CHECK_ERROR(machine, RemoveAllCPUIDLeaves());
468 break;
469 }
470
471 case MODIFYVM_NESTEDPAGING:
472 {
473 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, ValueUnion.f));
474 break;
475 }
476
477 case MODIFYVM_LARGEPAGES:
478 {
479 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_LargePages, ValueUnion.f));
480 break;
481 }
482
483 case MODIFYVM_VTXVPID:
484 {
485 CHECK_ERROR(machine, SetHWVirtExProperty(HWVirtExPropertyType_VPID, ValueUnion.f));
486 break;
487 }
488
489 case MODIFYVM_CPUS:
490 {
491 CHECK_ERROR(machine, COMSETTER(CPUCount)(ValueUnion.u32));
492 break;
493 }
494
495 case MODIFYVM_RTCUSEUTC:
496 {
497 CHECK_ERROR(machine, COMSETTER(RTCUseUTC)(ValueUnion.f));
498 break;
499 }
500
501 case MODIFYVM_CPUHOTPLUG:
502 {
503 CHECK_ERROR(machine, COMSETTER(CPUHotPlugEnabled)(ValueUnion.f));
504 break;
505 }
506
507 case MODIFYVM_PLUGCPU:
508 {
509 CHECK_ERROR(machine, HotPlugCPU(ValueUnion.u32));
510 break;
511 }
512
513 case MODIFYVM_UNPLUGCPU:
514 {
515 CHECK_ERROR(machine, HotUnplugCPU(ValueUnion.u32));
516 break;
517 }
518
519 case MODIFYVM_MONITORCOUNT:
520 {
521 CHECK_ERROR(machine, COMSETTER(MonitorCount)(ValueUnion.u32));
522 break;
523 }
524
525 case MODIFYVM_ACCELERATE3D:
526 {
527 CHECK_ERROR(machine, COMSETTER(Accelerate3DEnabled)(ValueUnion.f));
528 break;
529 }
530
531#ifdef VBOX_WITH_VIDEOHWACCEL
532 case MODIFYVM_ACCELERATE2DVIDEO:
533 {
534 CHECK_ERROR(machine, COMSETTER(Accelerate2DVideoEnabled)(ValueUnion.f));
535 break;
536 }
537#endif
538
539 case MODIFYVM_BIOSLOGOFADEIN:
540 {
541 CHECK_ERROR(biosSettings, COMSETTER(LogoFadeIn)(ValueUnion.f));
542 break;
543 }
544
545 case MODIFYVM_BIOSLOGOFADEOUT:
546 {
547 CHECK_ERROR(biosSettings, COMSETTER(LogoFadeOut)(ValueUnion.f));
548 break;
549 }
550
551 case MODIFYVM_BIOSLOGODISPLAYTIME:
552 {
553 CHECK_ERROR(biosSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u32));
554 break;
555 }
556
557 case MODIFYVM_BIOSLOGOIMAGEPATH:
558 {
559 CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz).raw()));
560 break;
561 }
562
563 case MODIFYVM_BIOSBOOTMENU:
564 {
565 if (!strcmp(ValueUnion.psz, "disabled"))
566 {
567 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_Disabled));
568 }
569 else if (!strcmp(ValueUnion.psz, "menuonly"))
570 {
571 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MenuOnly));
572 }
573 else if (!strcmp(ValueUnion.psz, "messageandmenu"))
574 {
575 CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MessageAndMenu));
576 }
577 else
578 {
579 errorArgument("Invalid --biosbootmenu argument '%s'", ValueUnion.psz);
580 rc = E_FAIL;
581 }
582 break;
583 }
584
585 case MODIFYVM_BIOSSYSTEMTIMEOFFSET:
586 {
587 CHECK_ERROR(biosSettings, COMSETTER(TimeOffset)(ValueUnion.i64));
588 break;
589 }
590
591 case MODIFYVM_BIOSPXEDEBUG:
592 {
593 CHECK_ERROR(biosSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f));
594 break;
595 }
596
597 case MODIFYVM_BOOT:
598 {
599 if (!strcmp(ValueUnion.psz, "none"))
600 {
601 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Null));
602 }
603 else if (!strcmp(ValueUnion.psz, "floppy"))
604 {
605 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Floppy));
606 }
607 else if (!strcmp(ValueUnion.psz, "dvd"))
608 {
609 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_DVD));
610 }
611 else if (!strcmp(ValueUnion.psz, "disk"))
612 {
613 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_HardDisk));
614 }
615 else if (!strcmp(ValueUnion.psz, "net"))
616 {
617 CHECK_ERROR(machine, SetBootOrder(GetOptState.uIndex, DeviceType_Network));
618 }
619 else
620 return errorArgument("Invalid boot device '%s'", ValueUnion.psz);
621 break;
622 }
623
624 case MODIFYVM_HDA: // deprecated
625 case MODIFYVM_HDB: // deprecated
626 case MODIFYVM_HDD: // deprecated
627 case MODIFYVM_SATAPORT: // deprecated
628 {
629 uint32_t u1 = 0, u2 = 0;
630 Bstr bstrController = L"IDE Controller";
631
632 switch (c)
633 {
634 case MODIFYVM_HDA: // deprecated
635 u1 = 0;
636 break;
637
638 case MODIFYVM_HDB: // deprecated
639 u1 = 0;
640 u2 = 1;
641 break;
642
643 case MODIFYVM_HDD: // deprecated
644 u1 = 1;
645 u2 = 1;
646 break;
647
648 case MODIFYVM_SATAPORT: // deprecated
649 u1 = GetOptState.uIndex;
650 bstrController = L"SATA";
651 break;
652 }
653
654 if (!strcmp(ValueUnion.psz, "none"))
655 {
656 machine->DetachDevice(bstrController.raw(), u1, u2);
657 }
658 else
659 {
660 ComPtr<IMedium> hardDisk;
661 rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz).raw(),
662 DeviceType_HardDisk,
663 hardDisk.asOutParam());
664 if (FAILED(rc))
665 {
666 /* open the new hard disk object */
667 CHECK_ERROR(a->virtualBox,
668 OpenMedium(Bstr(ValueUnion.psz).raw(),
669 DeviceType_HardDisk,
670 AccessMode_ReadWrite,
671 hardDisk.asOutParam()));
672 }
673 if (hardDisk)
674 {
675 CHECK_ERROR(machine, AttachDevice(bstrController.raw(),
676 u1, u2,
677 DeviceType_HardDisk,
678 hardDisk));
679 }
680 else
681 rc = E_FAIL;
682 }
683 break;
684 }
685
686 case MODIFYVM_IDECONTROLLER: // deprecated
687 {
688 ComPtr<IStorageController> storageController;
689 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("IDE Controller").raw(),
690 storageController.asOutParam()));
691
692 if (!RTStrICmp(ValueUnion.psz, "PIIX3"))
693 {
694 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX3));
695 }
696 else if (!RTStrICmp(ValueUnion.psz, "PIIX4"))
697 {
698 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX4));
699 }
700 else if (!RTStrICmp(ValueUnion.psz, "ICH6"))
701 {
702 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_ICH6));
703 }
704 else
705 {
706 errorArgument("Invalid --idecontroller argument '%s'", ValueUnion.psz);
707 rc = E_FAIL;
708 }
709 break;
710 }
711
712 case MODIFYVM_SATAIDEEMULATION: // deprecated
713 {
714 ComPtr<IStorageController> SataCtl;
715 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA").raw(),
716 SataCtl.asOutParam()));
717
718 if (SUCCEEDED(rc))
719 CHECK_ERROR(SataCtl, SetIDEEmulationPort(GetOptState.uIndex, ValueUnion.u32));
720 break;
721 }
722
723 case MODIFYVM_SATAPORTCOUNT: // deprecated
724 {
725 ComPtr<IStorageController> SataCtl;
726 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA").raw(),
727 SataCtl.asOutParam()));
728
729 if (SUCCEEDED(rc) && ValueUnion.u32 > 0)
730 CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32));
731 break;
732 }
733
734 case MODIFYVM_SATA: // deprecated
735 {
736 if (!strcmp(ValueUnion.psz, "on") || !strcmp(ValueUnion.psz, "enable"))
737 {
738 ComPtr<IStorageController> ctl;
739 CHECK_ERROR(machine, AddStorageController(Bstr("SATA").raw(),
740 StorageBus_SATA,
741 ctl.asOutParam()));
742 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
743 }
744 else if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
745 CHECK_ERROR(machine, RemoveStorageController(Bstr("SATA").raw()));
746 else
747 return errorArgument("Invalid --usb argument '%s'", ValueUnion.psz);
748 break;
749 }
750
751 case MODIFYVM_SCSIPORT: // deprecated
752 {
753 if (!strcmp(ValueUnion.psz, "none"))
754 {
755 rc = machine->DetachDevice(Bstr("LsiLogic").raw(),
756 GetOptState.uIndex, 0);
757 if (FAILED(rc))
758 CHECK_ERROR(machine, DetachDevice(Bstr("BusLogic").raw(),
759 GetOptState.uIndex, 0));
760 }
761 else
762 {
763 /* first guess is that it's a UUID */
764 ComPtr<IMedium> hardDisk;
765 rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz).raw(),
766 DeviceType_HardDisk,
767 hardDisk.asOutParam());
768 /* not successful? Then it must be a filename */
769 if (FAILED(rc))
770 {
771 /* open the new hard disk object */
772 CHECK_ERROR(a->virtualBox,
773 OpenMedium(Bstr(ValueUnion.psz).raw(),
774 DeviceType_HardDisk,
775 AccessMode_ReadWrite,
776 hardDisk.asOutParam()));
777 }
778 if (hardDisk)
779 {
780 rc = machine->AttachDevice(Bstr("LsiLogic").raw(),
781 GetOptState.uIndex, 0,
782 DeviceType_HardDisk,
783 hardDisk);
784 if (FAILED(rc))
785 CHECK_ERROR(machine,
786 AttachDevice(Bstr("BusLogic").raw(),
787 GetOptState.uIndex, 0,
788 DeviceType_HardDisk,
789 hardDisk));
790 }
791 else
792 rc = E_FAIL;
793 }
794 break;
795 }
796
797 case MODIFYVM_SCSITYPE: // deprecated
798 {
799 ComPtr<IStorageController> ctl;
800
801 if (!RTStrICmp(ValueUnion.psz, "LsiLogic"))
802 {
803 rc = machine->RemoveStorageController(Bstr("BusLogic").raw());
804 if (FAILED(rc))
805 CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic").raw()));
806
807 CHECK_ERROR(machine,
808 AddStorageController(Bstr("LsiLogic").raw(),
809 StorageBus_SCSI,
810 ctl.asOutParam()));
811
812 if (SUCCEEDED(rc))
813 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
814 }
815 else if (!RTStrICmp(ValueUnion.psz, "BusLogic"))
816 {
817 rc = machine->RemoveStorageController(Bstr("LsiLogic").raw());
818 if (FAILED(rc))
819 CHECK_ERROR(machine, RemoveStorageController(Bstr("BusLogic").raw()));
820
821 CHECK_ERROR(machine,
822 AddStorageController(Bstr("BusLogic").raw(),
823 StorageBus_SCSI,
824 ctl.asOutParam()));
825
826 if (SUCCEEDED(rc))
827 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
828 }
829 else
830 return errorArgument("Invalid --scsitype argument '%s'", ValueUnion.psz);
831 break;
832 }
833
834 case MODIFYVM_SCSI: // deprecated
835 {
836 if (!strcmp(ValueUnion.psz, "on") || !strcmp(ValueUnion.psz, "enable"))
837 {
838 ComPtr<IStorageController> ctl;
839
840 CHECK_ERROR(machine, AddStorageController(Bstr("BusLogic").raw(),
841 StorageBus_SCSI,
842 ctl.asOutParam()));
843 if (SUCCEEDED(rc))
844 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
845 }
846 else if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
847 {
848 rc = machine->RemoveStorageController(Bstr("BusLogic").raw());
849 if (FAILED(rc))
850 CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic").raw()));
851 }
852 break;
853 }
854
855 case MODIFYVM_DVDPASSTHROUGH: // deprecated
856 {
857 CHECK_ERROR(machine, PassthroughDevice(Bstr("IDE Controller").raw(),
858 1, 0,
859 !strcmp(ValueUnion.psz, "on")));
860 break;
861 }
862
863 case MODIFYVM_DVD: // deprecated
864 {
865 ComPtr<IMedium> dvdMedium;
866 Bstr uuid(ValueUnion.psz);
867
868 /* unmount? */
869 if (!strcmp(ValueUnion.psz, "none"))
870 {
871 /* nothing to do, NULL object will cause unmount */
872 }
873 /* host drive? */
874 else if (!strncmp(ValueUnion.psz, "host:", 5))
875 {
876 ComPtr<IHost> host;
877 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
878 rc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5).raw(),
879 dvdMedium.asOutParam());
880 if (!dvdMedium)
881 {
882 /* 2nd try: try with the real name, important on Linux+libhal */
883 char szPathReal[RTPATH_MAX];
884 if (RT_FAILURE(RTPathReal(ValueUnion.psz + 5, szPathReal, sizeof(szPathReal))))
885 {
886 errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
887 rc = E_FAIL;
888 break;
889 }
890 rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
891 dvdMedium.asOutParam());
892 if (!dvdMedium)
893 {
894 errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
895 rc = E_FAIL;
896 break;
897 }
898 }
899 }
900 else
901 {
902 /* first assume it's a UUID */
903 rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz).raw(),
904 DeviceType_DVD,
905 dvdMedium.asOutParam());
906 if (FAILED(rc) || !dvdMedium)
907 {
908 /* not registered, do that on the fly */
909 Bstr emptyUUID;
910 CHECK_ERROR(a->virtualBox,
911 OpenMedium(Bstr(ValueUnion.psz).raw(),
912 DeviceType_DVD,
913 AccessMode_ReadWrite,
914 dvdMedium.asOutParam()));
915 }
916 if (!dvdMedium)
917 {
918 rc = E_FAIL;
919 break;
920 }
921 }
922
923 if (dvdMedium)
924 dvdMedium->COMGETTER(Id)(uuid.asOutParam());
925 CHECK_ERROR(machine, MountMedium(Bstr("IDE Controller").raw(),
926 1, 0, uuid.raw(),
927 FALSE /* aForce */));
928 break;
929 }
930
931 case MODIFYVM_FLOPPY: // deprecated
932 {
933 Bstr uuid(ValueUnion.psz);
934 ComPtr<IMedium> floppyMedium;
935 ComPtr<IMediumAttachment> floppyAttachment;
936 machine->GetMediumAttachment(Bstr("Floppy Controller").raw(),
937 0, 0, floppyAttachment.asOutParam());
938
939 /* disable? */
940 if (!strcmp(ValueUnion.psz, "disabled"))
941 {
942 /* disable the controller */
943 if (floppyAttachment)
944 CHECK_ERROR(machine, DetachDevice(Bstr("Floppy Controller").raw(),
945 0, 0));
946 }
947 else
948 {
949 /* enable the controller */
950 if (!floppyAttachment)
951 CHECK_ERROR(machine, AttachDevice(Bstr("Floppy Controller").raw(),
952 0, 0,
953 DeviceType_Floppy, NULL));
954
955 /* unmount? */
956 if ( !strcmp(ValueUnion.psz, "none")
957 || !strcmp(ValueUnion.psz, "empty")) // deprecated
958 {
959 /* nothing to do, NULL object will cause unmount */
960 }
961 /* host drive? */
962 else if (!strncmp(ValueUnion.psz, "host:", 5))
963 {
964 ComPtr<IHost> host;
965 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
966 rc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5).raw(),
967 floppyMedium.asOutParam());
968 if (!floppyMedium)
969 {
970 errorArgument("Invalid host floppy drive name \"%s\"", ValueUnion.psz + 5);
971 rc = E_FAIL;
972 break;
973 }
974 }
975 else
976 {
977 /* first assume it's a UUID */
978 rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz).raw(),
979 DeviceType_Floppy,
980 floppyMedium.asOutParam());
981 if (FAILED(rc) || !floppyMedium)
982 {
983 /* not registered, do that on the fly */
984 Bstr emptyUUID;
985 CHECK_ERROR(a->virtualBox,
986 OpenMedium(Bstr(ValueUnion.psz).raw(),
987 DeviceType_Floppy,
988 AccessMode_ReadWrite,
989 floppyMedium.asOutParam()));
990 }
991 if (!floppyMedium)
992 {
993 rc = E_FAIL;
994 break;
995 }
996 }
997 floppyMedium->COMGETTER(Id)(uuid.asOutParam());
998 CHECK_ERROR(machine, MountMedium(Bstr("Floppy Controller").raw(),
999 0, 0, uuid.raw(),
1000 FALSE /* aForce */));
1001 }
1002 break;
1003 }
1004
1005 case MODIFYVM_NICTRACEFILE:
1006 {
1007 ComPtr<INetworkAdapter> nic;
1008
1009 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1010 ASSERT(nic);
1011
1012 CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz).raw()));
1013 break;
1014 }
1015
1016 case MODIFYVM_NICTRACE:
1017 {
1018 ComPtr<INetworkAdapter> nic;
1019
1020 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1021 ASSERT(nic);
1022
1023 CHECK_ERROR(nic, COMSETTER(TraceEnabled)(ValueUnion.f));
1024 break;
1025 }
1026
1027 case MODIFYVM_NICTYPE:
1028 {
1029 ComPtr<INetworkAdapter> nic;
1030
1031 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1032 ASSERT(nic);
1033
1034 if (!strcmp(ValueUnion.psz, "Am79C970A"))
1035 {
1036 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C970A));
1037 }
1038 else if (!strcmp(ValueUnion.psz, "Am79C973"))
1039 {
1040 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C973));
1041 }
1042#ifdef VBOX_WITH_E1000
1043 else if (!strcmp(ValueUnion.psz, "82540EM"))
1044 {
1045 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82540EM));
1046 }
1047 else if (!strcmp(ValueUnion.psz, "82543GC"))
1048 {
1049 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82543GC));
1050 }
1051 else if (!strcmp(ValueUnion.psz, "82545EM"))
1052 {
1053 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82545EM));
1054 }
1055#endif
1056#ifdef VBOX_WITH_VIRTIO
1057 else if (!strcmp(ValueUnion.psz, "virtio"))
1058 {
1059 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Virtio));
1060 }
1061#endif /* VBOX_WITH_VIRTIO */
1062 else
1063 {
1064 errorArgument("Invalid NIC type '%s' specified for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1065 rc = E_FAIL;
1066 }
1067 break;
1068 }
1069
1070 case MODIFYVM_NICSPEED:
1071 {
1072 ComPtr<INetworkAdapter> nic;
1073
1074 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1075 ASSERT(nic);
1076
1077 CHECK_ERROR(nic, COMSETTER(LineSpeed)(ValueUnion.u32));
1078 break;
1079 }
1080
1081 case MODIFYVM_NICBOOTPRIO:
1082 {
1083 ComPtr<INetworkAdapter> nic;
1084
1085 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1086 ASSERT(nic);
1087
1088 /* Somewhat arbitrary limitation - we can pass a list of up to 4 PCI devices
1089 * to the PXE ROM, hence only boot priorities 1-4 are allowed (in addition to
1090 * 0 for the default lowest priority).
1091 */
1092 if (ValueUnion.u32 > 4)
1093 {
1094 errorArgument("Invalid boot priority '%u' specfied for NIC %u", ValueUnion.u32, GetOptState.uIndex);
1095 rc = E_FAIL;
1096 }
1097 else
1098 {
1099 CHECK_ERROR(nic, COMSETTER(BootPriority)(ValueUnion.u32));
1100 }
1101 break;
1102 }
1103
1104 case MODIFYVM_NIC:
1105 {
1106 ComPtr<INetworkAdapter> nic;
1107
1108 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1109 ASSERT(nic);
1110
1111 if (!strcmp(ValueUnion.psz, "none"))
1112 {
1113 CHECK_ERROR(nic, COMSETTER(Enabled)(FALSE));
1114 }
1115 else if (!strcmp(ValueUnion.psz, "null"))
1116 {
1117 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1118 CHECK_ERROR(nic, Detach());
1119 }
1120 else if (!strcmp(ValueUnion.psz, "nat"))
1121 {
1122 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1123 CHECK_ERROR(nic, AttachToNAT());
1124 }
1125 else if ( !strcmp(ValueUnion.psz, "bridged")
1126 || !strcmp(ValueUnion.psz, "hostif")) /* backward compatibility */
1127 {
1128 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1129 CHECK_ERROR(nic, AttachToBridgedInterface());
1130 }
1131 else if (!strcmp(ValueUnion.psz, "intnet"))
1132 {
1133 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1134 CHECK_ERROR(nic, AttachToInternalNetwork());
1135 }
1136#if defined(VBOX_WITH_NETFLT)
1137 else if (!strcmp(ValueUnion.psz, "hostonly"))
1138 {
1139
1140 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1141 CHECK_ERROR(nic, AttachToHostOnlyInterface());
1142 }
1143#endif
1144#ifdef VBOX_WITH_VDE
1145 else if (!strcmp(ValueUnion.psz, "vde"))
1146 {
1147
1148 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1149 CHECK_ERROR(nic, AttachToVDE());
1150 }
1151#endif
1152 else
1153 {
1154 errorArgument("Invalid type '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1155 rc = E_FAIL;
1156 }
1157 break;
1158 }
1159
1160 case MODIFYVM_CABLECONNECTED:
1161 {
1162 ComPtr<INetworkAdapter> nic;
1163
1164 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1165 ASSERT(nic);
1166
1167 CHECK_ERROR(nic, COMSETTER(CableConnected)(ValueUnion.f));
1168 break;
1169 }
1170
1171 case MODIFYVM_BRIDGEADAPTER:
1172 case MODIFYVM_HOSTONLYADAPTER:
1173 {
1174 ComPtr<INetworkAdapter> nic;
1175
1176 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1177 ASSERT(nic);
1178
1179 /** @todo NULL string deprecated */
1180 /* remove it? */
1181 if (!strcmp(ValueUnion.psz, "none"))
1182 {
1183 CHECK_ERROR(nic, COMSETTER(HostInterface)(NULL));
1184 }
1185 else
1186 {
1187 CHECK_ERROR(nic, COMSETTER(HostInterface)(Bstr(ValueUnion.psz).raw()));
1188 }
1189 break;
1190 }
1191
1192 case MODIFYVM_INTNET:
1193 {
1194 ComPtr<INetworkAdapter> nic;
1195
1196 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1197 ASSERT(nic);
1198
1199 /** @todo NULL string deprecated */
1200 /* remove it? */
1201 if (!strcmp(ValueUnion.psz, "none"))
1202 {
1203 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(NULL));
1204 }
1205 else
1206 {
1207 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz).raw()));
1208 }
1209 break;
1210 }
1211
1212#ifdef VBOX_WITH_VDE
1213 case MODIFYVM_VDENET:
1214 {
1215 ComPtr<INetworkAdapter> nic;
1216
1217 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1218 ASSERT(nic);
1219
1220 /** @todo NULL string deprecated */
1221 /* remove it? */
1222 if (!strcmp(ValueUnion.psz, "default"))
1223 {
1224 CHECK_ERROR(nic, COMSETTER(VDENetwork)(NULL));
1225 }
1226 else
1227 {
1228 CHECK_ERROR(nic, COMSETTER(VDENetwork)(Bstr(ValueUnion.psz).raw()));
1229 }
1230 break;
1231 }
1232#endif
1233 case MODIFYVM_NATNET:
1234 {
1235 ComPtr<INetworkAdapter> nic;
1236 ComPtr<INATEngine> driver;
1237
1238 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1239 ASSERT(nic);
1240
1241 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1242
1243 const char *psz = ValueUnion.psz;
1244 if (!strcmp("default", psz))
1245 psz = "";
1246
1247 CHECK_ERROR(driver, COMSETTER(Network)(Bstr(psz).raw()));
1248 break;
1249 }
1250
1251 case MODIFYVM_NATBINDIP:
1252 {
1253 ComPtr<INetworkAdapter> nic;
1254 ComPtr<INATEngine> driver;
1255
1256 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1257 ASSERT(nic);
1258
1259 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1260 CHECK_ERROR(driver, COMSETTER(HostIP)(Bstr(ValueUnion.psz).raw()));
1261 break;
1262 }
1263
1264#define ITERATE_TO_NEXT_TERM(ch) \
1265 do { \
1266 while (*ch != ',') \
1267 { \
1268 if (*ch == 0) \
1269 { \
1270 return errorSyntax(USAGE_MODIFYVM, \
1271 "Missing or Invalid argument to '%s'", \
1272 GetOptState.pDef->pszLong); \
1273 } \
1274 ch++; \
1275 } \
1276 *ch = '\0'; \
1277 ch++; \
1278 } while(0)
1279
1280 case MODIFYVM_NATSETTINGS:
1281 {
1282 ComPtr<INetworkAdapter> nic;
1283 ComPtr<INATEngine> driver;
1284 char *strMtu;
1285 char *strSockSnd;
1286 char *strSockRcv;
1287 char *strTcpSnd;
1288 char *strTcpRcv;
1289 char *strRaw = RTStrDup(ValueUnion.psz);
1290 char *ch = strRaw;
1291 strMtu = RTStrStrip(ch);
1292 ITERATE_TO_NEXT_TERM(ch);
1293 strSockSnd = RTStrStrip(ch);
1294 ITERATE_TO_NEXT_TERM(ch);
1295 strSockRcv = RTStrStrip(ch);
1296 ITERATE_TO_NEXT_TERM(ch);
1297 strTcpSnd = RTStrStrip(ch);
1298 ITERATE_TO_NEXT_TERM(ch);
1299 strTcpRcv = RTStrStrip(ch);
1300
1301 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1302 ASSERT(nic);
1303
1304 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1305 CHECK_ERROR(driver, SetNetworkSettings(RTStrToUInt32(strMtu), RTStrToUInt32(strSockSnd), RTStrToUInt32(strSockRcv),
1306 RTStrToUInt32(strTcpSnd), RTStrToUInt32(strTcpRcv)));
1307 break;
1308 }
1309
1310
1311 case MODIFYVM_NATPF:
1312 {
1313 ComPtr<INetworkAdapter> nic;
1314 ComPtr<INATEngine> driver;
1315
1316 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1317 ASSERT(nic);
1318
1319 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1320 /* format name:proto:hostip:hostport:guestip:guestport*/
1321 if (RTStrCmp(ValueUnion.psz, "delete") != 0)
1322 {
1323 char *strName;
1324 char *strProto;
1325 char *strHostIp;
1326 char *strHostPort;
1327 char *strGuestIp;
1328 char *strGuestPort;
1329 char *strRaw = RTStrDup(ValueUnion.psz);
1330 char *ch = strRaw;
1331 strName = RTStrStrip(ch);
1332 ITERATE_TO_NEXT_TERM(ch);
1333 strProto = RTStrStrip(ch);
1334 ITERATE_TO_NEXT_TERM(ch);
1335 strHostIp = RTStrStrip(ch);
1336 ITERATE_TO_NEXT_TERM(ch);
1337 strHostPort = RTStrStrip(ch);
1338 ITERATE_TO_NEXT_TERM(ch);
1339 strGuestIp = RTStrStrip(ch);
1340 ITERATE_TO_NEXT_TERM(ch);
1341 strGuestPort = RTStrStrip(ch);
1342 NATProtocol_T proto;
1343 if (RTStrICmp(strProto, "udp") == 0)
1344 proto = NATProtocol_UDP;
1345 else if (RTStrICmp(strProto, "tcp") == 0)
1346 proto = NATProtocol_TCP;
1347 else
1348 {
1349 errorArgument("Invalid proto '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1350 rc = E_FAIL;
1351 break;
1352 }
1353 CHECK_ERROR(driver, AddRedirect(Bstr(strName).raw(), proto,
1354 Bstr(strHostIp).raw(),
1355 RTStrToUInt16(strHostPort),
1356 Bstr(strGuestIp).raw(),
1357 RTStrToUInt16(strGuestPort)));
1358 }
1359 else
1360 {
1361 /* delete NAT Rule operation */
1362 int vrc;
1363 vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
1364 if (RT_FAILURE(vrc))
1365 return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
1366 CHECK_ERROR(driver, RemoveRedirect(Bstr(ValueUnion.psz).raw()));
1367 }
1368 break;
1369 }
1370 #undef ITERATE_TO_NEXT_TERM
1371 case MODIFYVM_NATALIASMODE:
1372 {
1373 ComPtr<INetworkAdapter> nic;
1374 ComPtr<INATEngine> driver;
1375 uint32_t aliasMode = 0;
1376
1377 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1378 ASSERT(nic);
1379
1380 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1381 if (RTStrCmp(ValueUnion.psz,"default") == 0)
1382 {
1383 aliasMode = 0;
1384 }
1385 else
1386 {
1387 char *token = (char *)ValueUnion.psz;
1388 while(token)
1389 {
1390 if (RTStrNCmp(token, "log", 3) == 0)
1391 aliasMode |= 0x1;
1392 else if (RTStrNCmp(token, "proxyonly", 9) == 0)
1393 aliasMode |= 0x2;
1394 else if (RTStrNCmp(token, "sameports", 9) == 0)
1395 aliasMode |= 0x4;
1396 token = RTStrStr(token, ",");
1397 if (token == NULL)
1398 break;
1399 token++;
1400 }
1401 }
1402 CHECK_ERROR(driver, COMSETTER(AliasMode)(aliasMode));
1403 break;
1404 }
1405
1406 case MODIFYVM_NATTFTPPREFIX:
1407 {
1408 ComPtr<INetworkAdapter> nic;
1409 ComPtr<INATEngine> driver;
1410
1411 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1412 ASSERT(nic);
1413
1414 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1415 CHECK_ERROR(driver, COMSETTER(TftpPrefix)(Bstr(ValueUnion.psz).raw()));
1416 break;
1417 }
1418
1419 case MODIFYVM_NATTFTPFILE:
1420 {
1421 ComPtr<INetworkAdapter> nic;
1422 ComPtr<INATEngine> driver;
1423
1424 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1425 ASSERT(nic);
1426
1427 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1428 CHECK_ERROR(driver, COMSETTER(TftpBootFile)(Bstr(ValueUnion.psz).raw()));
1429 break;
1430 }
1431
1432 case MODIFYVM_NATTFTPSERVER:
1433 {
1434 ComPtr<INetworkAdapter> nic;
1435 ComPtr<INATEngine> driver;
1436
1437 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1438 ASSERT(nic);
1439
1440 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1441 CHECK_ERROR(driver, COMSETTER(TftpNextServer)(Bstr(ValueUnion.psz).raw()));
1442 break;
1443 }
1444 case MODIFYVM_NATDNSPASSDOMAIN:
1445 {
1446 ComPtr<INetworkAdapter> nic;
1447 ComPtr<INATEngine> driver;
1448
1449 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1450 ASSERT(nic);
1451
1452 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1453 CHECK_ERROR(driver, COMSETTER(DnsPassDomain)(ValueUnion.f));
1454 break;
1455 }
1456
1457 case MODIFYVM_NATDNSPROXY:
1458 {
1459 ComPtr<INetworkAdapter> nic;
1460 ComPtr<INATEngine> driver;
1461
1462 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1463 ASSERT(nic);
1464
1465 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1466 CHECK_ERROR(driver, COMSETTER(DnsProxy)(ValueUnion.f));
1467 break;
1468 }
1469
1470 case MODIFYVM_NATDNSHOSTRESOLVER:
1471 {
1472 ComPtr<INetworkAdapter> nic;
1473 ComPtr<INATEngine> driver;
1474
1475 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1476 ASSERT(nic);
1477
1478 CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
1479 CHECK_ERROR(driver, COMSETTER(DnsUseHostResolver)(ValueUnion.f));
1480 break;
1481 }
1482 case MODIFYVM_MACADDRESS:
1483 {
1484 ComPtr<INetworkAdapter> nic;
1485
1486 CHECK_ERROR_BREAK(machine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1487 ASSERT(nic);
1488
1489 /* generate one? */
1490 if (!strcmp(ValueUnion.psz, "auto"))
1491 {
1492 CHECK_ERROR(nic, COMSETTER(MACAddress)(NULL));
1493 }
1494 else
1495 {
1496 CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz).raw()));
1497 }
1498 break;
1499 }
1500
1501 case MODIFYVM_HIDPTR:
1502 {
1503 bool fEnableUsb = false;
1504 if (!strcmp(ValueUnion.psz, "ps2"))
1505 {
1506 CHECK_ERROR(machine, COMSETTER(PointingHidType)(PointingHidType_PS2Mouse));
1507 }
1508 else if (!strcmp(ValueUnion.psz, "usb"))
1509 {
1510 CHECK_ERROR(machine, COMSETTER(PointingHidType)(PointingHidType_USBMouse));
1511 if (SUCCEEDED(rc))
1512 fEnableUsb = true;
1513 }
1514 else if (!strcmp(ValueUnion.psz, "usbtablet"))
1515 {
1516 CHECK_ERROR(machine, COMSETTER(PointingHidType)(PointingHidType_USBTablet));
1517 if (SUCCEEDED(rc))
1518 fEnableUsb = true;
1519 }
1520 else
1521 {
1522 errorArgument("Invalid type '%s' specfied for pointing device", ValueUnion.psz);
1523 rc = E_FAIL;
1524 }
1525 if (fEnableUsb)
1526 {
1527 /* Make sure the OHCI controller is enabled. */
1528 ComPtr<IUSBController> UsbCtl;
1529 rc = machine->COMGETTER(USBController)(UsbCtl.asOutParam());
1530 if (SUCCEEDED(rc))
1531 {
1532 BOOL fEnabled;
1533 rc = UsbCtl->COMGETTER(Enabled)(&fEnabled);
1534 if (FAILED(rc))
1535 fEnabled = false;
1536 if (!fEnabled)
1537 CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(true));
1538 }
1539 }
1540 break;
1541 }
1542
1543 case MODIFYVM_HIDKBD:
1544 {
1545 bool fEnableUsb = false;
1546 if (!strcmp(ValueUnion.psz, "ps2"))
1547 {
1548 CHECK_ERROR(machine, COMSETTER(KeyboardHidType)(KeyboardHidType_PS2Keyboard));
1549 }
1550 else if (!strcmp(ValueUnion.psz, "usb"))
1551 {
1552 CHECK_ERROR(machine, COMSETTER(KeyboardHidType)(KeyboardHidType_USBKeyboard));
1553 if (SUCCEEDED(rc))
1554 fEnableUsb = true;
1555 }
1556 else
1557 {
1558 errorArgument("Invalid type '%s' specfied for keyboard", ValueUnion.psz);
1559 rc = E_FAIL;
1560 }
1561 if (fEnableUsb)
1562 {
1563 /* Make sure the OHCI controller is enabled. */
1564 ComPtr<IUSBController> UsbCtl;
1565 rc = machine->COMGETTER(USBController)(UsbCtl.asOutParam());
1566 if (SUCCEEDED(rc))
1567 {
1568 BOOL fEnabled;
1569 rc = UsbCtl->COMGETTER(Enabled)(&fEnabled);
1570 if (FAILED(rc))
1571 fEnabled = false;
1572 if (!fEnabled)
1573 CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(true));
1574 }
1575 }
1576 break;
1577 }
1578
1579 case MODIFYVM_UARTMODE:
1580 {
1581 ComPtr<ISerialPort> uart;
1582 char *pszIRQ = NULL;
1583
1584 CHECK_ERROR_BREAK(machine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
1585 ASSERT(uart);
1586
1587 if (!strcmp(ValueUnion.psz, "disconnected"))
1588 {
1589 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected));
1590 }
1591 else if ( !strcmp(ValueUnion.psz, "server")
1592 || !strcmp(ValueUnion.psz, "client")
1593 || !strcmp(ValueUnion.psz, "file"))
1594 {
1595 const char *pszMode = ValueUnion.psz;
1596
1597 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
1598 if (RT_FAILURE(vrc))
1599 return errorSyntax(USAGE_MODIFYVM,
1600 "Missing or Invalid argument to '%s'",
1601 GetOptState.pDef->pszLong);
1602
1603 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
1604
1605 if (!strcmp(pszMode, "server"))
1606 {
1607 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
1608 CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
1609 }
1610 else if (!strcmp(pszMode, "client"))
1611 {
1612 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
1613 CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
1614 }
1615 else if (!strcmp(pszMode, "file"))
1616 {
1617 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile));
1618 }
1619 }
1620 else
1621 {
1622 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
1623 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice));
1624 }
1625 break;
1626 }
1627
1628 case MODIFYVM_UART:
1629 {
1630 ComPtr<ISerialPort> uart;
1631
1632 CHECK_ERROR_BREAK(machine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
1633 ASSERT(uart);
1634
1635 if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
1636 CHECK_ERROR(uart, COMSETTER(Enabled)(FALSE));
1637 else
1638 {
1639 const char *pszIOBase = ValueUnion.psz;
1640 uint32_t uVal = 0;
1641
1642 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_UART;
1643 if (RT_FAILURE(vrc))
1644 return errorSyntax(USAGE_MODIFYVM,
1645 "Missing or Invalid argument to '%s'",
1646 GetOptState.pDef->pszLong);
1647
1648 CHECK_ERROR(uart, COMSETTER(IRQ)(ValueUnion.u32));
1649
1650 vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
1651 if (vrc != VINF_SUCCESS || uVal == 0)
1652 return errorArgument("Error parsing UART I/O base '%s'", pszIOBase);
1653 CHECK_ERROR(uart, COMSETTER(IOBase)(uVal));
1654
1655 CHECK_ERROR(uart, COMSETTER(Enabled)(TRUE));
1656 }
1657 break;
1658 }
1659
1660 case MODIFYVM_GUESTMEMORYBALLOON:
1661 {
1662 CHECK_ERROR(machine, COMSETTER(MemoryBalloonSize)(ValueUnion.u32));
1663 break;
1664 }
1665
1666 case MODIFYVM_AUDIOCONTROLLER:
1667 {
1668 ComPtr<IAudioAdapter> audioAdapter;
1669 machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
1670 ASSERT(audioAdapter);
1671
1672 if (!strcmp(ValueUnion.psz, "sb16"))
1673 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_SB16));
1674 else if (!strcmp(ValueUnion.psz, "ac97"))
1675 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_AC97));
1676 else if (!strcmp(ValueUnion.psz, "hda"))
1677 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_HDA));
1678 else
1679 {
1680 errorArgument("Invalid --audiocontroller argument '%s'", ValueUnion.psz);
1681 rc = E_FAIL;
1682 }
1683 break;
1684 }
1685
1686 case MODIFYVM_AUDIO:
1687 {
1688 ComPtr<IAudioAdapter> audioAdapter;
1689 machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
1690 ASSERT(audioAdapter);
1691
1692 /* disable? */
1693 if (!strcmp(ValueUnion.psz, "none"))
1694 {
1695 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(false));
1696 }
1697 else if (!strcmp(ValueUnion.psz, "null"))
1698 {
1699 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Null));
1700 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1701 }
1702#ifdef RT_OS_WINDOWS
1703#ifdef VBOX_WITH_WINMM
1704 else if (!strcmp(ValueUnion.psz, "winmm"))
1705 {
1706 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WinMM));
1707 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1708 }
1709#endif
1710 else if (!strcmp(ValueUnion.psz, "dsound"))
1711 {
1712 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_DirectSound));
1713 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1714 }
1715#endif /* RT_OS_WINDOWS */
1716#ifdef RT_OS_LINUX
1717# ifdef VBOX_WITH_ALSA
1718 else if (!strcmp(ValueUnion.psz, "alsa"))
1719 {
1720 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_ALSA));
1721 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1722 }
1723# endif
1724# ifdef VBOX_WITH_PULSE
1725 else if (!strcmp(ValueUnion.psz, "pulse"))
1726 {
1727 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
1728 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1729 }
1730# endif
1731#endif /* !RT_OS_LINUX */
1732#ifdef RT_OS_SOLARIS
1733 else if (!strcmp(ValueUnion.psz, "solaudio"))
1734 {
1735 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_SolAudio));
1736 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1737 }
1738#endif /* !RT_OS_SOLARIS */
1739#ifdef RT_OS_FREEBSD
1740 else if (!strcmp(ValueUnion.psz, "oss"))
1741 {
1742 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS));
1743 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1744 }
1745# ifdef VBOX_WITH_PULSE
1746 else if (!strcmp(ValueUnion.psz, "pulse"))
1747 {
1748 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
1749 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1750 }
1751# endif
1752#endif /* !RT_OS_FREEBSD */
1753#ifdef RT_OS_DARWIN
1754 else if (!strcmp(ValueUnion.psz, "coreaudio"))
1755 {
1756 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_CoreAudio));
1757 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1758 }
1759
1760#endif /* !RT_OS_DARWIN */
1761# if defined(RT_OS_FREEBSD) || defined(RT_OS_LINUX) || defined(VBOX_WITH_SOLARIS_OSS)
1762 else if (!strcmp(ValueUnion.psz, "oss"))
1763 {
1764 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS));
1765 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
1766 }
1767# endif
1768 else
1769 {
1770 errorArgument("Invalid --audio argument '%s'", ValueUnion.psz);
1771 rc = E_FAIL;
1772 }
1773 break;
1774 }
1775
1776 case MODIFYVM_CLIPBOARD:
1777 {
1778 if (!strcmp(ValueUnion.psz, "disabled"))
1779 {
1780 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_Disabled));
1781 }
1782 else if (!strcmp(ValueUnion.psz, "hosttoguest"))
1783 {
1784 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_HostToGuest));
1785 }
1786 else if (!strcmp(ValueUnion.psz, "guesttohost"))
1787 {
1788 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_GuestToHost));
1789 }
1790 else if (!strcmp(ValueUnion.psz, "bidirectional"))
1791 {
1792 CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_Bidirectional));
1793 }
1794 else
1795 {
1796 errorArgument("Invalid --clipboard argument '%s'", ValueUnion.psz);
1797 rc = E_FAIL;
1798 }
1799 break;
1800 }
1801
1802#ifdef VBOX_WITH_VRDP
1803 case MODIFYVM_VRDPPORT:
1804 {
1805 ComPtr<IVRDPServer> vrdpServer;
1806 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1807 ASSERT(vrdpServer);
1808
1809 if (!strcmp(ValueUnion.psz, "default"))
1810 CHECK_ERROR(vrdpServer, COMSETTER(Ports)(Bstr("0").raw()));
1811 else
1812 CHECK_ERROR(vrdpServer, COMSETTER(Ports)(Bstr(ValueUnion.psz).raw()));
1813 break;
1814 }
1815
1816 case MODIFYVM_VRDPADDRESS:
1817 {
1818 ComPtr<IVRDPServer> vrdpServer;
1819 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1820 ASSERT(vrdpServer);
1821
1822 CHECK_ERROR(vrdpServer, COMSETTER(NetAddress)(Bstr(ValueUnion.psz).raw()));
1823 break;
1824 }
1825
1826 case MODIFYVM_VRDPAUTHTYPE:
1827 {
1828 ComPtr<IVRDPServer> vrdpServer;
1829 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1830 ASSERT(vrdpServer);
1831
1832 if (!strcmp(ValueUnion.psz, "null"))
1833 {
1834 CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_Null));
1835 }
1836 else if (!strcmp(ValueUnion.psz, "external"))
1837 {
1838 CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_External));
1839 }
1840 else if (!strcmp(ValueUnion.psz, "guest"))
1841 {
1842 CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_Guest));
1843 }
1844 else
1845 {
1846 errorArgument("Invalid --vrdpauthtype argument '%s'", ValueUnion.psz);
1847 rc = E_FAIL;
1848 }
1849 break;
1850 }
1851
1852 case MODIFYVM_VRDPMULTICON:
1853 {
1854 ComPtr<IVRDPServer> vrdpServer;
1855 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1856 ASSERT(vrdpServer);
1857
1858 CHECK_ERROR(vrdpServer, COMSETTER(AllowMultiConnection)(ValueUnion.f));
1859 break;
1860 }
1861
1862 case MODIFYVM_VRDPREUSECON:
1863 {
1864 ComPtr<IVRDPServer> vrdpServer;
1865 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1866 ASSERT(vrdpServer);
1867
1868 CHECK_ERROR(vrdpServer, COMSETTER(ReuseSingleConnection)(ValueUnion.f));
1869 break;
1870 }
1871
1872 case MODIFYVM_VRDPVIDEOCHANNEL:
1873 {
1874 ComPtr<IVRDPServer> vrdpServer;
1875 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1876 ASSERT(vrdpServer);
1877
1878 CHECK_ERROR(vrdpServer, COMSETTER(VideoChannel)(ValueUnion.f));
1879 break;
1880 }
1881
1882 case MODIFYVM_VRDPVIDEOCHANNELQUALITY:
1883 {
1884 ComPtr<IVRDPServer> vrdpServer;
1885 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1886 ASSERT(vrdpServer);
1887
1888 CHECK_ERROR(vrdpServer, COMSETTER(VideoChannelQuality)(ValueUnion.u32));
1889 break;
1890 }
1891
1892 case MODIFYVM_VRDP:
1893 {
1894 ComPtr<IVRDPServer> vrdpServer;
1895 machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1896 ASSERT(vrdpServer);
1897
1898 CHECK_ERROR(vrdpServer, COMSETTER(Enabled)(ValueUnion.f));
1899 break;
1900 }
1901#endif /* VBOX_WITH_VRDP */
1902
1903 case MODIFYVM_USBEHCI:
1904 {
1905 ComPtr<IUSBController> UsbCtl;
1906 CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
1907 if (SUCCEEDED(rc))
1908 CHECK_ERROR(UsbCtl, COMSETTER(EnabledEhci)(ValueUnion.f));
1909 break;
1910 }
1911
1912 case MODIFYVM_USB:
1913 {
1914 ComPtr<IUSBController> UsbCtl;
1915 CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
1916 if (SUCCEEDED(rc))
1917 CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(ValueUnion.f));
1918 break;
1919 }
1920
1921 case MODIFYVM_SNAPSHOTFOLDER:
1922 {
1923 if (!strcmp(ValueUnion.psz, "default"))
1924 CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(NULL));
1925 else
1926 CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz).raw()));
1927 break;
1928 }
1929
1930 case MODIFYVM_TELEPORTER_ENABLED:
1931 {
1932 CHECK_ERROR(machine, COMSETTER(TeleporterEnabled)(ValueUnion.f));
1933 break;
1934 }
1935
1936 case MODIFYVM_TELEPORTER_PORT:
1937 {
1938 CHECK_ERROR(machine, COMSETTER(TeleporterPort)(ValueUnion.u32));
1939 break;
1940 }
1941
1942 case MODIFYVM_TELEPORTER_ADDRESS:
1943 {
1944 CHECK_ERROR(machine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz).raw()));
1945 break;
1946 }
1947
1948 case MODIFYVM_TELEPORTER_PASSWORD:
1949 {
1950 CHECK_ERROR(machine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz).raw()));
1951 break;
1952 }
1953
1954 case MODIFYVM_FAULT_TOLERANCE:
1955 {
1956 if (!strcmp(ValueUnion.psz, "master"))
1957 {
1958 CHECK_ERROR(machine, COMSETTER(FaultToleranceState(FaultToleranceState_Master)));
1959 }
1960 else
1961 if (!strcmp(ValueUnion.psz, "standby"))
1962 {
1963 CHECK_ERROR(machine, COMSETTER(FaultToleranceState(FaultToleranceState_Standby)));
1964 }
1965 else
1966 {
1967 errorArgument("Invalid --faulttolerance argument '%s'", ValueUnion.psz);
1968 rc = E_FAIL;
1969 }
1970 break;
1971 }
1972
1973 case MODIFYVM_FAULT_TOLERANCE_ADDRESS:
1974 {
1975 CHECK_ERROR(machine, COMSETTER(FaultToleranceAddress)(Bstr(ValueUnion.psz).raw()));
1976 break;
1977 }
1978
1979 case MODIFYVM_FAULT_TOLERANCE_PORT:
1980 {
1981 CHECK_ERROR(machine, COMSETTER(FaultTolerancePort)(ValueUnion.u32));
1982 break;
1983 }
1984
1985 case MODIFYVM_FAULT_TOLERANCE_PASSWORD:
1986 {
1987 CHECK_ERROR(machine, COMSETTER(FaultTolerancePassword)(Bstr(ValueUnion.psz).raw()));
1988 break;
1989 }
1990
1991 case MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL:
1992 {
1993 CHECK_ERROR(machine, COMSETTER(FaultToleranceSyncInterval)(ValueUnion.u32));
1994 break;
1995 }
1996
1997 case MODIFYVM_HARDWARE_UUID:
1998 {
1999 CHECK_ERROR(machine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz).raw()));
2000 break;
2001 }
2002
2003 case MODIFYVM_HPET:
2004 {
2005 CHECK_ERROR(machine, COMSETTER(HpetEnabled)(ValueUnion.f));
2006 break;
2007 }
2008
2009 case MODIFYVM_IOCACHE:
2010 {
2011 CHECK_ERROR(machine, COMSETTER(IoCacheEnabled)(ValueUnion.f));
2012 break;
2013 }
2014
2015 case MODIFYVM_IOCACHESIZE:
2016 {
2017 CHECK_ERROR(machine, COMSETTER(IoCacheSize)(ValueUnion.u32));
2018 break;
2019 }
2020
2021 default:
2022 {
2023 errorGetOpt(USAGE_MODIFYVM, c, &ValueUnion);
2024 rc = E_FAIL;
2025 break;
2026 }
2027 }
2028 }
2029
2030 /* commit changes */
2031 if (SUCCEEDED(rc))
2032 CHECK_ERROR(machine, SaveSettings());
2033
2034 /* it's important to always close sessions */
2035 a->session->UnlockMachine();
2036
2037 return SUCCEEDED(rc) ? 0 : 1;
2038}
2039
2040#endif /* !VBOX_ONLY_DOCS */
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette