VBoxManageGuestProp.cpp@ 28796

Last change on this file since 28796 was 28205, checked in by vboxsync, 15 years ago
Main/VirtualBoxCallback: rename OnSnapshotDiscard to OnSnapshotDeleted for consistency, clean up wording and other minor issues
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 15.6 KB

Line
1	/* $Id: VBoxManageGuestProp.cpp 28205 2010-04-12 13:39:18Z vboxsync $ */
2	/** @file
3	* VBoxManage - The 'guestproperty' command.
4	*/
5
6	/*
7	* Copyright (C) 2006-2009 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#include "VBoxManage.h"
27
28	#include <VBox/com/com.h>
29	#include <VBox/com/string.h>
30	#include <VBox/com/array.h>
31	#include <VBox/com/ErrorInfo.h>
32	#include <VBox/com/errorprint.h>
33
34	#include <VBox/com/VirtualBox.h>
35	#include <VBox/com/EventQueue.h>
36
37	#include <VBox/log.h>
38	#include <iprt/asm.h>
39	#include <iprt/stream.h>
40	#include <iprt/string.h>
41	#include <iprt/time.h>
42	#include <iprt/thread.h>
43
44	#ifdef USE_XPCOM_QUEUE
45	# include <sys/select.h>
46	# include <errno.h>
47	#endif
48
49	#ifdef RT_OS_DARWIN
50	# include <CoreFoundation/CFRunLoop.h>
51	#endif
52
53	using namespace com;
54
55	/**
56	* IVirtualBoxCallback implementation for handling the GuestPropertyCallback in
57	* relation to the "guestproperty wait" command.
58	*/
59	class GuestPropertyCallback :
60	VBOX_SCRIPTABLE_IMPL(IVirtualBoxCallback)
61	{
62	public:
63	GuestPropertyCallback(const char *pszPatterns, Guid aUuid)
64	: mSignalled(false), mPatterns(pszPatterns), mUuid(aUuid)
65	{
66	#ifndef VBOX_WITH_XPCOM
67	refcnt = 0;
68	#endif
69	}
70
71	virtual ~GuestPropertyCallback()
72	{
73	}
74
75	#ifndef VBOX_WITH_XPCOM
76	STDMETHOD_(ULONG, AddRef)()
77	{
78	return ::InterlockedIncrement(&refcnt);
79	}
80	STDMETHOD_(ULONG, Release)()
81	{
82	long cnt = ::InterlockedDecrement(&refcnt);
83	if (cnt == 0)
84	delete this;
85	return cnt;
86	}
87	#endif /* !VBOX_WITH_XPCOM */
88	VBOX_SCRIPTABLE_DISPATCH_IMPL(IVirtualBoxCallback)
89
90	NS_DECL_ISUPPORTS
91
92	STDMETHOD(OnMachineStateChange)(IN_BSTR machineId,
93	MachineState_T state)
94	{
95	return S_OK;
96	}
97
98	STDMETHOD(OnMachineDataChange)(IN_BSTR machineId)
99	{
100	return S_OK;
101	}
102
103	STDMETHOD(OnExtraDataCanChange)(IN_BSTR machineId, IN_BSTR key,
104	IN_BSTR value, BSTR *error,
105	BOOL *changeAllowed)
106	{
107	/* we never disagree */
108	if (!changeAllowed)
109	return E_INVALIDARG;
110	*changeAllowed = TRUE;
111	return S_OK;
112	}
113
114	STDMETHOD(OnExtraDataChange)(IN_BSTR machineId, IN_BSTR key,
115	IN_BSTR value)
116	{
117	return S_OK;
118	}
119
120	STDMETHOD(OnMediumRegistered)(IN_BSTR mediaId,
121	DeviceType_T mediaType, BOOL registered)
122	{
123	NOREF(mediaId);
124	NOREF(mediaType);
125	NOREF(registered);
126	return S_OK;
127	}
128
129	STDMETHOD(OnMachineRegistered)(IN_BSTR machineId, BOOL registered)
130	{
131	return S_OK;
132	}
133
134	STDMETHOD(OnSessionStateChange)(IN_BSTR machineId,
135	SessionState_T state)
136	{
137	return S_OK;
138	}
139
140	STDMETHOD(OnSnapshotTaken)(IN_BSTR aMachineId,
141	IN_BSTR aSnapshotId)
142	{
143	return S_OK;
144	}
145
146	STDMETHOD(OnSnapshotDeleted)(IN_BSTR aMachineId,
147	IN_BSTR aSnapshotId)
148	{
149	return S_OK;
150	}
151
152	STDMETHOD(OnSnapshotChange)(IN_BSTR aMachineId,
153	IN_BSTR aSnapshotId)
154	{
155	return S_OK;
156	}
157
158	STDMETHOD(OnGuestPropertyChange)(IN_BSTR machineId,
159	IN_BSTR name, IN_BSTR value,
160	IN_BSTR flags)
161	{
162	Utf8Str utf8Name(name);
163	Guid uuid(machineId);
164	if ( uuid == mUuid
165	&& RTStrSimplePatternMultiMatch(mPatterns, RTSTR_MAX,
166	utf8Name.raw(), RTSTR_MAX, NULL))
167	{
168	RTPrintf("Name: %lS, value: %lS, flags: %lS\n", name, value, flags);
169	ASMAtomicWriteBool(&mSignalled, true);
170	com::EventQueue::getMainEventQueue()->interruptEventQueueProcessing();
171	}
172	return S_OK;
173	}
174
175	bool Signalled(void) const
176	{
177	return mSignalled;
178	}
179
180	private:
181	bool volatile mSignalled;
182	const char *mPatterns;
183	Guid mUuid;
184	#ifndef VBOX_WITH_XPCOM
185	long refcnt;
186	#endif
187	};
188
189	#ifdef VBOX_WITH_XPCOM
190	NS_DECL_CLASSINFO(GuestPropertyCallback)
191	NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GuestPropertyCallback, IVirtualBoxCallback)
192	#endif /* VBOX_WITH_XPCOM */
193
194	void usageGuestProperty(void)
195	{
196	RTPrintf("VBoxManage guestproperty get <vmname>\|<uuid>\n"
197	" <property> [--verbose]\n"
198	"\n");
199	RTPrintf("VBoxManage guestproperty set <vmname>\|<uuid>\n"
200	" <property> [<value> [--flags <flags>]]\n"
201	"\n");
202	RTPrintf("VBoxManage guestproperty enumerate <vmname>\|<uuid>\n"
203	" [--patterns <patterns>]\n"
204	"\n");
205	RTPrintf("VBoxManage guestproperty wait <vmname>\|<uuid> <patterns>\n"
206	" [--timeout <msec>] [--fail-on-timeout]\n"
207	"\n");
208	}
209
210	static int handleGetGuestProperty(HandlerArg *a)
211	{
212	HRESULT rc = S_OK;
213
214	bool verbose = false;
215	if ( a->argc == 3
216	&& ( !strcmp(a->argv[2], "--verbose")
217	\|\| !strcmp(a->argv[2], "-verbose")))
218	verbose = true;
219	else if (a->argc != 2)
220	return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
221
222	ComPtr<IMachine> machine;
223	/* assume it's a UUID */
224	rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
225	if (FAILED(rc) \|\| !machine)
226	{
227	/* must be a name */
228	CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
229	}
230	if (machine)
231	{
232	Bstr uuid;
233	machine->COMGETTER(Id)(uuid.asOutParam());
234
235	/* open a session for the VM - new or existing */
236	if (FAILED (a->virtualBox->OpenSession(a->session, uuid)))
237	CHECK_ERROR_RET(a->virtualBox, OpenExistingSession(a->session, uuid), 1);
238
239	/* get the mutable session machine */
240	a->session->COMGETTER(Machine)(machine.asOutParam());
241
242	Bstr value;
243	ULONG64 u64Timestamp;
244	Bstr flags;
245	CHECK_ERROR(machine, GetGuestProperty(Bstr(a->argv[1]), value.asOutParam(),
246	&u64Timestamp, flags.asOutParam()));
247	if (!value)
248	RTPrintf("No value set!\n");
249	if (value)
250	RTPrintf("Value: %lS\n", value.raw());
251	if (value && verbose)
252	{
253	RTPrintf("Timestamp: %lld\n", u64Timestamp);
254	RTPrintf("Flags: %lS\n", flags.raw());
255	}
256	}
257	return SUCCEEDED(rc) ? 0 : 1;
258	}
259
260	static int handleSetGuestProperty(HandlerArg *a)
261	{
262	HRESULT rc = S_OK;
263
264	/*
265	* Check the syntax. We can deduce the correct syntax from the number of
266	* arguments.
267	*/
268	bool usageOK = true;
269	const char *pszName = NULL;
270	const char *pszValue = NULL;
271	const char *pszFlags = NULL;
272	if (a->argc == 3)
273	pszValue = a->argv[2];
274	else if (a->argc == 4)
275	usageOK = false;
276	else if (a->argc == 5)
277	{
278	pszValue = a->argv[2];
279	if ( strcmp(a->argv[3], "--flags")
280	&& strcmp(a->argv[3], "-flags"))
281	usageOK = false;
282	pszFlags = a->argv[4];
283	}
284	else if (a->argc != 2)
285	usageOK = false;
286	if (!usageOK)
287	return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
288	/* This is always needed. */
289	pszName = a->argv[1];
290
291	ComPtr<IMachine> machine;
292	/* assume it's a UUID */
293	rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
294	if (FAILED(rc) \|\| !machine)
295	{
296	/* must be a name */
297	CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
298	}
299	if (machine)
300	{
301	Bstr uuid;
302	machine->COMGETTER(Id)(uuid.asOutParam());
303
304	/* open a session for the VM - new or existing */
305	if (FAILED (a->virtualBox->OpenSession(a->session, uuid)))
306	CHECK_ERROR_RET (a->virtualBox, OpenExistingSession(a->session, uuid), 1);
307
308	/* get the mutable session machine */
309	a->session->COMGETTER(Machine)(machine.asOutParam());
310
311	if (!pszValue && !pszFlags)
312	CHECK_ERROR(machine, SetGuestPropertyValue(Bstr(pszName), Bstr("")));
313	else if (!pszFlags)
314	CHECK_ERROR(machine, SetGuestPropertyValue(Bstr(pszName), Bstr(pszValue)));
315	else
316	CHECK_ERROR(machine, SetGuestProperty(Bstr(pszName), Bstr(pszValue), Bstr(pszFlags)));
317
318	if (SUCCEEDED(rc))
319	CHECK_ERROR(machine, SaveSettings());
320
321	a->session->Close();
322	}
323	return SUCCEEDED(rc) ? 0 : 1;
324	}
325
326	/**
327	* Enumerates the properties in the guest property store.
328	*
329	* @returns 0 on success, 1 on failure
330	* @note see the command line API description for parameters
331	*/
332	static int handleEnumGuestProperty(HandlerArg *a)
333	{
334	/*
335	* Check the syntax. We can deduce the correct syntax from the number of
336	* arguments.
337	*/
338	if ( a->argc < 1
339	\|\| a->argc == 2
340	\|\| ( a->argc > 3
341	&& strcmp(a->argv[1], "--patterns")
342	&& strcmp(a->argv[1], "-patterns")))
343	return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
344
345	/*
346	* Pack the patterns
347	*/
348	Utf8Str Utf8Patterns(a->argc > 2 ? a->argv[2] : "*");
349	for (int i = 3; i < a->argc; ++i)
350	Utf8Patterns = Utf8StrFmt ("%s,%s", Utf8Patterns.raw(), a->argv[i]);
351
352	/*
353	* Make the actual call to Main.
354	*/
355	ComPtr<IMachine> machine;
356	/* assume it's a UUID */
357	HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
358	if (FAILED(rc) \|\| !machine)
359	{
360	/* must be a name */
361	CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
362	}
363	if (machine)
364	{
365	Bstr uuid;
366	machine->COMGETTER(Id)(uuid.asOutParam());
367
368	/* open a session for the VM - new or existing */
369	if (FAILED(a->virtualBox->OpenSession(a->session, uuid)))
370	CHECK_ERROR_RET (a->virtualBox, OpenExistingSession(a->session, uuid), 1);
371
372	/* get the mutable session machine */
373	a->session->COMGETTER(Machine)(machine.asOutParam());
374
375	com::SafeArray <BSTR> names;
376	com::SafeArray <BSTR> values;
377	com::SafeArray <ULONG64> timestamps;
378	com::SafeArray <BSTR> flags;
379	CHECK_ERROR(machine, EnumerateGuestProperties(Bstr(Utf8Patterns),
380	ComSafeArrayAsOutParam(names),
381	ComSafeArrayAsOutParam(values),
382	ComSafeArrayAsOutParam(timestamps),
383	ComSafeArrayAsOutParam(flags)));
384	if (SUCCEEDED(rc))
385	{
386	if (names.size() == 0)
387	RTPrintf("No properties found.\n");
388	for (unsigned i = 0; i < names.size(); ++i)
389	RTPrintf("Name: %lS, value: %lS, timestamp: %lld, flags: %lS\n",
390	names[i], values[i], timestamps[i], flags[i]);
391	}
392	}
393	return SUCCEEDED(rc) ? 0 : 1;
394	}
395
396	/**
397	* Enumerates the properties in the guest property store.
398	*
399	* @returns 0 on success, 1 on failure
400	* @note see the command line API description for parameters
401	*/
402	static int handleWaitGuestProperty(HandlerArg *a)
403	{
404	/*
405	* Handle arguments
406	*/
407	bool fFailOnTimeout = false;
408	const char *pszPatterns = NULL;
409	uint32_t cMsTimeout = RT_INDEFINITE_WAIT;
410	bool usageOK = true;
411	if (a->argc < 2)
412	usageOK = false;
413	else
414	pszPatterns = a->argv[1];
415	ComPtr<IMachine> machine;
416	/* assume it's a UUID */
417	HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
418	if (FAILED(rc) \|\| !machine)
419	{
420	/* must be a name */
421	CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
422	}
423	if (!machine)
424	usageOK = false;
425	for (int i = 2; usageOK && i < a->argc; ++i)
426	{
427	if ( !strcmp(a->argv[i], "--timeout")
428	\|\| !strcmp(a->argv[i], "-timeout"))
429	{
430	if ( i + 1 >= a->argc
431	\|\| RTStrToUInt32Full(a->argv[i + 1], 10, &cMsTimeout) != VINF_SUCCESS)
432	usageOK = false;
433	else
434	++i;
435	}
436	else if (!strcmp(a->argv[i], "--fail-on-timeout"))
437	fFailOnTimeout = true;
438	else
439	usageOK = false;
440	}
441	if (!usageOK)
442	return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
443
444	/*
445	* Set up the callback and loop until signal or timeout.
446	*
447	* We do this in 1000 ms chunks to be on the safe side (there used to be
448	* better reasons for it).
449	*/
450	Bstr uuid;
451	machine->COMGETTER(Id)(uuid.asOutParam());
452	GuestPropertyCallback *cbImpl = new GuestPropertyCallback(pszPatterns, uuid);
453	ComPtr<IVirtualBoxCallback> callback;
454	rc = createCallbackWrapper((IVirtualBoxCallback *)cbImpl, callback.asOutParam());
455	if (FAILED(rc))
456	{
457	RTPrintf("Error creating callback wrapper: %Rhrc\n", rc);
458	return 1;
459	}
460	a->virtualBox->RegisterCallback(callback);
461	uint64_t u64Started = RTTimeMilliTS();
462	do
463	{
464	unsigned cMsWait;
465	if (cMsTimeout == RT_INDEFINITE_WAIT)
466	cMsWait = 1000;
467	else
468	{
469	uint64_t cMsElapsed = RTTimeMilliTS() - u64Started;
470	if (cMsElapsed >= cMsTimeout)
471	break; /* timed out */
472	cMsWait = RT_MIN(1000, cMsTimeout - (uint32_t)cMsElapsed);
473	}
474	int vrc = com::EventQueue::getMainEventQueue()->processEventQueue(cMsWait);
475	if ( RT_FAILURE(vrc)
476	&& vrc != VERR_TIMEOUT)
477	{
478	RTPrintf("Error waiting for event: %Rrc\n", vrc);
479	return 1;
480	}
481	} while (!cbImpl->Signalled());
482
483	a->virtualBox->UnregisterCallback(callback);
484
485	int rcRet = 0;
486	if (!cbImpl->Signalled())
487	{
488	RTPrintf("Time out or interruption while waiting for a notification.\n");
489	if (fFailOnTimeout)
490	rcRet = 2;
491	}
492	return rcRet;
493	}
494
495	/**
496	* Access the guest property store.
497	*
498	* @returns 0 on success, 1 on failure
499	* @note see the command line API description for parameters
500	*/
501	int handleGuestProperty(HandlerArg *a)
502	{
503	HandlerArg arg = *a;
504	arg.argc = a->argc - 1;
505	arg.argv = a->argv + 1;
506
507	if (a->argc == 0)
508	return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
509
510	/* switch (cmd) */
511	if (strcmp(a->argv[0], "get") == 0)
512	return handleGetGuestProperty(&arg);
513	if (strcmp(a->argv[0], "set") == 0)
514	return handleSetGuestProperty(&arg);
515	if (strcmp(a->argv[0], "enumerate") == 0)
516	return handleEnumGuestProperty(&arg);
517	if (strcmp(a->argv[0], "wait") == 0)
518	return handleWaitGuestProperty(&arg);
519
520	/* default: */
521	return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
522	}

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

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

Download in other formats: