vbox-greeter.cpp@ 96588

Last change on this file since 96588 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 51.6 KB

Line
1	/* $Id: vbox-greeter.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2	/** @file
3	* vbox-greeter - an own LightDM greeter module supporting auto-logons
4	* controlled by the host.
5	*/
6
7	/*
8	* Copyright (C) 2012-2022 Oracle and/or its affiliates.
9	*
10	* This file is part of VirtualBox base platform packages, as
11	* available from https://www.virtualbox.org.
12	*
13	* This program is free software; you can redistribute it and/or
14	* modify it under the terms of the GNU General Public License
15	* as published by the Free Software Foundation, in version 3 of the
16	* License.
17	*
18	* This program is distributed in the hope that it will be useful, but
19	* WITHOUT ANY WARRANTY; without even the implied warranty of
20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21	* General Public License for more details.
22	*
23	* You should have received a copy of the GNU General Public License
24	* along with this program; if not, see <https://www.gnu.org/licenses>.
25	*
26	* SPDX-License-Identifier: GPL-3.0-only
27	*/
28
29
30	/*********************************************************************************************************************************
31	* Header Files *
32	*********************************************************************************************************************************/
33	#define GLIB_DISABLE_DEPRECATION_WARNINGS 1 /* g_type_init() is deprecated */
34	#include <pwd.h>
35	#include <syslog.h>
36	#include <stdlib.h>
37
38	#include <lightdm.h>
39	#ifdef VBOX_WITH_FLTK
40	# include <FL/Fl.H>
41	# include <FL/fl_ask.H> /* Yes, the casing is correct for 1.3.0 -- d'oh. */
42	# include <FL/Fl_Box.H>
43	# include <FL/Fl_Button.H>
44	# include <FL/fl_draw.H> /* Same as above. */
45	# include <FL/Fl_Double_Window.H>
46	# include <FL/Fl_Input.H>
47	# include <FL/Fl_Menu_Button.H>
48	# ifdef VBOX_GREETER_WITH_PNG_SUPPORT
49	# include <FL/Fl_PNG_Image.H>
50	# include <FL/Fl_Shared_Image.H>
51	# endif
52	# include <FL/Fl_Secret_Input.H>
53	#else
54	# include <cairo-xlib.h>
55	# include <gtk/gtk.h>
56	# include <gdk/gdkx.h>
57	#endif
58
59	#include <package-generated.h>
60	#include "product-generated.h"
61
62	#include <iprt/assert.h>
63	#include <iprt/buildconfig.h>
64	#include <iprt/env.h>
65	#include <iprt/file.h>
66	#include <iprt/getopt.h>
67	#include <iprt/initterm.h>
68	#include <iprt/mem.h>
69	#include <iprt/message.h>
70	#include <iprt/path.h>
71	#include <iprt/process.h>
72	#include <iprt/stream.h>
73	#include <iprt/system.h>
74	#include <iprt/string.h>
75	#include <iprt/thread.h>
76	#include <iprt/time.h>
77
78	#include <VBox/log.h>
79	#include <VBox/VBoxGuestLib.h>
80
81	/* The greeter's full name for logging. */
82	#define VBOX_MODULE_NAME "vbox-lightdm-greeter"
83
84	/* UI elements used in this greeter. */
85	#define VBOX_GREETER_UI_WND_GREETER "wnd_greeter"
86
87	#define VBOX_GREETER_UI_EDT_USER "edt_username"
88	#define VBOX_GREETER_UI_EDT_PASSWORD "edt_password"
89	#define VBOX_GREETER_UI_BTN_LOGIN "btn_login"
90	#define VBOX_GREETER_UI_LBL_INFO "lbl_info"
91
92	/* UI display options. */
93	/** Show the restart menu entry / button. */
94	#define VBOX_GREETER_UI_SHOW_RESTART RT_BIT(0)
95	/** Show the shutdown menu entry / button. */
96	#define VBOX_GREETER_UI_SHOW_SHUTDOWN RT_BIT(1)
97	/** Show the (customized) top banner. */
98	#define VBOX_GREETER_UI_SHOW_BANNER RT_BIT(2)
99	/** Enable custom colors */
100	#define VBOX_GREETER_UI_USE_THEMING RT_BIT(3)
101
102	/** Extracts the 8-bit red component from an uint32_t. */
103	#define VBOX_RGB_COLOR_RED(uColor) uColor & 0xFF
104	/** Extracts the 8-bit green component from an uint32_t. */
105	#define VBOX_RGB_COLOR_GREEN(uColor) (uColor >> 8) & 0xFF
106	/** Extracts the 8-bit blue component from an uint32_t. */
107	#define VBOX_RGB_COLOR_BLUE(uColor) (uColor >> 16) & 0xFF
108
109	#include <VBox/log.h>
110	#ifdef VBOX_WITH_GUEST_PROPS
111	# include <VBox/HostServices/GuestPropertySvc.h>
112	#endif
113
114	/** The program name (derived from argv[0]). */
115	char g_pszProgName = (char )"";
116	/** For debugging. */
117	#ifdef DEBUG
118	static int g_iVerbosity = 99;
119	#else
120	static int g_iVerbosity = 0;
121	#endif
122	static bool g_fRunning = true;
123
124	/** Logging parameters. */
125	/** @todo Make this configurable later. */
126	static PRTLOGGER g_pLoggerRelease = NULL;
127	static uint32_t g_cHistory = 10; /* Enable log rotation, 10 files. */
128	static uint32_t g_uHistoryFileTime = RT_SEC_1DAY; /* Max 1 day per file. */
129	static uint64_t g_uHistoryFileSize = 100 * _1M; /* Max 100MB per file. */
130
131	/**
132	* Context structure which contains all needed
133	* data within callbacks.
134	*/
135	typedef struct VBOXGREETERCTX
136	{
137	/** Pointer to this greeter instance. */
138	LightDMGreeter *pGreeter;
139	#ifdef VBOX_WITH_FLTK
140	Fl_Button *pBtnLogin;
141	Fl_Input *pEdtUsername;
142	Fl_Secret_Input *pEdtPassword;
143	Fl_Box *pLblInfo;
144	#else
145	/** The GTK builder instance for accessing
146	* the UI elements. */
147	GtkBuilder *pBuilder;
148	#endif
149	/** The timeout (in ms) to wait for credentials. */
150	uint32_t uTimeoutMS;
151	/** The starting timestamp (in ms) to calculate
152	* the timeout. */
153	uint64_t uStartMS;
154	/** Timestamp of last abort message. */
155	uint64_t uTsAbort;
156	/** The HGCM client ID. */
157	uint32_t uClientId;
158	/** The credential password. */
159	char *pszPassword;
160	} VBOXGREETERCTX, *PVBOXGREETERCTX;
161
162	static void vboxGreeterError(const char *pszFormat, ...)
163	{
164	va_list va;
165	char *buf;
166	va_start(va, pszFormat);
167	if (RTStrAPrintfV(&buf, pszFormat, va))
168	{
169	RTLogRelPrintf("%s: error: %s", VBOX_MODULE_NAME, buf);
170	RTStrFree(buf);
171	}
172	va_end(va);
173	}
174
175	static void vboxGreeterLog(const char *pszFormat, ...)
176	{
177	if (g_iVerbosity)
178	{
179	va_list va;
180	char *buf;
181	va_start(va, pszFormat);
182	if (RTStrAPrintfV(&buf, pszFormat, va))
183	{
184	/* Only do normal logging in debug mode; could contain
185	* sensitive data! */
186	RTLogRelPrintf("%s: %s", VBOX_MODULE_NAME, buf);
187	RTStrFree(buf);
188	}
189	va_end(va);
190	}
191	}
192
193	/** @tood Move the following two functions to VbglR3 (also see pam_vbox). */
194	#ifdef VBOX_WITH_GUEST_PROPS
195
196	/**
197	* Reads a guest property.
198	*
199	* @return IPRT status code.
200	* @param hPAM PAM handle.
201	* @param uClientID Guest property service client ID.
202	* @param pszKey Key (name) of guest property to read.
203	* @param fReadOnly Indicates whether this key needs to be
204	* checked if it only can be read (and not written)
205	* by the guest.
206	* @param pszValue Buffer where to store the key's value.
207	* @param cbValue Size of buffer (in bytes).
208	* @param puTimestamp Timestamp of the value
209	* retrieved. Optional.
210	*/
211	static int vbox_read_prop(uint32_t uClientID,
212	const char *pszKey, bool fReadOnly,
213	char pszValue, size_t cbValue, uint64_t puTimestamp)
214	{
215	AssertReturn(uClientID, VERR_INVALID_PARAMETER);
216	AssertPtrReturn(pszKey, VERR_INVALID_POINTER);
217	AssertPtrReturn(pszValue, VERR_INVALID_POINTER);
218	/* puTimestamp is optional. */
219
220	int rc;
221
222	uint64_t u64Timestamp = 0;
223	char *pszValTemp = NULL;
224	char *pszFlags = NULL;
225	/* The buffer for storing the data and its initial size. We leave a bit
226	* of space here in case the maximum values are raised. */
227	void *pvBuf = NULL;
228	uint32_t cbBuf = GUEST_PROP_MAX_VALUE_LEN + GUEST_PROP_MAX_FLAGS_LEN + _1K;
229
230	/* Because there is a race condition between our reading the size of a
231	* property and the guest updating it, we loop a few times here and
232	* hope. Actually this should never go wrong, as we are generous
233	* enough with buffer space. */
234	for (unsigned i = 0; i < 10; i++)
235	{
236	pvBuf = RTMemRealloc(pvBuf, cbBuf);
237	if (pvBuf)
238	{
239	rc = VbglR3GuestPropRead(uClientID, pszKey, pvBuf, cbBuf,
240	&pszValTemp, &u64Timestamp, &pszFlags,
241	&cbBuf);
242	}
243	else
244	rc = VERR_NO_MEMORY;
245
246	switch (rc)
247	{
248	case VERR_BUFFER_OVERFLOW:
249	{
250	/* Buffer too small, try it with a bigger one next time. */
251	cbBuf += _1K;
252	continue; /* Try next round. */
253	}
254
255	default:
256	break;
257	}
258
259	/* Everything except VERR_BUFFER_OVERLOW makes us bail out ... */
260	break;
261	}
262
263	if (RT_SUCCESS(rc))
264	{
265	/* Check security bits. */
266	if (pszFlags)
267	{
268	if ( fReadOnly
269	&& !RTStrStr(pszFlags, "RDONLYGUEST"))
270	{
271	/* If we want a property which is read-only on the guest
272	* and it is not marked as such, deny access! */
273	rc = VERR_ACCESS_DENIED;
274	}
275	}
276	else /* No flags, no access! */
277	rc = VERR_ACCESS_DENIED;
278
279	if (RT_SUCCESS(rc))
280	{
281	/* If everything went well copy property value to our destination buffer. */
282	if (!RTStrPrintf(pszValue, cbValue, "%s", pszValTemp))
283	rc = VERR_BUFFER_OVERFLOW;
284
285	if (puTimestamp)
286	*puTimestamp = u64Timestamp;
287	}
288	}
289
290	#ifdef DEBUG
291	vboxGreeterLog("Read guest property \"%s\"=\"%s\" (Flags: %s, TS: %RU64): %Rrc\n",
292	pszKey, pszValTemp ? pszValTemp : "<None>",
293	pszFlags ? pszFlags : "<None>", u64Timestamp, rc);
294	#endif
295
296	if (pvBuf)
297	RTMemFree(pvBuf);
298
299	return rc;
300	}
301
302	# if 0 /* unused */
303	/**
304	* Waits for a guest property to be changed.
305	*
306	* @return IPRT status code.
307	* @param hPAM PAM handle.
308	* @param uClientID Guest property service client ID.
309	* @param pszKey Key (name) of guest property to wait for.
310	* @param uTimeoutMS Timeout (in ms) to wait for the change. Specify
311	* RT_INDEFINITE_WAIT to wait indefinitly.
312	*/
313	static int vbox_wait_prop(uint32_t uClientID,
314	const char *pszKey, uint32_t uTimeoutMS)
315	{
316	AssertReturn(uClientID, VERR_INVALID_PARAMETER);
317	AssertPtrReturn(pszKey, VERR_INVALID_POINTER);
318
319	int rc;
320
321	/* The buffer for storing the data and its initial size. We leave a bit
322	* of space here in case the maximum values are raised. */
323	void *pvBuf = NULL;
324	uint32_t cbBuf = MAX_NAME_LEN + MAX_VALUE_LEN + MAX_FLAGS_LEN + _1K;
325
326	for (int i = 0; i < 10; i++)
327	{
328	void *pvTmpBuf = RTMemRealloc(pvBuf, cbBuf);
329	if (pvTmpBuf)
330	{
331	char *pszName = NULL;
332	char *pszValue = NULL;
333	uint64_t u64TimestampOut = 0;
334	char *pszFlags = NULL;
335
336	pvBuf = pvTmpBuf;
337	rc = VbglR3GuestPropWait(uClientID, pszKey, pvBuf, cbBuf,
338	0 /* Last timestamp; just wait for next event */, uTimeoutMS,
339	&pszName, &pszValue, &u64TimestampOut,
340	&pszFlags, &cbBuf, NULL);
341	}
342	else
343	rc = VERR_NO_MEMORY;
344
345	if (rc == VERR_BUFFER_OVERFLOW)
346	{
347	/* Buffer too small, try it with a bigger one next time. */
348	cbBuf += _1K;
349	continue; /* Try next round. */
350	}
351
352	/* Everything except VERR_BUFFER_OVERLOW makes us bail out ... */
353	break;
354	}
355
356	return rc;
357	}
358	# endif /* unused */
359
360	#endif /* VBOX_WITH_GUEST_PROPS */
361
362	/**
363	* Checks for credentials provided by the host / HGCM.
364	*
365	* @return IPRT status code. VERR_NOT_FOUND if no credentials are available,
366	* VINF_SUCCESS on successful retrieval or another IPRT error.
367	* @param pCtx Greeter context.
368	*/
369	static int vboxGreeterCheckCreds(PVBOXGREETERCTX pCtx)
370	{
371	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
372
373	static bool s_fCredsNotFoundMsgShown = false;
374	int rc = VbglR3CredentialsQueryAvailability();
375	if (RT_FAILURE(rc))
376	{
377	if (rc != VERR_NOT_FOUND)
378	vboxGreeterError("vboxGreeterCheckCreds: could not query for credentials! rc=%Rrc. Aborting\n", rc);
379	else if (!s_fCredsNotFoundMsgShown)
380	{
381	vboxGreeterLog("vboxGreeterCheckCreds: no credentials available\n");
382	s_fCredsNotFoundMsgShown = true;
383	}
384	}
385	else
386	{
387	/** @todo Domain handling needed? */
388	char pszUsername; / User name only is kept local. */
389	char *pszDomain = NULL;
390	rc = VbglR3CredentialsRetrieve(&pszUsername, &pCtx->pszPassword, &pszDomain);
391	if (RT_FAILURE(rc))
392	{
393	vboxGreeterError("vboxGreeterCheckCreds: could not retrieve credentials! rc=%Rrc. Aborting\n", rc);
394	}
395	else
396	{
397	vboxGreeterLog("vboxGreeterCheckCreds: credentials retrieved: user=%s, password=%s, domain=%s\n",
398	pszUsername,
399	#ifdef DEBUG
400	pCtx->pszPassword,
401	#else
402	"XXX",
403	#endif
404	pszDomain);
405	/* Trigger LightDM authentication with the user name just retrieved. */
406	lightdm_greeter_authenticate(pCtx->pGreeter, pszUsername); /* Must be the real user name from host! */
407
408	/* Securely wipe the user name + domain again. */
409	VbglR3CredentialsDestroy(pszUsername, NULL /* pszPassword */, pszDomain,
410	3 /* Three wipe passes */);
411	}
412	}
413
414	#ifdef DEBUG
415	vboxGreeterLog("vboxGreeterCheckCreds: returned with rc=%Rrc\n", rc);
416	#endif
417	return rc;
418	}
419
420	/**
421	* Called by LightDM when greeter is not needed anymore.
422	*
423	* @param signum Signal number.
424	*/
425	static void cb_sigterm(int signum)
426	{
427	RT_NOREF(signum);
428
429	/* Note: This handler must be reentrant-safe. */
430	#ifdef VBOX_WITH_FLTK
431	g_fRunning = false;
432	#else
433	exit(RTEXITCODE_SUCCESS);
434	#endif
435	}
436
437	/**
438	* Callback for showing a user prompt, issued by the LightDM server.
439	*
440	* @param pGreeter Pointer to this greeter instance.
441	* @param pszText Text to display.
442	* @param enmType Type of prompt to display.
443	* @param pvData Pointer to user-supplied data.
444	*/
445	static void cb_lightdm_show_prompt(LightDMGreeter *pGreeter,
446	const gchar *pszText, LightDMPromptType enmType,
447	gpointer pvData)
448	{
449	vboxGreeterLog("cb_lightdm_show_prompt: text=%s, type=%d\n", pszText, enmType);
450
451	PVBOXGREETERCTX pCtx = (PVBOXGREETERCTX)pvData;
452	AssertPtr(pCtx);
453
454	switch (enmType)
455	{
456	case 1: /* Password. */
457	{
458	if (pCtx->pszPassword)
459	{
460	lightdm_greeter_respond(pGreeter, pCtx->pszPassword);
461	}
462	else
463	{
464	#ifdef VBOX_WITH_FLTK
465	AssertPtr(pCtx->pEdtPassword);
466	const char *pszPwd = pCtx->pEdtPassword->value();
467	#else
468	GtkEntry *pEdtPwd = GTK_ENTRY(gtk_builder_get_object(pCtx->pBuilder, "edt_password"));
469	AssertPtr(pEdtPwd);
470	const gchar *pszPwd = gtk_entry_get_text(pEdtPwd);
471	#endif
472	lightdm_greeter_respond(pGreeter, pszPwd);
473	}
474	break;
475	}
476	/** @todo Other fields? */
477
478	default:
479	break;
480	}
481
482	VbglR3CredentialsDestroy(NULL /* pszUsername /, pCtx->pszPassword, NULL / pszDomain */,
483	3 /* Three wipe passes */);
484	pCtx->pszPassword = NULL;
485	}
486
487	/**
488	* Callback for showing a message, issued by the LightDM server.
489	*
490	* @param pGreeter Pointer to this greeter instance.
491	* @param pszText Text to display.
492	* @param enmType Type of message to display.
493	* @param pvData Pointer to user-supplied data.
494	*/
495	static void cb_lightdm_show_message(LightDMGreeter *pGreeter,
496	const gchar *pszText, LightDMPromptType enmType,
497	gpointer pvData)
498	{
499	RT_NOREF(pGreeter);
500	vboxGreeterLog("cb_lightdm_show_message: text=%s, type=%d\n", pszText, enmType);
501
502	PVBOXGREETERCTX pCtx = (PVBOXGREETERCTX)pvData;
503	AssertPtrReturnVoid(pCtx);
504
505	#ifdef VBOX_WITH_FLTK
506	AssertPtr(pCtx->pLblInfo);
507	pCtx->pLblInfo->copy_label(pszText);
508	#else
509	GtkLabel *pLblInfo = GTK_LABEL(gtk_builder_get_object(pCtx->pBuilder, "lbl_info"));
510	AssertPtr(pLblInfo);
511	gtk_label_set_text(pLblInfo, pszText);
512	#endif
513	}
514
515	/**
516	* Callback for authentication completion, issued by the LightDM server.
517	*
518	* @param pGreeter Pointer to this greeter instance.
519	*/
520	static void cb_lightdm_auth_complete(LightDMGreeter *pGreeter)
521	{
522	vboxGreeterLog("cb_lightdm_auth_complete\n");
523
524	const gchar *pszUser = lightdm_greeter_get_authentication_user(pGreeter);
525	vboxGreeterLog("authenticating user: %s\n", pszUser ? pszUser : "<NULL>");
526
527	if (lightdm_greeter_get_is_authenticated(pGreeter))
528	{
529	/** @todo Add non-default session support. */
530	gchar *pszSession = g_strdup(lightdm_greeter_get_default_session_hint(pGreeter));
531	if (pszSession)
532	{
533	vboxGreeterLog("starting session: %s\n", pszSession);
534	GError *pError = NULL;
535	if (!lightdm_greeter_start_session_sync(pGreeter, pszSession, &pError))
536	{
537	vboxGreeterError("unable to start session '%s': %s\n",
538	pszSession, pError ? pError->message : "Unknown error");
539	}
540	else
541	{
542	AssertPtr(pszSession);
543	vboxGreeterLog("session '%s' successfully started\n", pszSession);
544	}
545	if (pError)
546	g_error_free(pError);
547	g_free(pszSession);
548	}
549	else
550	vboxGreeterError("unable to get default session\n");
551	}
552	else
553	vboxGreeterLog("user not authenticated successfully (yet)\n");
554	}
555
556	/**
557	* Callback for clicking on the "Login" button.
558	*
559	* @param pWidget Widget this callback is bound to.
560	* @param pvData Pointer to user-supplied data.
561	*/
562	#ifdef VBOX_WITH_FLTK
563	void cb_btn_login(Fl_Widget pWidget, void pvData)
564	#else
565	void cb_btn_login(GtkWidget *pWidget, gpointer pvData)
566	#endif
567	{
568	PVBOXGREETERCTX pCtx = (PVBOXGREETERCTX)pvData;
569	RT_NOREF(pWidget);
570	AssertPtr(pCtx);
571
572	#ifdef VBOX_WITH_FLTK
573	AssertPtr(pCtx->pEdtUsername);
574	const char *pszUser = pCtx->pEdtUsername->value();
575	AssertPtr(pCtx->pEdtPassword);
576	const char *pszPwd = pCtx->pEdtPassword->value();
577	#else
578	GtkEntry *pEdtUser = GTK_ENTRY(gtk_builder_get_object(pCtx->pBuilder, VBOX_GREETER_UI_EDT_USER));
579	AssertPtr(pEdtUser);
580	const gchar *pszUser = gtk_entry_get_text(pEdtUser);
581
582	GtkEntry *pEdtPwd = GTK_ENTRY(gtk_builder_get_object(pCtx->pBuilder, VBOX_GREETER_UI_EDT_PASSWORD));
583	AssertPtr(pEdtPwd);
584	const gchar *pszPwd = gtk_entry_get_text(pEdtPwd);
585	#endif
586
587	/** @todo Add domain handling? */
588	vboxGreeterLog("login button pressed: greeter=%p, user=%s, password=%s\n",
589	pCtx->pGreeter,
590	pszUser ? pszUser : "<NONE>",
591	#ifdef DEBUG
592	pszPwd ? pszPwd : "<NONE>");
593	#else
594	/* Don't log passwords in release mode! */
595	"XXX");
596	#endif
597	if (strlen(pszUser)) /* Only authenticate if username is given. */
598	{
599	lightdm_greeter_respond(pCtx->pGreeter, pszPwd);
600	lightdm_greeter_authenticate(pCtx->pGreeter, pszUser);
601	}
602	}
603
604	/**
605	* Callback for clicking on the "Menu" button.
606	*
607	* @param pWidget Widget this callback is bound to.
608	* @param pvData Pointer to user-supplied data.
609	*/
610	#ifdef VBOX_WITH_FLTK
611	void cb_btn_menu(Fl_Widget pWidget, void pvData)
612	#else
613	void cb_btn_menu(GtkWidget *pWidget, gpointer pvData)
614	#endif
615	{
616	RT_NOREF(pWidget, pvData);
617	vboxGreeterLog("menu button pressed\n");
618	}
619
620	/**
621	* Callback for clicking on the "Restart" button / menu entry.
622	*
623	* @param pWidget Widget this callback is bound to.
624	* @param pvData Pointer to user-supplied data.
625	*/
626	#ifdef VBOX_WITH_FLTK
627	void cb_btn_restart(Fl_Widget pWidget, void pvData)
628	#else
629	void cb_btn_restart(GtkWidget *pWidget, gpointer pvData)
630	#endif
631	{
632	RT_NOREF(pWidget, pvData);
633	vboxGreeterLog("restart button pressed\n");
634
635	bool fRestart = true;
636	#ifdef VBOX_WITH_FLTK
637	int rc = fl_choice("Really restart the system?", "Yes", "No", NULL);
638	fRestart = rc == 0;
639	#endif
640
641	if (fRestart)
642	{
643	vboxGreeterLog("restart requested\n");
644	#ifndef DEBUG
645	lightdm_restart(NULL);
646	#endif
647	}
648	}
649
650	/**
651	* Callback for clicking on the "Shutdown" button / menu entry.
652	*
653	* @param pWidget Widget this callback is bound to.
654	* @param pvData Pointer to user-supplied data.
655	*/
656	#ifdef VBOX_WITH_FLTK
657	void cb_btn_shutdown(Fl_Widget pWidget, void pvData)
658	#else
659	void cb_btn_shutdown(GtkWidget *pWidget, gpointer pvData)
660	#endif
661	{
662	RT_NOREF(pWidget, pvData);
663	vboxGreeterLog("shutdown button pressed\n");
664
665	bool fShutdown = true;
666	#ifdef VBOX_WITH_FLTK
667	int rc = fl_choice("Really shutdown the system?", "Yes", "No", NULL);
668	fShutdown = rc == 0;
669	#endif
670
671	if (fShutdown)
672	{
673	vboxGreeterLog("shutdown requested\n");
674	#ifndef DEBUG
675	lightdm_shutdown(NULL);
676	#endif
677	}
678	}
679
680	#ifdef VBOX_WITH_FLTK
681	void cb_edt_username(Fl_Widget pWidget, void pvData)
682	#else
683	void cb_edt_username(GtkWidget *pWidget, gpointer pvData)
684	#endif
685	{
686	RT_NOREF(pWidget);
687	vboxGreeterLog("cb_edt_username called\n");
688
689	PVBOXGREETERCTX pCtx = (PVBOXGREETERCTX)pvData;
690	AssertPtr(pCtx);
691	#ifdef VBOX_WITH_FLTK
692	AssertPtr(pCtx->pEdtPassword);
693	Fl::focus(pCtx->pEdtPassword);
694	#endif
695	}
696
697	#ifdef VBOX_WITH_FLTK
698	void cb_edt_password(Fl_Widget pWidget, void pvData)
699	#else
700	void cb_edt_password(GtkWidget *pWidget, gpointer pvData)
701	#endif
702	{
703	RT_NOREF(pWidget, pvData);
704	vboxGreeterLog("cb_edt_password called\n");
705
706	PVBOXGREETERCTX pCtx = (PVBOXGREETERCTX)pvData;
707	AssertPtr(pCtx);
708	#ifdef VBOX_WITH_FLTK
709	AssertPtr(pCtx->pBtnLogin);
710	cb_btn_login(pCtx->pBtnLogin, pvData);
711	#endif
712	}
713
714	/**
715	* Callback for the timer event which is checking for new credentials
716	* from the host.
717	*
718	* @param pvData Pointer to user-supplied data.
719	*/
720	#ifdef VBOX_WITH_FLTK
721	static void cb_check_creds(void *pvData)
722	#else
723	static gboolean cb_check_creds(gpointer pvData)
724	#endif
725	{
726	PVBOXGREETERCTX pCtx = (PVBOXGREETERCTX)pvData;
727	AssertPtr(pCtx);
728
729	#ifdef DEBUG
730	vboxGreeterLog("cb_check_creds called, clientId=%RU32, timeoutMS=%RU32\n",
731	pCtx->uClientId, pCtx->uTimeoutMS);
732	#endif
733
734	int rc = VINF_SUCCESS;
735
736	#ifdef VBOX_WITH_GUEST_PROPS
737	bool fAbort = false;
738	char szVal[255];
739	if (pCtx->uClientId)
740	{
741	uint64_t tsAbort;
742	rc = vbox_read_prop(pCtx->uClientId,
743	"/VirtualBox/GuestAdd/PAM/CredsWaitAbort",
744	true /* Read-only on guest */,
745	szVal, sizeof(szVal), &tsAbort);
746	switch (rc)
747	{
748	case VINF_SUCCESS:
749	# ifdef DEBUG
750	vboxGreeterLog("cb_check_creds: tsAbort %RU64 <-> %RU64\n",
751	pCtx->uTsAbort, tsAbort);
752	# endif
753	if (tsAbort != pCtx->uTsAbort)
754	fAbort = true; /* Timestamps differs, abort. */
755	pCtx->uTsAbort = tsAbort;
756	break;
757
758	case VERR_TOO_MUCH_DATA:
759	vboxGreeterError("cb_check_creds: temporarily unable to get abort notification\n");
760	break;
761
762	case VERR_NOT_FOUND:
763	/* Value not found, continue checking for credentials. */
764	break;
765
766	default:
767	vboxGreeterError("cb_check_creds: the abort notification request failed with rc=%Rrc\n", rc);
768	fAbort = true; /* Abort on error. */
769	break;
770	}
771	}
772
773	if (fAbort)
774	{
775	/* Get optional message. */
776	szVal[0] = '\0';
777	int rc2 = vbox_read_prop(pCtx->uClientId,
778	"/VirtualBox/GuestAdd/PAM/CredsMsgWaitAbort",
779	true /* Read-only on guest */,
780	szVal, sizeof(szVal), NULL /* Timestamp. */);
781	if ( RT_FAILURE(rc2)
782	&& rc2 != VERR_NOT_FOUND)
783	vboxGreeterError("cb_check_creds: getting wait abort message failed with rc=%Rrc\n", rc2);
784	# ifdef VBOX_WITH_FLTK
785	AssertPtr(pCtx->pLblInfo);
786	pCtx->pLblInfo->copy_label(szVal);
787	# else /* !VBOX_WITH_FLTK */
788	GtkLabel *pLblInfo = GTK_LABEL(gtk_builder_get_object(pCtx->pBuilder, VBOX_GREETER_UI_LBL_INFO));
789	AssertPtr(pLblInfo);
790	gtk_label_set_text(pLblInfo, szVal);
791	# endif /* !VBOX_WITH_FLTK */
792	vboxGreeterLog("cb_check_creds: got notification from host to abort waiting\n");
793	}
794	else
795	{
796	#endif /* VBOX_WITH_GUEST_PROPS */
797	rc = vboxGreeterCheckCreds(pCtx);
798	if (RT_SUCCESS(rc))
799	{
800	/* Credentials retrieved. */
801	}
802	else if (rc == VERR_NOT_FOUND)
803	{
804	/* No credentials found, but try next round (if there's
805	* time left for) ... */
806	}
807	#ifdef VBOX_WITH_GUEST_PROPS
808	}
809	#endif /* VBOX_WITH_GUEST_PROPS */
810
811	if (rc == VERR_NOT_FOUND) /* No credential found this round. */
812	{
813	/* Calculate timeout value left after process has been started. */
814	uint64_t u64Elapsed = RTTimeMilliTS() - pCtx->uStartMS;
815	/* Is it time to bail out? */
816	if (pCtx->uTimeoutMS < u64Elapsed)
817	{
818	#ifdef VBOX_WITH_GUEST_PROPS
819	szVal[0] = '\0';
820	int rc2 = vbox_read_prop(pCtx->uClientId,
821	"/VirtualBox/GuestAdd/PAM/CredsMsgWaitTimeout",
822	true /* Read-only on guest */,
823	szVal, sizeof(szVal), NULL /* Timestamp. */);
824	if ( RT_FAILURE(rc2)
825	&& rc2 != VERR_NOT_FOUND)
826	vboxGreeterError("cb_check_creds: getting wait timeout message failed with rc=%Rrc\n", rc2);
827	# ifdef VBOX_WITH_FLTK
828	AssertPtr(pCtx->pLblInfo);
829	pCtx->pLblInfo->copy_label(szVal);
830	# else
831	GtkLabel *pLblInfo = GTK_LABEL(gtk_builder_get_object(pCtx->pBuilder, VBOX_GREETER_UI_LBL_INFO));
832	AssertPtr(pLblInfo);
833	gtk_label_set_text(pLblInfo, szVal);
834	# endif
835	#endif /* VBOX_WITH_GUEST_PROPS */
836	vboxGreeterLog("cb_check_creds: no credentials retrieved within time (%RU32ms), giving up\n",
837	pCtx->uTimeoutMS);
838	rc = VERR_TIMEOUT;
839	}
840	}
841
842	#ifdef DEBUG
843	vboxGreeterLog("cb_check_creds returned with rc=%Rrc\n", rc);
844	#endif
845
846	/* At the moment we only allow one shot from the host,
847	* so setting credentials in a second attempt won't be possible
848	* intentionally. */
849
850	if (rc == VERR_NOT_FOUND)
851	#ifdef VBOX_WITH_FLTK
852	Fl::repeat_timeout(0.5 /* 500 ms */, cb_check_creds, pvData);
853	#else
854	return TRUE; /* No credentials found, do another round. */
855
856	return FALSE; /* Remove timer source on every other error / status. */
857	#endif
858	}
859
860	/**
861	* Release logger callback.
862	*
863	* @return IPRT status code.
864	* @param pLoggerRelease
865	* @param enmPhase
866	* @param pfnLog
867	*/
868	static DECLCALLBACK(void) vboxGreeterLogHeaderFooter(PRTLOGGER pLoggerRelease, RTLOGPHASE enmPhase, PFNRTLOGPHASEMSG pfnLog)
869	{
870	/* Some introductory information. */
871	static RTTIMESPEC s_TimeSpec;
872	char szTmp[256];
873	if (enmPhase == RTLOGPHASE_BEGIN)
874	RTTimeNow(&s_TimeSpec);
875	RTTimeSpecToString(&s_TimeSpec, szTmp, sizeof(szTmp));
876
877	switch (enmPhase)
878	{
879	case RTLOGPHASE_BEGIN:
880	{
881	pfnLog(pLoggerRelease,
882	"vbox-greeter %s r%s (verbosity: %d) %s (%s %s) release log\n"
883	"Log opened %s\n",
884	RTBldCfgVersion(), RTBldCfgRevisionStr(), g_iVerbosity, VBOX_BUILD_TARGET,
885	__DATE__, __TIME__, szTmp);
886
887	int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
888	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
889	pfnLog(pLoggerRelease, "OS Product: %s\n", szTmp);
890	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
891	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
892	pfnLog(pLoggerRelease, "OS Release: %s\n", szTmp);
893	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
894	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
895	pfnLog(pLoggerRelease, "OS Version: %s\n", szTmp);
896	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
897	pfnLog(pLoggerRelease, "OS Service Pack: %s\n", szTmp);
898
899	/* the package type is interesting for Linux distributions */
900	char szExecName[RTPATH_MAX];
901	char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
902	pfnLog(pLoggerRelease,
903	"Executable: %s\n"
904	"Process ID: %u\n"
905	"Package type: %s"
906	#ifdef VBOX_OSE
907	" (OSE)"
908	#endif
909	"\n",
910	pszExecName ? pszExecName : "unknown",
911	RTProcSelf(),
912	VBOX_PACKAGE_STRING);
913	break;
914	}
915
916	case RTLOGPHASE_PREROTATE:
917	pfnLog(pLoggerRelease, "Log rotated - Log started %s\n", szTmp);
918	break;
919
920	case RTLOGPHASE_POSTROTATE:
921	pfnLog(pLoggerRelease, "Log continuation - Log started %s\n", szTmp);
922	break;
923
924	case RTLOGPHASE_END:
925	pfnLog(pLoggerRelease, "End of log file - Log started %s\n", szTmp);
926	break;
927
928	default:
929	/* nothing */;
930	}
931	}
932
933	/**
934	* Creates the default release logger outputting to the specified file.
935	*
936	* @return IPRT status code.
937	* @param pszLogFile Filename for log output. Optional.
938	*/
939	static int vboxGreeterLogCreate(const char *pszLogFile)
940	{
941	/* Create release logger (stdout + file). */
942	static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
943	RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD \| RTLOGFLAGS_PREFIX_TIME_PROG;
944	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
945	fFlags \|= RTLOGFLAGS_USECRLF;
946	#endif
947	int rc = RTLogCreateEx(&g_pLoggerRelease, "VBOXGREETER_RELEASE_LOG", fFlags, "all",
948	RT_ELEMENTS(s_apszGroups), s_apszGroups, UINT32_MAX /cMaxEntriesPerGroup/,
949	0 /cBufDescs/, NULL /paBufDescs/, RTLOGDEST_STDOUT,
950	vboxGreeterLogHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
951	NULL /pOutputIf/, NULL /pvOutputIfUser/,
952	NULL /pErrInfo/, pszLogFile);
953	if (RT_SUCCESS(rc))
954	{
955	/* register this logger as the release logger */
956	RTLogRelSetDefaultInstance(g_pLoggerRelease);
957
958	/* Explicitly flush the log in case of VBOXGREETER_RELEASE_LOG_FLAGS=buffered. */
959	RTLogFlush(g_pLoggerRelease);
960	}
961
962	return rc;
963	}
964
965	static void vboxGreeterLogDestroy(void)
966	{
967	RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
968	}
969
970	static int vboxGreeterUsage(void)
971	{
972	RTPrintf("Usage:\n"
973	" %-12s [-h\|-?\|--help] [-F\|--logfile <file>]\n"
974	" [-v\|--verbose] [-V\|--version]\n", g_pszProgName);
975
976	RTPrintf("\n"
977	" Copyright (C) 2012-" VBOX_C_YEAR " " VBOX_VENDOR "\n");
978
979	return RTEXITCODE_SYNTAX;
980	}
981
982	int main(int argc, char **argv)
983	{
984	int rc = RTR3InitExe(argc, &argv, 0);
985	if (RT_FAILURE(rc))
986	return RTMsgInitFailure(rc);
987	g_pszProgName = RTPathFilename(argv[0]);
988
989	static const RTGETOPTDEF s_aOptions[] =
990	{
991	{ "--logfile", 'F', RTGETOPT_REQ_STRING },
992	{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
993	{ "--version", 'V', RTGETOPT_REQ_NOTHING }
994	};
995
996	char szLogFile[RTPATH_MAX + 128] = "";
997
998	int ch;
999	RTGETOPTUNION ValueUnion;
1000	RTGETOPTSTATE GetState;
1001	RTGetOptInit(&GetState, argc, argv,
1002	s_aOptions, RT_ELEMENTS(s_aOptions),
1003	1 /iFirst/, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1004
1005	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
1006	&& RT_SUCCESS(rc))
1007	{
1008	/* For options that require an argument, ValueUnion has received the value. */
1009	switch (ch)
1010	{
1011	case 'F':
1012	if (!RTStrPrintf(szLogFile, sizeof(szLogFile), "%s", ValueUnion.psz))
1013	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to get prepare log file name");
1014	break;
1015
1016	case 'h':
1017	case '?':
1018	return vboxGreeterUsage();
1019
1020	case 'v': /* Raise verbosity. */
1021	g_iVerbosity++;
1022	break;
1023
1024	case 'V': /* Print version and exit. */
1025	RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
1026	return RTEXITCODE_SUCCESS;
1027	break; /* Never reached. */
1028
1029	default:
1030	return RTGetOptPrintError(ch, &ValueUnion);
1031	}
1032	}
1033
1034	if (RT_FAILURE(rc))
1035	return RTEXITCODE_SYNTAX;
1036
1037	rc = VbglR3InitUser();
1038	if (RT_FAILURE(rc))
1039	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to init Vbgl (%Rrc)", rc);
1040
1041	rc = vboxGreeterLogCreate(strlen(szLogFile) ? szLogFile : NULL);
1042	if (RT_FAILURE(rc))
1043	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to create release log (%s, %Rrc)",
1044	strlen(szLogFile) ? szLogFile : "<None>", rc);
1045
1046	vboxGreeterLog("init\n");
1047
1048	signal(SIGTERM, cb_sigterm);
1049
1050	/** @todo This function already is too long. Move code into
1051	* functions. */
1052
1053	VBOXGREETERCTX ctx;
1054	RT_ZERO(ctx);
1055
1056	/* UI parameters. */
1057	uint32_t uBgColor = 0; /* The background color. */
1058	uint32_t uLogonDlgHdrColor = 0;
1059	uint32_t uLogonDlgBgColor = 0; /* The greeter's dialog color. */
1060	uint32_t uLogonDlgBtnColor = 0; /* The greeter's button color. */
1061
1062	#ifdef VBOX_GREETER_WITH_PNG_SUPPORT
1063	char szBannerPath[RTPATH_MAX];
1064	#endif
1065
1066	/* By default most UI elements are shown. */
1067	uint32_t uOptsUI = VBOX_GREETER_UI_SHOW_RESTART
1068	\| VBOX_GREETER_UI_SHOW_SHUTDOWN;
1069	#ifdef VBOX_WITH_GUEST_PROPS
1070	uint32_t uClientId = 0;
1071	rc = VbglR3GuestPropConnect(&uClientId);
1072	if (RT_SUCCESS(rc))
1073	{
1074	vboxGreeterLog("clientId=%RU32\n", uClientId);
1075
1076	ctx.uClientId = uClientId;
1077
1078	char szVal[256];
1079	int rc2 = vbox_read_prop(uClientId,
1080	"/VirtualBox/GuestAdd/Greeter/HideRestart",
1081	true /* Read-only on guest */,
1082	szVal, sizeof(szVal), NULL /* Timestamp. */);
1083	if ( RT_SUCCESS(rc2)
1084	&& !RTStrICmp(szVal, "1"))
1085	{
1086	uOptsUI &= ~VBOX_GREETER_UI_SHOW_RESTART;
1087	}
1088
1089	rc2 = vbox_read_prop(uClientId,
1090	"/VirtualBox/GuestAdd/Greeter/HideShutdown",
1091	true /* Read-only on guest */,
1092	szVal, sizeof(szVal), NULL /* Timestamp. */);
1093	if ( RT_SUCCESS(rc2)
1094	&& !RTStrICmp(szVal, "1"))
1095	{
1096	uOptsUI &= ~VBOX_GREETER_UI_SHOW_SHUTDOWN;
1097	}
1098
1099	# ifdef VBOX_GREETER_WITH_PNG_SUPPORT
1100	/* Load the banner. */
1101	rc2 = vbox_read_prop(uClientId,
1102	"/VirtualBox/GuestAdd/Greeter/BannerPath",
1103	true /* Read-only on guest */,
1104	szBannerPath, sizeof(szBannerPath), NULL /* Timestamp. */);
1105	if (RT_SUCCESS(rc2))
1106	{
1107	if (RTFileExists(szBannerPath))
1108	{
1109	vboxGreeterLog("showing banner from '%s'\n", szBannerPath);
1110	uOptsUI \|= VBOX_GREETER_UI_SHOW_BANNER;
1111	}
1112	else
1113	vboxGreeterLog("warning: unable to find banner at '%s', skipping\n", szBannerPath);
1114	}
1115	# endif /* VBOX_GREETER_WITH_PNG_SUPPORT */
1116
1117	/* Use theming?. */
1118	rc2 = vbox_read_prop(uClientId,
1119	"/VirtualBox/GuestAdd/Greeter/UseTheming",
1120	true /* Read-only on guest */,
1121	szVal, sizeof(szVal), NULL /* Timestamp. */);
1122	if ( RT_SUCCESS(rc2)
1123	&& !RTStrICmp(szVal, "1"))
1124	{
1125	vboxGreeterLog("custom theming enabled\n");
1126	uOptsUI \|= VBOX_GREETER_UI_USE_THEMING;
1127	}
1128
1129	if (uOptsUI & VBOX_GREETER_UI_USE_THEMING)
1130	{
1131	/* Get background color. */
1132	rc2 = vbox_read_prop(uClientId,
1133	"/VirtualBox/GuestAdd/Greeter/Theme/BackgroundColor",
1134	true /* Read-only on guest */,
1135	szVal, sizeof(szVal), NULL /* Timestamp. */);
1136	if (RT_SUCCESS(rc2))
1137	{
1138	uBgColor = strtol(szVal, NULL,
1139	/* Change conversion base when having a 0x prefix. */
1140	RTStrStr(szVal, "0x") == szVal ? 0 : 16);
1141	}
1142
1143	/* Logon dialog. */
1144
1145	/* Get header color. */
1146	rc2 = vbox_read_prop(uClientId,
1147	"/VirtualBox/GuestAdd/Greeter/Theme/LogonDialog/HeaderColor",
1148	true /* Read-only on guest */,
1149	szVal, sizeof(szVal), NULL /* Timestamp. */);
1150	if (RT_SUCCESS(rc2))
1151	{
1152	uLogonDlgHdrColor = strtol(szVal, NULL,
1153	/* Change conversion base when having a 0x prefix. */
1154	RTStrStr(szVal, "0x") == szVal ? 0 : 16);
1155	}
1156
1157	/* Get dialog color. */
1158	rc2 = vbox_read_prop(uClientId,
1159	"/VirtualBox/GuestAdd/Greeter/Theme/LogonDialog/BackgroundColor",
1160	true /* Read-only on guest */,
1161	szVal, sizeof(szVal), NULL /* Timestamp. */);
1162	if (RT_SUCCESS(rc2))
1163	{
1164	uLogonDlgBgColor = strtol(szVal, NULL,
1165	/* Change conversion base when having a 0x prefix. */
1166	RTStrStr(szVal, "0x") == szVal ? 0 : 16);
1167	}
1168
1169	/* Get button color. */
1170	rc2 = vbox_read_prop(uClientId,
1171	"/VirtualBox/GuestAdd/Greeter/Theme/LogonDialog/ButtonColor",
1172	true /* Read-only on guest */,
1173	szVal, sizeof(szVal), NULL /* Timestamp. */);
1174	if (RT_SUCCESS(rc2))
1175	{
1176	uLogonDlgBtnColor = strtol(szVal, NULL,
1177	/* Change conversion base when having a 0x prefix. */
1178	RTStrStr(szVal, "0x") == szVal ? 0 : 16);
1179	}
1180	}
1181	}
1182	else
1183	vboxGreeterError("unable to connect to guest property service, rc=%Rrc\n", rc);
1184	#endif
1185	vboxGreeterLog("UI options are: %RU32\n", uOptsUI);
1186
1187	#ifdef VBOX_WITH_FLTK
1188	int rc2 = Fl::scheme("plastic");
1189	if (!rc2)
1190	vboxGreeterLog("warning: unable to set visual scheme\n");
1191
1192	Fl::visual(FL_DOUBLE \| FL_INDEX);
1193	Fl_Double_Window *pWndMain = new Fl_Double_Window(Fl::w(), Fl::h(), "VirtualBox Guest Additions");
1194	AssertPtr(pWndMain);
1195	if (uOptsUI & VBOX_GREETER_UI_USE_THEMING)
1196	pWndMain->color(fl_rgb_color(VBOX_RGB_COLOR_RED(uBgColor),
1197	VBOX_RGB_COLOR_GREEN(uBgColor),
1198	VBOX_RGB_COLOR_BLUE(uBgColor)));
1199	else /* Default colors. */
1200	pWndMain->color(fl_rgb_color(0x73, 0x7F, 0x8C));
1201
1202	Fl_Double_Window *pWndGreeter = new Fl_Double_Window(500, 350);
1203	AssertPtr(pWndGreeter);
1204	pWndGreeter->set_modal();
1205	if (uOptsUI & VBOX_GREETER_UI_USE_THEMING)
1206	pWndGreeter->color(fl_rgb_color(VBOX_RGB_COLOR_RED(uLogonDlgBgColor),
1207	VBOX_RGB_COLOR_GREEN(uLogonDlgBgColor),
1208	VBOX_RGB_COLOR_BLUE(uLogonDlgBgColor)));
1209	else /* Default colors. */
1210	pWndGreeter->color(fl_rgb_color(255, 255, 255));
1211
1212	uint32_t uOffsetX = 130;
1213	/**
1214	* For now we're using a simple Y offset for moving all elements
1215	* down if a banner needs to be shown on top of the greeter. Not
1216	* very clean but does the job. Use some more layouting stuff
1217	* when this gets more complex.
1218	*/
1219	uint32_t uOffsetY = 80;
1220
1221	# ifdef VBOX_GREETER_WITH_PNG_SUPPORT
1222	fl_register_images();
1223
1224	/** @todo Add basic image type detection based on file
1225	* extension. */
1226
1227	Fl_PNG_Image *pImgBanner = NULL;
1228	if (uOptsUI & VBOX_GREETER_UI_SHOW_BANNER)
1229	{
1230	pImgBanner = new Fl_PNG_Image(szBannerPath);
1231	AssertPtr(pImgBanner);
1232
1233	/** @todo Make the banner size configurable via guest
1234	* properties. For now it's hardcoded to 460 x 90px. */
1235	Fl_Box *pBoxBanner = new Fl_Box(20, uOffsetY, 460, 90, "");
1236	AssertPtr(pBoxBanner);
1237	pBoxBanner->image(pImgBanner);
1238
1239	uOffsetY = 120;
1240	}
1241	# endif
1242
1243	Fl_Box *pLblHeader = new Fl_Box(FL_NO_BOX, 242, uOffsetY, 300, 20,
1244	"Desktop Login");
1245	AssertPtr(pLblHeader);
1246
1247	/** Note to use an own font:
1248	* Fl_Font myfnt = FL_FREE_FONT + 1;
1249	* Fl::set_font(myfnt, "MyFont"); */
1250	Fl_Font fntHeader = FL_FREE_FONT;
1251	Fl::set_font(fntHeader, "Courier");
1252
1253	pLblHeader->align(FL_ALIGN_LEFT);
1254	pLblHeader->labelfont(FL_BOLD);
1255	pLblHeader->labelsize(24);
1256	if (uOptsUI & VBOX_GREETER_UI_USE_THEMING)
1257	pLblHeader->labelcolor(fl_rgb_color(VBOX_RGB_COLOR_RED(uLogonDlgHdrColor),
1258	VBOX_RGB_COLOR_GREEN(uLogonDlgHdrColor),
1259	VBOX_RGB_COLOR_BLUE(uLogonDlgHdrColor)));
1260	else /* Default color. */
1261	pLblHeader->labelcolor(fl_rgb_color(0x51, 0x5F, 0x77));
1262	uOffsetY += 40;
1263
1264	/** @todo Add basic NLS support. */
1265
1266	Fl_Input *pEdtUsername = new Fl_Input(uOffsetX, uOffsetY,
1267	300, 20, "User Name");
1268	AssertPtr(pEdtUsername);
1269	pEdtUsername->callback(cb_edt_username, &ctx);
1270	pEdtUsername->when(FL_WHEN_ENTER_KEY_ALWAYS);
1271	Fl::focus(pEdtUsername);
1272	ctx.pEdtUsername = pEdtUsername;
1273
1274	Fl_Secret_Input *pEdtPassword = new Fl_Secret_Input(uOffsetX, uOffsetY + 40,
1275	300, 20, "Password");
1276	AssertPtr(pEdtPassword);
1277	pEdtPassword->callback(cb_edt_password, &ctx);
1278	pEdtPassword->when(FL_WHEN_ENTER_KEY_ALWAYS);
1279	ctx.pEdtPassword = pEdtPassword;
1280
1281	Fl_Button *pBtnLogin = new Fl_Button(uOffsetX, uOffsetY + 70,
1282	100, 40, "Log In");
1283	AssertPtr(pBtnLogin);
1284	pBtnLogin->callback(cb_btn_login, &ctx);
1285	if (uOptsUI & VBOX_GREETER_UI_USE_THEMING)
1286	pBtnLogin->color(fl_rgb_color(VBOX_RGB_COLOR_RED(uLogonDlgBtnColor),
1287	VBOX_RGB_COLOR_GREEN(uLogonDlgBtnColor),
1288	VBOX_RGB_COLOR_BLUE(uLogonDlgBtnColor)));
1289	else /* Default color. */
1290	pBtnLogin->color(fl_rgb_color(255, 255, 255));
1291	ctx.pBtnLogin = pBtnLogin;
1292
1293	Fl_Menu_Button *pBtnMenu = new Fl_Menu_Button(uOffsetX + 120, uOffsetY + 70,
1294	100, 40, "Options");
1295	AssertPtr(pBtnMenu);
1296	pBtnMenu->callback(cb_btn_menu, &ctx);
1297	if (uOptsUI & VBOX_GREETER_UI_USE_THEMING)
1298	pBtnMenu->color(fl_rgb_color(VBOX_RGB_COLOR_RED(uLogonDlgBtnColor),
1299	VBOX_RGB_COLOR_GREEN(uLogonDlgBtnColor),
1300	VBOX_RGB_COLOR_BLUE(uLogonDlgBtnColor)));
1301	else /* Default color. */
1302	pBtnMenu->color(fl_rgb_color(255, 255, 255));
1303
1304	if (uOptsUI & VBOX_GREETER_UI_SHOW_RESTART)
1305	pBtnMenu->add("Restart", "" /* Shortcut /, cb_btn_restart, &ctx, 0 / Flags */);
1306	if (uOptsUI & VBOX_GREETER_UI_SHOW_SHUTDOWN)
1307	pBtnMenu->add("Shutdown", "" /* Shortcut /, cb_btn_shutdown, &ctx, 0 / Flags */);
1308
1309	char szLabel[255];
1310	RTStrPrintf(szLabel, sizeof(szLabel), "Oracle VM VirtualBox Guest Additions %sr%s",
1311	RTBldCfgVersion(), RTBldCfgRevisionStr());
1312	Fl_Box *pLblInfo = new Fl_Box(FL_NO_BOX , 50, uOffsetY + 150,
1313	400, 20, szLabel);
1314	AssertPtr(pLblInfo);
1315	ctx.pLblInfo = pLblInfo;
1316
1317	pWndGreeter->end();
1318	pWndGreeter->position((Fl::w() - pWndGreeter->w()) / 2,
1319	(Fl::h() - pWndGreeter->h()) / 2);
1320
1321	pWndMain->fullscreen();
1322	pWndMain->show(argc, argv);
1323	pWndMain->end();
1324
1325	pWndGreeter->show();
1326	#else /* !VBOX_WITH_FLTK */
1327	gtk_init(&argc, &argv);
1328
1329	/* Set default cursor */
1330	gdk_window_set_cursor(gdk_get_default_root_window(), gdk_cursor_new(GDK_LEFT_PTR));
1331
1332	GError *pError = NULL;
1333	GtkBuilder *pBuilder = gtk_builder_new();
1334	AssertPtr(pBuilder);
1335	if (!gtk_builder_add_from_file(pBuilder, "/usr/share/xgreeters/vbox-greeter.ui", &pError))
1336	{
1337	AssertPtr(pError);
1338	vboxGreeterError("unable to load UI: %s", pError->message);
1339	return RTEXITCODE_FAILURE;
1340	}
1341
1342	GtkWindow *pWndGreeter = GTK_WINDOW(gtk_builder_get_object(pBuilder, VBOX_GREETER_UI_WND_GREETER));
1343	AssertPtr(pWndGreeter);
1344	GtkButton *pBtnLogin = GTK_BUTTON(gtk_builder_get_object(pBuilder, VBOX_GREETER_UI_BTN_LOGIN));
1345	AssertPtr(pBtnLogin);
1346	GtkLabel *pLblInfo = GTK_LABEL(gtk_builder_get_object(pBuilder, VBOX_GREETER_UI_LBL_INFO));
1347	AssertPtr(pLblInfo);
1348
1349	ctx.pBuilder = pBuilder;
1350
1351	g_signal_connect(G_OBJECT(pBtnLogin), "clicked", G_CALLBACK(cb_btn_login), &ctx);
1352
1353	GdkRectangle rectScreen;
1354	gdk_screen_get_monitor_geometry(gdk_screen_get_default(), gdk_screen_get_primary_monitor(gdk_screen_get_default()), &rectScreen);
1355	vboxGreeterLog("monitor (default) is %dx%d\n", rectScreen.width, rectScreen.height);
1356
1357	gint iWndX, iWndY;
1358	gtk_window_get_default_size(pWndGreeter, &iWndX, &iWndY);
1359	vboxGreeterLog("greeter is %dx%d\n", iWndX, iWndY);
1360
1361	gtk_window_move(pWndGreeter,
1362	(rectScreen.width / 2) - (iWndX / 2),
1363	(rectScreen.height / 2) - (iWndY / 2));
1364	gtk_widget_show(GTK_WIDGET(pWndGreeter));
1365
1366	g_clear_error(&pError);
1367	#endif /* !VBOX_WITH_FLTK */
1368
1369	/* GType is needed in any case (for LightDM), whether we
1370	* use GTK3 or not. */
1371	g_type_init();
1372
1373	GMainLoop pMainLoop = g_main_loop_new(NULL, FALSE / Not yet running */);
1374	AssertPtr(pMainLoop); NOREF(pMainLoop);
1375
1376	LightDMGreeter *pGreeter = lightdm_greeter_new();
1377	AssertPtr(pGreeter);
1378
1379	g_signal_connect(pGreeter, "show-prompt", G_CALLBACK(cb_lightdm_show_prompt), &ctx);
1380	g_signal_connect(pGreeter, "show-message", G_CALLBACK(cb_lightdm_show_message), &ctx);
1381	g_signal_connect(pGreeter, "authentication-complete", G_CALLBACK(cb_lightdm_auth_complete), &ctx);
1382
1383	ctx.pGreeter = pGreeter;
1384
1385	if (!lightdm_greeter_connect_sync(pGreeter, NULL))
1386	{
1387	vboxGreeterError("unable to connect to LightDM server, aborting\n");
1388	return RTEXITCODE_FAILURE;
1389	}
1390
1391	vboxGreeterLog("connected to LightDM server\n");
1392
1393	#ifdef VBOX_WITH_GUEST_PROPS
1394	bool fCheckCreds = false;
1395	if (uClientId) /* Connected to guest property service? */
1396	{
1397	char szVal[256];
1398	rc2 = vbox_read_prop(uClientId,
1399	"/VirtualBox/GuestAdd/PAM/CredsWait",
1400	true /* Read-only on guest */,
1401	szVal, sizeof(szVal), NULL /* Timestamp. */);
1402	if (RT_SUCCESS(rc2))
1403	{
1404	uint32_t uTimeoutMS = RT_INDEFINITE_WAIT; /* Wait infinite by default. */
1405	rc2 = vbox_read_prop(uClientId,
1406	"/VirtualBox/GuestAdd/PAM/CredsWaitTimeout",
1407	true /* Read-only on guest */,
1408	szVal, sizeof(szVal), NULL /* Timestamp. */);
1409	if (RT_SUCCESS(rc2))
1410	{
1411	uTimeoutMS = RTStrToUInt32(szVal);
1412	if (!uTimeoutMS)
1413	{
1414	vboxGreeterError("pam_vbox_authenticate: invalid waiting timeout value specified, defaulting to infinite timeout\n");
1415	uTimeoutMS = RT_INDEFINITE_WAIT;
1416	}
1417	else
1418	uTimeoutMS = uTimeoutMS * 1000; /* Make ms out of s. */
1419	}
1420
1421	ctx.uTimeoutMS = uTimeoutMS;
1422
1423	rc2 = vbox_read_prop(uClientId,
1424	"/VirtualBox/GuestAdd/PAM/CredsMsgWaiting",
1425	true /* Read-only on guest */,
1426	szVal, sizeof(szVal), NULL /* Timestamp. */);
1427	if (RT_SUCCESS(rc2))
1428	{
1429	# ifdef VBOX_WITH_FLTK
1430	Assert(pLblInfo);
1431	pLblInfo->copy_label(szVal);
1432	# else
1433	gtk_label_set_text(pLblInfo, szVal);
1434	# endif
1435	}
1436
1437	/* Get initial timestamp so that we can compare the time
1438	* whether the value has been changed or not in our event callback. */
1439	vbox_read_prop(uClientId,
1440	"/VirtualBox/GuestAdd/PAM/CredsWaitAbort",
1441	true /* Read-only on guest */,
1442	szVal, sizeof(szVal), &ctx.uTsAbort);
1443
1444	if (RT_SUCCESS(rc))
1445	{
1446	/* Before we actuall wait for credentials just make sure we didn't already get credentials
1447	* set so that we can skip waiting for them ... */
1448	rc2 = vboxGreeterCheckCreds(&ctx);
1449	if (rc2 == VERR_NOT_FOUND)
1450	{
1451	/* Get current time stamp to later calculate rest of timeout left. */
1452	ctx.uStartMS = RTTimeMilliTS();
1453
1454	fCheckCreds = true;
1455	}
1456	}
1457	}
1458
1459	/* Start the timer to check credentials availability. */
1460	if (fCheckCreds)
1461	{
1462	vboxGreeterLog("No credentials available on startup, starting to check periodically ...\n");
1463	# ifdef VBOX_WITH_FLTK
1464	Fl::add_timeout(0.5 /* 500 ms */, cb_check_creds, &ctx);
1465	# else
1466	g_timeout_add(500 /* ms */, (GSourceFunc)cb_check_creds, &ctx);
1467	# endif
1468	}
1469	}
1470	#endif /* VBOX_WITH_GUEST_PROPS */
1471
1472	#ifdef VBOX_WITH_FLTK
1473	/*
1474	* Do own GDK main loop processing because FLTK also needs
1475	* to have the chance of processing its events.
1476	*/
1477	GMainContext *pMainCtx = g_main_context_default();
1478	AssertPtr(pMainCtx);
1479
1480	while (g_fRunning)
1481	{
1482	g_main_context_iteration(pMainCtx,
1483	FALSE /* No blocking */);
1484	Fl::check();
1485	RTThreadSleep(10); /* Wait a bit, don't hog the CPU too much. */
1486	}
1487
1488	g_main_context_unref(pMainCtx);
1489
1490	# ifdef VBOX_GREETER_WITH_PNG_SUPPORT
1491	if (pImgBanner)
1492	{
1493	delete pImgBanner; /* Call destructor to free bitmap data. */
1494	pImgBanner = NULL;
1495	}
1496	# endif /* VBOX_GREETER_WITH_PNG_SUPPORT */
1497	#else /* !VBOX_WITH_FLTK */
1498	gtk_main();
1499	/** @todo Never reached so far. LightDM sends a SIGTERM. */
1500	#endif /* !VBOX_WITH_FLTK */
1501
1502	vboxGreeterLog("terminating\n");
1503
1504	#ifdef VBOX_WITH_GUEST_PROPS
1505	if (uClientId)
1506	{
1507	rc2 = VbglR3GuestPropDisconnect(uClientId);
1508	AssertRC(rc2);
1509	}
1510	#endif /* VBOX_WITH_GUEST_PROPS */
1511
1512	VbglR3Term();
1513
1514	RTEXITCODE rcExit = RT_SUCCESS(rc)
1515	? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1516
1517	vboxGreeterLog("terminated with exit code %ld (rc=%Rrc)\n",
1518	rcExit, rc);
1519
1520	vboxGreeterLogDestroy();
1521
1522	return rcExit;
1523	}
1524
1525	#ifdef DEBUG
1526	DECLEXPORT(void) RTAssertMsg1Weak(const char pszExpr, unsigned uLine, const char pszFile, const char *pszFunction)
1527	{
1528	RTAssertMsg1(pszExpr, uLine, pszFile, pszFunction);
1529	}
1530	#endif
1531

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

source: vbox/trunk/src/VBox/Additions/linux/lightdm-greeter/vbox-greeter.cpp@ 96588

Download in other formats: