VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestProp.cpp@ 32718

Last change on this file since 32718 was 32718, checked in by vboxsync, 14 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 Id Revision
File size: 13.6 KB
Line 
1/* $Id: VBoxManageGuestProp.cpp 32718 2010-09-23 12:57:52Z vboxsync $ */
2/** @file
3 * VBoxManage - Implementation of guestproperty 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/*******************************************************************************
20* Header Files *
21*******************************************************************************/
22#include "VBoxManage.h"
23
24#ifndef VBOX_ONLY_DOCS
25
26#include <VBox/com/com.h>
27#include <VBox/com/string.h>
28#include <VBox/com/array.h>
29#include <VBox/com/ErrorInfo.h>
30#include <VBox/com/errorprint.h>
31
32#include <VBox/com/VirtualBox.h>
33#include <VBox/com/EventQueue.h>
34
35#include <VBox/log.h>
36#include <iprt/asm.h>
37#include <iprt/stream.h>
38#include <iprt/string.h>
39#include <iprt/time.h>
40#include <iprt/thread.h>
41
42#ifdef USE_XPCOM_QUEUE
43# include <sys/select.h>
44# include <errno.h>
45#endif
46
47#ifdef RT_OS_DARWIN
48# include <CoreFoundation/CFRunLoop.h>
49#endif
50
51using namespace com;
52
53#endif /* !VBOX_ONLY_DOCS */
54
55void usageGuestProperty(PRTSTREAM pStrm)
56{
57 RTStrmPrintf(pStrm,
58 "VBoxManage guestproperty get <vmname>|<uuid>\n"
59 " <property> [--verbose]\n"
60 "\n");
61 RTStrmPrintf(pStrm,
62 "VBoxManage guestproperty set <vmname>|<uuid>\n"
63 " <property> [<value> [--flags <flags>]]\n"
64 "\n");
65 RTStrmPrintf(pStrm,
66 "VBoxManage guestproperty enumerate <vmname>|<uuid>\n"
67 " [--patterns <patterns>]\n"
68 "\n");
69 RTStrmPrintf(pStrm,
70 "VBoxManage guestproperty wait <vmname>|<uuid> <patterns>\n"
71 " [--timeout <msec>] [--fail-on-timeout]\n"
72 "\n");
73}
74
75#ifndef VBOX_ONLY_DOCS
76
77static int handleGetGuestProperty(HandlerArg *a)
78{
79 HRESULT rc = S_OK;
80
81 bool verbose = false;
82 if ( a->argc == 3
83 && ( !strcmp(a->argv[2], "--verbose")
84 || !strcmp(a->argv[2], "-verbose")))
85 verbose = true;
86 else if (a->argc != 2)
87 return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
88
89 ComPtr<IMachine> machine;
90 /* assume it's a UUID */
91 rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
92 machine.asOutParam());
93 if (FAILED(rc) || !machine)
94 {
95 /* must be a name */
96 CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
97 machine.asOutParam()));
98 }
99 if (machine)
100 {
101 /* open a session for the VM - new or existing */
102 CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), 1);
103
104 /* get the mutable session machine */
105 a->session->COMGETTER(Machine)(machine.asOutParam());
106
107 Bstr value;
108 LONG64 i64Timestamp;
109 Bstr flags;
110 CHECK_ERROR(machine, GetGuestProperty(Bstr(a->argv[1]).raw(),
111 value.asOutParam(),
112 &i64Timestamp, flags.asOutParam()));
113 if (value.isEmpty())
114 RTPrintf("No value set!\n");
115 else
116 RTPrintf("Value: %lS\n", value.raw());
117 if (!value.isEmpty() && verbose)
118 {
119 RTPrintf("Timestamp: %lld\n", i64Timestamp);
120 RTPrintf("Flags: %lS\n", flags.raw());
121 }
122 }
123 return SUCCEEDED(rc) ? 0 : 1;
124}
125
126static int handleSetGuestProperty(HandlerArg *a)
127{
128 HRESULT rc = S_OK;
129
130 /*
131 * Check the syntax. We can deduce the correct syntax from the number of
132 * arguments.
133 */
134 bool usageOK = true;
135 const char *pszName = NULL;
136 const char *pszValue = NULL;
137 const char *pszFlags = NULL;
138 if (a->argc == 3)
139 pszValue = a->argv[2];
140 else if (a->argc == 4)
141 usageOK = false;
142 else if (a->argc == 5)
143 {
144 pszValue = a->argv[2];
145 if ( strcmp(a->argv[3], "--flags")
146 && strcmp(a->argv[3], "-flags"))
147 usageOK = false;
148 pszFlags = a->argv[4];
149 }
150 else if (a->argc != 2)
151 usageOK = false;
152 if (!usageOK)
153 return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
154 /* This is always needed. */
155 pszName = a->argv[1];
156
157 ComPtr<IMachine> machine;
158 /* assume it's a UUID */
159 rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
160 machine.asOutParam());
161 if (FAILED(rc) || !machine)
162 {
163 /* must be a name */
164 CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
165 machine.asOutParam()));
166 }
167 if (machine)
168 {
169 /* open a session for the VM - new or existing */
170 CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), 1);
171
172 /* get the mutable session machine */
173 a->session->COMGETTER(Machine)(machine.asOutParam());
174
175 if (!pszValue && !pszFlags)
176 CHECK_ERROR(machine, SetGuestPropertyValue(Bstr(pszName).raw(),
177 Bstr().raw()));
178 else if (!pszFlags)
179 CHECK_ERROR(machine, SetGuestPropertyValue(Bstr(pszName).raw(),
180 Bstr(pszValue).raw()));
181 else
182 CHECK_ERROR(machine, SetGuestProperty(Bstr(pszName).raw(),
183 Bstr(pszValue).raw(),
184 Bstr(pszFlags).raw()));
185
186 if (SUCCEEDED(rc))
187 CHECK_ERROR(machine, SaveSettings());
188
189 a->session->UnlockMachine();
190 }
191 return SUCCEEDED(rc) ? 0 : 1;
192}
193
194/**
195 * Enumerates the properties in the guest property store.
196 *
197 * @returns 0 on success, 1 on failure
198 * @note see the command line API description for parameters
199 */
200static int handleEnumGuestProperty(HandlerArg *a)
201{
202 /*
203 * Check the syntax. We can deduce the correct syntax from the number of
204 * arguments.
205 */
206 if ( a->argc < 1
207 || a->argc == 2
208 || ( a->argc > 3
209 && strcmp(a->argv[1], "--patterns")
210 && strcmp(a->argv[1], "-patterns")))
211 return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
212
213 /*
214 * Pack the patterns
215 */
216 Utf8Str Utf8Patterns(a->argc > 2 ? a->argv[2] : "");
217 for (int i = 3; i < a->argc; ++i)
218 Utf8Patterns = Utf8StrFmt ("%s,%s", Utf8Patterns.c_str(), a->argv[i]);
219
220 /*
221 * Make the actual call to Main.
222 */
223 ComPtr<IMachine> machine;
224 /* assume it's a UUID */
225 HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
226 machine.asOutParam());
227 if (FAILED(rc) || !machine)
228 {
229 /* must be a name */
230 CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
231 machine.asOutParam()));
232 }
233 if (machine)
234 {
235 /* open a session for the VM - new or existing */
236 CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), 1);
237
238 /* get the mutable session machine */
239 a->session->COMGETTER(Machine)(machine.asOutParam());
240
241 com::SafeArray<BSTR> names;
242 com::SafeArray<BSTR> values;
243 com::SafeArray<LONG64> timestamps;
244 com::SafeArray<BSTR> flags;
245 CHECK_ERROR(machine, EnumerateGuestProperties(Bstr(Utf8Patterns).raw(),
246 ComSafeArrayAsOutParam(names),
247 ComSafeArrayAsOutParam(values),
248 ComSafeArrayAsOutParam(timestamps),
249 ComSafeArrayAsOutParam(flags)));
250 if (SUCCEEDED(rc))
251 {
252 if (names.size() == 0)
253 RTPrintf("No properties found.\n");
254 for (unsigned i = 0; i < names.size(); ++i)
255 RTPrintf("Name: %lS, value: %lS, timestamp: %lld, flags: %lS\n",
256 names[i], values[i], timestamps[i], flags[i]);
257 }
258 }
259 return SUCCEEDED(rc) ? 0 : 1;
260}
261
262/**
263 * Enumerates the properties in the guest property store.
264 *
265 * @returns 0 on success, 1 on failure
266 * @note see the command line API description for parameters
267 */
268static int handleWaitGuestProperty(HandlerArg *a)
269{
270 /*
271 * Handle arguments
272 */
273 bool fFailOnTimeout = false;
274 const char *pszPatterns = NULL;
275 uint32_t cMsTimeout = RT_INDEFINITE_WAIT;
276 bool usageOK = true;
277 if (a->argc < 2)
278 usageOK = false;
279 else
280 pszPatterns = a->argv[1];
281 ComPtr<IMachine> machine;
282 /* assume it's a UUID */
283 HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
284 machine.asOutParam());
285 if (FAILED(rc) || !machine)
286 {
287 /* must be a name */
288 CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
289 machine.asOutParam()));
290 }
291 if (!machine)
292 usageOK = false;
293 for (int i = 2; usageOK && i < a->argc; ++i)
294 {
295 if ( !strcmp(a->argv[i], "--timeout")
296 || !strcmp(a->argv[i], "-timeout"))
297 {
298 if ( i + 1 >= a->argc
299 || RTStrToUInt32Full(a->argv[i + 1], 10, &cMsTimeout) != VINF_SUCCESS)
300 usageOK = false;
301 else
302 ++i;
303 }
304 else if (!strcmp(a->argv[i], "--fail-on-timeout"))
305 fFailOnTimeout = true;
306 else
307 usageOK = false;
308 }
309 if (!usageOK)
310 return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
311
312 /*
313 * Set up the event listener and wait until found match or timeout.
314 */
315 Bstr aMachStrGuid;
316 machine->COMGETTER(Id)(aMachStrGuid.asOutParam());
317 Guid aMachGuid(aMachStrGuid);
318 ComPtr<IEventSource> es;
319 CHECK_ERROR(a->virtualBox, COMGETTER(EventSource)(es.asOutParam()));
320 ComPtr<IEventListener> listener;
321 CHECK_ERROR(es, CreateListener(listener.asOutParam()));
322 com::SafeArray <VBoxEventType_T> eventTypes(1);
323 eventTypes.push_back(VBoxEventType_OnGuestPropertyChanged);
324 CHECK_ERROR(es, RegisterListener(listener, ComSafeArrayAsInParam(eventTypes), false));
325
326 uint64_t u64Started = RTTimeMilliTS();
327 bool fSignalled = false;
328 do
329 {
330 unsigned cMsWait;
331 if (cMsTimeout == RT_INDEFINITE_WAIT)
332 cMsWait = 1000;
333 else
334 {
335 uint64_t cMsElapsed = RTTimeMilliTS() - u64Started;
336 if (cMsElapsed >= cMsTimeout)
337 break; /* timed out */
338 cMsWait = RT_MIN(1000, cMsTimeout - (uint32_t)cMsElapsed);
339 }
340
341 ComPtr<IEvent> ev;
342 rc = es->GetEvent(listener, cMsWait, ev.asOutParam());
343 if (ev)
344 {
345 VBoxEventType_T aType;
346 rc = ev->COMGETTER(Type)(&aType);
347 switch (aType)
348 {
349 case VBoxEventType_OnGuestPropertyChanged:
350 {
351 ComPtr<IGuestPropertyChangedEvent> gpcev = ev;
352 Assert(gpcev);
353 Bstr aNextStrGuid;
354 gpcev->COMGETTER(MachineId)(aNextStrGuid.asOutParam());
355 if (aMachGuid != Guid(aNextStrGuid))
356 continue;
357 Bstr aNextName;
358 gpcev->COMGETTER(Name)(aNextName.asOutParam());
359 if (RTStrSimplePatternMultiMatch(pszPatterns, RTSTR_MAX,
360 Utf8Str(aNextName).c_str(), RTSTR_MAX, NULL))
361 {
362 Bstr aNextValue, aNextFlags;
363 gpcev->COMGETTER(Value)(aNextValue.asOutParam());
364 gpcev->COMGETTER(Flags)(aNextFlags.asOutParam());
365 RTPrintf("Name: %lS, value: %lS, flags: %lS\n",
366 aNextName.raw(), aNextValue.raw(), aNextFlags.raw());
367 fSignalled = true;
368 }
369 break;
370 }
371 default:
372 AssertFailed();
373 }
374 }
375 } while (!fSignalled);
376
377 es->UnregisterListener(listener);
378
379 int rcRet = 0;
380 if (!fSignalled)
381 {
382 RTMsgError("Time out or interruption while waiting for a notification.");
383 if (fFailOnTimeout)
384 rcRet = 2;
385 }
386 return rcRet;
387}
388
389/**
390 * Access the guest property store.
391 *
392 * @returns 0 on success, 1 on failure
393 * @note see the command line API description for parameters
394 */
395int handleGuestProperty(HandlerArg *a)
396{
397 HandlerArg arg = *a;
398 arg.argc = a->argc - 1;
399 arg.argv = a->argv + 1;
400
401 if (a->argc == 0)
402 return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
403
404 /* switch (cmd) */
405 if (strcmp(a->argv[0], "get") == 0)
406 return handleGetGuestProperty(&arg);
407 if (strcmp(a->argv[0], "set") == 0)
408 return handleSetGuestProperty(&arg);
409 if (strcmp(a->argv[0], "enumerate") == 0)
410 return handleEnumGuestProperty(&arg);
411 if (strcmp(a->argv[0], "wait") == 0)
412 return handleWaitGuestProperty(&arg);
413
414 /* default: */
415 return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
416}
417
418#endif /* !VBOX_ONLY_DOCS */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle
Contact – Privacy/Do Not Sell My Info – Terms of Use