VBoxService.cpp@ 69498

Last change on this file since 69498 was 69498, checked in by vboxsync, 7 years ago
backed out r118835 as it incorrectly updated the 'This file is based on' file headers.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 40.4 KB

Line
1	/* $Id: VBoxService.cpp 69498 2017-10-28 15:07:25Z vboxsync $ */
2	/** @file
3	* VBoxService - Guest Additions Service Skeleton.
4	*/
5
6	/*
7	* Copyright (C) 2007-2016 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	/** @page pg_vgsvc VBoxService
20	*
21	* VBoxService is a root daemon for implementing guest additions features.
22	*
23	* It is structured as one binary that contains many sub-services. The reason
24	* for this is partially historical and partially practical. The practical
25	* reason is that the VBoxService binary is typically statically linked, at
26	* least with IPRT and the guest library, so we save quite a lot of space having
27	* on single binary instead individual binaries for each sub-service and their
28	* helpers (currently up to 9 subservices and 8 helpers). The historical is
29	* simply that it started its life on OS/2 dreaming of conquring Windows next,
30	* so it kind of felt natural to have it all in one binary.
31	*
32	* Even if it's structured as a single binary, it is possible, by using command
33	* line options, to start each subservice as an individual process.
34	*
35	* Subservices:
36	* - @subpage pg_vgsvc_timesync "Time Synchronization"
37	* - @subpage pg_vgsvc_vminfo "VM Information"
38	* - @subpage pg_vgsvc_vmstats "VM Statistics"
39	* - @subpage pg_vgsvc_gstctrl "Guest Control"
40	* - @subpage pg_vgsvc_pagesharing "Page Sharing"
41	* - @subpage pg_vgsvc_memballoon "Memory Balooning"
42	* - @subpage pg_vgsvc_cpuhotplug "CPU Hot-Plugging"
43	* - @subpage pg_vgsvc_automount "Shared Folder Automounting"
44	* - @subpage pg_vgsvc_clipboard "Clipboard (OS/2 only)"
45	*
46	* Now, since the service predates a lot of stuff, including RTGetOpt, we're
47	* currently doing our own version of argument parsing here, which is kind of
48	* stupid. That will hopefully be cleaned up eventually.
49	*/
50
51
52	/*********************************************************************************************************************************
53	* Header Files *
54	*********************************************************************************************************************************/
55	/** @todo LOG_GROUP*/
56	#ifndef _MSC_VER
57	# include <unistd.h>
58	#endif
59	#include <errno.h>
60	#ifndef RT_OS_WINDOWS
61	# include <signal.h>
62	# ifdef RT_OS_OS2
63	# define pthread_sigmask sigprocmask
64	# endif
65	#endif
66	#ifdef RT_OS_FREEBSD
67	# include <pthread.h>
68	#endif
69
70	#include <package-generated.h>
71	#include "product-generated.h"
72
73	#include <iprt/asm.h>
74	#include <iprt/buildconfig.h>
75	#include <iprt/initterm.h>
76	#include <iprt/file.h>
77	#ifdef DEBUG
78	# include <iprt/memtracker.h>
79	#endif
80	#include <iprt/message.h>
81	#include <iprt/path.h>
82	#include <iprt/process.h>
83	#include <iprt/semaphore.h>
84	#include <iprt/string.h>
85	#include <iprt/stream.h>
86	#include <iprt/system.h>
87	#include <iprt/thread.h>
88
89	#include <VBox/log.h>
90
91	#include "VBoxServiceInternal.h"
92	#ifdef VBOX_WITH_VBOXSERVICE_CONTROL
93	# include "VBoxServiceControl.h"
94	#endif
95	#ifdef VBOX_WITH_VBOXSERVICE_TOOLBOX
96	# include "VBoxServiceToolBox.h"
97	#endif
98
99
100	/*********************************************************************************************************************************
101	* Global Variables *
102	*********************************************************************************************************************************/
103	/** The program name (derived from argv[0]). */
104	char g_pszProgName = (char )"";
105	/** The current verbosity level. */
106	unsigned g_cVerbosity = 0;
107	char g_szLogFile[RTPATH_MAX + 128] = "";
108	char g_szPidFile[RTPATH_MAX] = "";
109	/** Logging parameters. */
110	/** @todo Make this configurable later. */
111	static PRTLOGGER g_pLoggerRelease = NULL;
112	static uint32_t g_cHistory = 10; /* Enable log rotation, 10 files. */
113	static uint32_t g_uHistoryFileTime = RT_SEC_1DAY; /* Max 1 day per file. */
114	static uint64_t g_uHistoryFileSize = 100 * _1M; /* Max 100MB per file. */
115	/** Critical section for (debug) logging. */
116	#ifdef DEBUG
117	RTCRITSECT g_csLog;
118	#endif
119	/** The default service interval (the -i \| --interval) option). */
120	uint32_t g_DefaultInterval = 0;
121	#ifdef RT_OS_WINDOWS
122	/** Signal shutdown to the Windows service thread. */
123	static bool volatile g_fWindowsServiceShutdown;
124	/** Event the Windows service thread waits for shutdown. */
125	static RTSEMEVENT g_hEvtWindowsService;
126	#endif
127
128	/**
129	* The details of the services that has been compiled in.
130	*/
131	static struct
132	{
133	/** Pointer to the service descriptor. */
134	PCVBOXSERVICE pDesc;
135	/** The worker thread. NIL_RTTHREAD if it's the main thread. */
136	RTTHREAD Thread;
137	/** Whether Pre-init was called. */
138	bool fPreInited;
139	/** Shutdown indicator. */
140	bool volatile fShutdown;
141	/** Indicator set by the service thread exiting. */
142	bool volatile fStopped;
143	/** Whether the service was started or not. */
144	bool fStarted;
145	/** Whether the service is enabled or not. */
146	bool fEnabled;
147	} g_aServices[] =
148	{
149	#ifdef VBOX_WITH_VBOXSERVICE_CONTROL
150	{ &g_Control, NIL_RTTHREAD, false, false, false, false, true },
151	#endif
152	#ifdef VBOX_WITH_VBOXSERVICE_TIMESYNC
153	{ &g_TimeSync, NIL_RTTHREAD, false, false, false, false, true },
154	#endif
155	#ifdef VBOX_WITH_VBOXSERVICE_CLIPBOARD
156	{ &g_Clipboard, NIL_RTTHREAD, false, false, false, false, true },
157	#endif
158	#ifdef VBOX_WITH_VBOXSERVICE_VMINFO
159	{ &g_VMInfo, NIL_RTTHREAD, false, false, false, false, true },
160	#endif
161	#ifdef VBOX_WITH_VBOXSERVICE_CPUHOTPLUG
162	{ &g_CpuHotPlug, NIL_RTTHREAD, false, false, false, false, true },
163	#endif
164	#ifdef VBOX_WITH_VBOXSERVICE_MANAGEMENT
165	# ifdef VBOX_WITH_MEMBALLOON
166	{ &g_MemBalloon, NIL_RTTHREAD, false, false, false, false, true },
167	# endif
168	{ &g_VMStatistics, NIL_RTTHREAD, false, false, false, false, true },
169	#endif
170	#if defined(VBOX_WITH_VBOXSERVICE_PAGE_SHARING)
171	{ &g_PageSharing, NIL_RTTHREAD, false, false, false, false, true },
172	#endif
173	#ifdef VBOX_WITH_SHARED_FOLDERS
174	{ &g_AutoMount, NIL_RTTHREAD, false, false, false, false, true },
175	#endif
176	};
177
178
179	/*
180	* Default call-backs for services which do not need special behaviour.
181	*/
182
183	/**
184	* @interface_method_impl{VBOXSERVICE,pfnPreInit, Default Implementation}
185	*/
186	DECLCALLBACK(int) VGSvcDefaultPreInit(void)
187	{
188	return VINF_SUCCESS;
189	}
190
191
192	/**
193	* @interface_method_impl{VBOXSERVICE,pfnOption, Default Implementation}
194	*/
195	DECLCALLBACK(int) VGSvcDefaultOption(const char **ppszShort, int argc,
196	char *argv, int pi)
197	{
198	NOREF(ppszShort);
199	NOREF(argc);
200	NOREF(argv);
201	NOREF(pi);
202
203	return -1;
204	}
205
206
207	/**
208	* @interface_method_impl{VBOXSERVICE,pfnInit, Default Implementation}
209	*/
210	DECLCALLBACK(int) VGSvcDefaultInit(void)
211	{
212	return VINF_SUCCESS;
213	}
214
215
216	/**
217	* @interface_method_impl{VBOXSERVICE,pfnTerm, Default Implementation}
218	*/
219	DECLCALLBACK(void) VGSvcDefaultTerm(void)
220	{
221	return;
222	}
223
224
225	/**
226	* @callback_method_impl{FNRTLOGPHASE, Release logger callback}
227	*/
228	static DECLCALLBACK(void) vgsvcLogHeaderFooter(PRTLOGGER pLoggerRelease, RTLOGPHASE enmPhase, PFNRTLOGPHASEMSG pfnLog)
229	{
230	/* Some introductory information. */
231	static RTTIMESPEC s_TimeSpec;
232	char szTmp[256];
233	if (enmPhase == RTLOGPHASE_BEGIN)
234	RTTimeNow(&s_TimeSpec);
235	RTTimeSpecToString(&s_TimeSpec, szTmp, sizeof(szTmp));
236
237	switch (enmPhase)
238	{
239	case RTLOGPHASE_BEGIN:
240	{
241	pfnLog(pLoggerRelease,
242	"VBoxService %s r%s (verbosity: %u) %s (%s %s) release log\n"
243	"Log opened %s\n",
244	RTBldCfgVersion(), RTBldCfgRevisionStr(), g_cVerbosity, VBOX_BUILD_TARGET,
245	__DATE__, __TIME__, szTmp);
246
247	int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
248	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
249	pfnLog(pLoggerRelease, "OS Product: %s\n", szTmp);
250	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
251	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
252	pfnLog(pLoggerRelease, "OS Release: %s\n", szTmp);
253	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
254	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
255	pfnLog(pLoggerRelease, "OS Version: %s\n", szTmp);
256	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp));
257	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
258	pfnLog(pLoggerRelease, "OS Service Pack: %s\n", szTmp);
259
260	/* the package type is interesting for Linux distributions */
261	char szExecName[RTPATH_MAX];
262	char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
263	pfnLog(pLoggerRelease,
264	"Executable: %s\n"
265	"Process ID: %u\n"
266	"Package type: %s"
267	#ifdef VBOX_OSE
268	" (OSE)"
269	#endif
270	"\n",
271	pszExecName ? pszExecName : "unknown",
272	RTProcSelf(),
273	VBOX_PACKAGE_STRING);
274	break;
275	}
276
277	case RTLOGPHASE_PREROTATE:
278	pfnLog(pLoggerRelease, "Log rotated - Log started %s\n", szTmp);
279	break;
280
281	case RTLOGPHASE_POSTROTATE:
282	pfnLog(pLoggerRelease, "Log continuation - Log started %s\n", szTmp);
283	break;
284
285	case RTLOGPHASE_END:
286	pfnLog(pLoggerRelease, "End of log file - Log started %s\n", szTmp);
287	break;
288
289	default:
290	/* nothing */
291	break;
292	}
293	}
294
295
296	/**
297	* Creates the default release logger outputting to the specified file.
298	*
299	* Pass NULL to disabled logging.
300	*
301	* @return IPRT status code.
302	* @param pszLogFile Filename for log output. NULL disables logging.
303	*/
304	int VGSvcLogCreate(const char *pszLogFile)
305	{
306	/* Create release logger (stdout + file). */
307	static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
308	RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD \| RTLOGFLAGS_PREFIX_TIME_PROG;
309	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
310	fFlags \|= RTLOGFLAGS_USECRLF;
311	#endif
312	char szError[RTPATH_MAX + 128] = "";
313	int rc = RTLogCreateEx(&g_pLoggerRelease, fFlags, "all",
314	#ifdef DEBUG
315	"VBOXSERVICE_LOG",
316	#else
317	"VBOXSERVICE_RELEASE_LOG",
318	#endif
319	RT_ELEMENTS(s_apszGroups), s_apszGroups,
320	RTLOGDEST_STDOUT \| RTLOGDEST_USER,
321	vgsvcLogHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
322	szError, sizeof(szError), pszLogFile);
323	if (RT_SUCCESS(rc))
324	{
325	/* register this logger as the release logger */
326	RTLogRelSetDefaultInstance(g_pLoggerRelease);
327
328	/* Explicitly flush the log in case of VBOXSERVICE_RELEASE_LOG=buffered. */
329	RTLogFlush(g_pLoggerRelease);
330	}
331
332	return rc;
333	}
334
335
336	void VGSvcLogDestroy(void)
337	{
338	RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
339	}
340
341
342	/**
343	* Displays the program usage message.
344	*
345	* @returns 1.
346	*/
347	static int vgsvcUsage(void)
348	{
349	RTPrintf("Usage:\n"
350	" %-12s [-f\|--foreground] [-v\|--verbose] [-l\|--logfile <file>]\n"
351	" [-p\|--pidfile <file>] [-i\|--interval <seconds>]\n"
352	" [--disable-<service>] [--enable-<service>]\n"
353	" [--only-<service>] [-h\|-?\|--help]\n", g_pszProgName);
354	#ifdef RT_OS_WINDOWS
355	RTPrintf(" [-r\|--register] [-u\|--unregister]\n");
356	#endif
357	for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
358	if (g_aServices[j].pDesc->pszUsage)
359	RTPrintf("%s\n", g_aServices[j].pDesc->pszUsage);
360	RTPrintf("\n"
361	"Options:\n"
362	" -i \| --interval The default interval.\n"
363	" -f \| --foreground Don't daemonize the program. For debugging.\n"
364	" -l \| --logfile <file> Enables logging to a file.\n"
365	" -p \| --pidfile <file> Write the process ID to a file.\n"
366	" -v \| --verbose Increment the verbosity level. For debugging.\n"
367	" -V \| --version Show version information.\n"
368	" -h \| -? \| --help Show this message and exit with status 1.\n"
369	);
370	#ifdef RT_OS_WINDOWS
371	RTPrintf(" -r \| --register Installs the service.\n"
372	" -u \| --unregister Uninstall service.\n");
373	#endif
374
375	RTPrintf("\n"
376	"Service-specific options:\n");
377	for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
378	{
379	RTPrintf(" --enable-%-14s Enables the %s service. (default)\n", g_aServices[j].pDesc->pszName, g_aServices[j].pDesc->pszName);
380	RTPrintf(" --disable-%-13s Disables the %s service.\n", g_aServices[j].pDesc->pszName, g_aServices[j].pDesc->pszName);
381	RTPrintf(" --only-%-16s Only enables the %s service.\n", g_aServices[j].pDesc->pszName, g_aServices[j].pDesc->pszName);
382	if (g_aServices[j].pDesc->pszOptions)
383	RTPrintf("%s", g_aServices[j].pDesc->pszOptions);
384	}
385	RTPrintf("\n"
386	" Copyright (C) 2009-" VBOX_C_YEAR " " VBOX_VENDOR "\n");
387
388	return 1;
389	}
390
391
392	/**
393	* Displays an error message.
394	*
395	* @returns RTEXITCODE_FAILURE.
396	* @param pszFormat The message text.
397	* @param ... Format arguments.
398	*/
399	RTEXITCODE VGSvcError(const char *pszFormat, ...)
400	{
401	va_list args;
402	va_start(args, pszFormat);
403	char *psz = NULL;
404	RTStrAPrintfV(&psz, pszFormat, args);
405	va_end(args);
406
407	AssertPtr(psz);
408	LogRel(("Error: %s", psz));
409
410	RTStrFree(psz);
411
412	return RTEXITCODE_FAILURE;
413	}
414
415
416	/**
417	* Displays a verbose message.
418	*
419	* @param iLevel Minimum log level required to display this message.
420	* @param pszFormat The message text.
421	* @param ... Format arguments.
422	*/
423	void VGSvcVerbose(unsigned iLevel, const char *pszFormat, ...)
424	{
425	if (iLevel <= g_cVerbosity)
426	{
427	#ifdef DEBUG
428	int rc = RTCritSectEnter(&g_csLog);
429	if (RT_SUCCESS(rc))
430	{
431	#endif
432	va_list args;
433	va_start(args, pszFormat);
434	char *psz = NULL;
435	RTStrAPrintfV(&psz, pszFormat, args);
436	va_end(args);
437
438	AssertPtr(psz);
439	LogRel(("%s", psz));
440
441	RTStrFree(psz);
442	#ifdef DEBUG
443	RTCritSectLeave(&g_csLog);
444	}
445	#endif
446	}
447	}
448
449
450	/**
451	* Reports the current VBoxService status to the host.
452	*
453	* This makes sure that the Failed state is sticky.
454	*
455	* @return IPRT status code.
456	* @param enmStatus Status to report to the host.
457	*/
458	int VGSvcReportStatus(VBoxGuestFacilityStatus enmStatus)
459	{
460	/*
461	* VBoxGuestFacilityStatus_Failed is sticky.
462	*/
463	static VBoxGuestFacilityStatus s_enmLastStatus = VBoxGuestFacilityStatus_Inactive;
464	VGSvcVerbose(4, "Setting VBoxService status to %u\n", enmStatus);
465	if (s_enmLastStatus != VBoxGuestFacilityStatus_Failed)
466	{
467	int rc = VbglR3ReportAdditionsStatus(VBoxGuestFacilityType_VBoxService, enmStatus, 0 /* Flags */);
468	if (RT_FAILURE(rc))
469	{
470	VGSvcError("Could not report VBoxService status (%u), rc=%Rrc\n", enmStatus, rc);
471	return rc;
472	}
473	s_enmLastStatus = enmStatus;
474	}
475	return VINF_SUCCESS;
476	}
477
478
479	/**
480	* Gets a 32-bit value argument.
481	* @todo Get rid of this and VGSvcArgString() as soon as we have RTOpt handling.
482	*
483	* @returns 0 on success, non-zero exit code on error.
484	* @param argc The argument count.
485	* @param argv The argument vector
486	* @param psz Where in *pi to start looking for the value argument.
487	* @param pi Where to find and perhaps update the argument index.
488	* @param pu32 Where to store the 32-bit value.
489	* @param u32Min The minimum value.
490	* @param u32Max The maximum value.
491	*/
492	int VGSvcArgUInt32(int argc, char *argv, const char psz, int pi, uint32_t pu32, uint32_t u32Min, uint32_t u32Max)
493	{
494	if (psz == ':' \|\| psz == '=')
495	psz++;
496	if (!*psz)
497	{
498	if (*pi + 1 >= argc)
499	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Missing value for the '%s' argument\n", argv[*pi]);
500	psz = argv[++*pi];
501	}
502
503	char *pszNext;
504	int rc = RTStrToUInt32Ex(psz, &pszNext, 0, pu32);
505	if (RT_FAILURE(rc) \|\| *pszNext)
506	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Failed to convert interval '%s' to a number\n", psz);
507	if (pu32 < u32Min \|\| pu32 > u32Max)
508	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The timesync interval of %RU32 seconds is out of range [%RU32..%RU32]\n",
509	*pu32, u32Min, u32Max);
510	return 0;
511	}
512
513
514	/** @todo Get rid of this and VGSvcArgUInt32() as soon as we have RTOpt handling. */
515	static int vgsvcArgString(int argc, char *argv, const char psz, int pi, char pszBuf, size_t cbBuf)
516	{
517	AssertPtrReturn(pszBuf, VERR_INVALID_POINTER);
518	AssertPtrReturn(cbBuf, VERR_INVALID_PARAMETER);
519
520	if (psz == ':' \|\| psz == '=')
521	psz++;
522	if (!*psz)
523	{
524	if (*pi + 1 >= argc)
525	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Missing string for the '%s' argument\n", argv[*pi]);
526	psz = argv[++*pi];
527	}
528
529	if (!RTStrPrintf(pszBuf, cbBuf, "%s", psz))
530	return RTMsgErrorExit(RTEXITCODE_FAILURE, "String for '%s' argument too big\n", argv[*pi]);
531	return 0;
532	}
533
534
535	/**
536	* The service thread.
537	*
538	* @returns Whatever the worker function returns.
539	* @param ThreadSelf My thread handle.
540	* @param pvUser The service index.
541	*/
542	static DECLCALLBACK(int) vgsvcThread(RTTHREAD ThreadSelf, void *pvUser)
543	{
544	const unsigned i = (uintptr_t)pvUser;
545
546	#ifndef RT_OS_WINDOWS
547	/*
548	* Block all signals for this thread. Only the main thread will handle signals.
549	*/
550	sigset_t signalMask;
551	sigfillset(&signalMask);
552	pthread_sigmask(SIG_BLOCK, &signalMask, NULL);
553	#endif
554
555	int rc = g_aServices[i].pDesc->pfnWorker(&g_aServices[i].fShutdown);
556	ASMAtomicXchgBool(&g_aServices[i].fShutdown, true);
557	RTThreadUserSignal(ThreadSelf);
558	return rc;
559	}
560
561
562	/**
563	* Lazily calls the pfnPreInit method on each service.
564	*
565	* @returns VBox status code, error message displayed.
566	*/
567	static RTEXITCODE vgsvcLazyPreInit(void)
568	{
569	for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
570	if (!g_aServices[j].fPreInited)
571	{
572	int rc = g_aServices[j].pDesc->pfnPreInit();
573	if (RT_FAILURE(rc))
574	return VGSvcError("Service '%s' failed pre-init: %Rrc\n", g_aServices[j].pDesc->pszName, rc);
575	g_aServices[j].fPreInited = true;
576	}
577	return RTEXITCODE_SUCCESS;
578	}
579
580
581	/**
582	* Count the number of enabled services.
583	*/
584	static unsigned vgsvcCountEnabledServices(void)
585	{
586	unsigned cEnabled = 0;
587	for (unsigned i = 0; i < RT_ELEMENTS(g_aServices); i++)
588	cEnabled += g_aServices[i].fEnabled;
589	return cEnabled;
590	}
591
592
593	#ifdef RT_OS_WINDOWS
594	/**
595	* Console control event callback.
596	*
597	* @returns TRUE if handled, FALSE if not.
598	* @param dwCtrlType The control event type.
599	*
600	* @remarks This is generally called on a new thread, so we're racing every
601	* other thread in the process.
602	*/
603	static BOOL WINAPI vgsvcWinConsoleControlHandler(DWORD dwCtrlType)
604	{
605	int rc = VINF_SUCCESS;
606	bool fEventHandled = FALSE;
607	switch (dwCtrlType)
608	{
609	/* User pressed CTRL+C or CTRL+BREAK or an external event was sent
610	* via GenerateConsoleCtrlEvent(). */
611	case CTRL_BREAK_EVENT:
612	case CTRL_CLOSE_EVENT:
613	case CTRL_C_EVENT:
614	VGSvcVerbose(2, "ControlHandler: Received break/close event\n");
615	rc = VGSvcStopServices();
616	fEventHandled = TRUE;
617	break;
618	default:
619	break;
620	/** @todo Add other events here. */
621	}
622
623	if (RT_FAILURE(rc))
624	VGSvcError("ControlHandler: Event %ld handled with error rc=%Rrc\n",
625	dwCtrlType, rc);
626	return fEventHandled;
627	}
628	#endif /* RT_OS_WINDOWS */
629
630
631	/**
632	* Starts the service.
633	*
634	* @returns VBox status code, errors are fully bitched.
635	*
636	* @remarks Also called from VBoxService-win.cpp, thus not static.
637	*/
638	int VGSvcStartServices(void)
639	{
640	int rc;
641
642	VGSvcReportStatus(VBoxGuestFacilityStatus_Init);
643
644	/*
645	* Initialize the services.
646	*/
647	VGSvcVerbose(2, "Initializing services ...\n");
648	for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
649	if (g_aServices[j].fEnabled)
650	{
651	rc = g_aServices[j].pDesc->pfnInit();
652	if (RT_FAILURE(rc))
653	{
654	if (rc != VERR_SERVICE_DISABLED)
655	{
656	VGSvcError("Service '%s' failed to initialize: %Rrc\n", g_aServices[j].pDesc->pszName, rc);
657	VGSvcReportStatus(VBoxGuestFacilityStatus_Failed);
658	return rc;
659	}
660	g_aServices[j].fEnabled = false;
661	VGSvcVerbose(0, "Service '%s' was disabled because of missing functionality\n", g_aServices[j].pDesc->pszName);
662
663	}
664	}
665
666	/*
667	* Start the service(s).
668	*/
669	VGSvcVerbose(2, "Starting services ...\n");
670	rc = VINF_SUCCESS;
671	for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
672	{
673	if (!g_aServices[j].fEnabled)
674	continue;
675
676	VGSvcVerbose(2, "Starting service '%s' ...\n", g_aServices[j].pDesc->pszName);
677	rc = RTThreadCreate(&g_aServices[j].Thread, vgsvcThread, (void *)(uintptr_t)j, 0,
678	RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, g_aServices[j].pDesc->pszName);
679	if (RT_FAILURE(rc))
680	{
681	VGSvcError("RTThreadCreate failed, rc=%Rrc\n", rc);
682	break;
683	}
684	g_aServices[j].fStarted = true;
685
686	/* Wait for the thread to initialize. */
687	/** @todo There is a race between waiting and checking
688	* the fShutdown flag of a thread here and processing
689	* the thread's actual worker loop. If the thread decides
690	* to exit the loop before we skipped the fShutdown check
691	* below the service will fail to start! */
692	/** @todo This presumably means either a one-shot service or that
693	* something has gone wrong. In the second case treating it as failure
694	* to start is probably right, so we need a way to signal the first
695	* rather than leaving the idle thread hanging around. A flag in the
696	* service description? */
697	RTThreadUserWait(g_aServices[j].Thread, 60 * 1000);
698	if (g_aServices[j].fShutdown)
699	{
700	VGSvcError("Service '%s' failed to start!\n", g_aServices[j].pDesc->pszName);
701	rc = VERR_GENERAL_FAILURE;
702	}
703	}
704
705	if (RT_SUCCESS(rc))
706	VGSvcVerbose(1, "All services started.\n");
707	else
708	{
709	VGSvcError("An error occcurred while the services!\n");
710	VGSvcReportStatus(VBoxGuestFacilityStatus_Failed);
711	}
712	return rc;
713	}
714
715
716	/**
717	* Stops and terminates the services.
718	*
719	* This should be called even when VBoxServiceStartServices fails so it can
720	* clean up anything that we succeeded in starting.
721	*
722	* @remarks Also called from VBoxService-win.cpp, thus not static.
723	*/
724	int VGSvcStopServices(void)
725	{
726	VGSvcReportStatus(VBoxGuestFacilityStatus_Terminating);
727
728	/*
729	* Signal all the services.
730	*/
731	for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
732	ASMAtomicWriteBool(&g_aServices[j].fShutdown, true);
733
734	/*
735	* Do the pfnStop callback on all running services.
736	*/
737	for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
738	if (g_aServices[j].fStarted)
739	{
740	VGSvcVerbose(3, "Calling stop function for service '%s' ...\n", g_aServices[j].pDesc->pszName);
741	g_aServices[j].pDesc->pfnStop();
742	}
743
744	VGSvcVerbose(3, "All stop functions for services called\n");
745
746	/*
747	* Wait for all the service threads to complete.
748	*/
749	int rc = VINF_SUCCESS;
750	for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
751	{
752	if (!g_aServices[j].fEnabled) /* Only stop services which were started before. */
753	continue;
754	if (g_aServices[j].Thread != NIL_RTTHREAD)
755	{
756	VGSvcVerbose(2, "Waiting for service '%s' to stop ...\n", g_aServices[j].pDesc->pszName);
757	int rc2 = VINF_SUCCESS;
758	for (int i = 0; i < 30; i++) /* Wait 30 seconds in total */
759	{
760	rc2 = RTThreadWait(g_aServices[j].Thread, 1000 /* Wait 1 second */, NULL);
761	if (RT_SUCCESS(rc2))
762	break;
763	#ifdef RT_OS_WINDOWS
764	/* Notify SCM that it takes a bit longer ... */
765	VGSvcWinSetStopPendingStatus(i + j*32);
766	#endif
767	}
768	if (RT_FAILURE(rc2))
769	{
770	VGSvcError("Service '%s' failed to stop. (%Rrc)\n", g_aServices[j].pDesc->pszName, rc2);
771	rc = rc2;
772	}
773	}
774	VGSvcVerbose(3, "Terminating service '%s' (%d) ...\n", g_aServices[j].pDesc->pszName, j);
775	g_aServices[j].pDesc->pfnTerm();
776	}
777
778	#ifdef RT_OS_WINDOWS
779	/*
780	* Wake up and tell the main() thread that we're shutting down (it's
781	* sleeping in VBoxServiceMainWait).
782	*/
783	ASMAtomicWriteBool(&g_fWindowsServiceShutdown, true);
784	if (g_hEvtWindowsService != NIL_RTSEMEVENT)
785	{
786	VGSvcVerbose(3, "Stopping the main thread...\n");
787	int rc2 = RTSemEventSignal(g_hEvtWindowsService);
788	AssertRC(rc2);
789	}
790	#endif
791
792	VGSvcVerbose(2, "Stopping services returning: %Rrc\n", rc);
793	VGSvcReportStatus(RT_SUCCESS(rc) ? VBoxGuestFacilityStatus_Paused : VBoxGuestFacilityStatus_Failed);
794	return rc;
795	}
796
797
798	/**
799	* Block the main thread until the service shuts down.
800	*
801	* @remarks Also called from VBoxService-win.cpp, thus not static.
802	*/
803	void VGSvcMainWait(void)
804	{
805	int rc;
806
807	VGSvcReportStatus(VBoxGuestFacilityStatus_Active);
808
809	#ifdef RT_OS_WINDOWS
810	/*
811	* Wait for the semaphore to be signalled.
812	*/
813	VGSvcVerbose(1, "Waiting in main thread\n");
814	rc = RTSemEventCreate(&g_hEvtWindowsService);
815	AssertRC(rc);
816	while (!ASMAtomicReadBool(&g_fWindowsServiceShutdown))
817	{
818	rc = RTSemEventWait(g_hEvtWindowsService, RT_INDEFINITE_WAIT);
819	AssertRC(rc);
820	}
821	RTSemEventDestroy(g_hEvtWindowsService);
822	g_hEvtWindowsService = NIL_RTSEMEVENT;
823	#else
824	/*
825	* Wait explicitly for a HUP, INT, QUIT, ABRT or TERM signal, blocking
826	* all important signals.
827	*
828	* The annoying EINTR/ERESTART loop is for the benefit of Solaris where
829	* sigwait returns when we receive a SIGCHLD. Kind of makes sense since
830	*/
831	sigset_t signalMask;
832	sigemptyset(&signalMask);
833	sigaddset(&signalMask, SIGHUP);
834	sigaddset(&signalMask, SIGINT);
835	sigaddset(&signalMask, SIGQUIT);
836	sigaddset(&signalMask, SIGABRT);
837	sigaddset(&signalMask, SIGTERM);
838	pthread_sigmask(SIG_BLOCK, &signalMask, NULL);
839
840	int iSignal;
841	do
842	{
843	iSignal = -1;
844	rc = sigwait(&signalMask, &iSignal);
845	}
846	while ( rc == EINTR
847	# ifdef ERESTART
848	\|\| rc == ERESTART
849	# endif
850	);
851
852	VGSvcVerbose(3, "VGSvcMainWait: Received signal %d (rc=%d)\n", iSignal, rc);
853	#endif /* !RT_OS_WINDOWS */
854	}
855
856
857	int main(int argc, char **argv)
858	{
859	RTEXITCODE rcExit;
860
861	/*
862	* Init globals and such.
863	*/
864	int rc = RTR3InitExe(argc, &argv, 0);
865	if (RT_FAILURE(rc))
866	return RTMsgInitFailure(rc);
867	g_pszProgName = RTPathFilename(argv[0]);
868	#ifdef DEBUG
869	rc = RTCritSectInit(&g_csLog);
870	AssertRC(rc);
871	#endif
872
873	#ifdef VBOX_WITH_VBOXSERVICE_TOOLBOX
874	/*
875	* Run toolbox code before all other stuff since these things are simpler
876	* shell/file/text utility like programs that just happens to be inside
877	* VBoxService and shouldn't be subject to /dev/vboxguest, pid-files and
878	* global mutex restrictions.
879	*/
880	if (VGSvcToolboxMain(argc, argv, &rcExit))
881	return rcExit;
882	#endif
883
884	bool fUserSession = false;
885	#ifdef VBOX_WITH_VBOXSERVICE_CONTROL
886	/*
887	* Check if we're the specially spawned VBoxService.exe process that
888	* handles a guest control session.
889	*/
890	if ( argc >= 2
891	&& !RTStrICmp(argv[1], "guestsession"))
892	fUserSession = true;
893	#endif
894
895	/*
896	* Connect to the kernel part before daemonizing so we can fail and
897	* complain if there is some kind of problem. We need to initialize the
898	* guest lib before we do the pre-init just in case one of services needs
899	* do to some initial stuff with it.
900	*/
901	if (fUserSession)
902	rc = VbglR3InitUser();
903	else
904	rc = VbglR3Init();
905	if (RT_FAILURE(rc))
906	{
907	if (rc == VERR_ACCESS_DENIED)
908	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Insufficient privileges to start %s! Please start with Administrator/root privileges!\n",
909	g_pszProgName);
910	return RTMsgErrorExit(RTEXITCODE_FAILURE, "VbglR3Init failed with rc=%Rrc\n", rc);
911	}
912
913	#ifdef RT_OS_WINDOWS
914	/*
915	* Check if we're the specially spawned VBoxService.exe process that
916	* handles page fusion. This saves an extra statically linked executable.
917	*/
918	if ( argc == 2
919	&& !RTStrICmp(argv[1], "pagefusion"))
920	return VGSvcPageSharingWorkerChild();
921	#endif
922
923	#ifdef VBOX_WITH_VBOXSERVICE_CONTROL
924	/*
925	* Check if we're the specially spawned VBoxService.exe process that
926	* handles a guest control session.
927	*/
928	if (fUserSession)
929	return VGSvcGstCtrlSessionSpawnInit(argc, argv);
930	#endif
931
932	/*
933	* Parse the arguments.
934	*
935	* Note! This code predates RTGetOpt, thus the manual parsing.
936	*/
937	bool fDaemonize = true;
938	bool fDaemonized = false;
939	for (int i = 1; i < argc; i++)
940	{
941	const char *psz = argv[i];
942	if (*psz != '-')
943	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown argument '%s'\n", psz);
944	psz++;
945
946	/* translate long argument to short */
947	if (*psz == '-')
948	{
949	psz++;
950	size_t cch = strlen(psz);
951	#define MATCHES(strconst) ( cch == sizeof(strconst) - 1 \
952	&& !memcmp(psz, strconst, sizeof(strconst) - 1) )
953	if (MATCHES("foreground"))
954	psz = "f";
955	else if (MATCHES("verbose"))
956	psz = "v";
957	else if (MATCHES("version"))
958	psz = "V";
959	else if (MATCHES("help"))
960	psz = "h";
961	else if (MATCHES("interval"))
962	psz = "i";
963	#ifdef RT_OS_WINDOWS
964	else if (MATCHES("register"))
965	psz = "r";
966	else if (MATCHES("unregister"))
967	psz = "u";
968	#endif
969	else if (MATCHES("logfile"))
970	psz = "l";
971	else if (MATCHES("pidfile"))
972	psz = "p";
973	else if (MATCHES("daemonized"))
974	{
975	fDaemonized = true;
976	continue;
977	}
978	else
979	{
980	bool fFound = false;
981
982	if (cch > sizeof("enable-") && !memcmp(psz, RT_STR_TUPLE("enable-")))
983	for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
984	if ((fFound = !RTStrICmp(psz + sizeof("enable-") - 1, g_aServices[j].pDesc->pszName)))
985	g_aServices[j].fEnabled = true;
986
987	if (cch > sizeof("disable-") && !memcmp(psz, RT_STR_TUPLE("disable-")))
988	for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
989	if ((fFound = !RTStrICmp(psz + sizeof("disable-") - 1, g_aServices[j].pDesc->pszName)))
990	g_aServices[j].fEnabled = false;
991
992	if (cch > sizeof("only-") && !memcmp(psz, RT_STR_TUPLE("only-")))
993	for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
994	{
995	g_aServices[j].fEnabled = !RTStrICmp(psz + sizeof("only-") - 1, g_aServices[j].pDesc->pszName);
996	if (g_aServices[j].fEnabled)
997	fFound = true;
998	}
999
1000	if (!fFound)
1001	{
1002	rcExit = vgsvcLazyPreInit();
1003	if (rcExit != RTEXITCODE_SUCCESS)
1004	return rcExit;
1005	for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
1006	{
1007	rc = g_aServices[j].pDesc->pfnOption(NULL, argc, argv, &i);
1008	fFound = rc == VINF_SUCCESS;
1009	if (fFound)
1010	break;
1011	if (rc != -1)
1012	return rc;
1013	}
1014	}
1015	if (!fFound)
1016	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown option '%s'\n", argv[i]);
1017	continue;
1018	}
1019	#undef MATCHES
1020	}
1021
1022	/* handle the string of short options. */
1023	do
1024	{
1025	switch (*psz)
1026	{
1027	case 'i':
1028	rc = VGSvcArgUInt32(argc, argv, psz + 1, &i,
1029	&g_DefaultInterval, 1, (UINT32_MAX / 1000) - 1);
1030	if (rc)
1031	return rc;
1032	psz = NULL;
1033	break;
1034
1035	case 'f':
1036	fDaemonize = false;
1037	break;
1038
1039	case 'v':
1040	g_cVerbosity++;
1041	break;
1042
1043	case 'V':
1044	RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
1045	return RTEXITCODE_SUCCESS;
1046
1047	case 'h':
1048	case '?':
1049	return vgsvcUsage();
1050
1051	#ifdef RT_OS_WINDOWS
1052	case 'r':
1053	return VGSvcWinInstall();
1054
1055	case 'u':
1056	return VGSvcWinUninstall();
1057	#endif
1058
1059	case 'l':
1060	{
1061	rc = vgsvcArgString(argc, argv, psz + 1, &i,
1062	g_szLogFile, sizeof(g_szLogFile));
1063	if (rc)
1064	return rc;
1065	psz = NULL;
1066	break;
1067	}
1068
1069	case 'p':
1070	{
1071	rc = vgsvcArgString(argc, argv, psz + 1, &i,
1072	g_szPidFile, sizeof(g_szPidFile));
1073	if (rc)
1074	return rc;
1075	psz = NULL;
1076	break;
1077	}
1078
1079	default:
1080	{
1081	rcExit = vgsvcLazyPreInit();
1082	if (rcExit != RTEXITCODE_SUCCESS)
1083	return rcExit;
1084
1085	bool fFound = false;
1086	for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
1087	{
1088	rc = g_aServices[j].pDesc->pfnOption(&psz, argc, argv, &i);
1089	fFound = rc == VINF_SUCCESS;
1090	if (fFound)
1091	break;
1092	if (rc != -1)
1093	return rc;
1094	}
1095	if (!fFound)
1096	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown option '%c' (%s)\n", *psz, argv[i]);
1097	break;
1098	}
1099	}
1100	} while (psz && *++psz);
1101	}
1102
1103	/* Check that at least one service is enabled. */
1104	if (vgsvcCountEnabledServices() == 0)
1105	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "At least one service must be enabled\n");
1106
1107	rc = VGSvcLogCreate(g_szLogFile[0] ? g_szLogFile : NULL);
1108	if (RT_FAILURE(rc))
1109	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to create release log '%s', rc=%Rrc\n",
1110	g_szLogFile[0] ? g_szLogFile : "<None>", rc);
1111
1112	/* Call pre-init if we didn't do it already. */
1113	rcExit = vgsvcLazyPreInit();
1114	if (rcExit != RTEXITCODE_SUCCESS)
1115	return rcExit;
1116
1117	#ifdef RT_OS_WINDOWS
1118	/*
1119	* Make sure only one instance of VBoxService runs at a time. Create a
1120	* global mutex for that.
1121	*
1122	* Note! The \\Global\ namespace was introduced with Win2K, thus the
1123	* version check.
1124	* Note! If the mutex exists CreateMutex will open it and set last error to
1125	* ERROR_ALREADY_EXISTS.
1126	*/
1127	OSVERSIONINFOEX OSInfoEx;
1128	RT_ZERO(OSInfoEx);
1129	OSInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1130
1131	SetLastError(NO_ERROR);
1132	HANDLE hMutexAppRunning;
1133	if ( GetVersionEx((LPOSVERSIONINFO)&OSInfoEx)
1134	&& OSInfoEx.dwPlatformId == VER_PLATFORM_WIN32_NT
1135	&& OSInfoEx.dwMajorVersion >= 5 /* NT 5.0 a.k.a W2K */)
1136	hMutexAppRunning = CreateMutex(NULL, FALSE, "Global\\" VBOXSERVICE_NAME);
1137	else
1138	hMutexAppRunning = CreateMutex(NULL, FALSE, VBOXSERVICE_NAME);
1139	if (hMutexAppRunning == NULL)
1140	{
1141	DWORD dwErr = GetLastError();
1142	if ( dwErr == ERROR_ALREADY_EXISTS
1143	\|\| dwErr == ERROR_ACCESS_DENIED)
1144	{
1145	VGSvcError("%s is already running! Terminating.\n", g_pszProgName);
1146	return RTEXITCODE_FAILURE;
1147	}
1148
1149	VGSvcError("CreateMutex failed with last error %u! Terminating.\n", GetLastError());
1150	return RTEXITCODE_FAILURE;
1151	}
1152
1153	#else /* !RT_OS_WINDOWS */
1154	/** @todo Add PID file creation here? */
1155	#endif /* !RT_OS_WINDOWS */
1156
1157	VGSvcVerbose(0, "%s r%s started. Verbose level = %d\n", RTBldCfgVersion(), RTBldCfgRevisionStr(), g_cVerbosity);
1158
1159	/*
1160	* Daemonize if requested.
1161	*/
1162	if (fDaemonize && !fDaemonized)
1163	{
1164	#ifdef RT_OS_WINDOWS
1165	VGSvcVerbose(2, "Starting service dispatcher ...\n");
1166	rcExit = VGSvcWinEnterCtrlDispatcher();
1167	#else
1168	VGSvcVerbose(1, "Daemonizing...\n");
1169	rc = VbglR3Daemonize(false /* fNoChDir /, false / fNoClose */,
1170	false /* fRespawn /, NULL / pcRespawn */);
1171	if (RT_FAILURE(rc))
1172	return VGSvcError("Daemon failed: %Rrc\n", rc);
1173	/* in-child */
1174	#endif
1175	}
1176	#ifdef RT_OS_WINDOWS
1177	else
1178	#endif
1179	{
1180	/*
1181	* Windows: We're running the service as a console application now. Start the
1182	* services, enter the main thread's run loop and stop them again
1183	* when it returns.
1184	*
1185	* POSIX: This is used for both daemons and console runs. Start all services
1186	* and return immediately.
1187	*/
1188	#ifdef RT_OS_WINDOWS
1189	# ifndef RT_OS_NT4 /** @todo r=bird: What's RT_OS_NT4??? */
1190	/* Install console control handler. */
1191	if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)vgsvcWinConsoleControlHandler, TRUE /* Add handler */))
1192	{
1193	VGSvcError("Unable to add console control handler, error=%ld\n", GetLastError());
1194	/* Just skip this error, not critical. */
1195	}
1196	# endif /* !RT_OS_NT4 */
1197	#endif /* RT_OS_WINDOWS */
1198	rc = VGSvcStartServices();
1199	RTFILE hPidFile = NIL_RTFILE;
1200	if (RT_SUCCESS(rc))
1201	if (g_szPidFile[0])
1202	rc = VbglR3PidFile(g_szPidFile, &hPidFile);
1203	rcExit = RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1204	if (RT_SUCCESS(rc))
1205	VGSvcMainWait();
1206	if (g_szPidFile[0] && hPidFile != NIL_RTFILE)
1207	VbglR3ClosePidFile(g_szPidFile, hPidFile);
1208	#ifdef RT_OS_WINDOWS
1209	# ifndef RT_OS_NT4
1210	/* Uninstall console control handler. */
1211	if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)NULL, FALSE /* Remove handler */))
1212	{
1213	VGSvcError("Unable to remove console control handler, error=%ld\n", GetLastError());
1214	/* Just skip this error, not critical. */
1215	}
1216	# endif /* !RT_OS_NT4 */
1217	#else /* !RT_OS_WINDOWS */
1218	/* On Windows - since we're running as a console application - we already stopped all services
1219	* through the console control handler. So only do the stopping of services here on other platforms
1220	* where the break/shutdown/whatever signal was just received. */
1221	VGSvcStopServices();
1222	#endif /* RT_OS_WINDOWS */
1223	}
1224	VGSvcReportStatus(VBoxGuestFacilityStatus_Terminated);
1225
1226	#ifdef RT_OS_WINDOWS
1227	/*
1228	* Cleanup mutex.
1229	*/
1230	CloseHandle(hMutexAppRunning);
1231	#endif
1232
1233	VGSvcVerbose(0, "Ended.\n");
1234
1235	#ifdef DEBUG
1236	RTCritSectDelete(&g_csLog);
1237	//RTMemTrackerDumpAllToStdOut();
1238	#endif
1239
1240	VGSvcLogDestroy();
1241
1242	return rcExit;
1243	}
1244

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

source: vbox/trunk/src/VBox/Additions/common/VBoxService/VBoxService.cpp@ 69498

Download in other formats: