moving 1.4 to trunk

src/lib/arch/CArchDaemonWindows.cpp

@@ -0,0 +1,841 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2002 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "CArchDaemonWindows.h"
+#include "CArch.h"
+#include "CArchMiscWindows.h"
+#include "XArchWindows.h"
+#include "stdvector.h"
+
+//
+// CArchDaemonWindows
+//
+
+CArchDaemonWindows*		CArchDaemonWindows::s_daemon = NULL;
+
+CArchDaemonWindows::CArchDaemonWindows() :
+m_daemonThreadID(0)
+{
+	m_quitMessage = RegisterWindowMessage("SynergyDaemonExit");
+}
+
+CArchDaemonWindows::~CArchDaemonWindows()
+{
+	// do nothing
+}
+
+int
+CArchDaemonWindows::runDaemon(RunFunc runFunc)
+{
+	assert(s_daemon != NULL);
+
+	return s_daemon->doRunDaemon(runFunc);
+}
+
+void
+CArchDaemonWindows::daemonRunning(bool running)
+{
+	// if s_daemon is NULL we assume we're running on the windows
+	// 95 family and we just ignore this call so the caller doesn't
+	// have to go through the trouble of not calling it on the
+	// windows 95 family.
+	if (s_daemon != NULL) {
+		s_daemon->doDaemonRunning(running);
+	}
+}
+
+UINT
+CArchDaemonWindows::getDaemonQuitMessage()
+{
+	if (s_daemon != NULL) {
+		return s_daemon->doGetDaemonQuitMessage();
+	}
+	else {
+		return 0;
+	}
+}
+
+void
+CArchDaemonWindows::daemonFailed(int result)
+{
+	// if s_daemon is NULL we assume we're running on the windows
+	// 95 family and we just ignore this call so the caller doesn't
+	// have to go through the trouble of not calling it on the
+	// windows 95 family.
+	if (s_daemon != NULL) {
+		throw XArchDaemonRunFailed(result);
+	}
+}
+
+void
+CArchDaemonWindows::installDaemon(const char* name,
+				const char* description,
+				const char* pathname,
+				const char* commandLine,
+				const char* dependencies,
+				bool allUsers)
+{
+	// if not for all users then use the user's autostart registry.
+	// key.  if windows 95 family then use windows 95 services key.
+	if (!allUsers || CArchMiscWindows::isWindows95Family()) {
+		// open registry
+		HKEY key = (allUsers && CArchMiscWindows::isWindows95Family()) ?
+							open95ServicesKey() : openUserStartupKey();
+		if (key == NULL) {
+			// can't open key
+			throw XArchDaemonInstallFailed(new XArchEvalWindows);
+		}
+
+		// construct entry
+		std::string value;
+		value += "\"";
+		value += pathname;
+		value += "\" ";
+		value += commandLine;
+
+		// install entry
+		CArchMiscWindows::setValue(key, name, value);
+
+		// clean up
+		CArchMiscWindows::closeKey(key);
+	}
+
+	// windows NT family services
+	else {
+		// open service manager
+		SC_HANDLE mgr = OpenSCManager(NULL, NULL, GENERIC_WRITE);
+		if (mgr == NULL) {
+			// can't open service manager
+			throw XArchDaemonInstallFailed(new XArchEvalWindows);
+		}
+
+		// create the service
+		SC_HANDLE service = CreateService(mgr,
+								name,
+								name,
+								0,
+								SERVICE_WIN32_OWN_PROCESS |
+									SERVICE_INTERACTIVE_PROCESS,
+								SERVICE_AUTO_START,
+								SERVICE_ERROR_NORMAL,
+								pathname,
+								NULL,
+								NULL,
+								dependencies,
+								NULL,
+								NULL);
+		if (service == NULL) {
+			// can't create service
+			DWORD err = GetLastError();
+			if (err != ERROR_SERVICE_EXISTS) {
+				CloseServiceHandle(mgr);
+				throw XArchDaemonInstallFailed(new XArchEvalWindows(err));
+			}
+		}
+		else {
+			// done with service (but only try to close if not null)
+			CloseServiceHandle(service);
+		}
+
+		// done with manager
+		CloseServiceHandle(mgr);
+
+		// open the registry key for this service
+		HKEY key = openNTServicesKey();
+		key      = CArchMiscWindows::addKey(key, name);
+		if (key == NULL) {
+			// can't open key
+			DWORD err = GetLastError();
+			try {
+				uninstallDaemon(name, allUsers);
+			}
+			catch (...) {
+				// ignore
+			}
+			throw XArchDaemonInstallFailed(new XArchEvalWindows(err));
+		}
+
+		// set the description
+		CArchMiscWindows::setValue(key, _T("Description"), description);
+
+		// set command line
+		key = CArchMiscWindows::addKey(key, _T("Parameters"));
+		if (key == NULL) {
+			// can't open key
+			DWORD err = GetLastError();
+			CArchMiscWindows::closeKey(key);
+			try {
+				uninstallDaemon(name, allUsers);
+			}
+			catch (...) {
+				// ignore
+			}
+			throw XArchDaemonInstallFailed(new XArchEvalWindows(err));
+		}
+		CArchMiscWindows::setValue(key, _T("CommandLine"), commandLine);
+
+		// done with registry
+		CArchMiscWindows::closeKey(key);
+	}
+}
+
+void
+CArchDaemonWindows::uninstallDaemon(const char* name, bool allUsers)
+{
+	// if not for all users then use the user's autostart registry.
+	// key.  if windows 95 family then use windows 95 services key.
+	if (!allUsers || CArchMiscWindows::isWindows95Family()) {
+		// open registry
+		HKEY key = (allUsers && CArchMiscWindows::isWindows95Family()) ?
+							open95ServicesKey() : openUserStartupKey();
+		if (key == NULL) {
+			// can't open key.  daemon is probably not installed.
+			throw XArchDaemonUninstallNotInstalled(new XArchEvalWindows);
+		}
+
+		// remove entry
+		CArchMiscWindows::deleteValue(key, name);
+
+		// clean up
+		CArchMiscWindows::closeKey(key);
+	}
+
+	// windows NT family services
+	else {
+		// remove parameters for this service.  ignore failures.
+		HKEY key = openNTServicesKey();
+		key      = CArchMiscWindows::openKey(key, name);
+		if (key != NULL) {
+			CArchMiscWindows::deleteKey(key, _T("Parameters"));
+			CArchMiscWindows::closeKey(key);
+		}
+
+		// open service manager
+		SC_HANDLE mgr = OpenSCManager(NULL, NULL, GENERIC_WRITE);
+		if (mgr == NULL) {
+			// can't open service manager
+			throw XArchDaemonUninstallFailed(new XArchEvalWindows);
+		}
+
+		// open the service.  oddly, you must open a service to delete it.
+		SC_HANDLE service = OpenService(mgr, name, DELETE | SERVICE_STOP);
+		if (service == NULL) {
+			DWORD err = GetLastError();
+			CloseServiceHandle(mgr);
+			if (err != ERROR_SERVICE_DOES_NOT_EXIST) {
+				throw XArchDaemonUninstallFailed(new XArchEvalWindows(err));
+			}
+			throw XArchDaemonUninstallNotInstalled(new XArchEvalWindows(err));
+		}
+
+		// stop the service.  we don't care if we fail.
+		SERVICE_STATUS status;
+		ControlService(service, SERVICE_CONTROL_STOP, &status);
+
+		// delete the service
+		const bool okay = (DeleteService(service) == 0);
+		const DWORD err = GetLastError();
+
+		// clean up
+		CloseServiceHandle(service);
+		CloseServiceHandle(mgr);
+
+		// give windows a chance to remove the service before
+		// we check if it still exists.
+		ARCH->sleep(1);
+
+		// handle failure.  ignore error if service isn't installed anymore.
+		if (!okay && isDaemonInstalled(name, allUsers)) {
+			if (err == ERROR_SUCCESS) {
+				// this seems to occur even though the uninstall was successful.
+				// it could be a timing issue, i.e., isDaemonInstalled is
+				// called too soon. i've added a sleep to try and stop this.
+				return;
+			}
+			if (err == ERROR_IO_PENDING) {
+				// this seems to be a spurious error
+				return;
+			}
+			if (err != ERROR_SERVICE_MARKED_FOR_DELETE) {
+				throw XArchDaemonUninstallFailed(new XArchEvalWindows(err));
+			}
+			throw XArchDaemonUninstallNotInstalled(new XArchEvalWindows(err));
+		}
+	}
+}
+
+int
+CArchDaemonWindows::daemonize(const char* name, DaemonFunc func)
+{
+	assert(name != NULL);
+	assert(func != NULL);
+
+	// windows 95 family services
+	if (CArchMiscWindows::isWindows95Family()) {
+		typedef DWORD (WINAPI *RegisterServiceProcessT)(DWORD, DWORD);
+
+		// mark this process as a service so it's not killed when the
+		// user logs off.
+		HINSTANCE kernel = LoadLibrary("kernel32.dll");
+		if (kernel == NULL) {
+			throw XArchDaemonFailed(new XArchEvalWindows);
+		}
+		RegisterServiceProcessT RegisterServiceProcess =
+								reinterpret_cast<RegisterServiceProcessT>(
+									GetProcAddress(kernel,
+										"RegisterServiceProcess"));
+		if (RegisterServiceProcess == NULL) {
+			// missing RegisterServiceProcess function
+			DWORD err = GetLastError();
+			FreeLibrary(kernel);
+			throw XArchDaemonFailed(new XArchEvalWindows(err));
+		}
+		if (RegisterServiceProcess(0, 1) == 0) {
+			// RegisterServiceProcess failed
+			DWORD err = GetLastError();
+			FreeLibrary(kernel);
+			throw XArchDaemonFailed(new XArchEvalWindows(err));
+		}
+		FreeLibrary(kernel);
+
+		// now simply call the daemon function
+		return func(1, &name);
+	}
+
+	// windows NT family services
+	else {
+		// save daemon function
+		m_daemonFunc = func;
+
+		// construct the service entry
+		SERVICE_TABLE_ENTRY entry[2];
+		entry[0].lpServiceName = const_cast<char*>(name);
+		entry[0].lpServiceProc = &CArchDaemonWindows::serviceMainEntry;
+		entry[1].lpServiceName = NULL;
+		entry[1].lpServiceProc = NULL;
+
+		// hook us up to the service control manager.  this won't return
+		// (if successful) until the processes have terminated.
+		s_daemon = this;
+		if (StartServiceCtrlDispatcher(entry) == 0) {
+			// StartServiceCtrlDispatcher failed
+			s_daemon = NULL;
+			throw XArchDaemonFailed(new XArchEvalWindows);
+		}
+
+		s_daemon = NULL;
+		return m_daemonResult;
+	}
+}
+
+bool
+CArchDaemonWindows::canInstallDaemon(const char* /*name*/, bool allUsers)
+{
+	// if not for all users then use the user's autostart registry.
+	// key.  if windows 95 family then use windows 95 services key.
+	if (!allUsers || CArchMiscWindows::isWindows95Family()) {
+		// check if we can open the registry key
+		HKEY key = (allUsers && CArchMiscWindows::isWindows95Family()) ?
+							open95ServicesKey() : openUserStartupKey();
+		CArchMiscWindows::closeKey(key);
+		return (key != NULL);
+	}
+
+	// windows NT family services
+	else {
+		// check if we can open service manager for write
+		SC_HANDLE mgr = OpenSCManager(NULL, NULL, GENERIC_WRITE);
+		if (mgr == NULL) {
+			return false;
+		}
+		CloseServiceHandle(mgr);
+
+		// check if we can open the registry key
+		HKEY key = openNTServicesKey();
+//		key      = CArchMiscWindows::addKey(key, name);
+//		key      = CArchMiscWindows::addKey(key, _T("Parameters"));
+		CArchMiscWindows::closeKey(key);
+
+		return (key != NULL);
+	}
+}
+
+bool
+CArchDaemonWindows::isDaemonInstalled(const char* name, bool allUsers)
+{
+	// open service manager
+	SC_HANDLE mgr = OpenSCManager(NULL, NULL, GENERIC_READ);
+	if (mgr == NULL) {
+		return false;
+	}
+
+	// open the service
+	SC_HANDLE service = OpenService(mgr, name, GENERIC_READ);
+
+	// clean up
+	if (service != NULL) {
+		CloseServiceHandle(service);
+	}
+	CloseServiceHandle(mgr);
+
+	return (service != NULL);
+}
+
+HKEY
+CArchDaemonWindows::openNTServicesKey()
+{
+	static const char* s_keyNames[] = {
+		_T("SYSTEM"),
+		_T("CurrentControlSet"),
+		_T("Services"),
+		NULL
+	};
+
+	return CArchMiscWindows::addKey(HKEY_LOCAL_MACHINE, s_keyNames);
+}
+
+HKEY
+CArchDaemonWindows::open95ServicesKey()
+{
+	static const char* s_keyNames[] = {
+		_T("Software"),
+		_T("Microsoft"),
+		_T("Windows"),
+		_T("CurrentVersion"),
+		_T("RunServices"),
+		NULL
+	};
+
+	return CArchMiscWindows::addKey(HKEY_LOCAL_MACHINE, s_keyNames);
+}
+
+HKEY
+CArchDaemonWindows::openUserStartupKey()
+{
+	static const char* s_keyNames[] = {
+		_T("Software"),
+		_T("Microsoft"),
+		_T("Windows"),
+		_T("CurrentVersion"),
+		_T("Run"),
+		NULL
+	};
+
+	return CArchMiscWindows::addKey(HKEY_CURRENT_USER, s_keyNames);
+}
+
+bool
+CArchDaemonWindows::isRunState(DWORD state)
+{
+	switch (state) {
+	case SERVICE_START_PENDING:
+	case SERVICE_CONTINUE_PENDING:
+	case SERVICE_RUNNING:
+		return true;
+
+	default:
+		return false;
+	}
+}
+
+int
+CArchDaemonWindows::doRunDaemon(RunFunc run)
+{
+	// should only be called from DaemonFunc
+	assert(m_serviceMutex != NULL);
+	assert(run            != NULL);
+
+	// create message queue for this thread
+	MSG dummy;
+	PeekMessage(&dummy, NULL, 0, 0, PM_NOREMOVE);
+
+	int result = 0;
+	ARCH->lockMutex(m_serviceMutex);
+	m_daemonThreadID = GetCurrentThreadId();
+	while (m_serviceState != SERVICE_STOPPED) {
+		// wait until we're told to start
+		while (!isRunState(m_serviceState) &&
+				m_serviceState != SERVICE_STOP_PENDING) {
+			ARCH->waitCondVar(m_serviceCondVar, m_serviceMutex, -1.0);
+		}
+
+		// run unless told to stop
+		if (m_serviceState != SERVICE_STOP_PENDING) {
+			ARCH->unlockMutex(m_serviceMutex);
+			try {
+				result = run();
+			}
+			catch (...) {
+				ARCH->lockMutex(m_serviceMutex);
+				setStatusError(0);
+				m_serviceState = SERVICE_STOPPED;
+				setStatus(m_serviceState);
+				ARCH->broadcastCondVar(m_serviceCondVar);
+				ARCH->unlockMutex(m_serviceMutex);
+				throw;
+			}
+			ARCH->lockMutex(m_serviceMutex);
+		}
+
+		// notify of new state
+		if (m_serviceState == SERVICE_PAUSE_PENDING) {
+			m_serviceState = SERVICE_PAUSED;
+		}
+		else {
+			m_serviceState = SERVICE_STOPPED;
+		}
+		setStatus(m_serviceState);
+		ARCH->broadcastCondVar(m_serviceCondVar);
+	}
+	ARCH->unlockMutex(m_serviceMutex);
+	return result;
+}
+
+void
+CArchDaemonWindows::doDaemonRunning(bool running)
+{
+	ARCH->lockMutex(m_serviceMutex);
+	if (running) {
+		m_serviceState = SERVICE_RUNNING;
+		setStatus(m_serviceState);
+		ARCH->broadcastCondVar(m_serviceCondVar);
+	}
+	ARCH->unlockMutex(m_serviceMutex);
+}
+
+UINT
+CArchDaemonWindows::doGetDaemonQuitMessage()
+{
+	return m_quitMessage;
+}
+
+void
+CArchDaemonWindows::setStatus(DWORD state)
+{
+	setStatus(state, 0, 0);
+}
+
+void
+CArchDaemonWindows::setStatus(DWORD state, DWORD step, DWORD waitHint)
+{
+	assert(s_daemon != NULL);
+
+	SERVICE_STATUS status;
+	status.dwServiceType             = SERVICE_WIN32_OWN_PROCESS |
+										SERVICE_INTERACTIVE_PROCESS;
+	status.dwCurrentState            = state;
+	status.dwControlsAccepted        = SERVICE_ACCEPT_STOP |
+										SERVICE_ACCEPT_PAUSE_CONTINUE |
+										SERVICE_ACCEPT_SHUTDOWN;
+	status.dwWin32ExitCode           = NO_ERROR;
+	status.dwServiceSpecificExitCode = 0;
+	status.dwCheckPoint              = step;
+	status.dwWaitHint                = waitHint;
+	SetServiceStatus(s_daemon->m_statusHandle, &status);
+}
+
+void
+CArchDaemonWindows::setStatusError(DWORD error)
+{
+	assert(s_daemon != NULL);
+
+	SERVICE_STATUS status;
+	status.dwServiceType             = SERVICE_WIN32_OWN_PROCESS |
+										SERVICE_INTERACTIVE_PROCESS;
+	status.dwCurrentState            = SERVICE_STOPPED;
+	status.dwControlsAccepted        = SERVICE_ACCEPT_STOP |
+										SERVICE_ACCEPT_PAUSE_CONTINUE |
+										SERVICE_ACCEPT_SHUTDOWN;
+	status.dwWin32ExitCode           = ERROR_SERVICE_SPECIFIC_ERROR;
+	status.dwServiceSpecificExitCode = error;
+	status.dwCheckPoint              = 0;
+	status.dwWaitHint                = 0;
+	SetServiceStatus(s_daemon->m_statusHandle, &status);
+}
+
+void
+CArchDaemonWindows::serviceMain(DWORD argc, LPTSTR* argvIn)
+{
+	typedef std::vector<LPCTSTR> ArgList;
+	typedef std::vector<std::string> Arguments;
+	const char** argv = const_cast<const char**>(argvIn);
+
+	// create synchronization objects
+	m_serviceMutex        = ARCH->newMutex();
+	m_serviceCondVar      = ARCH->newCondVar();
+	
+	// register our service handler function
+	m_statusHandle = RegisterServiceCtrlHandler(argv[0],
+								&CArchDaemonWindows::serviceHandlerEntry);
+	if (m_statusHandle == 0) {
+		// cannot start as service
+		m_daemonResult = -1;
+		ARCH->closeCondVar(m_serviceCondVar);
+		ARCH->closeMutex(m_serviceMutex);
+		return;
+	}
+
+	// tell service control manager that we're starting
+	m_serviceState = SERVICE_START_PENDING;
+	setStatus(m_serviceState, 0, 10000);
+
+	std::string commandLine;
+
+	// if no arguments supplied then try getting them from the registry.
+	// the first argument doesn't count because it's the service name.
+	Arguments args;
+	ArgList myArgv;
+	if (argc <= 1) {
+		// read command line
+		HKEY key = openNTServicesKey();
+		key      = CArchMiscWindows::openKey(key, argvIn[0]);
+		key      = CArchMiscWindows::openKey(key, _T("Parameters"));
+		if (key != NULL) {
+			commandLine = CArchMiscWindows::readValueString(key,
+												_T("CommandLine"));
+		}
+
+		// if the command line isn't empty then parse and use it
+		if (!commandLine.empty()) {
+			// parse, honoring double quoted substrings
+			std::string::size_type i = commandLine.find_first_not_of(" \t");
+			while (i != std::string::npos && i != commandLine.size()) {
+				// find end of string
+				std::string::size_type e;
+				if (commandLine[i] == '\"') {
+					// quoted.  find closing quote.
+					++i;
+					e = commandLine.find("\"", i);
+
+					// whitespace must follow closing quote
+					if (e == std::string::npos ||
+						(e + 1 != commandLine.size() &&
+						commandLine[e + 1] != ' ' &&
+						commandLine[e + 1] != '\t')) {
+						args.clear();
+						break;
+					}
+
+					// extract
+					args.push_back(commandLine.substr(i, e - i));
+					i = e + 1;
+				}
+				else {
+					// unquoted.  find next whitespace.
+					e = commandLine.find_first_of(" \t", i);
+					if (e == std::string::npos) {
+						e = commandLine.size();
+					}
+
+					// extract
+					args.push_back(commandLine.substr(i, e - i));
+					i = e + 1;
+				}
+
+				// next argument
+				i = commandLine.find_first_not_of(" \t", i);
+			}
+
+			// service name goes first
+			myArgv.push_back(argv[0]);
+
+			// get pointers
+			for (size_t j = 0; j < args.size(); ++j) {
+				myArgv.push_back(args[j].c_str());
+			}
+
+			// adjust argc/argv
+			argc = (DWORD)myArgv.size();
+			argv = &myArgv[0];
+		}
+	}
+
+	m_commandLine = commandLine;
+
+	try {
+		// invoke daemon function
+		m_daemonResult = m_daemonFunc(static_cast<int>(argc), argv);
+	}
+	catch (XArchDaemonRunFailed& e) {
+		setStatusError(e.m_result);
+		m_daemonResult = -1;
+	}
+	catch (...) {
+		setStatusError(1);
+		m_daemonResult = -1;
+	}
+
+	// clean up
+	ARCH->closeCondVar(m_serviceCondVar);
+	ARCH->closeMutex(m_serviceMutex);
+
+	// we're going to exit now, so set status to stopped
+	m_serviceState = SERVICE_STOPPED;
+	setStatus(m_serviceState, 0, 10000);
+}
+
+void WINAPI
+CArchDaemonWindows::serviceMainEntry(DWORD argc, LPTSTR* argv)
+{
+	s_daemon->serviceMain(argc, argv);
+}
+
+void
+CArchDaemonWindows::serviceHandler(DWORD ctrl)
+{
+	assert(m_serviceMutex   != NULL);
+	assert(m_serviceCondVar != NULL);
+
+	ARCH->lockMutex(m_serviceMutex);
+
+	// ignore request if service is already stopped
+	if (s_daemon == NULL || m_serviceState == SERVICE_STOPPED) {
+		if (s_daemon != NULL) {
+			setStatus(m_serviceState);
+		}
+		ARCH->unlockMutex(m_serviceMutex);
+		return;
+	}
+
+	switch (ctrl) {
+	case SERVICE_CONTROL_PAUSE:
+		m_serviceState = SERVICE_PAUSE_PENDING;
+		setStatus(m_serviceState, 0, 5000);
+		PostThreadMessage(m_daemonThreadID, m_quitMessage, 0, 0);
+		while (isRunState(m_serviceState)) {
+			ARCH->waitCondVar(m_serviceCondVar, m_serviceMutex, -1.0);
+		}
+		break;
+
+	case SERVICE_CONTROL_CONTINUE:
+		// FIXME -- maybe should flush quit messages from queue
+		m_serviceState = SERVICE_CONTINUE_PENDING;
+		setStatus(m_serviceState, 0, 5000);
+		ARCH->broadcastCondVar(m_serviceCondVar);
+		break;
+
+	case SERVICE_CONTROL_STOP:
+	case SERVICE_CONTROL_SHUTDOWN:
+		m_serviceState = SERVICE_STOP_PENDING;
+		setStatus(m_serviceState, 0, 5000);
+		PostThreadMessage(m_daemonThreadID, m_quitMessage, 0, 0);
+		ARCH->broadcastCondVar(m_serviceCondVar);
+		while (isRunState(m_serviceState)) {
+			ARCH->waitCondVar(m_serviceCondVar, m_serviceMutex, -1.0);
+		}
+		break;
+
+	default:
+		// unknown service command
+		// fall through
+
+	case SERVICE_CONTROL_INTERROGATE:
+		setStatus(m_serviceState);
+		break;
+	}
+
+	ARCH->unlockMutex(m_serviceMutex);
+}
+
+void WINAPI
+CArchDaemonWindows::serviceHandlerEntry(DWORD ctrl)
+{
+	s_daemon->serviceHandler(ctrl);
+}
+
+void
+CArchDaemonWindows::start(const char* name)
+{
+	// open service manager
+	SC_HANDLE mgr = OpenSCManager(NULL, NULL, GENERIC_READ);
+	if (mgr == NULL) {
+		throw XArchDaemonFailed(new XArchEvalWindows());
+	}
+
+	// open the service
+	SC_HANDLE service = OpenService(
+		mgr, name, SERVICE_START);
+
+	if (service == NULL) {
+		CloseServiceHandle(mgr);
+		throw XArchDaemonFailed(new XArchEvalWindows());
+	}
+
+	// start the service
+	if (!StartService(service, 0, NULL)) {
+		throw XArchDaemonFailed(new XArchEvalWindows());
+	}
+}
+
+void
+CArchDaemonWindows::stop(const char* name)
+{
+	// open service manager
+	SC_HANDLE mgr = OpenSCManager(NULL, NULL, GENERIC_READ);
+	if (mgr == NULL) {
+		throw XArchDaemonFailed(new XArchEvalWindows());
+	}
+
+	// open the service
+	SC_HANDLE service = OpenService(
+		mgr, name,
+		SERVICE_STOP | SERVICE_QUERY_STATUS);
+
+	if (service == NULL) {
+		CloseServiceHandle(mgr);
+		throw XArchDaemonFailed(new XArchEvalWindows());
+	}
+
+	// ask the service to stop, asynchronously
+	SERVICE_STATUS ss;
+	if (!ControlService(service, SERVICE_CONTROL_STOP, &ss)) {
+		DWORD dwErrCode = GetLastError(); 
+		if (dwErrCode != ERROR_SERVICE_NOT_ACTIVE) {
+			throw XArchDaemonFailed(new XArchEvalWindows());
+		}
+	}
+}
+
+void
+CArchDaemonWindows::installDaemon()
+{
+	// install default daemon if not already installed.
+	if (!isDaemonInstalled(DEFAULT_DAEMON_NAME, true)) {
+		char path[MAX_PATH];
+		GetModuleFileName(CArchMiscWindows::instanceWin32(), path, MAX_PATH);
+		installDaemon(DEFAULT_DAEMON_NAME, DEFAULT_DAEMON_INFO, path, "", "", true);
+	}
+
+	start(DEFAULT_DAEMON_NAME);
+}
+
+void
+CArchDaemonWindows::uninstallDaemon()
+{
+	// remove legacy services if installed.
+	if (isDaemonInstalled(LEGACY_SERVER_DAEMON_NAME, true)) {
+		uninstallDaemon(LEGACY_SERVER_DAEMON_NAME, true);
+	}
+	if (isDaemonInstalled(LEGACY_CLIENT_DAEMON_NAME, true)) {
+		uninstallDaemon(LEGACY_CLIENT_DAEMON_NAME, true);
+	}
+
+	// remove new service if installed.
+	if (isDaemonInstalled(DEFAULT_DAEMON_NAME, true)) {
+		uninstallDaemon(DEFAULT_DAEMON_NAME, true);
+	}
+}