mirror of
https://github.com/TigerVNC/tigervnc.git
synced 2024-08-21 05:58:01 +02:00
![Constantin Kaplinsky](/assets/img/avatar_default.png)
git-svn-id: svn://svn.code.sf.net/p/tigervnc/code/trunk@2 3789f03b-4d11-0410-bbf8-ca57d06f2519
638 lines
19 KiB
C++
638 lines
19 KiB
C++
/* Copyright (C) 2002-2003 RealVNC Ltd. All Rights Reserved.
|
|
*
|
|
* This 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.
|
|
*
|
|
* This software 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 software; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
* USA.
|
|
*/
|
|
|
|
// -=- Service.cxx
|
|
|
|
#include <rfb_win32/Service.h>
|
|
#include <rfb_win32/MsgWindow.h>
|
|
#include <rfb_win32/Registry.h>
|
|
#include <rfb_win32/Win32Util.h>
|
|
#include <rfb_win32/OSVersion.h>
|
|
#include <rfb/Threading.h>
|
|
#include <rfb/LogWriter.h>
|
|
#include <rfb/util.h>
|
|
#include <rdr/Exception.h>
|
|
|
|
#include <logmessages/messages.h>
|
|
|
|
using namespace rdr;
|
|
using namespace rfb;
|
|
using namespace win32;
|
|
|
|
static LogWriter vlog("Service");
|
|
|
|
|
|
// - Internal service implementation functions
|
|
|
|
Service* service = 0;
|
|
|
|
VOID WINAPI serviceHandler(DWORD control) {
|
|
vlog.debug("service control %u", control);
|
|
switch (control) {
|
|
case SERVICE_CONTROL_INTERROGATE:
|
|
service->setStatus();
|
|
break;
|
|
case SERVICE_CONTROL_PARAMCHANGE:
|
|
service->readParams();
|
|
break;
|
|
case SERVICE_CONTROL_SHUTDOWN:
|
|
service->osShuttingDown();
|
|
break;
|
|
case SERVICE_CONTROL_STOP:
|
|
service->setStatus(SERVICE_STOP_PENDING);
|
|
service->stop();
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
// -=- Message window derived class used under Win9x to implement stopService
|
|
|
|
#define WM_SMSG_SERVICE_STOP WM_USER
|
|
|
|
class ServiceMsgWindow : public MsgWindow {
|
|
public:
|
|
ServiceMsgWindow(const TCHAR* name) : MsgWindow(name) {}
|
|
LRESULT processMessage(UINT msg, WPARAM wParam, LPARAM lParam) {
|
|
switch (msg) {
|
|
case WM_SMSG_SERVICE_STOP:
|
|
service->stop();
|
|
return TRUE;
|
|
}
|
|
return MsgWindow::processMessage(msg, wParam, lParam);
|
|
}
|
|
|
|
static const TCHAR* baseName;
|
|
};
|
|
|
|
const TCHAR* ServiceMsgWindow::baseName = _T("ServiceWindow:");
|
|
|
|
|
|
// -=- Service main procedure, used under WinNT/2K/XP by the SCM
|
|
|
|
VOID WINAPI serviceProc(DWORD dwArgc, LPTSTR* lpszArgv) {
|
|
vlog.debug("entering %s serviceProc", service->getName());
|
|
service->status_handle = RegisterServiceCtrlHandler(service->getName(), serviceHandler);
|
|
if (!service->status_handle) {
|
|
vlog.error("unable to register service control handler");
|
|
return;
|
|
}
|
|
service->setStatus(SERVICE_START_PENDING);
|
|
vlog.debug("entering %s serviceMain", service->getName());
|
|
service->status.dwWin32ExitCode = service->serviceMain(dwArgc, lpszArgv);
|
|
vlog.debug("leaving %s serviceMain", service->getName());
|
|
service->setStatus(SERVICE_STOPPED);
|
|
}
|
|
|
|
|
|
// -=- Service
|
|
|
|
Service::Service(const TCHAR* name_) : name(name_) {
|
|
vlog.debug("Service");
|
|
status_handle = 0;
|
|
status.dwControlsAccepted = SERVICE_CONTROL_INTERROGATE | SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_STOP;
|
|
status.dwServiceType = SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS;
|
|
status.dwWin32ExitCode = NO_ERROR;
|
|
status.dwServiceSpecificExitCode = 0;
|
|
status.dwCheckPoint = 0;
|
|
status.dwWaitHint = 30000;
|
|
status.dwCurrentState = SERVICE_STOPPED;
|
|
}
|
|
|
|
void
|
|
Service::start() {
|
|
if (osVersion.isPlatformNT) {
|
|
SERVICE_TABLE_ENTRY entry[2];
|
|
entry[0].lpServiceName = (TCHAR*)name;
|
|
entry[0].lpServiceProc = serviceProc;
|
|
entry[1].lpServiceName = NULL;
|
|
entry[1].lpServiceProc = NULL;
|
|
vlog.debug("entering dispatcher");
|
|
if (!SetProcessShutdownParameters(0x100, 0))
|
|
vlog.error("unable to set shutdown parameters: %d", GetLastError());
|
|
service = this;
|
|
if (!StartServiceCtrlDispatcher(entry))
|
|
throw SystemException("unable to start service", GetLastError());
|
|
} else {
|
|
|
|
// - Create the service window, so the service can be stopped
|
|
TCharArray wndName(_tcslen(getName()) + _tcslen(ServiceMsgWindow::baseName) + 1);
|
|
_tcscpy(wndName.buf, ServiceMsgWindow::baseName);
|
|
_tcscat(wndName.buf, getName());
|
|
ServiceMsgWindow service_window(wndName.buf);
|
|
|
|
// - Locate the RegisterServiceProcess function
|
|
typedef DWORD (WINAPI * _RegisterServiceProcess_proto)(DWORD, DWORD);
|
|
DynamicFn<_RegisterServiceProcess_proto> _RegisterServiceProcess(_T("kernel32.dll"), "RegisterServiceProcess");
|
|
if (!_RegisterServiceProcess.isValid())
|
|
throw Exception("unable to find RegisterServiceProcess");
|
|
|
|
// - Run the service
|
|
(*_RegisterServiceProcess)(NULL, 1);
|
|
service = this;
|
|
serviceMain(0, 0);
|
|
(*_RegisterServiceProcess)(NULL, 0);
|
|
}
|
|
}
|
|
|
|
void
|
|
Service::setStatus() {
|
|
setStatus(status.dwCurrentState);
|
|
}
|
|
|
|
void
|
|
Service::setStatus(DWORD state) {
|
|
if (!osVersion.isPlatformNT)
|
|
return;
|
|
if (status_handle == 0) {
|
|
vlog.debug("warning - cannot setStatus");
|
|
return;
|
|
}
|
|
status.dwCurrentState = state;
|
|
status.dwCheckPoint++;
|
|
if (!SetServiceStatus(status_handle, &status)) {
|
|
status.dwWin32ExitCode = GetLastError();
|
|
vlog.error("unable to set service status:%u", status.dwWin32ExitCode);
|
|
stop();
|
|
}
|
|
vlog.debug("set status to %u(%u)", state, status.dwCheckPoint);
|
|
}
|
|
|
|
Service::~Service() {
|
|
vlog.debug("~Service");
|
|
service = 0;
|
|
}
|
|
|
|
|
|
// Find out whether this process is running as the WinVNC service
|
|
bool thisIsService() {
|
|
return service && (service->status.dwCurrentState != SERVICE_STOPPED);
|
|
}
|
|
|
|
|
|
// -=- Desktop handling code
|
|
|
|
// Switch the current thread to the specified desktop
|
|
static bool
|
|
switchToDesktop(HDESK desktop) {
|
|
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
|
|
if (!SetThreadDesktop(desktop)) {
|
|
vlog.debug("switchToDesktop failed:%u", GetLastError());
|
|
return false;
|
|
}
|
|
if (!CloseDesktop(old_desktop))
|
|
vlog.debug("unable to close old desktop:%u", GetLastError());
|
|
return true;
|
|
}
|
|
|
|
// Determine whether the thread's current desktop is the input one
|
|
static bool
|
|
inputDesktopSelected() {
|
|
HDESK current = GetThreadDesktop(GetCurrentThreadId());
|
|
HDESK input = OpenInputDesktop(0, FALSE,
|
|
DESKTOP_CREATEMENU | DESKTOP_CREATEWINDOW |
|
|
DESKTOP_ENUMERATE | DESKTOP_HOOKCONTROL |
|
|
DESKTOP_WRITEOBJECTS | DESKTOP_READOBJECTS |
|
|
DESKTOP_SWITCHDESKTOP | GENERIC_WRITE);
|
|
if (!input) {
|
|
vlog.debug("unable to OpenInputDesktop(1):%u", GetLastError());
|
|
return false;
|
|
}
|
|
|
|
DWORD size;
|
|
char currentname[256];
|
|
char inputname[256];
|
|
|
|
if (!GetUserObjectInformation(current, UOI_NAME, currentname, 256, &size)) {
|
|
vlog.debug("unable to GetUserObjectInformation(1):%u", GetLastError());
|
|
CloseDesktop(input);
|
|
return false;
|
|
}
|
|
if (!GetUserObjectInformation(input, UOI_NAME, inputname, 256, &size)) {
|
|
vlog.debug("unable to GetUserObjectInformation(2):%u", GetLastError());
|
|
CloseDesktop(input);
|
|
return false;
|
|
}
|
|
if (!CloseDesktop(input))
|
|
vlog.debug("unable to close input desktop:%u", GetLastError());
|
|
|
|
// *** vlog.debug("current=%s, input=%s", currentname, inputname);
|
|
bool result = strcmp(currentname, inputname) == 0;
|
|
return result;
|
|
}
|
|
|
|
// Switch the current thread into the input desktop
|
|
static bool
|
|
selectInputDesktop() {
|
|
// - Open the input desktop
|
|
HDESK desktop = OpenInputDesktop(0, FALSE,
|
|
DESKTOP_CREATEMENU | DESKTOP_CREATEWINDOW |
|
|
DESKTOP_ENUMERATE | DESKTOP_HOOKCONTROL |
|
|
DESKTOP_WRITEOBJECTS | DESKTOP_READOBJECTS |
|
|
DESKTOP_SWITCHDESKTOP | GENERIC_WRITE);
|
|
if (!desktop) {
|
|
vlog.debug("unable to OpenInputDesktop(2):%u", GetLastError());
|
|
return false;
|
|
}
|
|
|
|
// - Switch into it
|
|
if (!switchToDesktop(desktop)) {
|
|
CloseDesktop(desktop);
|
|
return false;
|
|
}
|
|
|
|
// ***
|
|
DWORD size = 256;
|
|
char currentname[256];
|
|
if (GetUserObjectInformation(desktop, UOI_NAME, currentname, 256, &size)) {
|
|
vlog.debug("switched to %s", currentname);
|
|
}
|
|
// ***
|
|
|
|
vlog.debug("switched to input desktop");
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// -=- Access points to desktop-switching routines
|
|
|
|
bool
|
|
rfb::win32::desktopChangeRequired() {
|
|
if (!osVersion.isPlatformNT)
|
|
return false;
|
|
|
|
return !inputDesktopSelected();
|
|
}
|
|
|
|
bool
|
|
rfb::win32::changeDesktop() {
|
|
if (!osVersion.isPlatformNT)
|
|
return true;
|
|
if (osVersion.cannotSwitchDesktop)
|
|
return false;
|
|
|
|
return selectInputDesktop();
|
|
}
|
|
|
|
|
|
// -=- Ctrl-Alt-Del emulation
|
|
|
|
class CADThread : public Thread {
|
|
public:
|
|
CADThread() : Thread("CtrlAltDel Emulator"), result(false) {}
|
|
virtual void run() {
|
|
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
|
|
|
|
if (switchToDesktop(OpenDesktop(_T("Winlogon"), 0, FALSE, DESKTOP_CREATEMENU | DESKTOP_CREATEWINDOW |
|
|
DESKTOP_ENUMERATE | DESKTOP_HOOKCONTROL |
|
|
DESKTOP_WRITEOBJECTS | DESKTOP_READOBJECTS |
|
|
DESKTOP_SWITCHDESKTOP | GENERIC_WRITE))) {
|
|
PostMessage(HWND_BROADCAST, WM_HOTKEY, 0, MAKELONG(MOD_ALT | MOD_CONTROL, VK_DELETE));
|
|
switchToDesktop(old_desktop);
|
|
result = true;
|
|
}
|
|
}
|
|
bool result;
|
|
};
|
|
|
|
bool
|
|
rfb::win32::emulateCtrlAltDel() {
|
|
if (!osVersion.isPlatformNT)
|
|
return false;
|
|
|
|
CADThread* cad_thread = new CADThread();
|
|
vlog.debug("emulate Ctrl-Alt-Del");
|
|
if (cad_thread) {
|
|
cad_thread->start();
|
|
cad_thread->join();
|
|
bool result = cad_thread->result;
|
|
delete cad_thread;
|
|
return result;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
// -=- Application Event Log target Logger class
|
|
|
|
class Logger_EventLog : public Logger {
|
|
public:
|
|
Logger_EventLog(const TCHAR* srcname) : Logger("EventLog") {
|
|
eventlog = RegisterEventSource(NULL, srcname);
|
|
if (!eventlog)
|
|
printf("Unable to open event log:%ld\n", GetLastError());
|
|
}
|
|
~Logger_EventLog() {
|
|
if (eventlog)
|
|
DeregisterEventSource(eventlog);
|
|
}
|
|
|
|
virtual void write(int level, const char *logname, const char *message) {
|
|
if (!eventlog) return;
|
|
TStr log(logname), msg(message);
|
|
const TCHAR* strings[] = {log, msg};
|
|
WORD type = EVENTLOG_INFORMATION_TYPE;
|
|
if (level == 0) type = EVENTLOG_ERROR_TYPE;
|
|
if (!ReportEvent(eventlog, type, 0, VNC4LogMessage, NULL, 2, 0, strings, NULL)) {
|
|
// *** It's not at all clear what is the correct behaviour if this fails...
|
|
printf("ReportEvent failed:%ld\n", GetLastError());
|
|
}
|
|
}
|
|
|
|
protected:
|
|
HANDLE eventlog;
|
|
};
|
|
|
|
static Logger_EventLog* logger = 0;
|
|
|
|
bool rfb::win32::initEventLogLogger(const TCHAR* srcname) {
|
|
if (logger)
|
|
return false;
|
|
if (osVersion.isPlatformNT) {
|
|
logger = new Logger_EventLog(srcname);
|
|
logger->registerLogger();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// -=- Registering and unregistering the service
|
|
|
|
bool rfb::win32::registerService(const TCHAR* name, const TCHAR* desc,
|
|
int argc, const char* argv[]) {
|
|
|
|
// - Initialise the default service parameters
|
|
const TCHAR* defaultcmdline;
|
|
if (osVersion.isPlatformNT)
|
|
defaultcmdline = _T("-service");
|
|
else
|
|
defaultcmdline = _T("-noconsole -service");
|
|
|
|
// - Get the full pathname of our executable
|
|
ModuleFileName buffer;
|
|
|
|
// - Calculate the command-line length
|
|
int cmdline_len = _tcslen(buffer.buf) + 4;
|
|
int i;
|
|
for (i=0; i<argc; i++) {
|
|
cmdline_len += strlen(argv[i]) + 3;
|
|
}
|
|
|
|
// - Add the supplied extra parameters to the command line
|
|
TCharArray cmdline(cmdline_len+_tcslen(defaultcmdline));
|
|
_stprintf(cmdline.buf, _T("\"%s\" %s"), buffer.buf, defaultcmdline);
|
|
for (i=0; i<argc; i++) {
|
|
_tcscat(cmdline.buf, _T(" \""));
|
|
_tcscat(cmdline.buf, TStr(argv[i]));
|
|
_tcscat(cmdline.buf, _T("\""));
|
|
}
|
|
|
|
// - Register the service
|
|
|
|
if (osVersion.isPlatformNT) {
|
|
|
|
// - Open the SCM
|
|
ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
|
|
if (!scm)
|
|
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
|
|
|
|
|
|
ServiceHandle service = CreateService(scm,
|
|
name, desc, SC_MANAGER_ALL_ACCESS,
|
|
SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
|
|
SERVICE_AUTO_START, SERVICE_ERROR_IGNORE,
|
|
cmdline.buf, NULL, NULL, NULL, NULL, NULL);
|
|
if (!service)
|
|
throw rdr::SystemException("unable to create service", GetLastError());
|
|
|
|
// - Register the event log source
|
|
RegKey hk, hk2;
|
|
|
|
hk2.createKey(HKEY_LOCAL_MACHINE, _T("SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application"));
|
|
hk.createKey(hk2, name);
|
|
|
|
for (i=_tcslen(buffer.buf); i>0; i--) {
|
|
if (buffer.buf[i] == _T('\\')) {
|
|
buffer.buf[i+1] = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
const TCHAR* dllFilename = _T("logmessages.dll");
|
|
TCharArray dllPath(_tcslen(buffer.buf) + _tcslen(dllFilename) + 1);
|
|
_tcscpy(dllPath.buf, buffer.buf);
|
|
_tcscat(dllPath.buf, dllFilename);
|
|
|
|
hk.setExpandString(_T("EventMessageFile"), dllPath.buf);
|
|
hk.setInt(_T("TypesSupported"), EVENTLOG_ERROR_TYPE | EVENTLOG_INFORMATION_TYPE);
|
|
|
|
} else {
|
|
|
|
RegKey services;
|
|
services.createKey(HKEY_LOCAL_MACHINE, _T("Software\\Microsoft\\Windows\\CurrentVersion\\RunServices"));
|
|
services.setString(name, cmdline.buf);
|
|
|
|
}
|
|
|
|
Sleep(500);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool rfb::win32::unregisterService(const TCHAR* name) {
|
|
if (osVersion.isPlatformNT) {
|
|
|
|
// - Open the SCM
|
|
ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
|
|
if (!scm)
|
|
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
|
|
|
|
// - Create the service
|
|
ServiceHandle service = OpenService(scm, name, SC_MANAGER_ALL_ACCESS);
|
|
if (!service)
|
|
throw rdr::SystemException("unable to locate the service", GetLastError());
|
|
if (!DeleteService(service))
|
|
throw rdr::SystemException("unable to remove the service", GetLastError());
|
|
|
|
// - Register the event log source
|
|
RegKey hk;
|
|
hk.openKey(HKEY_LOCAL_MACHINE, _T("SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application"));
|
|
hk.deleteKey(name);
|
|
|
|
} else {
|
|
|
|
RegKey services;
|
|
services.openKey(HKEY_LOCAL_MACHINE, _T("Software\\Microsoft\\Windows\\CurrentVersion\\RunServices"));
|
|
services.deleteValue(name);
|
|
|
|
}
|
|
|
|
Sleep(500);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// -=- Starting and stopping the service
|
|
|
|
HWND findServiceWindow(const TCHAR* name) {
|
|
TCharArray wndName(_tcslen(ServiceMsgWindow::baseName)+_tcslen(name)+1);
|
|
_tcscpy(wndName.buf, ServiceMsgWindow::baseName);
|
|
_tcscat(wndName.buf, name);
|
|
vlog.debug("searching for %s window", CStr(wndName.buf));
|
|
return FindWindow(0, wndName.buf);
|
|
}
|
|
|
|
bool rfb::win32::startService(const TCHAR* name) {
|
|
|
|
if (osVersion.isPlatformNT) {
|
|
// - Open the SCM
|
|
ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
|
|
if (!scm)
|
|
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
|
|
|
|
// - Locate the service
|
|
ServiceHandle service = OpenService(scm, name, SERVICE_START);
|
|
if (!service)
|
|
throw rdr::SystemException("unable to open the service", GetLastError());
|
|
|
|
// - Start the service
|
|
if (!StartService(service, 0, NULL))
|
|
throw rdr::SystemException("unable to start the service", GetLastError());
|
|
} else {
|
|
// - Check there is no service window
|
|
if (findServiceWindow(name))
|
|
throw rdr::Exception("the service is already running");
|
|
|
|
// - Find the RunServices registry key
|
|
RegKey services;
|
|
services.openKey(HKEY_LOCAL_MACHINE, _T("Software\\Microsoft\\Windows\\CurrentVersion\\RunServices"));
|
|
|
|
// - Read the command-line from it
|
|
TCharArray cmdLine = services.getString(name);
|
|
|
|
// - Start the service
|
|
PROCESS_INFORMATION proc_info;
|
|
STARTUPINFO startup_info;
|
|
ZeroMemory(&startup_info, sizeof(startup_info));
|
|
startup_info.cb = sizeof(startup_info);
|
|
if (!CreateProcess(0, cmdLine.buf, 0, 0, FALSE, CREATE_NEW_CONSOLE, 0, 0, &startup_info, &proc_info)) {
|
|
throw SystemException("unable to start service", GetLastError());
|
|
}
|
|
}
|
|
|
|
Sleep(500);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool rfb::win32::stopService(const TCHAR* name) {
|
|
if (osVersion.isPlatformNT) {
|
|
// - Open the SCM
|
|
ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
|
|
if (!scm)
|
|
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
|
|
|
|
// - Locate the service
|
|
ServiceHandle service = OpenService(scm, name, SERVICE_STOP);
|
|
if (!service)
|
|
throw rdr::SystemException("unable to open the service", GetLastError());
|
|
|
|
// - Start the service
|
|
SERVICE_STATUS status;
|
|
if (!ControlService(service, SERVICE_CONTROL_STOP, &status))
|
|
throw rdr::SystemException("unable to stop the service", GetLastError());
|
|
|
|
} else {
|
|
// - Find the service window
|
|
HWND service_window = findServiceWindow(name);
|
|
if (!service_window)
|
|
throw Exception("unable to locate running service");
|
|
|
|
// Tell it to quit
|
|
vlog.debug("sending service stop request");
|
|
if (!SendMessage(service_window, WM_SMSG_SERVICE_STOP, 0, 0))
|
|
throw Exception("unable to stop service");
|
|
|
|
// Check it's quitting...
|
|
DWORD process_id = 0;
|
|
HANDLE process = 0;
|
|
if (!GetWindowThreadProcessId(service_window, &process_id))
|
|
throw SystemException("unable to verify service has quit", GetLastError());
|
|
process = OpenProcess(SYNCHRONIZE | PROCESS_TERMINATE, FALSE, process_id);
|
|
if (!process)
|
|
throw SystemException("unable to obtain service handle", GetLastError());
|
|
int retries = 5;
|
|
vlog.debug("checking status");
|
|
while (retries-- && (WaitForSingleObject(process, 1000) != WAIT_OBJECT_0)) {}
|
|
if (!retries) {
|
|
vlog.debug("failed to quit - terminating");
|
|
// May not have quit because of silly Win9x registry watching bug..
|
|
if (!TerminateProcess(process, 1))
|
|
throw SystemException("unable to terminate process!", GetLastError());
|
|
throw Exception("service failed to quit - called TerminateProcess");
|
|
}
|
|
}
|
|
|
|
Sleep(500);
|
|
|
|
return true;
|
|
}
|
|
|
|
void rfb::win32::printServiceStatus(const TCHAR* name) {
|
|
if (osVersion.isPlatformNT) {
|
|
// - Open the SCM
|
|
ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
|
|
if (!scm)
|
|
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
|
|
|
|
// - Locate the service
|
|
ServiceHandle service = OpenService(scm, name, SERVICE_INTERROGATE);
|
|
if (!service)
|
|
throw rdr::SystemException("unable to open the service", GetLastError());
|
|
|
|
// - Get the service status
|
|
SERVICE_STATUS status;
|
|
if (!ControlService(service, SERVICE_CONTROL_INTERROGATE, (SERVICE_STATUS*)&status))
|
|
throw rdr::SystemException("unable to query the service", GetLastError());
|
|
|
|
printf("Service is in the ");
|
|
switch (status.dwCurrentState) {
|
|
case SERVICE_RUNNING: printf("running"); break;
|
|
case SERVICE_STOPPED: printf("stopped"); break;
|
|
case SERVICE_STOP_PENDING: printf("stop pending"); break;
|
|
default: printf("unknown (%lu)", status.dwCurrentState); break;
|
|
};
|
|
printf(" state.\n");
|
|
|
|
} else {
|
|
HWND service_window = findServiceWindow(name);
|
|
printf("Service is in the ");
|
|
if (!service_window) printf("stopped");
|
|
else printf("running");
|
|
printf(" state.\n");
|
|
}
|
|
}
|
|
|
|
|
|
bool rfb::win32::isServiceProcess() {
|
|
return service != 0;
|
|
} |