app.cpp

/* SLiM - Simple Login Manager
   Copyright (C) 1997, 1998 Per Liden
   Copyright (C) 2004-06 Simone Rota <sip@varlock.com>
   Copyright (C) 2004-06 Johannes Winkelmann <jw@tks6.net>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
*/

#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_PROCCTL
#include <sys/procctl.h>
#endif
#include <unistd.h>
#include <fcntl.h>
#include <stdint.h>
#include <limits.h>
#include <login_cap.h>
#include <cerrno>
#include <cstring>
#include <cstdio>
#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>

#include "app.h"
#include "numlock.h"
#include "util.h"

#ifdef HAVE_SHADOW
#include <shadow.h>
#endif

using namespace std;

static const int LOGIN_CAP_VAR_COUNT = 4;
static const char* LOGIN_CAP_VARS[] = {
	"lang",
	"charset",
	"timezone",
	"manpath",
};
static const char* LOGIN_CAP_ENVS[] = {
	"LANG",
	"MM_CHARSET",
	"TZ",
	"MANPATH",
};

#ifdef USE_PAM
#include <string>

int conv(int num_msg, const struct pam_message **msg,
		 struct pam_response **resp, void *appdata_ptr){
	if (num_msg <= 0 || resp == NULL)
		return PAM_BUF_ERR;
	*resp = static_cast<pam_response*>(calloc(num_msg, sizeof(pam_response)));
	if (*resp == NULL)
		return PAM_BUF_ERR;
	Panel* panel = *static_cast<Panel**>(appdata_ptr);
	int result = PAM_SUCCESS;
	for (int i=0; i<num_msg; i++){
		(*resp)[i].resp=0;
		(*resp)[i].resp_retcode=0;
		switch(msg[i]->msg_style){
			case PAM_PROMPT_ECHO_ON:
				/* We assume PAM is asking for the username */
				panel->EventHandler(Panel::Get_Name);
				switch(panel->getAction()){
					case Panel::Suspend:
					case Panel::Halt:
					case Panel::Reboot:
						(*resp)[i].resp=strdup("root");
						break;

					case Panel::Console:
					case Panel::Exit:
					case Panel::Login:
						(*resp)[i].resp=strdup(panel->GetName().c_str());
						break;
					case Panel::Restart:
						result=PAM_CONV_ERR;
						break;
					case Panel::Theme:
						result=PAM_CONV_ERR;
						break;
					default:
						break;
				}
				break;

			case PAM_PROMPT_ECHO_OFF:
				/* We assume PAM is asking for the password */
				switch(panel->getAction()){
					case Panel::Console:
					case Panel::Exit:
					case Panel::Restart:
					case Panel::Theme:
						/* We should leave now! */
						result=PAM_CONV_ERR;
						break;

					default:
						panel->EventHandler(Panel::Get_Passwd);
						(*resp)[i].resp=strdup(panel->GetPasswd().c_str());
						break;
				}
				break;

			case PAM_ERROR_MSG:
			case PAM_TEXT_INFO:
				/* We simply write these to the log
				   TODO: Maybe we should simply ignore them */
				logStream << APPNAME << ": " << msg[i]->msg << endl;
				break;
		}
		if (result!=PAM_SUCCESS) break;
	}
	if (result!=PAM_SUCCESS){
		for (int i=0; i<num_msg; i++){
			if ((*resp)[i].resp==0) continue;
			free((*resp)[i].resp);
			(*resp)[i].resp=0;
		};
		free(*resp);
		*resp=0;
	};
	return result;
}
#endif

extern App* LoginApp;

int xioerror(Display *disp) {
	LoginApp->RestartServer();
	return 0;
}

void CatchSignal(int sig) {
	logStream << APPNAME << ": unexpected signal " << sig << endl;

	if (LoginApp->isServerStarted())
		LoginApp->StopServer();

	LoginApp->RemoveLock();
	exit(ERR_EXIT);
}

void User1Signal(int sig) {
	signal(sig, User1Signal);
}

static void AddToEnv(char*** curr_env, const char *name, const char *value) {
	int n;
	for (n = 0; (*curr_env)[n] != NULL; n++) ;
	n++;
	char** new_env = static_cast<char**>(malloc(sizeof(char*) * (n + 1)));
	if (new_env == NULL)
		return;
	memcpy(new_env, *curr_env, sizeof(char*) * n);
	size_t entry_len = strlen(name) + strlen(value) + 2;
	char* entry = static_cast<char*>(malloc(entry_len));
	if (entry == NULL) {
		free(new_env);
		return;
	}
	strlcpy(entry, name, entry_len);
	strlcat(entry, "=", entry_len);
	strlcat(entry, value, entry_len);
	new_env[n-1] = entry;
	new_env[n] = NULL;
	free(*curr_env);
	*curr_env = new_env;
}

/* The main configuration contains commands executed with elevated
 * privileges.  When running as root, require both the file and its parent
 * directory to be controlled by root and reject symlinks. */
static bool secure_command_config(const char *path) {
	if (geteuid() != 0)
		return true;

	struct stat st;
	if (lstat(path, &st) != 0)
		return errno == ENOENT;
	if (!S_ISREG(st.st_mode) || st.st_uid != 0 ||
		(st.st_mode & (S_IWGRP | S_IWOTH)) != 0)
		return false;

	std::string filename(path);
	std::string directory = filename.substr(0, filename.rfind('/'));
	if (directory.empty())
		directory = ".";
	if (lstat(directory.c_str(), &st) != 0)
		return false;
	return S_ISDIR(st.st_mode) && st.st_uid == 0 &&
		(st.st_mode & (S_IWGRP | S_IWOTH)) == 0;
}

#if defined(USE_PAM) || defined(USE_CONSOLEKIT)
/* Validate a runtime directory provided by PAM (e.g. pam_xdg) or
 * ConsoleKit before files are created in it as root.  It must be a canonical
 * absolute path (no symlink, "." or ".." components) to a real directory
 * owned by the user with mode 0700, and every ancestor must be a root-owned
 * directory that group and others cannot modify. */
static bool valid_runtime_dir(const string &path, uid_t uid) {
	char resolved[PATH_MAX];
	struct stat st;

	if (path.empty() || path[0] != '/' ||
		realpath(path.c_str(), resolved) == NULL || path != resolved)
		return false;
	for (string::size_type pos = 0; pos != string::npos;
		 pos = path.find('/', pos + 1)) {
		string ancestor = pos == 0 ? string("/") : path.substr(0, pos);
		if (lstat(ancestor.c_str(), &st) != 0 || !S_ISDIR(st.st_mode) ||
			st.st_uid != 0 || (st.st_mode & (S_IWGRP | S_IWOTH)) != 0)
			return false;
	}
	if (lstat(path.c_str(), &st) != 0)
		return false;
	return S_ISDIR(st.st_mode) && st.st_uid == uid &&
		(st.st_mode & 07777) == 0700;
}
#endif

/* Create or validate the per-user runtime directory required by the XDG
 * Base Directory Specification.  This is the fallback used when neither PAM
 * nor ConsoleKit provided a usable directory.  Do not trust an inherited
 * root-side XDG_RUNTIME_DIR: the login manager must select the directory for
 * the authenticated user.  /var/run/xdg is keyed by user name to match
 * pam_xdg(8); the other bases are keyed by uid. */
static bool ensure_runtime_dir(uid_t uid, gid_t gid, const char *name,
							   string &runtime_dir, bool &created) {
	static const struct {
		const char *path;
		bool by_name;
	} bases[] = {
		{ "/var/run/user", false },
		{ "/var/run/xdg", true },
		{ "/run/user", false },
		{ NULL, false }
	};
	struct stat st;
	created = false;

	for (int i = 0; bases[i].path != NULL; i++) {
		if (bases[i].by_name && (name == NULL || name[0] == '\0' ||
			name[0] == '.' || strchr(name, '/') != NULL))
			continue;
		if (lstat(bases[i].path, &st) != 0) {
			if (errno != ENOENT || geteuid() != 0 ||
				mkdir(bases[i].path, 0755) != 0)
				continue;
			if (lstat(bases[i].path, &st) != 0)
				continue;
		}
		if (!S_ISDIR(st.st_mode) || st.st_uid != 0 ||
			(st.st_mode & (S_IWGRP | S_IWOTH)) != 0)
			continue;

		runtime_dir = string(bases[i].path) + "/" +
			(bases[i].by_name ? string(name) : to_string(uid));
		if (mkdir(runtime_dir.c_str(), 0700) != 0) {
			if (errno != EEXIST)
				return false;
		} else {
			created = true;
			/* The base is root-owned and not writable by others, so the
			 * new directory cannot be replaced before it is handed over */
			if (chown(runtime_dir.c_str(), uid, gid) != 0)
				return false;
		}
		if (lstat(runtime_dir.c_str(), &st) != 0)
			return false;
		return S_ISDIR(st.st_mode) && st.st_uid == uid &&
			(st.st_mode & 0777) == 0700;
	}
	return false;
}

/* Create the session authority file before dropping privileges.  O_EXCL and
 * O_NOFOLLOW prevent an existing path or final symlink from being reused. */
static bool create_session_authfile(const string &path, uid_t uid, gid_t gid) {
	int flags = O_RDWR | O_CREAT | O_EXCL;
#ifdef O_NOFOLLOW
	flags |= O_NOFOLLOW;
#endif
	int fd = open(path.c_str(), flags, 0600);
	if (fd == -1)
		return false;
	bool valid = fchown(fd, uid, gid) == 0 && fchmod(fd, 0600) == 0;
	if (close(fd) != 0)
		valid = false;
	if (!valid)
		unlink(path.c_str());
	return valid;
}

/* Grace period between asking session processes to exit and killing them */
static const int SESSION_EXIT_GRACE_MS = 3000;
static const int SESSION_KILL_WAIT_MS = 1000;
static const int SESSION_POLL_MS = 100;

#ifdef HAVE_PROCCTL
/* Collect exited processes that were reparented to mlogind while it is the
 * session reaper and return how many session descendants remain.  Only pids
 * on the reaper list are waited for, so the X server, which was started
 * before PROC_REAP_ACQUIRE, is never collected here. */
static u_int reap_session_descendants() {
	struct procctl_reaper_status rs = {};
	if (procctl(P_PID, getpid(), PROC_REAP_STATUS, &rs) != 0 ||
		rs.rs_descendants == 0)
		return 0;

	vector<struct procctl_reaper_pidinfo> info(rs.rs_descendants);
	struct procctl_reaper_pids rp = {};
	rp.rp_count = info.size();
	rp.rp_pids = info.data();
	if (procctl(P_PID, getpid(), PROC_REAP_GETPIDS, &rp) == 0) {
		for (size_t i = 0; i < info.size(); i++) {
			if ((info[i].pi_flags & REAPER_PIDINFO_VALID) &&
				(info[i].pi_flags & REAPER_PIDINFO_CHILD))
				waitpid(info[i].pi_pid, NULL, WNOHANG);
		}
	}

	rs = {};
	if (procctl(P_PID, getpid(), PROC_REAP_STATUS, &rs) != 0)
		return 0;
	return rs.rs_descendants;
}
#endif

/* Reap exited members of the session process group (and, when mlogind is
 * the session reaper, its other descendants) and report whether any are
 * still present. */
static bool session_processes_remain(pid_t pgrp, bool reaper) {
	while (waitpid(-pgrp, NULL, WNOHANG) > 0)
		;
	bool remain = killpg(pgrp, 0) == 0 || errno == EPERM;
#ifdef HAVE_PROCCTL
	if (reaper && reap_session_descendants() > 0)
		remain = true;
#else
	(void)reaper;
#endif
	return remain;
}

/* Poll until the session's processes are gone or timeout_ms has elapsed. */
static void wait_for_session_exit(pid_t pgrp, bool reaper, int timeout_ms) {
	for (int waited = 0; session_processes_remain(pgrp, reaper) &&
		 waited < timeout_ms; waited += SESSION_POLL_MS)
		usleep(SESSION_POLL_MS * 1000);
}

static string configured_vt(Cfg *config, bool daemon) {
	istringstream arguments(config->getOption("xserver_arguments"));
	string argument;
	while (arguments >> argument) {
		if (argument.size() <= 2 || argument.compare(0, 2, "vt") != 0)
			continue;
		bool valid = false;
		int vt = Cfg::string2int(argument.c_str() + 2, &valid);
		if (valid && vt > 0)
			return to_string(vt);
	}
	return daemon ? "9" : "";
}

#ifdef USE_PAM
App::App(int argc, char** argv)
  : pam(conv, static_cast<void*>(&LoginPanel))
#else
App::App(int argc, char** argv)
#endif
{
	int tmp;
	ServerPID = -1;
	Scr = 0;
	LoginPanel = nullptr;
	DisplayName = nullptr;
	DispName = nullptr;
	cfg = nullptr;
	image = nullptr;
	testing = false;
	serverStarted = false;
	mcookie = string(App::mcookiesize, 'a');
	daemonmode = false;
	force_nodaemon = false;
	firstlogin = true;
	Dpy = nullptr;

	/* Parse command line
	   Note: we force a option for nodaemon switch to handle "-nodaemon" */
	while((tmp = getopt(argc, argv, "vhp:n:d?")) != EOF) {
		switch (tmp) {
		case 'p':	/* Test theme */
			testtheme = optarg;
			testing = true;
			if (testtheme == NULL) {
				logStream << "The -p option requires an argument" << endl;
				exit(ERR_EXIT);
			}
			break;
		case 'd':	/* Daemon mode */
			daemonmode = true;
			break;
		case 'n':	/* Daemon mode */
			daemonmode = false;
			force_nodaemon = true;
			break;
		case 'v':	/* Version */
			std::cout << APPNAME << " version " << VERSION << endl;
			exit(OK_EXIT);
			break;
		case '?':	/* Illegal */
			logStream << endl;
		case 'h':   /* Help */
			logStream << "usage:  " << APPNAME << " [option ...]" << endl
			<< "options:" << endl
			<< "	-d: daemon mode" << endl
			<< "	-nodaemon: no-daemon mode" << endl
			<< "	-v: show version" << endl
			<< "	-p /path/to/theme/dir: preview theme" << endl;
			exit(OK_EXIT);
			break;
		}
	}
#ifndef XNEST_DEBUG
	if (getuid() != 0 && !testing) {
		logStream << APPNAME << ": only root can run this program" << endl;
		exit(ERR_EXIT);
	}
#endif /* XNEST_DEBUG */

}

void App::Run() {
	DisplayName = DISPLAY;

#ifdef XNEST_DEBUG
	char* p = getenv("DISPLAY");
	if (p && p[0]) {
		DisplayName = p;
		cout << "Using display name " << DisplayName << endl;
	}
#endif

	/* Read configuration and theme */
	cfg = new Cfg;
	if (!secure_command_config(CFGFILE)) {
		std::cerr << APPNAME << ": refusing insecure command configuration: "
			  << CFGFILE << std::endl;
		exit(ERR_EXIT);
	}
	cfg->readConf(CFGFILE);
	string themebase = "";
	string themefile = "";
	string themedir = "";
	vector<string> themeSet;
	size_t themeIndex = 0;
	themeName = "";
	if (testing) {
		themeName = testtheme;
	} else {
		themebase = string(THEMESDIR) + "/";
		string configuredThemes = cfg->getOption("current_theme");
		themeName = configuredThemes;
		if (themeName.empty())
			themeName = "default";
		string::size_type pos;
		if ((pos = themeName.find(",")) != string::npos) {
			/* Retain valid entries so F2 can cycle through the set. */
			vector<string> configuredSet;
			Cfg::split(configuredSet, configuredThemes, ',');
			for (size_t i = 0; i < configuredSet.size(); i++) {
				string candidate = Cfg::Trim(configuredSet[i]);
				struct stat st;
				if (!candidate.empty() &&
					stat((themebase + candidate + THEMESFILE).c_str(), &st) == 0 &&
					S_ISREG(st.st_mode) && access((themebase + candidate + THEMESFILE).c_str(), R_OK) == 0)
					themeSet.push_back(candidate);
			}
			themeName = findValidRandomTheme(configuredThemes);
			if (themeName == "") {
				themeName = "default";
			} else {
				for (size_t i = 0; i < themeSet.size(); i++) {
					if (themeSet[i] == themeName) {
						themeIndex = i;
						break;
					}
				}
			}
		}
	}

#ifdef USE_PAM
	try{
		pam.start("mlogind");
		pam.set_item(PAM::Authenticator::TTY, DisplayName);
		pam.set_item(PAM::Authenticator::Requestor, "root");
	}
	catch(PAM::Exception& e){
		logStream << APPNAME << ": " << e << endl;
		exit(ERR_EXIT);
	};
#endif

	bool loaded = false;
	while (!loaded) {
		themedir =  themebase + themeName;
		themefile = themedir + THEMESFILE;
		if (!cfg->readConf(themefile)) {
			if (themeName == "default") {
				logStream << APPNAME << ": Failed to open default theme file "
					 << themefile << endl;
				exit(ERR_EXIT);
			} else {
				logStream << APPNAME << ": Invalid theme in config: "
					 << themeName << endl;
				themeName = "default";
			}
		} else {
			loaded = true;
		}
	}

	if (!testing) {
		/* Create lock file */
		LoginApp->GetLock();

		/* Start x-server */
		setenv("DISPLAY", DisplayName, 1);
		signal(SIGQUIT, CatchSignal);
		signal(SIGTERM, CatchSignal);
		signal(SIGINT, CatchSignal);
		signal(SIGHUP, CatchSignal);
		signal(SIGPIPE, CatchSignal);
		signal(SIGUSR1, User1Signal);

#ifndef XNEST_DEBUG
		if (!force_nodaemon && cfg->getOption("daemon") == "yes") {
			daemonmode = true;
		}

		/* Daemonize */
		if (daemonmode) {
			if (daemon(0, 0) == -1) {
				logStream << APPNAME << ": " << strerror(errno) << endl;
				exit(ERR_EXIT);
			}
		}

		OpenLog();

		if (daemonmode)
			UpdatePid();

		CreateServerAuth();
		StartServer();
#endif

	}

	/* Open display */
	if((Dpy = XOpenDisplay(DisplayName)) == 0) {
		logStream << APPNAME << ": could not open display '"
			 << DisplayName << "'" << endl;
		if (!testing) StopServer();
		exit(ERR_EXIT);
	}

	/* Get screen and root window */
	Scr = DefaultScreen(Dpy);
	Root = RootWindow(Dpy, Scr);

	// Intern _XROOTPMAP_ID property
	BackgroundPixmapId = XInternAtom(Dpy, "_XROOTPMAP_ID", False);

	/* for tests we use a standard window */
	if (testing) {
		Window RealRoot = RootWindow(Dpy, Scr);
		Root = XCreateSimpleWindow(Dpy, RealRoot, 0, 0, 1280, 1024, 0, 0, 0);
		XMapWindow(Dpy, Root);
		XFlush(Dpy);
	} else {
		blankScreen();
	}

	HideCursor();

	/* Create panel */
	LoginPanel = new Panel(Dpy, Scr, Root, cfg, themedir, Panel::Mode_DM);
	bool firstloop = true; /* 1st time panel is shown (for automatic username) */
	bool focuspass = cfg->getOption("focus_password")=="yes";
	bool autologin = cfg->getOption("auto_login")=="yes";

	if (firstlogin && cfg->getOption("default_user") != "") {
		LoginPanel->SetName(cfg->getOption("default_user") );
#ifdef USE_PAM
	pam.set_item(PAM::Authenticator::User, cfg->getOption("default_user").c_str());
#endif
		firstlogin = false;
		if (autologin) {
			Login();
		}
	}

	/* Set NumLock */
	string numlock = cfg->getOption("numlock");
	if (numlock == "on") {
		NumLock::setOn(Dpy);
	} else if (numlock == "off") {
		NumLock::setOff(Dpy);
	}

	/* Start looping */
	int panelclosed = 1;
	Panel::ActionType Action;

	while(1) {
		if(panelclosed) {
			/* Init root */
			setBackground(themedir);

			/* Close all clients */
			if (!testing) {
				KillAllClients(False);
				KillAllClients(True);
			}

			/* Show panel */
			LoginPanel->OpenPanel();
		}

		LoginPanel->Reset();

		if (firstloop && cfg->getOption("default_user") != "") {
			LoginPanel->SetName(cfg->getOption("default_user") );
		}

        if (firstloop) {
            LoginPanel->SwitchSession();
        }

		if (!AuthenticateUser(focuspass && firstloop)){
			panelclosed = 0;
			firstloop = false;
			LoginPanel->ClearPanel();
			XBell(Dpy, 100);
			continue;
		}

		firstloop = false;

		Action = LoginPanel->getAction();
		/* for themes test we just quit */
		if (testing) {
			Action = Panel::Exit;
		}
		panelclosed = 1;
		LoginPanel->ClosePanel();

		switch(Action) {
			case Panel::Login:
				Login();
#ifndef XNEST_DEBUG
				/* Restart the X server between sessions to force auth cookie
				 * rotation. This prevents a logged-out user from reconnecting
				 * to the running display using the old session authority. */
				delete LoginPanel;
				LoginPanel = nullptr;
				StopServer();
				Dpy = nullptr;
				while (waitpid(-1, NULL, WNOHANG) > 0);
				signal(SIGQUIT, CatchSignal);
				signal(SIGTERM, CatchSignal);
				signal(SIGINT, CatchSignal);
				signal(SIGHUP, CatchSignal);
				signal(SIGPIPE, CatchSignal);
				signal(SIGUSR1, User1Signal);
				CreateServerAuth();
				StartServer();
				Scr = DefaultScreen(Dpy);
				Root = RootWindow(Dpy, Scr);
				BackgroundPixmapId = XInternAtom(Dpy, "_XROOTPMAP_ID", False);
				blankScreen();
				HideCursor();
				LoginPanel = new Panel(Dpy, Scr, Root, cfg, themedir, Panel::Mode_DM);
				if (numlock == "on") NumLock::setOn(Dpy);
				else if (numlock == "off") NumLock::setOff(Dpy);
#endif
#ifdef USE_PAM
				try{
					pam.start("mlogind");
					pam.set_item(PAM::Authenticator::TTY, DisplayName);
					pam.set_item(PAM::Authenticator::Requestor, "root");
				}
				catch(PAM::Exception& e){
					logStream << APPNAME << ": " << e << endl;
					exit(ERR_EXIT);
				};
#endif
				firstloop = true;
				break;
			case Panel::Console:
				Console();
				break;
			case Panel::Reboot:
				Reboot();
				break;
			case Panel::Halt:
				Halt();
				break;
			case Panel::Suspend:
				Suspend();
				break;
			case Panel::Exit:
				Exit();
				break;
			case Panel::Restart:
				RestartServer();
				break;
			case Panel::Theme:
				if (themeSet.size() > 1) {
					bool switched = false;
					for (size_t attempt = 0; attempt < themeSet.size(); attempt++) {
						size_t next = (themeIndex + attempt + 1) % themeSet.size();
						string nextTheme = themeSet[next];
						string nextThemeFile = themebase + nextTheme + THEMESFILE;
						Cfg *nextCfg = new Cfg;
						if (!nextCfg->readConf(CFGFILE) ||
							!nextCfg->readConf(nextThemeFile)) {
							delete nextCfg;
							continue;
						}
						delete cfg;
						cfg = nextCfg;
						themeIndex = next;
						themeName = nextTheme;
						themedir = themebase + themeName;
						themefile = nextThemeFile;
						delete LoginPanel;
						LoginPanel = nullptr;
						setBackground(themedir);
						LoginPanel = new Panel(Dpy, Scr, Root, cfg, themedir, Panel::Mode_DM);
						LoginPanel->SwitchSession();
						focuspass = cfg->getOption("focus_password") == "yes";
						switched = true;
						break;
					}
					if (!switched)
						logStream << APPNAME << ": could not load another configured theme" << endl;
				}
				break;
			default:
				break;
		}
	}
}

#ifdef USE_PAM
bool App::AuthenticateUser(bool focuspass){
	/* Reset the username */
	try{
		if (!focuspass)
			pam.set_item(PAM::Authenticator::User, 0);
		pam.authenticate();
	}
	catch(PAM::Auth_Exception& e){
		switch(LoginPanel->getAction()){
			case Panel::Exit:
			case Panel::Console:
			case Panel::Restart:
			case Panel::Theme:
				return true; /* <--- This is simply fake! */
			default:
				break;
		};
		logStream << APPNAME << ": " << e << endl;
		return false;
	}
	catch(PAM::Exception& e){
		logStream << APPNAME << ": " << e << endl;
		exit(ERR_EXIT);
	};
	return true;
}
#else
bool App::AuthenticateUser(bool focuspass){
	if (!focuspass){
		LoginPanel->EventHandler(Panel::Get_Name);
		switch(LoginPanel->getAction()){
			case Panel::Exit:
			case Panel::Console:
			case Panel::Restart:
			case Panel::Theme:
				logStream << APPNAME << ": Got a special command (" << LoginPanel->GetName() << ")" << endl;
				return true; /* <--- This is simply fake! */
			default:
				break;
		}
	}
	LoginPanel->EventHandler(Panel::Get_Passwd);
	if (LoginPanel->getAction() == Panel::Restart ||
		LoginPanel->getAction() == Panel::Theme)
		return true;

	char *encrypted, *correct;
	struct passwd *pw;

	switch(LoginPanel->getAction()){
		case Panel::Lock:
		case Panel::Restart:
		case Panel::Theme:
			return true;
		case Panel::Suspend:
		case Panel::Halt:
		case Panel::Reboot:
			pw = getpwnam("root");
			break;
		case Panel::Console:
		case Panel::Exit:
		case Panel::Login:
			pw = getpwnam(LoginPanel->GetName().c_str());
			break;
	}
	endpwent();
	if(pw == 0)
		return false;

#ifdef HAVE_SHADOW
	struct spwd *sp = getspnam(pw->pw_name);
	endspent();
	if(sp)
		correct = sp->sp_pwdp;
	else
#endif		/* HAVE_SHADOW */
		correct = pw->pw_passwd;

	if(correct == 0 || correct[0] == '\0')
		return true;

	encrypted = crypt(LoginPanel->GetPasswd().c_str(), correct);
	if (encrypted && strcmp(encrypted, correct) == 0)
		return true;
	sleep(cfg->getIntOption("wrong_passwd_timeout"));
	return false;
}
#endif

int App::GetServerPID() {
	return ServerPID;
}

/* Hide the cursor */
void App::HideCursor() {
	if (cfg->getOption("hidecursor") == "true") {
		XColor			black;
		char			cursordata[1];
		Pixmap			cursorpixmap;
		Cursor			cursor;
		cursordata[0]=0;
		cursorpixmap=XCreateBitmapFromData(Dpy,Root,cursordata,1,1);
		black.red=0;
		black.green=0;
		black.blue=0;
		cursor=XCreatePixmapCursor(Dpy,cursorpixmap,cursorpixmap,&black,&black,0,0);
		XDefineCursor(Dpy,Root,cursor);
	}
}

void App::Login() {
	struct passwd *pw;
	pid_t pid;
	bool session_reaper = false;

#ifdef USE_PAM
	try{
		pam.open_session();
		pw = getpwnam(static_cast<const char*>(pam.get_item(PAM::Authenticator::User)));
	}
	catch(PAM::Cred_Exception& e){
		/* Credentials couldn't be established */
		logStream << APPNAME << ": " << e << endl;
		return;
	}
	catch(PAM::Exception& e){
		logStream << APPNAME << ": " << e << endl;
		exit(ERR_EXIT);
	};
#else
	pw = getpwnam(LoginPanel->GetName().c_str());
#endif
	endpwent();
	if(pw == 0)
		return;
	if (pw->pw_shell[0] == '\0') {
		setusershell();
		char *shell = strdup(getusershell());
		endusershell();
		if (shell)
			pw->pw_shell = shell;
		/* shell is freed when this child process exits */
	}

	/* Close the ConsoleKit and PAM sessions opened for this login */
	auto close_sessions = [&]() {
#ifdef USE_CONSOLEKIT
		try {
			ck.close_session();
		}
		catch(Ck::Exception &e) {
			logStream << APPNAME << ": " << e << endl;
		};
#endif
#ifdef USE_PAM
		try{
			pam.close_session();
		}
		catch(PAM::Exception& e){
			logStream << APPNAME << ": " << e << endl;
		};
		try{
			pam.end();
		}
		catch(PAM::Exception& e){
			logStream << APPNAME << ": " << e << endl;
		};
#endif
	};

#ifdef USE_CONSOLEKIT
	/* Setup the ConsoleKit session.  It is opened before the runtime
	 * directory is chosen because ConsoleKit replaces any existing
	 * /var/run/user/<uid> when the user's first session opens.  A failure
	 * is not fatal: continue without a ConsoleKit session. */
	try {
		ck.open_session(DisplayName, pw->pw_uid);
	}
	catch(Ck::Exception &e) {
		logStream << APPNAME << ": " << e
			  << "; continuing without a ConsoleKit session" << endl;
	}
#endif

	/* Choose XDG_RUNTIME_DIR: prefer one set up by a PAM module (pam_xdg),
	 * then the one managed by ConsoleKit, and only create one ourselves if
	 * neither is usable.  Only a directory mlogind created is removed at
	 * logout; the others belong to PAM or ConsoleKit. */
	string runtime_dir;
	bool runtime_dir_created = false;
#ifdef USE_PAM
	const char *pam_runtime_dir = pam.getenv("XDG_RUNTIME_DIR");
	if (pam_runtime_dir != NULL) {
		if (valid_runtime_dir(pam_runtime_dir, pw->pw_uid))
			runtime_dir = pam_runtime_dir;
		else
			logStream << APPNAME << ": ignoring XDG_RUNTIME_DIR " << pam_runtime_dir
				  << " from PAM: not a private directory owned by "
				  << pw->pw_name << endl;
	}
#endif
#ifdef USE_CONSOLEKIT
	if (runtime_dir.empty() && ck.is_open()) {
		try {
			string ck_runtime_dir = ck.get_runtime_dir();
			if (valid_runtime_dir(ck_runtime_dir, pw->pw_uid))
				runtime_dir = ck_runtime_dir;
			else if (!ck_runtime_dir.empty())
				logStream << APPNAME << ": ignoring ConsoleKit runtime directory "
					  << ck_runtime_dir << ": not a private directory owned by "
					  << pw->pw_name << endl;
		}
		catch(Ck::Exception &e) {
			logStream << APPNAME << ": " << e << endl;
		}
	}
#endif
	if (runtime_dir.empty() &&
		!ensure_runtime_dir(pw->pw_uid, pw->pw_gid, pw->pw_name, runtime_dir,
							runtime_dir_created)) {
		logStream << APPNAME << ": could not create or validate XDG_RUNTIME_DIR for "
			  << pw->pw_name << endl;
		close_sessions();
		if (runtime_dir_created)
			rmdir(runtime_dir.c_str());
		return;
	}
	static unsigned long session_counter = 0;
	string session_id = "mlogind-" + to_string(getpid()) + "-" +
		to_string(++session_counter);
	string session_desktop = LoginPanel->getSessionDesktop();
	string current_desktop = session_desktop;
	for (size_t i = 0; i < current_desktop.size(); i++) {
		if (current_desktop[i] == ';')
			current_desktop[i] = ':';
	}
	string desktop = session_desktop;
	string::size_type desktop_separator = desktop.find(';');
	if (desktop_separator != string::npos)
		desktop.erase(desktop_separator);
	string xdg_vtnr = configured_vt(cfg, daemonmode);

	/* Setup the environment */
	char* term = getenv("TERM");
	string maildir = _PATH_MAILDIR;
	maildir.append("/");
	maildir.append(pw->pw_name);
	string xauthority = runtime_dir + "/Xauthority-" + session_id;

#ifdef USE_PAM
	/* Setup the PAM environment */
	try{
		if(term) pam.setenv("TERM", term);
		pam.setenv("HOME", pw->pw_dir);
		pam.setenv("PWD", pw->pw_dir);
		pam.setenv("SHELL", pw->pw_shell);
		pam.setenv("USER", pw->pw_name);
		pam.setenv("LOGNAME", pw->pw_name);
		pam.setenv("PATH", cfg->getOption("default_path").c_str());
		pam.setenv("DISPLAY", DisplayName);
		pam.setenv("MAIL", maildir.c_str());
		pam.setenv("XAUTHORITY", xauthority.c_str());
		pam.setenv("XDG_RUNTIME_DIR", runtime_dir.c_str());
		pam.setenv("XDG_SESSION_ID", session_id.c_str());
		pam.setenv("XDG_SESSION_TYPE", "x11");
		pam.setenv("XDG_SESSION_CLASS", "user");
		pam.setenv("XDG_SEAT", "seat0");
		if (!xdg_vtnr.empty())
			pam.setenv("XDG_VTNR", xdg_vtnr.c_str());
		if (!current_desktop.empty())
			pam.setenv("XDG_CURRENT_DESKTOP", current_desktop.c_str());
		if (!desktop.empty())
			pam.setenv("XDG_SESSION_DESKTOP", desktop.c_str());
	}
	catch(PAM::Exception& e){
		logStream << APPNAME << ": " << e << endl;
		exit(ERR_EXIT);
	}
#endif

	bool session_auth_created = create_session_authfile(xauthority,
		pw->pw_uid, pw->pw_gid);
	if (!session_auth_created) {
		logStream << APPNAME << ": could not create session Xauthority file "
			  << xauthority << endl;
		close_sessions();
		if (runtime_dir_created)
			rmdir(runtime_dir.c_str());
		return;
	}

	/*
	 * On MidnightBSD/FreeBSD, retain orphaned descendants of the session
	 * under mlogind.  This covers desktop processes that daemonize by calling
	 * setsid(), which cannot be reached through the session process group.
	 * Existing children keep their current reaper, so the X server is not
	 * included in this subtree.
	 */
#ifdef HAVE_PROCCTL
	if (procctl(P_PID, getpid(), PROC_REAP_ACQUIRE, NULL) == 0)
		session_reaper = true;
	else if (errno != ENOSYS && errno != EINVAL)
		logStream << APPNAME << ": procctl reaper setup failed: "
			  << strerror(errno) << endl;
#endif

	/* Create new process */
	pid = fork();
	if (pid < 0) {
		logStream << APPNAME << ": fork failed: " << strerror(errno) << endl;
#ifdef HAVE_PROCCTL
		if (session_reaper)
			procctl(P_PID, getpid(), PROC_REAP_RELEASE, NULL);
#endif
		close_sessions();
		if (session_auth_created)
			unlink(xauthority.c_str());
		if (runtime_dir_created)
			rmdir(runtime_dir.c_str());
		return;
	}
	if(pid == 0) {
#ifdef USE_PAM
		/* Get a copy of the environment and close the child's copy */
		/* of the PAM-handle. */
		char** child_env = pam.getenvlist();
		if (child_env == NULL)
			_exit(ERR_EXIT);

# ifdef USE_CONSOLEKIT
		/* Only a successfully opened ConsoleKit session has a cookie */
		const char *ck_cookie = ck.get_xdg_session_cookie();
		if (ck_cookie != NULL)
			AddToEnv(&child_env, "XDG_SESSION_COOKIE", ck_cookie);
# endif /* USE_CONSOLEKIT */
#else

	# ifdef USE_CONSOLEKIT
		const int Num_Of_Variables = 17; /* Number of env. variables + 1 */
	# else
		const int Num_Of_Variables = 16; /* Number of env. variables + 1 */
# endif /* USE_CONSOLEKIT */
		char** child_env = static_cast<char**>(malloc(sizeof(char*)*Num_Of_Variables));
		if (child_env == NULL)
			_exit(ERR_EXIT);
		int n = 0;
		if(term) child_env[n++]=StrConcat("TERM=", term);
		child_env[n++]=StrConcat("HOME=", pw->pw_dir);
		child_env[n++]=StrConcat("PWD=", pw->pw_dir);
		child_env[n++]=StrConcat("SHELL=", pw->pw_shell);
		child_env[n++]=StrConcat("USER=", pw->pw_name);
		child_env[n++]=StrConcat("LOGNAME=", pw->pw_name);
		child_env[n++]=StrConcat("PATH=", cfg->getOption("default_path").c_str());
		child_env[n++]=StrConcat("DISPLAY=", DisplayName);
		child_env[n++]=StrConcat("MAIL=", maildir.c_str());
		child_env[n++]=StrConcat("XAUTHORITY=", xauthority.c_str());
		child_env[n++]=StrConcat("XDG_RUNTIME_DIR=", runtime_dir.c_str());
		child_env[n++]=StrConcat("XDG_SESSION_ID=", session_id.c_str());
		child_env[n++]=StrConcat("XDG_SESSION_TYPE=x11", "");
		child_env[n++]=StrConcat("XDG_SESSION_CLASS=user", "");
		child_env[n++]=StrConcat("XDG_SEAT=seat0", "");
# ifdef USE_CONSOLEKIT
		const char *ck_cookie = ck.get_xdg_session_cookie();
		if (ck_cookie != NULL)
			child_env[n++]=StrConcat("XDG_SESSION_COOKIE=", ck_cookie);
# endif /* USE_CONSOLEKIT */
			child_env[n++]=0;
		/* AddToEnv needs the NULL terminator written above */
		if (!xdg_vtnr.empty())
			AddToEnv(&child_env, "XDG_VTNR", xdg_vtnr.c_str());

#endif
		if (!current_desktop.empty())
			AddToEnv(&child_env, "XDG_CURRENT_DESKTOP", current_desktop.c_str());
		if (!desktop.empty())
			AddToEnv(&child_env, "XDG_SESSION_DESKTOP", desktop.c_str());

		login_cap_t *lc = login_getpwclass(pw);
		if (lc != NULL) {
			for (int i = 0; i < LOGIN_CAP_VAR_COUNT; i++) {
				const char *value = login_getcapstr(lc, LOGIN_CAP_VARS[i], NULL, NULL);
				if (value != NULL) {
					AddToEnv(&child_env, LOGIN_CAP_ENVS[i], value);
				}
			}
			login_close(lc);
		}

		/* Login process starts here */
		SwitchUser Su(pw, cfg, DisplayName, child_env, xauthority);
		string session = LoginPanel->getSession();
		string loginCommand = cfg->getOption("login_cmd");

		replaceVariables(loginCommand, SESSION_VAR, Util::shell_escape(session));
		replaceVariables(loginCommand, THEME_VAR, Util::shell_escape(themeName));

		/* Wrap login command with a per-session bus when available.
		 * This is required for desktop environments like XFCE 4.20 that use
		 * DBus for settings persistence (xfconf). On non-systemd systems such
		 * as MidnightBSD, prefer dbus-run-session and retain dbus-launch as a
		 * compatibility fallback. */
		string dbusLaunch = cfg->getOption("dbus_launch");
		bool dbus_run_session = false;
		if (dbusLaunch == "auto") {
			dbusLaunch = "";
			static const char* candidates[] = {
				"/usr/local/bin/dbus-run-session",
				"/usr/bin/dbus-run-session",
				"/usr/local/bin/dbus-launch",
				"/usr/bin/dbus-launch",
				NULL
			};
			for (int i = 0; candidates[i] != NULL; i++) {
				if (access(candidates[i], X_OK) == 0) {
					dbusLaunch = candidates[i];
					dbus_run_session = string(candidates[i]).find("dbus-run-session") != string::npos;
					break;
				}
			}
		}
		if (!dbus_run_session && dbusLaunch.find("dbus-run-session") != string::npos)
			dbus_run_session = true;
		if (!dbusLaunch.empty()) {
			string dbus_arguments = dbus_run_session ? " -- " : " --exit-with-session ";
			if (loginCommand.compare(0, 5, "exec ") == 0) {
				loginCommand = "exec " + dbusLaunch + dbus_arguments + loginCommand.substr(5);
			} else {
				loginCommand = dbusLaunch + dbus_arguments + loginCommand;
			}
		}

		string sessStart = cfg->getOption("sessionstart_cmd");
		if (sessStart != "") {
			replaceVariables(sessStart, USER_VAR, Util::shell_escape(pw->pw_name));
			Util::run_command(sessStart);
		}
		Su.Login(loginCommand.c_str(), mcookie.c_str());
		_exit(OK_EXIT);
	}

#ifndef XNEST_DEBUG
	CloseLog();
#endif

	/* Wait until user is logging out (login process terminates) */
	pid_t wpid = -1;
	int status;
	while (wpid != pid) {
		wpid = wait(&status);
		if (wpid == -1) {
			if (errno == EINTR)
				continue;
			break;
		}
		if (wpid == ServerPID) {
			/* Server died before session exited: terminate the session and
			 * continue to the normal session cleanup path below. */
			killpg(pid, SIGHUP);
			if (killpg(pid, SIGTERM) < 0 && errno == ESRCH)
				continue; /* Session process group already gone */
			/* Give session a grace period to exit cleanly before forcing it */
			sleep(3);
			if (killpg(pid, SIGKILL) < 0 && errno != ESRCH)
				logStream << APPNAME << ": killpg SIGKILL failed: " << strerror(errno) << endl;
		}
	}
	if (WIFEXITED(status) && WEXITSTATUS(status)) {
		LoginPanel->Message("Failed to execute login command");
		sleep(3);
	} else {
		 string sessStop = cfg->getOption("sessionstop_cmd");
		 if (sessStop != "") {
			replaceVariables(sessStop, USER_VAR, Util::shell_escape(pw->pw_name));
			Util::run_command(sessStop);
		}
	}

	/* Terminate the session before closing the ConsoleKit and PAM
	 * sessions: ConsoleKit (and pam_xdg) remove the runtime directory when
	 * the session closes, which must not happen while session processes
	 * such as dconf-service or gvfsd can still write to it. */

	/* Close all clients */
	KillAllClients(False);
	KillAllClients(True);

	bool keep_processes = cfg->getOption("keep_session_processes") == "yes";
	if (!keep_processes) {
		/* Ask the session process group and, when mlogind is the reaper,
		 * every other session descendant to exit */
		killpg(pid, SIGHUP);
		killpg(pid, SIGTERM);
#ifdef HAVE_PROCCTL
		struct procctl_reaper_kill reap = {};
		reap.rk_flags = REAPER_KILL_SUBTREE;
		reap.rk_subtree = pid;
		if (session_reaper) {
			reap.rk_sig = SIGHUP;
			procctl(P_PID, getpid(), PROC_REAP_KILL, &reap);
			reap.rk_sig = SIGTERM;
			procctl(P_PID, getpid(), PROC_REAP_KILL, &reap);
		}
#endif
		/* Give the session a grace period to exit cleanly, then force it */
		wait_for_session_exit(pid, session_reaper, SESSION_EXIT_GRACE_MS);
		if (killpg(pid, SIGKILL) < 0 && errno != ESRCH)
			logStream << APPNAME << ": killpg SIGKILL failed: " << strerror(errno) << endl;
#ifdef HAVE_PROCCTL
		if (session_reaper) {
			reap.rk_sig = SIGKILL;
			procctl(P_PID, getpid(), PROC_REAP_KILL, &reap);
		}
#endif
		wait_for_session_exit(pid, session_reaper, SESSION_KILL_WAIT_MS);
	}

#ifdef HAVE_PROCCTL
	/* Surviving descendants (keep_session_processes) are reparented to
	 * init when the reaper is released */
	if (session_reaper &&
		procctl(P_PID, getpid(), PROC_REAP_RELEASE, NULL) != 0)
		logStream << APPNAME << ": procctl reaper release failed: "
			  << strerror(errno) << endl;
#endif

	close_sessions();

	if (session_auth_created && unlink(xauthority.c_str()) != 0 && errno != ENOENT)
		logStream << APPNAME << ": could not remove session Xauthority file "
			  << xauthority << ": " << strerror(errno) << endl;
	if (runtime_dir_created && rmdir(runtime_dir.c_str()) != 0 &&
		errno != ENOENT && errno != ENOTEMPTY)
		logStream << APPNAME << ": could not remove XDG_RUNTIME_DIR "
			  << runtime_dir << ": " << strerror(errno) << endl;

	HideCursor();

#ifndef XNEST_DEBUG
	/* Re-activate log file */
	OpenLog();
#endif

}

void App::Reboot() {
#ifdef USE_PAM
	try{
		pam.end();
	}
	catch(PAM::Exception& e){
		logStream << APPNAME << ": " << e << endl;
	};
#endif

	/* Write message */
	LoginPanel->Message(cfg->getOption("reboot_msg"));
	sleep(3);

	/* Stop server and reboot */
	StopServer();
	RemoveLock();
	Util::run_command(cfg->getOption("reboot_cmd"));
	exit(OK_EXIT);
}


void App::Halt() {
#ifdef USE_PAM
	try{
		pam.end();
	}
	catch(PAM::Exception& e){
		logStream << APPNAME << ": " << e << endl;
	};
#endif

	/* Write message */
	LoginPanel->Message(cfg->getOption("shutdown_msg"));
	sleep(3);

	/* Stop server and halt */
	StopServer();
	RemoveLock();
	Util::run_command(cfg->getOption("halt_cmd"));
	exit(OK_EXIT);
}

void App::Suspend() {
	sleep(1);
	Util::run_command(cfg->getOption("suspend_cmd"));
}


/*
 * Returns true if every printf conversion specifier in fmt is a plain
 * integer specifier (%d, %i, %u, %o, %x, %X) with only optional
 * decimal-digit width/precision modifiers.  %% is also accepted.
 * Anything else (%s, %p, %n, %l, ...) causes a return of false.
 */
static bool console_cmd_format_safe(const std::string &fmt)
{
	for (size_t i = 0; i < fmt.size(); i++) {
		if (fmt[i] != '%')
			continue;
		i++;
		if (i >= fmt.size())
			return false;  /* trailing lone % */
		if (fmt[i] == '%')
			continue;      /* %% — literal percent, fine */
		/* skip optional decimal width/precision (e.g. "10", ".5") */
		while (i < fmt.size() && (isdigit((unsigned char)fmt[i]) || fmt[i] == '.'))
			i++;
		if (i >= fmt.size())
			return false;
		switch (fmt[i]) {
			case 'd': case 'i': case 'u':
			case 'o': case 'x': case 'X':
				break;      /* safe integer specifiers */
			default:
				return false;
		}
	}
	return true;
}

void App::Console() {
	int posx = 40;
	int posy = 40;
	int fontx = 9;
	int fonty = 15;
	int width = (XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)) - (posx * 2)) / fontx;
	int height = (XHeightOfScreen(ScreenOfDisplay(Dpy, Scr)) - (posy * 2)) / fonty;

	/* Execute console */
	string cmd_template = cfg->getOption("console_cmd");
	if (!console_cmd_format_safe(cmd_template)) {
		logStream << APPNAME
			  << ": console_cmd contains unsafe format specifiers, refusing to execute"
			  << endl;
		return;
	}
	/* 6 integer substitutions, each at most 10 digits */
	vector<char> buf(cmd_template.size() + 6 * 10 + 1);
	snprintf(buf.data(), buf.size(), cmd_template.c_str(),
		 width, height, posx, posy, fontx, fonty);
	Util::run_command(buf.data());
}


void App::Exit() {
#ifdef USE_PAM
	try{
		pam.end();
	}
	catch(PAM::Exception& e){
		logStream << APPNAME << ": " << e << endl;
	};
#endif

	if (testing) {
		const char* testmsg = "This is a test message :-)";
		LoginPanel->Message(testmsg);
		sleep(3);
		delete LoginPanel;
		XCloseDisplay(Dpy);
	} else {
		delete LoginPanel;
		StopServer();
		RemoveLock();
	}
	delete cfg;
	exit(OK_EXIT);
}

int CatchErrors(Display *dpy, XErrorEvent *ev) {
	return 0;
}

void App::RestartServer() {
#ifdef USE_PAM
	try{
		pam.end();
	}
	catch(PAM::Exception& e){
		logStream << APPNAME << ": " << e << endl;
	};
#endif

	StopServer();
	RemoveLock();
	while (waitpid(-1, NULL, WNOHANG) > 0); /* Collects all dead childrens */
	Run();
}

void App::KillAllClients(Bool top) {
	Window dummywindow;
	Window *children;
	unsigned int nchildren;
	unsigned int i;
	XWindowAttributes attr;

	XSync(Dpy, 0);
	XSetErrorHandler(CatchErrors);

	nchildren = 0;
	XQueryTree(Dpy, Root, &dummywindow, &dummywindow, &children, &nchildren);
	if(!top) {
		for(i=0; i<nchildren; i++) {
			if(XGetWindowAttributes(Dpy, children[i], &attr) && (attr.map_state == IsViewable))
				children[i] = XmuClientWindow(Dpy, children[i]);
			else
				children[i] = 0;
		}
	}

	for(i=0; i<nchildren; i++) {
		if(children[i])
			XKillClient(Dpy, children[i]);
	}
	XFree(children);

	XSync(Dpy, 0);
	XSetErrorHandler(NULL);
}


int App::ServerTimeout(int timeout, const char* text) {
	int	i = 0;
	int pidfound = -1;
	static const char *lasttext;

	for(;;) {
		pidfound = waitpid(ServerPID, NULL, WNOHANG);
		if(pidfound == ServerPID)
			break;
		if(timeout) {
			if(i == 0 && text != lasttext)
				logStream << endl << APPNAME << ": waiting for " << text;
			else
				logStream << ".";
		}
		if(timeout)
			sleep(1);
		if(++i > timeout)
			break;
	}

	if(i > 0)
		logStream << endl;
	lasttext = text;

	return (ServerPID != pidfound);
}


int App::WaitForServer() {
	int	ncycles	 = 120;
	int	cycles;

	for(cycles = 0; cycles < ncycles; cycles++) {
		if((Dpy = XOpenDisplay(DisplayName))) {
			XSetIOErrorHandler(xioerror);
			return 1;
		} else {
			if(!ServerTimeout(1, "X server to begin accepting connections"))
				break;
		}
	}

	logStream << "Giving up." << endl;

	return 0;
}


int App::StartServer() {
	ServerPID = fork();

	static const int MAX_XSERVER_ARGS = 256;
	static char* server[MAX_XSERVER_ARGS+2] = { NULL };
	server[0] = const_cast<char*>(cfg->getOption("default_xserver").c_str());
	string argOption = cfg->getOption("xserver_arguments");
	/* Add mandatory -xauth option */
	argOption = argOption + " -auth " + cfg->getOption("authfile");
	size_t args_len = argOption.length() + 2; /* +1 for null, +1 for vt token */
	char* args = new char[args_len];
	strlcpy(args, argOption.c_str(), args_len);

	serverStarted = false;

	int argc = 1;
	int pos = 0;
	bool hasVtSet = false;
	while (args[pos] != '\0') {
		if (args[pos] == ' ' || args[pos] == '\t') {
			*(args+pos) = '\0';
			server[argc++] = args+pos+1;
		} else if (pos == 0) {
			server[argc++] = args+pos;
		}
		++pos;

		if (argc+1 >= MAX_XSERVER_ARGS) {
			/* ignore _all_ arguments to make sure the server starts at */
			/* all */
			argc = 1;
			break;
		}
	}

	for (int i=0; i<argc; i++) {
		if (server[i][0] == 'v' && server[i][1] == 't') {
			bool ok = false;
			Cfg::string2int(server[i]+2, &ok);
			if (ok) {
				hasVtSet = true;
			}
		}
	}

	if (!hasVtSet && daemonmode) {
		server[argc++] = const_cast<char*>("vt09");
	}
	server[argc] = NULL;

	switch(ServerPID) {
	case 0:
		signal(SIGTTIN, SIG_IGN);
		signal(SIGTTOU, SIG_IGN);
		signal(SIGUSR1, SIG_IGN);
		setpgid(0,getpid());

		execvp(server[0], server);
		logStream << APPNAME << ": X server could not be started" << endl;
		exit(ERR_EXIT);
		break;

	case -1:
		break;

	default:
		errno = 0;
		if(!ServerTimeout(0, "")) {
			ServerPID = -1;
			break;
		}

		/* Wait for server to start up */
		if(WaitForServer() == 0) {
			logStream << APPNAME << ": unable to connect to X server" << endl;
			StopServer();
			ServerPID = -1;
			exit(ERR_EXIT);
		}
		break;
	}

	delete [] args;

	serverStarted = true;

	return ServerPID;
}

jmp_buf CloseEnv;
int IgnoreXIO(Display *d) {
	logStream << APPNAME << ": connection to X server lost." << endl;
	longjmp(CloseEnv, 1);
}

void App::StopServer() {
	signal(SIGQUIT, SIG_IGN);
	signal(SIGINT, SIG_IGN);
	signal(SIGHUP, SIG_IGN);
	signal(SIGPIPE, SIG_IGN);
	signal(SIGTERM, SIG_DFL);
	signal(SIGKILL, SIG_DFL);

	/* Catch X error */
	XSetIOErrorHandler(IgnoreXIO);
	if(!setjmp(CloseEnv) && Dpy)
		XCloseDisplay(Dpy);

	/* Send HUP to process group */
	errno = 0;
	if((killpg(getpid(), SIGHUP) != 0) && (errno != ESRCH))
		logStream << APPNAME << ": can't send HUP to process group " << getpid() << endl;

	/* Send TERM to server */
	if(ServerPID < 0)
		return;
	errno = 0;
	if(killpg(ServerPID, SIGTERM) < 0) {
		if(errno == EPERM) {
			logStream << APPNAME << ": can't kill X server" << endl;
			exit(ERR_EXIT);
		}
		if(errno == ESRCH)
			return;
	}

	/* Wait for server to shut down */
	if(!ServerTimeout(10, "X server to shut down")) {
		logStream << endl;
		return;
	}

	logStream << endl << APPNAME << ":  X server slow to shut down, sending KILL signal." << endl;

	/* Send KILL to server */
	errno = 0;
	if(killpg(ServerPID, SIGKILL) < 0) {
		if(errno == ESRCH)
			return;
	}

	/* Wait for server to die */
	if(ServerTimeout(3, "server to die")) {
		logStream << endl << APPNAME << ": can't kill server" << endl;
		exit(ERR_EXIT);
	}
	logStream << endl;
}

void App::blankScreen()
{
	GC gc = XCreateGC(Dpy, Root, 0, 0);
	XSetForeground(Dpy, gc, BlackPixel(Dpy, Scr));
	XFillRectangle(Dpy, Root, gc, 0, 0,
				   XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)),
				   XHeightOfScreen(ScreenOfDisplay(Dpy, Scr)));
	XFlush(Dpy);
	XFreeGC(Dpy, gc);

}

void App::setBackground(const string& themedir) {
	string filename;
	filename = themedir + "/background.png";
	image = new Image;
	bool loaded = image->Read(filename.c_str());
	if (!loaded) { /* try jpeg */
		filename = themedir + "/background.jpg";
		loaded = image->Read(filename.c_str());
	}
	if (!loaded) { /* try SVG */
		filename = themedir + "/background.svg";
		loaded = image->Read(filename.c_str());
	}
	if (loaded) {
		string bgstyle = cfg->getOption("background_style");
		if (bgstyle == "stretch") {
			image->Resize(XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)), XHeightOfScreen(ScreenOfDisplay(Dpy, Scr)));
		} else if (bgstyle == "tile") {
			image->Tile(XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)), XHeightOfScreen(ScreenOfDisplay(Dpy, Scr)));
		} else if (bgstyle == "center") {
			string hexvalue = cfg->getOption("background_color");
			hexvalue = hexvalue.substr(1,6);
			image->Center(XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)), XHeightOfScreen(ScreenOfDisplay(Dpy, Scr)),
						hexvalue.c_str());
		} else { /* plain color or error */
			string hexvalue = cfg->getOption("background_color");
			hexvalue = hexvalue.substr(1,6);
			image->Center(XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)), XHeightOfScreen(ScreenOfDisplay(Dpy, Scr)),
						hexvalue.c_str());
		}
		Pixmap p = image->createPixmap(Dpy, Scr, Root);
		XSetWindowBackgroundPixmap(Dpy, Root, p);
		XChangeProperty(Dpy, Root, BackgroundPixmapId, XA_PIXMAP, 32,
			PropModeReplace, reinterpret_cast<unsigned char*>(&p), 1);
	}
	XClearWindow(Dpy, Root);

	XFlush(Dpy);
	delete image;
}

/* Write the current PID into an open lock file descriptor. */
static bool WriteLockPid(int fd) {
	char buf[32];
	int len = snprintf(buf, sizeof(buf), "%d\n", getpid());
	if (len <= 0 || (size_t)len >= sizeof(buf))
		return false;
	ssize_t written = write(fd, buf, (size_t)len);
	return (written == (ssize_t)len);
}

/* Check if there is a lockfile and a corresponding process.
 * Uses O_CREAT|O_EXCL for atomic creation to avoid TOCTOU races. */
void App::GetLock() {
	string lockpath = cfg->getOption("lockfile");
	struct stat statbuf;

	/* Attempt atomic creation */
	int fd = open(lockpath.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0644);
	if (fd >= 0) {
		if (!WriteLockPid(fd)) {
			logStream << APPNAME << ": Failed to write PID to lock file: " << lockpath << std::endl;
			close(fd);
			unlink(lockpath.c_str());
			exit(ERR_EXIT);
		}
		close(fd);
		return;
	}

	if (errno != EEXIST) {
		logStream << APPNAME << ": Could not create lock file: " << lockpath << ": " << strerror(errno) << std::endl;
		exit(ERR_EXIT);
	}

	/* Open with O_NOFOLLOW so symlinks are rejected atomically.
	 * fstat() on the open fd then checks type and ownership without
	 * a separate lstat() race. */
	int rfd = open(lockpath.c_str(), O_RDONLY | O_NOFOLLOW);
	if (rfd < 0) {
		if (errno == ELOOP)
			logStream << APPNAME << ": Security error: lock file is a symbolic link: " << lockpath << std::endl;
		else
			logStream << APPNAME << ": Could not open existing lock file: " << lockpath << ": " << strerror(errno) << std::endl;
		exit(ERR_EXIT);
	}

	if (fstat(rfd, &statbuf) != 0) {
		logStream << APPNAME << ": Could not stat existing lock file: " << lockpath << std::endl;
		close(rfd);
		exit(ERR_EXIT);
	}

	if (statbuf.st_uid != 0) {
		logStream << APPNAME << ": Security error: lock file is not owned by root: " << lockpath << std::endl;
		close(rfd);
		exit(ERR_EXIT);
	}

	if (!S_ISREG(statbuf.st_mode)) {
		logStream << APPNAME << ": Security error: lock file is not a regular file: " << lockpath << std::endl;
		close(rfd);
		exit(ERR_EXIT);
	}

	/* Read the PID and check if the process is alive */
	int pid = 0;
	char pidbuf[32] = {};
	ssize_t nr = read(rfd, pidbuf, sizeof(pidbuf) - 1);
	close(rfd);
	if (nr > 0)
		sscanf(pidbuf, "%d", &pid);

	if (pid > 0) {
		int ret = kill(pid, 0);
		if (ret == 0 || (ret == -1 && errno == EPERM)) {
			logStream << APPNAME << ": Another instance of the program is already running with PID " << pid << std::endl;
			exit(0);
		}
	}

	/* Stale lock — remove and re-create atomically */
	logStream << APPNAME << ": Stale lockfile found, removing it" << std::endl;
	if (unlink(lockpath.c_str()) != 0) {
		logStream << APPNAME << ": Could not remove stale lock file: " << lockpath << ": " << strerror(errno) << std::endl;
		exit(ERR_EXIT);
	}

	fd = open(lockpath.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0644);
	if (fd < 0) {
		logStream << APPNAME << ": Could not create lock file after removing stale one: " << lockpath << ": " << strerror(errno) << std::endl;
		exit(ERR_EXIT);
	}
	if (!WriteLockPid(fd)) {
		logStream << APPNAME << ": Failed to write PID to lock file: " << lockpath << std::endl;
		close(fd);
		unlink(lockpath.c_str());
		exit(ERR_EXIT);
	}
	close(fd);
}

/* Remove lockfile and close logs */
void App::RemoveLock() {
	remove(cfg->getOption("lockfile").c_str());
}

/* Get server start check flag. */
bool App::isServerStarted() {
	return serverStarted;
}

/* Redirect stdout and stderr to log file */
void App::OpenLog() {

	if ( !logStream.openLog( cfg->getOption("logfile").c_str() ) ) {
		logStream <<  APPNAME << ": Could not accesss log file: " << cfg->getOption("logfile") << endl;
		RemoveLock();
		exit(ERR_EXIT);
	}
	/* I should set the buffers to imediate write, but I just flush on every << operation. */
}

/* Relases stdout/err */
void App::CloseLog(){
	/* Simply closing the log */
	logStream.closeLog();
}

string App::findValidRandomTheme(const string& set)
{
	/* extract random theme from theme set; return empty string on error */
	string name = set;
	struct stat buf;

	if (!name.empty() && name[name.length()-1] == ',') {
		name = name.substr(0, name.length() - 1);
	}

	Util::srandom(Util::makeseed());

	vector<string> themes;
	string themefile;
	Cfg::split(themes, name, ',');
	if (themes.empty())
		return "";
	do {
		size_t sel = static_cast<size_t>(Util::random()) % themes.size();

		name = Cfg::Trim(themes[sel]);
		themefile = string(THEMESDIR) +"/" + name + THEMESFILE;
		if (stat(themefile.c_str(), &buf) != 0) {
			themes.erase(themes.begin() + sel);
			logStream << APPNAME << ": Invalid theme in config: "
				 << name << endl;
			name = "";
		}
	} while (name == "" && themes.size());
	return name;
}


void App::replaceVariables(string& input,
			   const string& var,
			   const string& value)
{
	string::size_type pos = 0;
	int len = var.size();
	while ((pos = input.find(var, pos)) != string::npos) {
		input = input.substr(0, pos) + value + input.substr(pos+len);
	}
}

void App::CreateServerAuth() {
	/* create mit cookie using cryptographically secure random bytes */
	uint8_t buf[App::mcookiesize / 2];
	const char *digits = "0123456789abcdef";
	arc4random_buf(buf, sizeof(buf));
	for (int i = 0; i < App::mcookiesize; i += 2) {
		mcookie[i]   = digits[buf[i/2] & 0x0f];
		mcookie[i+1] = digits[buf[i/2] >> 4];
	}
	/* reinitialize auth file */
	string authfile = cfg->getOption("authfile");
	remove(authfile.c_str());
	/* setenv copies the value internally; no manual buffer management needed */
	setenv("XAUTHORITY", authfile.c_str(), 1);
	Util::add_mcookie(mcookie, ":0", cfg->getOption("xauth_path"),
	  authfile);
}

char* App::StrConcat(const char* str1, const char* str2) {
	size_t str1len = 0; 
	size_t str2len = 0;
	size_t tmplen;
	if (str1 != NULL)
		str1len = strlen(str1);
	if (str2 != NULL)
		str2len = strlen(str2);
	tmplen = str1len + str2len + 1;
	char* tmp = new char[tmplen];

	strlcpy(tmp, str1, tmplen);

	if (str2 != NULL)
		strlcat(tmp, str2, tmplen);
	return tmp;
}

void App::UpdatePid() {
	string lockpath = cfg->getOption("lockfile");
	int fd = open(lockpath.c_str(), O_WRONLY | O_NOFOLLOW | O_TRUNC);
	if (fd < 0) {
		logStream << APPNAME << ": Could not update lock file: " << lockpath << ": " << strerror(errno) << std::endl;
		exit(ERR_EXIT);
	}
	if (!WriteLockPid(fd)) {
		logStream << APPNAME << ": Failed to write PID to lock file: " << lockpath << std::endl;
		close(fd);
		exit(ERR_EXIT);
	}
	close(fd);
}