VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp@ 105387

Last change on this file since 105387 was 105387, checked in by vboxsync, 3 months ago

FE/VBoxManage + Manual: Updates for the new recording API. Russian translation TBD. bugref:10718

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 89.4 KB
Line 
1/* $Id: VBoxManageControlVM.cpp 105387 2024-07-17 17:04:04Z vboxsync $ */
2/** @file
3 * VBoxManage - Implementation of the controlvm command.
4 */
5
6/*
7 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28
29/*********************************************************************************************************************************
30* Header Files *
31*********************************************************************************************************************************/
32#include <VBox/com/com.h>
33#include <VBox/com/string.h>
34#include <VBox/com/Guid.h>
35#include <VBox/com/array.h>
36#include <VBox/com/ErrorInfo.h>
37#include <VBox/com/errorprint.h>
38#include <VBox/com/VirtualBox.h>
39
40#include <iprt/ctype.h>
41#include <iprt/getopt.h>
42#include <iprt/stream.h>
43#include <iprt/string.h>
44#include <iprt/thread.h>
45#include <iprt/uuid.h>
46#include <iprt/file.h>
47#include <VBox/log.h>
48
49#include "VBoxManage.h"
50#include "VBoxManageUtils.h"
51
52#include <list>
53
54DECLARE_TRANSLATION_CONTEXT(ControlVM);
55
56/**
57 * Parses a number.
58 *
59 * @returns Valid number on success.
60 * @returns 0 if invalid number. All necessary bitching has been done.
61 * @param psz Pointer to the nic number.
62 */
63static unsigned parseNum(const char *psz, unsigned cMaxNum, const char *name)
64{
65 uint32_t u32;
66 char *pszNext;
67 int vrc = RTStrToUInt32Ex(psz, &pszNext, 10, &u32);
68 if ( RT_SUCCESS(vrc)
69 && *pszNext == '\0'
70 && u32 >= 1
71 && u32 <= cMaxNum)
72 return (unsigned)u32;
73 errorArgument(ControlVM::tr("Invalid %s number '%s'."), name, psz);
74 return 0;
75}
76
77#define KBDCHARDEF_MOD_NONE 0x00
78#define KBDCHARDEF_MOD_SHIFT 0x01
79
80typedef struct KBDCHARDEF
81{
82 uint8_t u8Scancode;
83 uint8_t u8Modifiers;
84} KBDCHARDEF;
85
86static const KBDCHARDEF g_aASCIIChars[0x80] =
87{
88 /* 0x00 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
89 /* 0x01 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
90 /* 0x02 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
91 /* 0x03 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
92 /* 0x04 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
93 /* 0x05 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
94 /* 0x06 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
95 /* 0x07 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
96 /* 0x08 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
97 /* 0x09 ' ' */ {0x0f, KBDCHARDEF_MOD_NONE},
98 /* 0x0A ' ' */ {0x1c, KBDCHARDEF_MOD_NONE},
99 /* 0x0B ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
100 /* 0x0C ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
101 /* 0x0D ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
102 /* 0x0E ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
103 /* 0x0F ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
104 /* 0x10 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
105 /* 0x11 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
106 /* 0x12 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
107 /* 0x13 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
108 /* 0x14 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
109 /* 0x15 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
110 /* 0x16 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
111 /* 0x17 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
112 /* 0x18 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
113 /* 0x19 ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
114 /* 0x1A ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
115 /* 0x1B ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
116 /* 0x1C ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
117 /* 0x1D ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
118 /* 0x1E ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
119 /* 0x1F ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
120 /* 0x20 ' ' */ {0x39, KBDCHARDEF_MOD_NONE},
121 /* 0x21 '!' */ {0x02, KBDCHARDEF_MOD_SHIFT},
122 /* 0x22 '"' */ {0x28, KBDCHARDEF_MOD_SHIFT},
123 /* 0x23 '#' */ {0x04, KBDCHARDEF_MOD_SHIFT},
124 /* 0x24 '$' */ {0x05, KBDCHARDEF_MOD_SHIFT},
125 /* 0x25 '%' */ {0x06, KBDCHARDEF_MOD_SHIFT},
126 /* 0x26 '&' */ {0x08, KBDCHARDEF_MOD_SHIFT},
127 /* 0x27 ''' */ {0x28, KBDCHARDEF_MOD_NONE},
128 /* 0x28 '(' */ {0x0a, KBDCHARDEF_MOD_SHIFT},
129 /* 0x29 ')' */ {0x0b, KBDCHARDEF_MOD_SHIFT},
130 /* 0x2A '*' */ {0x09, KBDCHARDEF_MOD_SHIFT},
131 /* 0x2B '+' */ {0x0d, KBDCHARDEF_MOD_SHIFT},
132 /* 0x2C ',' */ {0x33, KBDCHARDEF_MOD_NONE},
133 /* 0x2D '-' */ {0x0c, KBDCHARDEF_MOD_NONE},
134 /* 0x2E '.' */ {0x34, KBDCHARDEF_MOD_NONE},
135 /* 0x2F '/' */ {0x35, KBDCHARDEF_MOD_NONE},
136 /* 0x30 '0' */ {0x0b, KBDCHARDEF_MOD_NONE},
137 /* 0x31 '1' */ {0x02, KBDCHARDEF_MOD_NONE},
138 /* 0x32 '2' */ {0x03, KBDCHARDEF_MOD_NONE},
139 /* 0x33 '3' */ {0x04, KBDCHARDEF_MOD_NONE},
140 /* 0x34 '4' */ {0x05, KBDCHARDEF_MOD_NONE},
141 /* 0x35 '5' */ {0x06, KBDCHARDEF_MOD_NONE},
142 /* 0x36 '6' */ {0x07, KBDCHARDEF_MOD_NONE},
143 /* 0x37 '7' */ {0x08, KBDCHARDEF_MOD_NONE},
144 /* 0x38 '8' */ {0x09, KBDCHARDEF_MOD_NONE},
145 /* 0x39 '9' */ {0x0a, KBDCHARDEF_MOD_NONE},
146 /* 0x3A ':' */ {0x27, KBDCHARDEF_MOD_SHIFT},
147 /* 0x3B ';' */ {0x27, KBDCHARDEF_MOD_NONE},
148 /* 0x3C '<' */ {0x33, KBDCHARDEF_MOD_SHIFT},
149 /* 0x3D '=' */ {0x0d, KBDCHARDEF_MOD_NONE},
150 /* 0x3E '>' */ {0x34, KBDCHARDEF_MOD_SHIFT},
151 /* 0x3F '?' */ {0x35, KBDCHARDEF_MOD_SHIFT},
152 /* 0x40 '@' */ {0x03, KBDCHARDEF_MOD_SHIFT},
153 /* 0x41 'A' */ {0x1e, KBDCHARDEF_MOD_SHIFT},
154 /* 0x42 'B' */ {0x30, KBDCHARDEF_MOD_SHIFT},
155 /* 0x43 'C' */ {0x2e, KBDCHARDEF_MOD_SHIFT},
156 /* 0x44 'D' */ {0x20, KBDCHARDEF_MOD_SHIFT},
157 /* 0x45 'E' */ {0x12, KBDCHARDEF_MOD_SHIFT},
158 /* 0x46 'F' */ {0x21, KBDCHARDEF_MOD_SHIFT},
159 /* 0x47 'G' */ {0x22, KBDCHARDEF_MOD_SHIFT},
160 /* 0x48 'H' */ {0x23, KBDCHARDEF_MOD_SHIFT},
161 /* 0x49 'I' */ {0x17, KBDCHARDEF_MOD_SHIFT},
162 /* 0x4A 'J' */ {0x24, KBDCHARDEF_MOD_SHIFT},
163 /* 0x4B 'K' */ {0x25, KBDCHARDEF_MOD_SHIFT},
164 /* 0x4C 'L' */ {0x26, KBDCHARDEF_MOD_SHIFT},
165 /* 0x4D 'M' */ {0x32, KBDCHARDEF_MOD_SHIFT},
166 /* 0x4E 'N' */ {0x31, KBDCHARDEF_MOD_SHIFT},
167 /* 0x4F 'O' */ {0x18, KBDCHARDEF_MOD_SHIFT},
168 /* 0x50 'P' */ {0x19, KBDCHARDEF_MOD_SHIFT},
169 /* 0x51 'Q' */ {0x10, KBDCHARDEF_MOD_SHIFT},
170 /* 0x52 'R' */ {0x13, KBDCHARDEF_MOD_SHIFT},
171 /* 0x53 'S' */ {0x1f, KBDCHARDEF_MOD_SHIFT},
172 /* 0x54 'T' */ {0x14, KBDCHARDEF_MOD_SHIFT},
173 /* 0x55 'U' */ {0x16, KBDCHARDEF_MOD_SHIFT},
174 /* 0x56 'V' */ {0x2f, KBDCHARDEF_MOD_SHIFT},
175 /* 0x57 'W' */ {0x11, KBDCHARDEF_MOD_SHIFT},
176 /* 0x58 'X' */ {0x2d, KBDCHARDEF_MOD_SHIFT},
177 /* 0x59 'Y' */ {0x15, KBDCHARDEF_MOD_SHIFT},
178 /* 0x5A 'Z' */ {0x2c, KBDCHARDEF_MOD_SHIFT},
179 /* 0x5B '[' */ {0x1a, KBDCHARDEF_MOD_NONE},
180 /* 0x5C '\' */ {0x2b, KBDCHARDEF_MOD_NONE},
181 /* 0x5D ']' */ {0x1b, KBDCHARDEF_MOD_NONE},
182 /* 0x5E '^' */ {0x07, KBDCHARDEF_MOD_SHIFT},
183 /* 0x5F '_' */ {0x0c, KBDCHARDEF_MOD_SHIFT},
184 /* 0x60 '`' */ {0x28, KBDCHARDEF_MOD_NONE},
185 /* 0x61 'a' */ {0x1e, KBDCHARDEF_MOD_NONE},
186 /* 0x62 'b' */ {0x30, KBDCHARDEF_MOD_NONE},
187 /* 0x63 'c' */ {0x2e, KBDCHARDEF_MOD_NONE},
188 /* 0x64 'd' */ {0x20, KBDCHARDEF_MOD_NONE},
189 /* 0x65 'e' */ {0x12, KBDCHARDEF_MOD_NONE},
190 /* 0x66 'f' */ {0x21, KBDCHARDEF_MOD_NONE},
191 /* 0x67 'g' */ {0x22, KBDCHARDEF_MOD_NONE},
192 /* 0x68 'h' */ {0x23, KBDCHARDEF_MOD_NONE},
193 /* 0x69 'i' */ {0x17, KBDCHARDEF_MOD_NONE},
194 /* 0x6A 'j' */ {0x24, KBDCHARDEF_MOD_NONE},
195 /* 0x6B 'k' */ {0x25, KBDCHARDEF_MOD_NONE},
196 /* 0x6C 'l' */ {0x26, KBDCHARDEF_MOD_NONE},
197 /* 0x6D 'm' */ {0x32, KBDCHARDEF_MOD_NONE},
198 /* 0x6E 'n' */ {0x31, KBDCHARDEF_MOD_NONE},
199 /* 0x6F 'o' */ {0x18, KBDCHARDEF_MOD_NONE},
200 /* 0x70 'p' */ {0x19, KBDCHARDEF_MOD_NONE},
201 /* 0x71 'q' */ {0x10, KBDCHARDEF_MOD_NONE},
202 /* 0x72 'r' */ {0x13, KBDCHARDEF_MOD_NONE},
203 /* 0x73 's' */ {0x1f, KBDCHARDEF_MOD_NONE},
204 /* 0x74 't' */ {0x14, KBDCHARDEF_MOD_NONE},
205 /* 0x75 'u' */ {0x16, KBDCHARDEF_MOD_NONE},
206 /* 0x76 'v' */ {0x2f, KBDCHARDEF_MOD_NONE},
207 /* 0x77 'w' */ {0x11, KBDCHARDEF_MOD_NONE},
208 /* 0x78 'x' */ {0x2d, KBDCHARDEF_MOD_NONE},
209 /* 0x79 'y' */ {0x15, KBDCHARDEF_MOD_NONE},
210 /* 0x7A 'z' */ {0x2c, KBDCHARDEF_MOD_NONE},
211 /* 0x7B '{' */ {0x1a, KBDCHARDEF_MOD_SHIFT},
212 /* 0x7C '|' */ {0x2b, KBDCHARDEF_MOD_SHIFT},
213 /* 0x7D '}' */ {0x1b, KBDCHARDEF_MOD_SHIFT},
214 /* 0x7E '~' */ {0x29, KBDCHARDEF_MOD_SHIFT},
215 /* 0x7F ' ' */ {0x00, KBDCHARDEF_MOD_NONE},
216};
217
218static HRESULT keyboardPutScancodes(IKeyboard *pKeyboard, const std::list<LONG> &llScancodes)
219{
220 /* Send scancodes to the VM. */
221 com::SafeArray<LONG> saScancodes(llScancodes);
222
223 HRESULT hrc = S_OK;
224 size_t i;
225 for (i = 0; i < saScancodes.size(); ++i)
226 {
227 hrc = pKeyboard->PutScancode(saScancodes[i]);
228 if (FAILED(hrc))
229 {
230 RTMsgError(ControlVM::tr("Failed to send a scancode."));
231 break;
232 }
233
234 RTThreadSleep(10); /* "Typing" too fast causes lost characters. */
235 }
236
237 return hrc;
238}
239
240static void keyboardCharsToScancodes(const char *pch, size_t cchMax, std::list<LONG> &llScancodes, bool *pfShift)
241{
242 size_t cchProcessed = 0;
243 const char *p = pch;
244 while (cchProcessed < cchMax)
245 {
246 ++cchProcessed;
247 const uint8_t c = (uint8_t)*p++;
248 if (c < RT_ELEMENTS(g_aASCIIChars))
249 {
250 const KBDCHARDEF *d = &g_aASCIIChars[c];
251 if (d->u8Scancode)
252 {
253 const bool fNeedShift = RT_BOOL(d->u8Modifiers & KBDCHARDEF_MOD_SHIFT);
254 if (*pfShift != fNeedShift)
255 {
256 *pfShift = fNeedShift;
257 /* Press or release the SHIFT key. */
258 llScancodes.push_back(0x2a | (fNeedShift? 0x00: 0x80));
259 }
260
261 llScancodes.push_back(d->u8Scancode);
262 llScancodes.push_back(d->u8Scancode | 0x80);
263 }
264 }
265 }
266}
267
268static HRESULT keyboardPutString(IKeyboard *pKeyboard, int argc, char **argv)
269{
270 std::list<LONG> llScancodes;
271 bool fShift = false;
272
273 /* Convert command line string(s) to the en-us keyboard scancodes. */
274 int i;
275 for (i = 1 + 1; i < argc; ++i)
276 {
277 if (!llScancodes.empty())
278 {
279 /* Insert a SPACE before the next string. */
280 llScancodes.push_back(0x39);
281 llScancodes.push_back(0x39 | 0x80);
282 }
283
284 keyboardCharsToScancodes(argv[i], strlen(argv[i]), llScancodes, &fShift);
285 }
286
287 /* Release SHIFT if pressed. */
288 if (fShift)
289 llScancodes.push_back(0x2a | 0x80);
290
291 return keyboardPutScancodes(pKeyboard, llScancodes);
292}
293
294static HRESULT keyboardPutFile(IKeyboard *pKeyboard, const char *pszFilename)
295{
296 std::list<LONG> llScancodes;
297 bool fShift = false;
298
299 RTFILE File = NIL_RTFILE;
300 int vrc = RTFileOpen(&File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
301 if (RT_SUCCESS(vrc))
302 {
303 uint64_t cbFile = 0;
304 vrc = RTFileQuerySize(File, &cbFile);
305 if (RT_SUCCESS(vrc))
306 {
307 const uint64_t cbFileMax = _64K;
308 if (cbFile <= cbFileMax)
309 {
310 const size_t cbBuffer = _4K;
311 char *pchBuf = (char *)RTMemAlloc(cbBuffer);
312 if (pchBuf)
313 {
314 size_t cbRemaining = (size_t)cbFile;
315 while (cbRemaining > 0)
316 {
317 const size_t cbToRead = cbRemaining > cbBuffer ? cbBuffer : cbRemaining;
318
319 size_t cbRead = 0;
320 vrc = RTFileRead(File, pchBuf, cbToRead, &cbRead);
321 if (RT_FAILURE(vrc) || cbRead == 0)
322 break;
323
324 keyboardCharsToScancodes(pchBuf, cbRead, llScancodes, &fShift);
325 cbRemaining -= cbRead;
326 }
327
328 RTMemFree(pchBuf);
329 }
330 else
331 RTMsgError(ControlVM::tr("Out of memory allocating %d bytes.", "", cbBuffer), cbBuffer);
332 }
333 else
334 RTMsgError(ControlVM::tr("File size %RI64 is greater than %RI64: '%s'."), cbFile, cbFileMax, pszFilename);
335 }
336 else
337 RTMsgError(ControlVM::tr("Cannot get size of file '%s': %Rrc."), pszFilename, vrc);
338
339 RTFileClose(File);
340 }
341 else
342 RTMsgError(ControlVM::tr("Cannot open file '%s': %Rrc."), pszFilename, vrc);
343
344 /* Release SHIFT if pressed. */
345 if (fShift)
346 llScancodes.push_back(0x2a | 0x80);
347
348 return keyboardPutScancodes(pKeyboard, llScancodes);
349}
350
351
352RTEXITCODE handleControlVM(HandlerArg *a)
353{
354 using namespace com;
355 bool fNeedsSaving = false;
356 HRESULT hrc;
357
358 if (a->argc < 2)
359 return errorSyntax(ControlVM::tr("Not enough parameters."));
360
361 /* try to find the given machine */
362 ComPtr<IMachine> machine;
363 CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
364 machine.asOutParam()));
365 if (FAILED(hrc))
366 return RTEXITCODE_FAILURE;
367
368 /* open a session for the VM */
369 CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE);
370
371 ComPtr<IConsole> console;
372 ComPtr<IMachine> sessionMachine;
373
374 do
375 {
376 /* get the associated console */
377 CHECK_ERROR_BREAK(a->session, COMGETTER(Console)(console.asOutParam()));
378 if (!console)
379 return RTMsgErrorExit(RTEXITCODE_FAILURE, ControlVM::tr("Machine '%s' is not currently running."), a->argv[0]);
380
381 /* ... and session machine */
382 CHECK_ERROR_BREAK(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()));
383
384 /* which command? */
385 if (!strcmp(a->argv[1], "pause"))
386 {
387 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_PAUSE);
388 CHECK_ERROR_BREAK(console, Pause());
389 }
390 else if (!strcmp(a->argv[1], "resume"))
391 {
392 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_RESUME);
393 CHECK_ERROR_BREAK(console, Resume());
394 }
395 else if (!strcmp(a->argv[1], "reset"))
396 {
397 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_RESET);
398 CHECK_ERROR_BREAK(console, Reset());
399 }
400 else if (!strcmp(a->argv[1], "unplugcpu"))
401 {
402 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_UNPLUGCPU);
403 if (a->argc <= 1 + 1)
404 {
405 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
406 hrc = E_FAIL;
407 break;
408 }
409
410 unsigned n = parseNum(a->argv[2], 32, "CPU");
411
412 CHECK_ERROR_BREAK(sessionMachine, HotUnplugCPU(n));
413 }
414 else if (!strcmp(a->argv[1], "plugcpu"))
415 {
416 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_PLUGCPU);
417 if (a->argc <= 1 + 1)
418 {
419 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
420 hrc = E_FAIL;
421 break;
422 }
423
424 unsigned n = parseNum(a->argv[2], 32, "CPU");
425
426 CHECK_ERROR_BREAK(sessionMachine, HotPlugCPU(n));
427 }
428 else if (!strcmp(a->argv[1], "cpuexecutioncap"))
429 {
430 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_CPUEXECUTIONCAP);
431 if (a->argc <= 1 + 1)
432 {
433 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
434 hrc = E_FAIL;
435 break;
436 }
437
438 unsigned n = parseNum(a->argv[2], 100, "ExecutionCap");
439
440 CHECK_ERROR_BREAK(sessionMachine, COMSETTER(CPUExecutionCap)(n));
441 }
442 else if (!strcmp(a->argv[1], "audioin"))
443 {
444 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_AUDIOIN);
445
446 ComPtr<IAudioSettings> audioSettings;
447 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
448 ComPtr<IAudioAdapter> adapter;
449 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(adapter.asOutParam()));
450 if (adapter)
451 {
452 bool fEnabled;
453 if (RT_FAILURE(parseBool(a->argv[2], &fEnabled)))
454 {
455 errorSyntax(ControlVM::tr("Invalid value '%s'."), a->argv[2]);
456 hrc = E_FAIL;
457 break;
458 }
459 CHECK_ERROR_RET(adapter, COMSETTER(EnabledIn)(fEnabled), RTEXITCODE_FAILURE);
460 fNeedsSaving = true;
461 }
462 else
463 {
464 errorSyntax(ControlVM::tr("Audio adapter not enabled in VM configuration."));
465 hrc = E_FAIL;
466 break;
467 }
468 }
469 else if (!strcmp(a->argv[1], "audioout"))
470 {
471 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_AUDIOOUT);
472
473 ComPtr<IAudioSettings> audioSettings;
474 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
475 ComPtr<IAudioAdapter> adapter;
476 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(adapter.asOutParam()));
477 if (adapter)
478 {
479 bool fEnabled;
480 if (RT_FAILURE(parseBool(a->argv[2], &fEnabled)))
481 {
482 errorSyntax(ControlVM::tr("Invalid value '%s'."), a->argv[2]);
483 hrc = E_FAIL;
484 break;
485 }
486 CHECK_ERROR_RET(adapter, COMSETTER(EnabledOut)(fEnabled), RTEXITCODE_FAILURE);
487 fNeedsSaving = true;
488 }
489 else
490 {
491 errorSyntax(ControlVM::tr("Audio adapter not enabled in VM configuration."));
492 hrc = E_FAIL;
493 break;
494 }
495 }
496#ifdef VBOX_WITH_SHARED_CLIPBOARD
497 else if (!strcmp(a->argv[1], "clipboard"))
498 {
499 if (a->argc <= 1 + 1)
500 {
501 errorArgument(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
502 hrc = E_FAIL;
503 break;
504 }
505
506 ClipboardMode_T mode = ClipboardMode_Disabled; /* Shut up MSC */
507 if (!strcmp(a->argv[2], "mode"))
508 {
509 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_CLIPBOARD_MODE);
510 if (a->argc <= 1 + 2)
511 {
512 errorSyntax(ControlVM::tr("Missing argument to '%s %s'."), a->argv[1], a->argv[2]);
513 hrc = E_FAIL;
514 break;
515 }
516
517 if (!strcmp(a->argv[3], "disabled"))
518 mode = ClipboardMode_Disabled;
519 else if (!strcmp(a->argv[3], "hosttoguest"))
520 mode = ClipboardMode_HostToGuest;
521 else if (!strcmp(a->argv[3], "guesttohost"))
522 mode = ClipboardMode_GuestToHost;
523 else if (!strcmp(a->argv[3], "bidirectional"))
524 mode = ClipboardMode_Bidirectional;
525 else
526 {
527 errorSyntax(ControlVM::tr("Invalid '%s %s' argument '%s'."), a->argv[1], a->argv[2], a->argv[3]);
528 hrc = E_FAIL;
529 break;
530 }
531
532 CHECK_ERROR_BREAK(sessionMachine, COMSETTER(ClipboardMode)(mode));
533 if (SUCCEEDED(hrc))
534 fNeedsSaving = true;
535 }
536# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
537 else if (!strcmp(a->argv[2], "filetransfers"))
538 {
539 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_CLIPBOARD_FILETRANSFERS);
540 if (a->argc <= 1 + 2)
541 {
542 errorSyntax(ControlVM::tr("Missing argument to '%s %s'."), a->argv[1], a->argv[2]);
543 hrc = E_FAIL;
544 break;
545 }
546
547 bool fEnabled;
548 if (RT_FAILURE(parseBool(a->argv[3], &fEnabled)))
549 {
550 errorSyntax(ControlVM::tr("Invalid '%s %s' argument '%s'."), a->argv[1], a->argv[2], a->argv[3]);
551 hrc = E_FAIL;
552 break;
553 }
554
555 CHECK_ERROR_BREAK(sessionMachine, COMSETTER(ClipboardFileTransfersEnabled)(fEnabled));
556 fNeedsSaving = true;
557 }
558# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
559 else
560 {
561 errorArgument(ControlVM::tr("Invalid '%s' argument '%s'."), a->argv[1], a->argv[2]);
562 hrc = E_FAIL;
563 break;
564 }
565 }
566#endif /* VBOX_WITH_SHARED_CLIPBOARD */
567 else if (!strcmp(a->argv[1], "draganddrop"))
568 {
569 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_DRAGANDDROP);
570 if (a->argc <= 1 + 1)
571 {
572 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
573 hrc = E_FAIL;
574 break;
575 }
576
577 DnDMode_T mode = DnDMode_Disabled; /* Shup up MSC. */
578 if (!strcmp(a->argv[2], "disabled"))
579 mode = DnDMode_Disabled;
580 else if (!strcmp(a->argv[2], "hosttoguest"))
581 mode = DnDMode_HostToGuest;
582 else if (!strcmp(a->argv[2], "guesttohost"))
583 mode = DnDMode_GuestToHost;
584 else if (!strcmp(a->argv[2], "bidirectional"))
585 mode = DnDMode_Bidirectional;
586 else
587 {
588 errorSyntax(ControlVM::tr("Invalid '%s' argument '%s'."), a->argv[1], a->argv[2]);
589 hrc = E_FAIL;
590 }
591 if (SUCCEEDED(hrc))
592 {
593 CHECK_ERROR_BREAK(sessionMachine, COMSETTER(DnDMode)(mode));
594 if (SUCCEEDED(hrc))
595 fNeedsSaving = true;
596 }
597 }
598 else if (!strcmp(a->argv[1], "poweroff"))
599 {
600 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_POWEROFF);
601 ComPtr<IProgress> progress;
602 CHECK_ERROR_BREAK(console, PowerDown(progress.asOutParam()));
603
604 hrc = showProgress(progress);
605 CHECK_PROGRESS_ERROR(progress, (ControlVM::tr("Failed to power off machine.")));
606 }
607 else if (!strcmp(a->argv[1], "savestate"))
608 {
609 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_SAVESTATE);
610 /* first pause so we don't trigger a live save which needs more time/resources */
611 bool fPaused = false;
612 hrc = console->Pause();
613 if (FAILED(hrc))
614 {
615 bool fError = true;
616 if (hrc == VBOX_E_INVALID_VM_STATE)
617 {
618 /* check if we are already paused */
619 MachineState_T machineState;
620 CHECK_ERROR_BREAK(console, COMGETTER(State)(&machineState));
621 /* the error code was lost by the previous instruction */
622 hrc = VBOX_E_INVALID_VM_STATE;
623 if (machineState != MachineState_Paused)
624 {
625 RTMsgError(ControlVM::tr("Machine in invalid state %d -- %s."),
626 machineState, machineStateToName(machineState, false));
627 }
628 else
629 {
630 fError = false;
631 fPaused = true;
632 }
633 }
634 if (fError)
635 break;
636 }
637
638 ComPtr<IProgress> progress;
639 CHECK_ERROR(sessionMachine, SaveState(progress.asOutParam()));
640 if (FAILED(hrc))
641 {
642 if (!fPaused)
643 console->Resume();
644 break;
645 }
646
647 hrc = showProgress(progress);
648 CHECK_PROGRESS_ERROR(progress, (ControlVM::tr("Failed to save machine state.")));
649 if (FAILED(hrc))
650 {
651 if (!fPaused)
652 console->Resume();
653 }
654 }
655 else if (!strcmp(a->argv[1], "acpipowerbutton"))
656 {
657 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_ACPIPOWERBUTTON);
658 CHECK_ERROR_BREAK(console, PowerButton());
659 }
660 else if (!strcmp(a->argv[1], "acpisleepbutton"))
661 {
662 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_ACPISLEEPBUTTON);
663 CHECK_ERROR_BREAK(console, SleepButton());
664 }
665#ifdef VBOX_WITH_GUEST_CONTROL
666 else if ( !strcmp(a->argv[1], "reboot")
667 || !strcmp(a->argv[1], "shutdown")) /* With shutdown we mean gracefully powering off the VM by letting the guest OS do its thing. */
668 {
669 const bool fReboot = !strcmp(a->argv[1], "reboot");
670 if (fReboot)
671 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_REBOOT);
672 else
673 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_SHUTDOWN);
674
675 ComPtr<IGuest> pGuest;
676 CHECK_ERROR_BREAK(console, COMGETTER(Guest)(pGuest.asOutParam()));
677 if (!pGuest)
678 {
679 RTMsgError(ControlVM::tr("Guest not running."));
680 hrc = E_FAIL;
681 break;
682 }
683
684 com::SafeArray<GuestShutdownFlag_T> aShutdownFlags;
685 if (fReboot)
686 aShutdownFlags.push_back(GuestShutdownFlag_Reboot);
687 else
688 aShutdownFlags.push_back(GuestShutdownFlag_PowerOff);
689
690 if ( a->argc >= 3
691 && !strcmp(a->argv[2], "--force"))
692 aShutdownFlags.push_back(GuestShutdownFlag_Force);
693
694 CHECK_ERROR(pGuest, Shutdown(ComSafeArrayAsInParam(aShutdownFlags)));
695 if (FAILED(hrc))
696 {
697 if (hrc == VBOX_E_NOT_SUPPORTED)
698 {
699 if (fReboot)
700 RTMsgError(ControlVM::tr("Current installed Guest Additions don't support rebooting the guest."));
701 else
702 RTMsgError(ControlVM::tr("Current installed Guest Additions don't support shutting down the guest."));
703 }
704 }
705 }
706#endif
707 else if (!strcmp(a->argv[1], "keyboardputscancode"))
708 {
709 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_KEYBOARDPUTSCANCODE);
710 ComPtr<IKeyboard> pKeyboard;
711 CHECK_ERROR_BREAK(console, COMGETTER(Keyboard)(pKeyboard.asOutParam()));
712 if (!pKeyboard)
713 {
714 RTMsgError(ControlVM::tr("Guest not running."));
715 hrc = E_FAIL;
716 break;
717 }
718
719 if (a->argc <= 1 + 1)
720 {
721 errorSyntax(ControlVM::tr("Missing argument to '%s'. Expected IBM PC AT set 2 keyboard scancode(s)."),
722 a->argv[1]);
723 hrc = E_FAIL;
724 break;
725 }
726
727 std::list<LONG> llScancodes;
728
729 /* Process the command line. */
730 int i;
731 for (i = 1 + 1; i < a->argc; i++)
732 {
733 if ( RT_C_IS_XDIGIT (a->argv[i][0])
734 && RT_C_IS_XDIGIT (a->argv[i][1])
735 && a->argv[i][2] == 0)
736 {
737 uint8_t u8Scancode;
738 int vrc = RTStrToUInt8Ex(a->argv[i], NULL, 16, &u8Scancode);
739 if (RT_FAILURE (vrc))
740 {
741 RTMsgError(ControlVM::tr("Converting '%s' returned %Rrc!"), a->argv[i], vrc);
742 hrc = E_FAIL;
743 break;
744 }
745
746 llScancodes.push_back(u8Scancode);
747 }
748 else
749 {
750 RTMsgError(ControlVM::tr("'%s' is not a hex byte!"), a->argv[i]);
751 hrc = E_FAIL;
752 break;
753 }
754 }
755
756 if (FAILED(hrc))
757 break;
758
759 hrc = keyboardPutScancodes(pKeyboard, llScancodes);
760 }
761 else if (!strcmp(a->argv[1], "keyboardputstring"))
762 {
763 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_KEYBOARDPUTSTRING);
764 ComPtr<IKeyboard> pKeyboard;
765 CHECK_ERROR_BREAK(console, COMGETTER(Keyboard)(pKeyboard.asOutParam()));
766 if (!pKeyboard)
767 {
768 RTMsgError(ControlVM::tr("Guest not running."));
769 hrc = E_FAIL;
770 break;
771 }
772
773 if (a->argc <= 1 + 1)
774 {
775 errorSyntax(ControlVM::tr("Missing argument to '%s'. Expected ASCII string(s)."), a->argv[1]);
776 hrc = E_FAIL;
777 break;
778 }
779
780 hrc = keyboardPutString(pKeyboard, a->argc, a->argv);
781 }
782 else if (!strcmp(a->argv[1], "keyboardputfile"))
783 {
784 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_KEYBOARDPUTFILE);
785 ComPtr<IKeyboard> pKeyboard;
786 CHECK_ERROR_BREAK(console, COMGETTER(Keyboard)(pKeyboard.asOutParam()));
787 if (!pKeyboard)
788 {
789 RTMsgError(ControlVM::tr("Guest not running."));
790 hrc = E_FAIL;
791 break;
792 }
793
794 if (a->argc <= 1 + 1)
795 {
796 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
797 hrc = E_FAIL;
798 break;
799 }
800
801 hrc = keyboardPutFile(pKeyboard, a->argv[2]);
802 }
803 else if (!strncmp(a->argv[1], "setlinkstate", 12))
804 {
805 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_SETLINKSTATE);
806 /* Get the number of network adapters */
807 ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
808 unsigned n = parseNum(&a->argv[1][12], NetworkAdapterCount, "NIC");
809 if (!n)
810 {
811 hrc = E_FAIL;
812 break;
813 }
814 if (a->argc <= 1 + 1)
815 {
816 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
817 hrc = E_FAIL;
818 break;
819 }
820 /* get the corresponding network adapter */
821 ComPtr<INetworkAdapter> adapter;
822 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam()));
823 if (adapter)
824 {
825 bool fEnabled;
826 if (RT_FAILURE(parseBool(a->argv[2], &fEnabled)))
827 {
828 errorSyntax(ControlVM::tr("Invalid link state '%s'."), a->argv[2]);
829 hrc = E_FAIL;
830 break;
831 }
832 CHECK_ERROR_BREAK(adapter, COMSETTER(CableConnected)(fEnabled));
833 fNeedsSaving = true;
834 }
835 }
836 /* here the order in which strncmp is called is important
837 * cause nictracefile can be very well compared with
838 * nictrace and nic and thus everything will always fail
839 * if the order is changed
840 */
841 else if (!strncmp(a->argv[1], "nictracefile", 12))
842 {
843 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NICTRACEFILE);
844 /* Get the number of network adapters */
845 ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
846 unsigned n = parseNum(&a->argv[1][12], NetworkAdapterCount, "NIC");
847 if (!n)
848 {
849 hrc = E_FAIL;
850 break;
851 }
852 if (a->argc <= 2)
853 {
854 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
855 hrc = E_FAIL;
856 break;
857 }
858
859 /* get the corresponding network adapter */
860 ComPtr<INetworkAdapter> adapter;
861 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam()));
862 if (adapter)
863 {
864 BOOL fEnabled;
865 adapter->COMGETTER(Enabled)(&fEnabled);
866 if (fEnabled)
867 {
868 if (a->argv[2])
869 {
870 CHECK_ERROR_RET(adapter, COMSETTER(TraceFile)(Bstr(a->argv[2]).raw()), RTEXITCODE_FAILURE);
871 }
872 else
873 {
874 errorSyntax(ControlVM::tr("Filename not specified for NIC %lu."), n);
875 hrc = E_FAIL;
876 break;
877 }
878 if (SUCCEEDED(hrc))
879 fNeedsSaving = true;
880 }
881 else
882 RTMsgError(ControlVM::tr("The NIC %d is currently disabled and thus its tracefile can't be changed."), n);
883 }
884 }
885 else if (!strncmp(a->argv[1], "nictrace", 8))
886 {
887 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NICTRACE);
888 /* Get the number of network adapters */
889 ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
890 unsigned n = parseNum(&a->argv[1][8], NetworkAdapterCount, "NIC");
891 if (!n)
892 {
893 hrc = E_FAIL;
894 break;
895 }
896 if (a->argc <= 2)
897 {
898 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
899 hrc = E_FAIL;
900 break;
901 }
902
903 /* get the corresponding network adapter */
904 ComPtr<INetworkAdapter> adapter;
905 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam()));
906 if (adapter)
907 {
908 BOOL fEnabled;
909 adapter->COMGETTER(Enabled)(&fEnabled);
910 if (fEnabled)
911 {
912 bool fTraceEnabled;
913 if (RT_FAILURE(parseBool(a->argv[2], &fTraceEnabled)))
914 {
915 errorSyntax(ControlVM::tr("Invalid nictrace%lu argument '%s'."), n, a->argv[2]);
916 hrc = E_FAIL;
917 break;
918 }
919 CHECK_ERROR_RET(adapter, COMSETTER(TraceEnabled)(fTraceEnabled), RTEXITCODE_FAILURE);
920 fNeedsSaving = true;
921 }
922 else
923 RTMsgError(ControlVM::tr("The NIC %d is currently disabled and thus its trace flag can't be changed."), n);
924 }
925 }
926 else if( a->argc > 2
927 && !strncmp(a->argv[1], "natpf", 5))
928 {
929 /* Get the number of network adapters */
930 ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
931 unsigned n = parseNum(&a->argv[1][5], NetworkAdapterCount, "NIC");
932 if (!n)
933 {
934 hrc = E_FAIL;
935 break;
936 }
937 if (a->argc <= 2)
938 {
939 errorArgument(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
940 hrc = E_FAIL;
941 break;
942 }
943
944 /* get the corresponding network adapter */
945 ComPtr<INetworkAdapter> adapter;
946 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam()));
947 if (!adapter)
948 {
949 hrc = E_FAIL;
950 break;
951 }
952 ComPtr<INATEngine> engine;
953 CHECK_ERROR(adapter, COMGETTER(NATEngine)(engine.asOutParam()));
954 if (!engine)
955 {
956 hrc = E_FAIL;
957 break;
958 }
959
960 if (!strcmp(a->argv[2], "delete"))
961 {
962 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NATPF_DELETE);
963 if (a->argc >= 3)
964 CHECK_ERROR(engine, RemoveRedirect(Bstr(a->argv[3]).raw()));
965 }
966 else
967 {
968 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NATPF);
969#define ITERATE_TO_NEXT_TERM(ch) \
970 do { \
971 while (*ch != ',') \
972 { \
973 if (*ch == 0) \
974 { \
975 return errorSyntax(ControlVM::tr("Missing or invalid argument to '%s'."), \
976 a->argv[1]); \
977 } \
978 ch++; \
979 } \
980 *ch = '\0'; \
981 ch++; \
982 } while(0)
983
984 char *strName;
985 char *strProto;
986 char *strHostIp;
987 char *strHostPort;
988 char *strGuestIp;
989 char *strGuestPort;
990 char *strRaw = RTStrDup(a->argv[2]);
991 char *ch = strRaw;
992 strName = RTStrStrip(ch);
993 ITERATE_TO_NEXT_TERM(ch);
994 strProto = RTStrStrip(ch);
995 ITERATE_TO_NEXT_TERM(ch);
996 strHostIp = RTStrStrip(ch);
997 ITERATE_TO_NEXT_TERM(ch);
998 strHostPort = RTStrStrip(ch);
999 ITERATE_TO_NEXT_TERM(ch);
1000 strGuestIp = RTStrStrip(ch);
1001 ITERATE_TO_NEXT_TERM(ch);
1002 strGuestPort = RTStrStrip(ch);
1003 NATProtocol_T proto;
1004 if (RTStrICmp(strProto, "udp") == 0)
1005 proto = NATProtocol_UDP;
1006 else if (RTStrICmp(strProto, "tcp") == 0)
1007 proto = NATProtocol_TCP;
1008 else
1009 {
1010 return errorSyntax(ControlVM::tr("Wrong rule proto '%s' specified -- only 'udp' and 'tcp' are allowed."),
1011 strProto);
1012 }
1013 CHECK_ERROR(engine, AddRedirect(Bstr(strName).raw(), proto, Bstr(strHostIp).raw(),
1014 RTStrToUInt16(strHostPort), Bstr(strGuestIp).raw(), RTStrToUInt16(strGuestPort)));
1015#undef ITERATE_TO_NEXT_TERM
1016 }
1017 if (SUCCEEDED(hrc))
1018 fNeedsSaving = true;
1019 }
1020 else if (!strncmp(a->argv[1], "nicproperty", 11))
1021 {
1022 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NICPROPERTY);
1023 /* Get the number of network adapters */
1024 ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
1025 unsigned n = parseNum(&a->argv[1][11], NetworkAdapterCount, "NIC");
1026 if (!n)
1027 {
1028 hrc = E_FAIL;
1029 break;
1030 }
1031 if (a->argc <= 2)
1032 {
1033 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
1034 hrc = E_FAIL;
1035 break;
1036 }
1037
1038 /* get the corresponding network adapter */
1039 ComPtr<INetworkAdapter> adapter;
1040 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam()));
1041 if (adapter)
1042 {
1043 BOOL fEnabled;
1044 adapter->COMGETTER(Enabled)(&fEnabled);
1045 if (fEnabled)
1046 {
1047 /* Parse 'name=value' */
1048 char *pszProperty = RTStrDup(a->argv[2]);
1049 if (pszProperty)
1050 {
1051 char *pDelimiter = strchr(pszProperty, '=');
1052 if (pDelimiter)
1053 {
1054 *pDelimiter = '\0';
1055
1056 Bstr bstrName = pszProperty;
1057 Bstr bstrValue = &pDelimiter[1];
1058 CHECK_ERROR(adapter, SetProperty(bstrName.raw(), bstrValue.raw()));
1059 if (SUCCEEDED(hrc))
1060 fNeedsSaving = true;
1061 }
1062 else
1063 {
1064 errorSyntax(ControlVM::tr("Invalid nicproperty%d argument '%s'."), n, a->argv[2]);
1065 hrc = E_FAIL;
1066 }
1067 RTStrFree(pszProperty);
1068 }
1069 else
1070 {
1071 RTMsgError(ControlVM::tr("Failed to allocate memory for nicproperty%d '%s'."),
1072 n, a->argv[2]);
1073 hrc = E_FAIL;
1074 }
1075 if (FAILED(hrc))
1076 break;
1077 }
1078 else
1079 RTMsgError(ControlVM::tr("The NIC %d is currently disabled and thus its properties can't be changed."), n);
1080 }
1081 }
1082 else if (!strncmp(a->argv[1], "nicpromisc", 10))
1083 {
1084 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NICPROMISC);
1085 /* Get the number of network adapters */
1086 ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
1087 unsigned n = parseNum(&a->argv[1][10], NetworkAdapterCount, "NIC");
1088 if (!n)
1089 {
1090 hrc = E_FAIL;
1091 break;
1092 }
1093 if (a->argc <= 2)
1094 {
1095 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
1096 hrc = E_FAIL;
1097 break;
1098 }
1099
1100 /* get the corresponding network adapter */
1101 ComPtr<INetworkAdapter> adapter;
1102 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam()));
1103 if (adapter)
1104 {
1105 BOOL fEnabled;
1106 adapter->COMGETTER(Enabled)(&fEnabled);
1107 if (fEnabled)
1108 {
1109 NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
1110 if (!strcmp(a->argv[2], "deny"))
1111 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_Deny;
1112 else if ( !strcmp(a->argv[2], "allow-vms")
1113 || !strcmp(a->argv[2], "allow-network"))
1114 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowNetwork;
1115 else if (!strcmp(a->argv[2], "allow-all"))
1116 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowAll;
1117 else
1118 {
1119 errorSyntax(ControlVM::tr("Unknown promiscuous mode policy '%s'."), a->argv[2]);
1120 hrc = E_INVALIDARG;
1121 break;
1122 }
1123
1124 CHECK_ERROR(adapter, COMSETTER(PromiscModePolicy)(enmPromiscModePolicy));
1125 if (SUCCEEDED(hrc))
1126 fNeedsSaving = true;
1127 }
1128 else
1129 RTMsgError(ControlVM::tr("The NIC %d is currently disabled and thus its promiscuous mode can't be changed."), n);
1130 }
1131 }
1132 else if (!strncmp(a->argv[1], "nic", 3))
1133 {
1134 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NIC);
1135 /* Get the number of network adapters */
1136 ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
1137 unsigned n = parseNum(&a->argv[1][3], NetworkAdapterCount, "NIC");
1138 if (!n)
1139 {
1140 hrc = E_FAIL;
1141 break;
1142 }
1143 if (a->argc <= 2)
1144 {
1145 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
1146 hrc = E_FAIL;
1147 break;
1148 }
1149
1150 /* get the corresponding network adapter */
1151 ComPtr<INetworkAdapter> adapter;
1152 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam()));
1153 if (adapter)
1154 {
1155 BOOL fEnabled;
1156 adapter->COMGETTER(Enabled)(&fEnabled);
1157 if (fEnabled)
1158 {
1159 if (!strcmp(a->argv[2], "null"))
1160 {
1161 CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_Null), RTEXITCODE_FAILURE);
1162 }
1163 else if (!strcmp(a->argv[2], "nat"))
1164 {
1165 if (a->argc == 4)
1166 CHECK_ERROR_RET(adapter, COMSETTER(NATNetwork)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE);
1167 CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_NAT), RTEXITCODE_FAILURE);
1168 }
1169 else if ( !strcmp(a->argv[2], "bridged")
1170 || !strcmp(a->argv[2], "hostif")) /* backward compatibility */
1171 {
1172 if (a->argc <= 3)
1173 {
1174 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[2]);
1175 hrc = E_FAIL;
1176 break;
1177 }
1178 CHECK_ERROR_RET(adapter, COMSETTER(BridgedInterface)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE);
1179 verifyHostNetworkInterfaceName(a->virtualBox, a->argv[3], HostNetworkInterfaceType_Bridged);
1180 CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged), RTEXITCODE_FAILURE);
1181 }
1182 else if (!strcmp(a->argv[2], "intnet"))
1183 {
1184 if (a->argc <= 3)
1185 {
1186 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[2]);
1187 hrc = E_FAIL;
1188 break;
1189 }
1190 CHECK_ERROR_RET(adapter, COMSETTER(InternalNetwork)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE);
1191 CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_Internal), RTEXITCODE_FAILURE);
1192 }
1193#if defined(VBOX_WITH_NETFLT)
1194 else if (!strcmp(a->argv[2], "hostonly"))
1195 {
1196 if (a->argc <= 3)
1197 {
1198 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[2]);
1199 hrc = E_FAIL;
1200 break;
1201 }
1202 CHECK_ERROR_RET(adapter, COMSETTER(HostOnlyInterface)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE);
1203 verifyHostNetworkInterfaceName(a->virtualBox, a->argv[3], HostNetworkInterfaceType_HostOnly);
1204 CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly), RTEXITCODE_FAILURE);
1205 }
1206#endif
1207 else if (!strcmp(a->argv[2], "generic"))
1208 {
1209 if (a->argc <= 3)
1210 {
1211 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[2]);
1212 hrc = E_FAIL;
1213 break;
1214 }
1215 CHECK_ERROR_RET(adapter, COMSETTER(GenericDriver)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE);
1216 CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_Generic), RTEXITCODE_FAILURE);
1217 }
1218 else if (!strcmp(a->argv[2], "natnetwork"))
1219 {
1220 if (a->argc <= 3)
1221 {
1222 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[2]);
1223 hrc = E_FAIL;
1224 break;
1225 }
1226 CHECK_ERROR_RET(adapter, COMSETTER(NATNetwork)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE);
1227 CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_NATNetwork), RTEXITCODE_FAILURE);
1228 }
1229 else
1230 {
1231 errorSyntax(ControlVM::tr("Invalid type '%s' specfied for NIC %lu."), a->argv[2], n);
1232 hrc = E_FAIL;
1233 break;
1234 }
1235 if (SUCCEEDED(hrc))
1236 fNeedsSaving = true;
1237 }
1238 else
1239 RTMsgError(ControlVM::tr("The NIC %d is currently disabled and thus its attachment type can't be changed."), n);
1240 }
1241 }
1242 else if ( !strcmp(a->argv[1], "vrde")
1243 || !strcmp(a->argv[1], "vrdp"))
1244 {
1245 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_VRDE);
1246 if (!strcmp(a->argv[1], "vrdp"))
1247 RTMsgWarning(ControlVM::tr("'vrdp' is deprecated. Use 'vrde'."));
1248
1249 if (a->argc <= 1 + 1)
1250 {
1251 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
1252 hrc = E_FAIL;
1253 break;
1254 }
1255 ComPtr<IVRDEServer> vrdeServer;
1256 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
1257 ASSERT(vrdeServer);
1258 if (vrdeServer)
1259 {
1260 bool fEnabled;
1261 if (RT_FAILURE(parseBool(a->argv[2], &fEnabled)))
1262 {
1263 errorSyntax(ControlVM::tr("Invalid remote desktop server state '%s'."), a->argv[2]);
1264 hrc = E_FAIL;
1265 break;
1266 }
1267 CHECK_ERROR_BREAK(vrdeServer, COMSETTER(Enabled)(fEnabled));
1268 fNeedsSaving = true;
1269 }
1270 }
1271 else if ( !strcmp(a->argv[1], "vrdeport")
1272 || !strcmp(a->argv[1], "vrdpport"))
1273 {
1274 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_VRDEPORT);
1275 if (!strcmp(a->argv[1], "vrdpport"))
1276 RTMsgWarning(ControlVM::tr("'vrdpport' is deprecated. Use 'vrdeport'."));
1277
1278 if (a->argc <= 1 + 1)
1279 {
1280 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
1281 hrc = E_FAIL;
1282 break;
1283 }
1284
1285 ComPtr<IVRDEServer> vrdeServer;
1286 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
1287 ASSERT(vrdeServer);
1288 if (vrdeServer)
1289 {
1290 Bstr ports;
1291
1292 if (!strcmp(a->argv[2], "default"))
1293 ports = "0";
1294 else
1295 ports = a->argv[2];
1296
1297 CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), ports.raw()));
1298 if (SUCCEEDED(hrc))
1299 fNeedsSaving = true;
1300 }
1301 }
1302 else if ( !strcmp(a->argv[1], "vrdevideochannelquality")
1303 || !strcmp(a->argv[1], "vrdpvideochannelquality"))
1304 {
1305 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_VRDEVIDEOCHANNELQUALITY);
1306 if (!strcmp(a->argv[1], "vrdpvideochannelquality"))
1307 RTMsgWarning(ControlVM::tr("'vrdpvideochannelquality' is deprecated. Use 'vrdevideochannelquality'."));
1308
1309 if (a->argc <= 1 + 1)
1310 {
1311 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
1312 hrc = E_FAIL;
1313 break;
1314 }
1315 ComPtr<IVRDEServer> vrdeServer;
1316 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
1317 ASSERT(vrdeServer);
1318 if (vrdeServer)
1319 {
1320 Bstr value = a->argv[2];
1321
1322 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Quality").raw(), value.raw()));
1323 if (SUCCEEDED(hrc))
1324 fNeedsSaving = true;
1325 }
1326 }
1327 else if (!strcmp(a->argv[1], "vrdeproperty"))
1328 {
1329 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_VRDEPROPERTY);
1330 if (a->argc <= 1 + 1)
1331 {
1332 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
1333 hrc = E_FAIL;
1334 break;
1335 }
1336 ComPtr<IVRDEServer> vrdeServer;
1337 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
1338 ASSERT(vrdeServer);
1339 if (vrdeServer)
1340 {
1341 /* Parse 'name=value' */
1342 char *pszProperty = RTStrDup(a->argv[2]);
1343 if (pszProperty)
1344 {
1345 char *pDelimiter = strchr(pszProperty, '=');
1346 if (pDelimiter)
1347 {
1348 *pDelimiter = '\0';
1349
1350 Bstr bstrName = pszProperty;
1351 Bstr bstrValue = &pDelimiter[1];
1352 CHECK_ERROR(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw()));
1353 if (SUCCEEDED(hrc))
1354 fNeedsSaving = true;
1355 }
1356 else
1357 {
1358 errorSyntax(ControlVM::tr("Invalid vrdeproperty argument '%s'."), a->argv[2]);
1359 hrc = E_FAIL;
1360 }
1361 RTStrFree(pszProperty);
1362 }
1363 else
1364 {
1365 RTMsgError(ControlVM::tr("Failed to allocate memory for VRDE property '%s'."),
1366 a->argv[2]);
1367 hrc = E_FAIL;
1368 }
1369 }
1370 if (FAILED(hrc))
1371 {
1372 break;
1373 }
1374 }
1375 else if ( !strcmp(a->argv[1], "usbattach")
1376 || !strcmp(a->argv[1], "usbdetach"))
1377 {
1378 bool attach = !strcmp(a->argv[1], "usbattach");
1379 if (attach)
1380 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_USBATTACH);
1381 else
1382 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_USBDETACH);
1383
1384 if (a->argc < 3)
1385 {
1386 errorSyntax(ControlVM::tr("Not enough parameters."));
1387 hrc = E_FAIL;
1388 break;
1389 }
1390 else if (a->argc == 4 || a->argc > 5)
1391 {
1392 errorSyntax(ControlVM::tr("Wrong number of arguments."));
1393 hrc = E_FAIL;
1394 break;
1395 }
1396
1397 Bstr usbId = a->argv[2];
1398 Bstr captureFilename;
1399
1400 if (a->argc == 5)
1401 {
1402 if (!strcmp(a->argv[3], "--capturefile"))
1403 captureFilename = a->argv[4];
1404 else
1405 {
1406 errorSyntax(ControlVM::tr("Invalid parameter '%s'."), a->argv[3]);
1407 hrc = E_FAIL;
1408 break;
1409 }
1410 }
1411
1412 Guid guid(usbId);
1413 if (!guid.isValid())
1414 {
1415 // assume address
1416 if (attach)
1417 {
1418 ComPtr<IHost> host;
1419 CHECK_ERROR_BREAK(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1420 SafeIfaceArray <IHostUSBDevice> coll;
1421 CHECK_ERROR_BREAK(host, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(coll)));
1422 ComPtr<IHostUSBDevice> dev;
1423 CHECK_ERROR_BREAK(host, FindUSBDeviceByAddress(Bstr(a->argv[2]).raw(),
1424 dev.asOutParam()));
1425 CHECK_ERROR_BREAK(dev, COMGETTER(Id)(usbId.asOutParam()));
1426 }
1427 else
1428 {
1429 SafeIfaceArray <IUSBDevice> coll;
1430 CHECK_ERROR_BREAK(console, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(coll)));
1431 ComPtr<IUSBDevice> dev;
1432 CHECK_ERROR_BREAK(console, FindUSBDeviceByAddress(Bstr(a->argv[2]).raw(),
1433 dev.asOutParam()));
1434 CHECK_ERROR_BREAK(dev, COMGETTER(Id)(usbId.asOutParam()));
1435 }
1436 }
1437 else if (guid.isZero())
1438 {
1439 errorSyntax(ControlVM::tr("Zero UUID argument '%s'."), a->argv[2]);
1440 hrc = E_FAIL;
1441 break;
1442 }
1443
1444 if (attach)
1445 CHECK_ERROR_BREAK(console, AttachUSBDevice(usbId.raw(), captureFilename.raw()));
1446 else
1447 {
1448 ComPtr<IUSBDevice> dev;
1449 CHECK_ERROR_BREAK(console, DetachUSBDevice(usbId.raw(),
1450 dev.asOutParam()));
1451 }
1452 }
1453 else if (!strcmp(a->argv[1], "setvideomodehint"))
1454 {
1455 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_SETVIDEOMODEHINT);
1456 if (a->argc != 5 && a->argc != 6 && a->argc != 7 && a->argc != 9)
1457 {
1458 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1459 hrc = E_FAIL;
1460 break;
1461 }
1462 bool fEnabled = true;
1463 uint32_t uXRes = RTStrToUInt32(a->argv[2]);
1464 uint32_t uYRes = RTStrToUInt32(a->argv[3]);
1465 uint32_t uBpp = RTStrToUInt32(a->argv[4]);
1466 uint32_t uDisplayIdx = 0;
1467 bool fChangeOrigin = false;
1468 int32_t iOriginX = 0;
1469 int32_t iOriginY = 0;
1470 if (a->argc >= 6)
1471 uDisplayIdx = RTStrToUInt32(a->argv[5]);
1472 if (a->argc >= 7)
1473 {
1474 if (RT_FAILURE(parseBool(a->argv[6], &fEnabled)))
1475 {
1476 errorSyntax(ControlVM::tr("Either \"yes\" or \"no\" is expected."));
1477 hrc = E_FAIL;
1478 break;
1479 }
1480 }
1481 if (a->argc == 9)
1482 {
1483 iOriginX = RTStrToInt32(a->argv[7]);
1484 iOriginY = RTStrToInt32(a->argv[8]);
1485 fChangeOrigin = true;
1486 }
1487
1488 ComPtr<IDisplay> pDisplay;
1489 CHECK_ERROR_BREAK(console, COMGETTER(Display)(pDisplay.asOutParam()));
1490 if (!pDisplay)
1491 {
1492 RTMsgError(ControlVM::tr("Guest not running."));
1493 hrc = E_FAIL;
1494 break;
1495 }
1496 CHECK_ERROR_BREAK(pDisplay, SetVideoModeHint(uDisplayIdx, fEnabled,
1497 fChangeOrigin, iOriginX, iOriginY,
1498 uXRes, uYRes, uBpp, true));
1499 }
1500 else if (!strcmp(a->argv[1], "setscreenlayout"))
1501 {
1502 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_SETSCREENLAYOUT);
1503 if (a->argc < 4)
1504 {
1505 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1506 hrc = E_FAIL;
1507 break;
1508 }
1509
1510 ComPtr<IDisplay> pDisplay;
1511 CHECK_ERROR_BREAK(console, COMGETTER(Display)(pDisplay.asOutParam()));
1512 if (!pDisplay)
1513 {
1514 RTMsgError(ControlVM::tr("Guest not running."));
1515 hrc = E_FAIL;
1516 break;
1517 }
1518
1519 com::SafeIfaceArray<IGuestScreenInfo> aGuestScreenInfos;
1520
1521 /* Parse "<display> on|primary <xorigin> <yorigin> <xres> <yres> <bpp> | off" sequences. */
1522 int argc = a->argc - 2;
1523 char **argv = &a->argv[2];
1524 while (argc >= 2)
1525 {
1526 ULONG aDisplay = RTStrToUInt32(argv[0]);
1527 BOOL aPrimary = FALSE;
1528
1529 GuestMonitorStatus_T aStatus;
1530 if (RTStrICmp(argv[1], "primary") == 0)
1531 {
1532 aStatus = GuestMonitorStatus_Enabled;
1533 aPrimary = TRUE;
1534 }
1535 else if (RTStrICmp(argv[1], "on") == 0)
1536 aStatus = GuestMonitorStatus_Enabled;
1537 else if (RTStrICmp(argv[1], "off") == 0)
1538 aStatus = GuestMonitorStatus_Disabled;
1539 else
1540 {
1541 errorSyntax(ControlVM::tr("Display status must be <on> or <off>."));
1542 hrc = E_FAIL;
1543 break;
1544 }
1545
1546 BOOL aChangeOrigin = FALSE;
1547 LONG aOriginX = 0;
1548 LONG aOriginY = 0;
1549 ULONG aWidth = 0;
1550 ULONG aHeight = 0;
1551 ULONG aBitsPerPixel = 0;
1552 if (aStatus == GuestMonitorStatus_Enabled)
1553 {
1554 if (argc < 7)
1555 {
1556 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1557 hrc = E_FAIL;
1558 break;
1559 }
1560
1561 aChangeOrigin = TRUE;
1562 aOriginX = RTStrToUInt32(argv[2]);
1563 aOriginY = RTStrToUInt32(argv[3]);
1564 aWidth = RTStrToUInt32(argv[4]);
1565 aHeight = RTStrToUInt32(argv[5]);
1566 aBitsPerPixel = RTStrToUInt32(argv[6]);
1567
1568 argc -= 7;
1569 argv += 7;
1570 }
1571 else
1572 {
1573 argc -= 2;
1574 argv += 2;
1575 }
1576
1577 ComPtr<IGuestScreenInfo> pInfo;
1578 CHECK_ERROR_BREAK(pDisplay, CreateGuestScreenInfo(aDisplay, aStatus, aPrimary, aChangeOrigin,
1579 aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel,
1580 pInfo.asOutParam()));
1581 aGuestScreenInfos.push_back(pInfo);
1582 }
1583
1584 if (FAILED(hrc))
1585 break;
1586
1587 CHECK_ERROR_BREAK(pDisplay, SetScreenLayout(ScreenLayoutMode_Apply, ComSafeArrayAsInParam(aGuestScreenInfos)));
1588 }
1589 else if (!strcmp(a->argv[1], "setcredentials"))
1590 {
1591 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_SETCREDENTIALS);
1592 bool fAllowLocalLogon = true;
1593 if ( a->argc == 7
1594 || ( a->argc == 8
1595 && ( !strcmp(a->argv[3], "-p")
1596 || !strcmp(a->argv[3], "--passwordfile"))))
1597 {
1598 if ( strcmp(a->argv[5 + (a->argc - 7)], "--allowlocallogon")
1599 && strcmp(a->argv[5 + (a->argc - 7)], "-allowlocallogon"))
1600 {
1601 errorSyntax(ControlVM::tr("Invalid parameter '%s'."), a->argv[5]);
1602 hrc = E_FAIL;
1603 break;
1604 }
1605 if (!strcmp(a->argv[6 + (a->argc - 7)], "no"))
1606 fAllowLocalLogon = false;
1607 }
1608 else if ( a->argc != 5
1609 && ( a->argc != 6
1610 || ( strcmp(a->argv[3], "-p")
1611 && strcmp(a->argv[3], "--passwordfile"))))
1612 {
1613 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1614 hrc = E_FAIL;
1615 break;
1616 }
1617 Utf8Str passwd, domain;
1618 if (a->argc == 5 || a->argc == 7)
1619 {
1620 passwd = a->argv[3];
1621 domain = a->argv[4];
1622 }
1623 else
1624 {
1625 RTEXITCODE rcExit = readPasswordFile(a->argv[4], &passwd);
1626 if (rcExit != RTEXITCODE_SUCCESS)
1627 {
1628 hrc = E_FAIL;
1629 break;
1630 }
1631 domain = a->argv[5];
1632 }
1633
1634 ComPtr<IGuest> pGuest;
1635 CHECK_ERROR_BREAK(console, COMGETTER(Guest)(pGuest.asOutParam()));
1636 if (!pGuest)
1637 {
1638 RTMsgError(ControlVM::tr("Guest not running."));
1639 hrc = E_FAIL;
1640 break;
1641 }
1642 CHECK_ERROR_BREAK(pGuest, SetCredentials(Bstr(a->argv[2]).raw(),
1643 Bstr(passwd).raw(),
1644 Bstr(domain).raw(),
1645 fAllowLocalLogon));
1646 }
1647 else if (!strcmp(a->argv[1], "guestmemoryballoon"))
1648 {
1649 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_GUESTMEMORYBALLOON);
1650 if (a->argc != 3)
1651 {
1652 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1653 hrc = E_FAIL;
1654 break;
1655 }
1656 uint32_t uVal;
1657 int vrc;
1658 vrc = RTStrToUInt32Ex(a->argv[2], NULL, 0, &uVal);
1659 if (vrc != VINF_SUCCESS)
1660 {
1661 errorSyntax(ControlVM::tr("Error parsing guest memory balloon size '%s'."), a->argv[2]);
1662 hrc = E_FAIL;
1663 break;
1664 }
1665 /* guest is running; update IGuest */
1666 ComPtr<IGuest> pGuest;
1667 hrc = console->COMGETTER(Guest)(pGuest.asOutParam());
1668 if (SUCCEEDED(hrc))
1669 {
1670 if (!pGuest)
1671 {
1672 RTMsgError(ControlVM::tr("Guest not running."));
1673 hrc = E_FAIL;
1674 break;
1675 }
1676 CHECK_ERROR(pGuest, COMSETTER(MemoryBalloonSize)(uVal));
1677 }
1678 }
1679 else if (!strcmp(a->argv[1], "teleport"))
1680 {
1681 Bstr bstrHostname;
1682 uint32_t uMaxDowntime = 250 /*ms*/;
1683 uint32_t uPort = UINT32_MAX;
1684 uint32_t cMsTimeout = 0;
1685 Utf8Str strPassword;
1686 static const RTGETOPTDEF s_aTeleportOptions[] =
1687 {
1688 { "--host", 'h', RTGETOPT_REQ_STRING }, /** @todo RTGETOPT_FLAG_MANDATORY */
1689 { "--maxdowntime", 'd', RTGETOPT_REQ_UINT32 },
1690 { "--port", 'P', RTGETOPT_REQ_UINT32 }, /** @todo RTGETOPT_FLAG_MANDATORY */
1691 { "--passwordfile", 'p', RTGETOPT_REQ_STRING },
1692 { "--password", 'W', RTGETOPT_REQ_STRING },
1693 { "--timeout", 't', RTGETOPT_REQ_UINT32 },
1694 { "--detailed-progress", 'D', RTGETOPT_REQ_NOTHING }
1695 };
1696 RTGETOPTSTATE GetOptState;
1697 RTGetOptInit(&GetOptState, a->argc, a->argv, s_aTeleportOptions, RT_ELEMENTS(s_aTeleportOptions), 2, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1698 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_TELEPORT);
1699 int ch;
1700 RTGETOPTUNION Value;
1701 while ( SUCCEEDED(hrc)
1702 && (ch = RTGetOpt(&GetOptState, &Value)))
1703 {
1704 switch (ch)
1705 {
1706 case 'h': bstrHostname = Value.psz; break;
1707 case 'd': uMaxDowntime = Value.u32; break;
1708 case 'D': g_fDetailedProgress = true; break;
1709 case 'P': uPort = Value.u32; break;
1710 case 'p':
1711 {
1712 RTEXITCODE rcExit = readPasswordFile(Value.psz, &strPassword);
1713 if (rcExit != RTEXITCODE_SUCCESS)
1714 hrc = E_FAIL;
1715 break;
1716 }
1717 case 'W': strPassword = Value.psz; break;
1718 case 't': cMsTimeout = Value.u32; break;
1719 default:
1720 errorGetOpt(ch, &Value);
1721 hrc = E_FAIL;
1722 break;
1723 }
1724 }
1725 if (FAILED(hrc))
1726 break;
1727
1728 ComPtr<IProgress> progress;
1729 CHECK_ERROR_BREAK(console, Teleport(bstrHostname.raw(), uPort,
1730 Bstr(strPassword).raw(),
1731 uMaxDowntime,
1732 progress.asOutParam()));
1733
1734 if (cMsTimeout)
1735 {
1736 hrc = progress->COMSETTER(Timeout)(cMsTimeout);
1737 if (FAILED(hrc) && hrc != VBOX_E_INVALID_OBJECT_STATE)
1738 CHECK_ERROR_BREAK(progress, COMSETTER(Timeout)(cMsTimeout)); /* lazyness */
1739 }
1740
1741 hrc = showProgress(progress);
1742 CHECK_PROGRESS_ERROR(progress, (ControlVM::tr("Teleportation failed")));
1743 }
1744 else if (!strcmp(a->argv[1], "screenshotpng"))
1745 {
1746 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_SCREENSHOTPNG);
1747 if (a->argc <= 2 || a->argc > 4)
1748 {
1749 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1750 hrc = E_FAIL;
1751 break;
1752 }
1753 int vrc;
1754 uint32_t iScreen = 0;
1755 if (a->argc == 4)
1756 {
1757 vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &iScreen);
1758 if (vrc != VINF_SUCCESS)
1759 {
1760 errorSyntax(ControlVM::tr("Error parsing display number '%s'."), a->argv[3]);
1761 hrc = E_FAIL;
1762 break;
1763 }
1764 }
1765 ComPtr<IDisplay> pDisplay;
1766 CHECK_ERROR_BREAK(console, COMGETTER(Display)(pDisplay.asOutParam()));
1767 if (!pDisplay)
1768 {
1769 RTMsgError(ControlVM::tr("Guest not running."));
1770 hrc = E_FAIL;
1771 break;
1772 }
1773 ULONG width, height, bpp;
1774 LONG xOrigin, yOrigin;
1775 GuestMonitorStatus_T monitorStatus;
1776 CHECK_ERROR_BREAK(pDisplay, GetScreenResolution(iScreen, &width, &height, &bpp, &xOrigin, &yOrigin, &monitorStatus));
1777 com::SafeArray<BYTE> saScreenshot;
1778 CHECK_ERROR_BREAK(pDisplay, TakeScreenShotToArray(iScreen, width, height, BitmapFormat_PNG, ComSafeArrayAsOutParam(saScreenshot)));
1779 RTFILE pngFile = NIL_RTFILE;
1780 vrc = RTFileOpen(&pngFile, a->argv[2], RTFILE_O_OPEN_CREATE | RTFILE_O_WRITE | RTFILE_O_TRUNCATE | RTFILE_O_DENY_ALL);
1781 if (RT_FAILURE(vrc))
1782 {
1783 RTMsgError(ControlVM::tr("Failed to create file '%s' (%Rrc)."), a->argv[2], vrc);
1784 hrc = E_FAIL;
1785 break;
1786 }
1787 vrc = RTFileWrite(pngFile, saScreenshot.raw(), saScreenshot.size(), NULL);
1788 if (RT_FAILURE(vrc))
1789 {
1790 RTMsgError(ControlVM::tr("Failed to write screenshot to file '%s' (%Rrc)."), a->argv[2], vrc);
1791 hrc = E_FAIL;
1792 }
1793 RTFileClose(pngFile);
1794 }
1795#ifdef VBOX_WITH_RECORDING
1796 else if ( !strcmp(a->argv[1], "recording")
1797 || !strcmp(a->argv[1], "videocap") /* legacy command */)
1798 {
1799 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_RECORDING);
1800
1801 if (!strcmp(a->argv[1], "videocap"))
1802 RTMsgWarning(ControlVM::tr("Sub command 'videocap' is deprecated -- please use 'recording' instead ."));
1803
1804 if (a->argc < 3)
1805 {
1806 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1807 hrc = E_FAIL;
1808 break;
1809 }
1810
1811 ComPtr<IRecordingSettings> recordingSettings;
1812 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()));
1813
1814 SafeIfaceArray <IRecordingScreenSettings> saRecordingScreenScreens;
1815 CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordingScreenScreens)));
1816
1817 ComPtr<IGraphicsAdapter> pGraphicsAdapter;
1818 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(GraphicsAdapter)(pGraphicsAdapter.asOutParam()));
1819
1820 /* Note: For now all screens have the same configuration. */
1821
1822 bool fEnabled;
1823 if (RT_SUCCESS(parseBool(a->argv[2], &fEnabled)))
1824 {
1825 CHECK_ERROR_RET(recordingSettings, COMSETTER(Enabled)(fEnabled), RTEXITCODE_FAILURE);
1826
1827 if (fEnabled)
1828 RTPrintf(ControlVM::tr("Recording enabled. Use 'start' to start recording.\n"));
1829 }
1830 else if (!strcmp(a->argv[2], "start"))
1831 {
1832 bool fWait = false;
1833 if (a->argc >= 4 && !strcmp(a->argv[3], "--wait"))
1834 fWait = true;
1835
1836 ComPtr<IProgress> progress;
1837 CHECK_ERROR_BREAK(recordingSettings, Start(progress.asOutParam()));
1838
1839 if (fWait)
1840 {
1841 hrc = showProgress(progress, SHOW_PROGRESS_OPS);
1842 CHECK_PROGRESS_ERROR(progress, (ControlVM::tr("Recording failed.")));
1843 }
1844 else
1845 RTPrintf(ControlVM::tr("Recording started (detacted).\n"));
1846 }
1847 else if (!strcmp(a->argv[2], "stop"))
1848 {
1849 ComPtr<IProgress> progress;
1850 CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Progress)(progress.asOutParam()));
1851 CHECK_ERROR_BREAK(progress, Cancel());
1852 }
1853 else if (!strcmp(a->argv[2], "attach"))
1854 {
1855 ComPtr<IProgress> progress;
1856 CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Progress)(progress.asOutParam()));
1857 hrc = showProgress(progress, SHOW_PROGRESS_OPS);
1858 }
1859 else if (!strcmp(a->argv[2], "screens"))
1860 {
1861 ULONG cMonitors = 64;
1862 CHECK_ERROR_BREAK(pGraphicsAdapter, COMGETTER(MonitorCount)(&cMonitors));
1863 com::SafeArray<BOOL> saScreens(cMonitors);
1864 if (a->argc != 4)
1865 {
1866 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1867 hrc = E_FAIL;
1868 break;
1869 }
1870 if (RT_FAILURE(parseScreens(a->argv[3], &saScreens)))
1871 {
1872 errorSyntax(ControlVM::tr("Error parsing list of screen IDs '%s'."), a->argv[3]);
1873 hrc = E_FAIL;
1874 break;
1875 }
1876
1877 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
1878 CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Enabled)(saScreens[i]));
1879 }
1880 else if (!strcmp(a->argv[2], "filename"))
1881 {
1882 if (a->argc != 4)
1883 {
1884 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1885 hrc = E_FAIL;
1886 break;
1887 }
1888
1889 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
1890 CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Filename)(Bstr(a->argv[3]).raw()));
1891 }
1892 else if ( !strcmp(a->argv[2], "videores")
1893 || !strcmp(a->argv[2], "videoresolution"))
1894 {
1895 if (a->argc != 5)
1896 {
1897 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1898 hrc = E_FAIL;
1899 break;
1900 }
1901
1902 uint32_t uWidth;
1903 int vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &uWidth);
1904 if (RT_FAILURE(vrc))
1905 {
1906 errorSyntax(ControlVM::tr("Error parsing video width '%s'."), a->argv[3]);
1907 hrc = E_FAIL;
1908 break;
1909 }
1910
1911 uint32_t uHeight;
1912 vrc = RTStrToUInt32Ex(a->argv[4], NULL, 0, &uHeight);
1913 if (RT_FAILURE(vrc))
1914 {
1915 errorSyntax(ControlVM::tr("Error parsing video height '%s'."), a->argv[4]);
1916 hrc = E_FAIL;
1917 break;
1918 }
1919
1920 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
1921 {
1922 CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoWidth)(uWidth));
1923 CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoHeight)(uHeight));
1924 }
1925 }
1926 else if (!strcmp(a->argv[2], "videorate"))
1927 {
1928 if (a->argc != 4)
1929 {
1930 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1931 hrc = E_FAIL;
1932 break;
1933 }
1934
1935 uint32_t uRate;
1936 int vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &uRate);
1937 if (RT_FAILURE(vrc))
1938 {
1939 errorSyntax(ControlVM::tr("Error parsing video rate '%s'."), a->argv[3]);
1940 hrc = E_FAIL;
1941 break;
1942 }
1943
1944 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
1945 CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoRate)(uRate));
1946 }
1947 else if (!strcmp(a->argv[2], "videofps"))
1948 {
1949 if (a->argc != 4)
1950 {
1951 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1952 hrc = E_FAIL;
1953 break;
1954 }
1955
1956 uint32_t uFPS;
1957 int vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &uFPS);
1958 if (RT_FAILURE(vrc))
1959 {
1960 errorSyntax(ControlVM::tr("Error parsing video FPS '%s'."), a->argv[3]);
1961 hrc = E_FAIL;
1962 break;
1963 }
1964
1965 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
1966 CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoFPS)(uFPS));
1967 }
1968 else if (!strcmp(a->argv[2], "maxtime"))
1969 {
1970 if (a->argc != 4)
1971 {
1972 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1973 hrc = E_FAIL;
1974 break;
1975 }
1976
1977 uint32_t uMaxTime;
1978 int vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &uMaxTime);
1979 if (RT_FAILURE(vrc))
1980 {
1981 errorSyntax(ControlVM::tr("Error parsing maximum time '%s'."), a->argv[3]);
1982 hrc = E_FAIL;
1983 break;
1984 }
1985
1986 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
1987 CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(MaxTime)(uMaxTime));
1988 }
1989 else if (!strcmp(a->argv[2], "maxfilesize"))
1990 {
1991 if (a->argc != 4)
1992 {
1993 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
1994 hrc = E_FAIL;
1995 break;
1996 }
1997
1998 uint32_t uMaxFileSize;
1999 int vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &uMaxFileSize);
2000 if (RT_FAILURE(vrc))
2001 {
2002 errorSyntax(ControlVM::tr("Error parsing maximum file size '%s'."), a->argv[3]);
2003 hrc = E_FAIL;
2004 break;
2005 }
2006
2007 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
2008 CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(MaxFileSize)(uMaxFileSize));
2009 }
2010 else if (!strcmp(a->argv[2], "opts"))
2011 {
2012 if (a->argc != 4)
2013 {
2014 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
2015 hrc = E_FAIL;
2016 break;
2017 }
2018
2019 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
2020 CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Options)(Bstr(a->argv[3]).raw()));
2021 }
2022 }
2023#endif /* VBOX_WITH_RECORDING */
2024 else if (!strcmp(a->argv[1], "webcam"))
2025 {
2026 if (a->argc < 3)
2027 {
2028 errorArgument(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
2029 hrc = E_FAIL;
2030 break;
2031 }
2032
2033 ComPtr<IEmulatedUSB> pEmulatedUSB;
2034 CHECK_ERROR_BREAK(console, COMGETTER(EmulatedUSB)(pEmulatedUSB.asOutParam()));
2035 if (!pEmulatedUSB)
2036 {
2037 RTMsgError(ControlVM::tr("Guest not running."));
2038 hrc = E_FAIL;
2039 break;
2040 }
2041
2042 if (!strcmp(a->argv[2], "attach"))
2043 {
2044 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_WEBCAM_ATTACH);
2045 Bstr path("");
2046 if (a->argc >= 4)
2047 path = a->argv[3];
2048 Bstr settings("");
2049 if (a->argc >= 5)
2050 settings = a->argv[4];
2051 CHECK_ERROR_BREAK(pEmulatedUSB, WebcamAttach(path.raw(), settings.raw()));
2052 }
2053 else if (!strcmp(a->argv[2], "detach"))
2054 {
2055 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_WEBCAM_DETACH);
2056 Bstr path("");
2057 if (a->argc >= 4)
2058 path = a->argv[3];
2059 CHECK_ERROR_BREAK(pEmulatedUSB, WebcamDetach(path.raw()));
2060 }
2061 else if (!strcmp(a->argv[2], "list"))
2062 {
2063 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_WEBCAM_LIST);
2064 com::SafeArray <BSTR> webcams;
2065 CHECK_ERROR_BREAK(pEmulatedUSB, COMGETTER(Webcams)(ComSafeArrayAsOutParam(webcams)));
2066 for (size_t i = 0; i < webcams.size(); ++i)
2067 {
2068 RTPrintf("%ls\n", webcams[i][0]? webcams[i]: Bstr("default").raw());
2069 }
2070 }
2071 else
2072 {
2073 errorArgument(ControlVM::tr("Invalid argument to '%s'."), a->argv[1]);
2074 hrc = E_FAIL;
2075 break;
2076 }
2077 }
2078 else if (!strcmp(a->argv[1], "addencpassword"))
2079 {
2080 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_ADDENCPASSWORD);
2081 if ( a->argc != 4
2082 && a->argc != 6)
2083 {
2084 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
2085 break;
2086 }
2087
2088 BOOL fRemoveOnSuspend = FALSE;
2089 if (a->argc == 6)
2090 {
2091 if ( strcmp(a->argv[4], "--removeonsuspend")
2092 || ( strcmp(a->argv[5], "yes")
2093 && strcmp(a->argv[5], "no")))
2094 {
2095 errorSyntax(ControlVM::tr("Invalid parameters."));
2096 break;
2097 }
2098 if (!strcmp(a->argv[5], "yes"))
2099 fRemoveOnSuspend = TRUE;
2100 }
2101
2102 Bstr bstrPwId(a->argv[2]);
2103 Utf8Str strPassword;
2104
2105 if (!RTStrCmp(a->argv[3], "-"))
2106 {
2107 /* Get password from console. */
2108 RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, ControlVM::tr("Enter password:"));
2109 if (rcExit == RTEXITCODE_FAILURE)
2110 break;
2111 }
2112 else
2113 {
2114 RTEXITCODE rcExit = readPasswordFile(a->argv[3], &strPassword);
2115 if (rcExit == RTEXITCODE_FAILURE)
2116 {
2117 RTMsgError(ControlVM::tr("Failed to read new password from file."));
2118 break;
2119 }
2120 }
2121
2122 CHECK_ERROR_BREAK(console, AddEncryptionPassword(bstrPwId.raw(), Bstr(strPassword).raw(), fRemoveOnSuspend));
2123 }
2124 else if (!strcmp(a->argv[1], "removeencpassword"))
2125 {
2126 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_REMOVEENCPASSWORD);
2127 if (a->argc != 3)
2128 {
2129 errorSyntax(ControlVM::tr("Incorrect number of parameters."));
2130 break;
2131 }
2132 Bstr bstrPwId(a->argv[2]);
2133 CHECK_ERROR_BREAK(console, RemoveEncryptionPassword(bstrPwId.raw()));
2134 }
2135 /** @todo r=bird: 'removeallencpasswords' is very much unreadable carp. Use
2136 * dashes as word separators to make it less fishy. */
2137 else if (!strcmp(a->argv[1], "removeallencpasswords"))
2138 {
2139 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_REMOVEALLENCPASSWORDS);
2140 CHECK_ERROR_BREAK(console, ClearAllEncryptionPasswords());
2141 }
2142 else if (!strncmp(a->argv[1], "changeuartmode", 14))
2143 {
2144 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_CHANGEUARTMODE);
2145 unsigned n = parseNum(&a->argv[1][14], 4, "UART");
2146 if (!n)
2147 {
2148 hrc = E_FAIL;
2149 break;
2150 }
2151 if (a->argc < 3)
2152 {
2153 errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
2154 hrc = E_FAIL;
2155 break;
2156 }
2157
2158 ComPtr<ISerialPort> uart;
2159
2160 CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(n - 1, uart.asOutParam()));
2161 ASSERT(uart);
2162
2163 if (!RTStrICmp(a->argv[2], "disconnected"))
2164 {
2165 if (a->argc != 3)
2166 {
2167 errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
2168 hrc = E_FAIL;
2169 break;
2170 }
2171 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected));
2172 }
2173 else if ( !RTStrICmp(a->argv[2], "server")
2174 || !RTStrICmp(a->argv[2], "client")
2175 || !RTStrICmp(a->argv[2], "tcpserver")
2176 || !RTStrICmp(a->argv[2], "tcpclient")
2177 || !RTStrICmp(a->argv[2], "file"))
2178 {
2179 const char *pszMode = a->argv[2];
2180 if (a->argc != 4)
2181 {
2182 errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
2183 hrc = E_FAIL;
2184 break;
2185 }
2186
2187 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(a->argv[3]).raw()));
2188
2189 /*
2190 * Change to disconnected first to get changes in just a parameter causing
2191 * the correct changes later on.
2192 */
2193 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected));
2194 if (!RTStrICmp(pszMode, "server"))
2195 {
2196 CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
2197 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
2198 }
2199 else if (!RTStrICmp(pszMode, "client"))
2200 {
2201 CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
2202 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
2203 }
2204 else if (!RTStrICmp(pszMode, "tcpserver"))
2205 {
2206 CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
2207 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP));
2208 }
2209 else if (!RTStrICmp(pszMode, "tcpclient"))
2210 {
2211 CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
2212 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP));
2213 }
2214 else if (!RTStrICmp(pszMode, "file"))
2215 {
2216 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile));
2217 }
2218 }
2219 else
2220 {
2221 if (a->argc != 3)
2222 {
2223 errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
2224 hrc = E_FAIL;
2225 break;
2226 }
2227 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(a->argv[2]).raw()));
2228 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice));
2229 }
2230 }
2231 else if (!strncmp(a->argv[1], "vm-process-priority", 14))
2232 {
2233 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_VM_PROCESS_PRIORITY);
2234 if (a->argc != 3)
2235 {
2236 errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
2237 hrc = E_FAIL;
2238 break;
2239 }
2240 VMProcPriority_T enmPriority = nameToVMProcPriority(a->argv[2]);
2241 if (enmPriority == VMProcPriority_Invalid)
2242 {
2243 errorSyntax(ControlVM::tr("Invalid vm-process-priority '%s'."), a->argv[2]);
2244 hrc = E_FAIL;
2245 }
2246 else
2247 {
2248 CHECK_ERROR(sessionMachine, COMSETTER(VMProcessPriority)(enmPriority));
2249 }
2250 break;
2251 }
2252 else if (!strncmp(a->argv[1], "autostart-enabled", 17))
2253 {
2254 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_AUTOSTART_ENABLED);
2255 if (a->argc != 3)
2256 {
2257 errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
2258 hrc = E_FAIL;
2259 break;
2260 }
2261 bool fEnabled;
2262 if (RT_FAILURE(parseBool(a->argv[2], &fEnabled)))
2263 {
2264 errorSyntax(ControlVM::tr("Invalid value '%s'."), a->argv[2]);
2265 hrc = E_FAIL;
2266 break;
2267 }
2268 CHECK_ERROR(sessionMachine, COMSETTER(AutostartEnabled)(TRUE));
2269 fNeedsSaving = true;
2270 break;
2271 }
2272 else if (!strncmp(a->argv[1], "autostart-delay", 15))
2273 {
2274 setCurrentSubcommand(HELP_SCOPE_CONTROLVM_AUTOSTART_DELAY);
2275 if (a->argc != 3)
2276 {
2277 errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
2278 hrc = E_FAIL;
2279 break;
2280 }
2281 uint32_t u32;
2282 char *pszNext;
2283 int vrc = RTStrToUInt32Ex(a->argv[2], &pszNext, 10, &u32);
2284 if (RT_FAILURE(vrc) || *pszNext != '\0')
2285 {
2286 errorSyntax(ControlVM::tr("Invalid autostart delay number '%s'."), a->argv[2]);
2287 hrc = E_FAIL;
2288 break;
2289 }
2290 CHECK_ERROR(sessionMachine, COMSETTER(AutostartDelay)(u32));
2291 if (SUCCEEDED(hrc))
2292 fNeedsSaving = true;
2293 break;
2294 }
2295 else
2296 {
2297 errorSyntax(ControlVM::tr("Invalid parameter '%s'."), a->argv[1]);
2298 hrc = E_FAIL;
2299 }
2300 } while (0);
2301
2302 /* The client has to trigger saving the state explicitely. */
2303 if (fNeedsSaving)
2304 CHECK_ERROR(sessionMachine, SaveSettings());
2305
2306 a->session->UnlockMachine();
2307
2308 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2309}
Note: See TracBrowser for help on using the repository browser.

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