VBoxManageGuestProp.cpp@ 45733

Last change on this file since 45733 was 44329, checked in by vboxsync, 12 years ago
VBoxManagerGuestProp.cpp: Allow unix shell users to use 'unset' instead of 'delete'.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 14.3 KB

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

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

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

Download in other formats: