static void WINAPI
_ServiceMain(DWORD dwArgc, LPWSTR* lpszArgv)
{
SERVICE_STATUS_HANDLE hServiceStatus;
SERVICE_STATUS ServiceStatus;
UNREFERENCED_PARAMETER(dwArgc);
UNREFERENCED_PARAMETER(lpszArgv);
// Register our service for control.
hServiceStatus = RegisterServiceCtrlHandlerExW(SERVICE_NAME, _ServiceControlHandlerEx, NULL);
// Report SERVICE_RUNNING status.
ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
ServiceStatus.dwServiceSpecificExitCode = 0;
ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
ServiceStatus.dwWaitHint = 4000;
ServiceStatus.dwWin32ExitCode = NO_ERROR;
ServiceStatus.dwCurrentState = SERVICE_RUNNING;
SetServiceStatus(hServiceStatus, &ServiceStatus);
// Do our funky crazy stuff.
_DoDLLInjection();
// Our work is done.
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
SetServiceStatus(hServiceStatus, &ServiceStatus);
}
static void WINAPI ServiceMain( DWORD argc, LPWSTR *argv )
{
SERVICE_STATUS status;
WINE_TRACE( "starting service\n" );
stop_event = CreateEventW( NULL, TRUE, FALSE, NULL );
service_handle = RegisterServiceCtrlHandlerExW( termserviceW, service_handler, NULL );
if (!service_handle)
return;
status.dwServiceType = SERVICE_WIN32;
status.dwCurrentState = SERVICE_RUNNING;
status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
status.dwWin32ExitCode = 0;
status.dwServiceSpecificExitCode = 0;
status.dwCheckPoint = 0;
status.dwWaitHint = 10000;
SetServiceStatus( service_handle, &status );
WaitForSingleObject( stop_event, INFINITE );
status.dwCurrentState = SERVICE_STOPPED;
status.dwControlsAccepted = 0;
SetServiceStatus( service_handle, &status );
WINE_TRACE( "service stopped\n" );
}
VOID WINAPI
ServiceMain(DWORD argc, LPTSTR *argv)
{
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
DPRINT("ServiceMain() called\n");
ServiceStatusHandle = RegisterServiceCtrlHandlerExW(ServiceName,
ServiceControlHandler,
NULL);
if (!ServiceStatusHandle)
{
DPRINT1("RegisterServiceCtrlHandlerExW() failed! (Error %lu)\n", GetLastError());
return;
}
UpdateServiceStatus(SERVICE_RUNNING);
do
{
Sleep(1);
} while (1);
UpdateServiceStatus(SERVICE_STOPPED);
}
VOID WINAPI
ServiceMain(DWORD argc, LPTSTR *argv)
{
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
DPRINT("ServiceMain() called\n");
ServiceStatusHandle = RegisterServiceCtrlHandlerExW(ServiceName,
ServiceControlHandler,
NULL);
if (!ServiceStatusHandle)
{
DPRINT1("RegisterServiceCtrlHandlerExW() failed! (Error %lu)\n", GetLastError());
return;
}
ShutdownEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
UpdateServiceStatus(SERVICE_RUNNING);
WaitForSingleObject(ShutdownEvent, INFINITE);
CloseHandle(ShutdownEvent);
UpdateServiceStatus(SERVICE_STOPPED);
}
/* Service entry point */
VOID WINAPI
ServiceMain(DWORD dwArgc, LPWSTR *lpszArgv)
{
HANDLE fileTxThread;
static const WCHAR qmgr_nameW[] = {'B','I','T','S',0};
DWORD threadId;
TRACE("\n");
stop_event = CreateEventW(NULL, TRUE, FALSE, NULL);
if (!stop_event) {
ERR("failed to create stop_event\n");
return;
}
status_handle = RegisterServiceCtrlHandlerExW(qmgr_nameW, ServiceHandler, NULL);
if (!status_handle) {
ERR("failed to register handler: %u\n", GetLastError());
return;
}
UpdateStatus(SERVICE_START_PENDING, NO_ERROR, 3000);
if (!StartCount()) {
ERR("failed starting service thread\n");
UpdateStatus(SERVICE_STOPPED, NO_ERROR, 0);
return;
}
globalMgr.jobEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
if (!globalMgr.jobEvent) {
ERR("Couldn't create event: error %d\n", GetLastError());
UpdateStatus(SERVICE_STOPPED, NO_ERROR, 0);
return;
}
fileTxThread = CreateThread(NULL, 0, fileTransfer, NULL, 0, &threadId);
if (!fileTxThread)
{
ERR("Failed starting file transfer thread\n");
UpdateStatus(SERVICE_STOPPED, NO_ERROR, 0);
return;
}
UpdateStatus(SERVICE_RUNNING, NO_ERROR, 0);
WaitForSingleObject(fileTxThread, INFINITE);
UpdateStatus(SERVICE_STOPPED, NO_ERROR, 0);
CloseHandle(stop_event);
TRACE("service stopped\n");
CoUninitialize();
}
static VOID CALLBACK
ServiceMain(DWORD argc,
LPWSTR *argv)
{
DWORD dwError;
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
DPRINT("ServiceMain() called\n");
ServiceStatusHandle = RegisterServiceCtrlHandlerExW(ServiceName,
ServiceControlHandler,
NULL);
if (!ServiceStatusHandle)
{
dwError = GetLastError();
DPRINT1("RegisterServiceCtrlHandlerW() failed! (Error %lu)\n", dwError);
return;
}
UpdateServiceStatus(SERVICE_START_PENDING);
dwError = ServiceInit();
if (dwError != ERROR_SUCCESS)
{
DPRINT("Service stopped (dwError: %lu\n", dwError);
UpdateServiceStatus(SERVICE_START_PENDING);
}
else
{
DPRINT("Service started\n");
UpdateServiceStatus(SERVICE_RUNNING);
ReportProductInfoEvent();
LogfReportEvent(EVENTLOG_INFORMATION_TYPE,
0,
EVENT_EventlogStarted,
0,
NULL,
0,
NULL);
}
DPRINT("ServiceMain() done\n");
}
static VOID CALLBACK
ServiceMain(DWORD argc, LPWSTR *argv)
{
HANDLE hThread;
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
DPRINT("ServiceMain() called\n");
SvcStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
SvcStatus.dwCurrentState = SERVICE_START_PENDING;
SvcStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
SvcStatus.dwCheckPoint = 0;
SvcStatus.dwWin32ExitCode = NO_ERROR;
SvcStatus.dwServiceSpecificExitCode = 0;
SvcStatus.dwWaitHint = 4000;
ServiceStatusHandle = RegisterServiceCtrlHandlerExW(ServiceName,
ServiceControlHandler,
NULL);
UpdateServiceStatus(ServiceStatusHandle, SERVICE_RUNNING, 0);
hThread = CreateThread(NULL,
0,
(LPTHREAD_START_ROUTINE)
RpcThreadRoutine,
NULL,
0,
NULL);
if (!hThread)
{
DPRINT("Can't create RpcThread\n");
UpdateServiceStatus(ServiceStatusHandle, SERVICE_STOPPED, 0);
}
else
{
CloseHandle(hThread);
}
DPRINT("ServiceMain() done\n");
}
static VOID WINAPI
service_main (DWORD argc,
LPWSTR * argv)
{
(void) argc;
(void) argv;
status_handle = RegisterServiceCtrlHandlerExW (service_name, &handle_service_ctrl, NULL);
if (status_handle == NULL)
{
log_system_error (TR_LOG_ERROR, GetLastError (), "RegisterServiceCtrlHandlerEx() failed");
return;
}
update_service_status (SERVICE_START_PENDING, NO_ERROR, 0, 1, 1000);
service_thread = (HANDLE) _beginthreadex (NULL, 0, &service_thread_main, NULL, 0, NULL);
if (service_thread == NULL)
{
log_system_error (TR_LOG_ERROR, GetLastError (), "_beginthreadex() failed");
return;
}
update_service_status (SERVICE_RUNNING, NO_ERROR, 0, 0, 0);
if (WaitForSingleObject (service_thread, INFINITE) != WAIT_OBJECT_0)
log_system_error (TR_LOG_ERROR, GetLastError (), "WaitForSingleObject() failed");
if (service_stop_thread != NULL)
{
WaitForSingleObject (service_stop_thread, INFINITE);
CloseHandle (service_stop_thread);
}
DWORD exit_code;
if (!GetExitCodeThread (service_thread, &exit_code))
exit_code = 1;
CloseHandle (service_thread);
update_service_status (SERVICE_STOPPED, NO_ERROR, exit_code, 0, 0);
}
static VOID WINAPI
_ServiceMain(DWORD dwArgc, LPWSTR* lpszArgv)
{
HANDLE hThread;
UNREFERENCED_PARAMETER(dwArgc);
UNREFERENCED_PARAMETER(lpszArgv);
// Register our service for control
hServiceStatus = RegisterServiceCtrlHandlerExW(wszServiceName, _ServiceControlHandlerEx, NULL);
// Report initial SERVICE_START_PENDING status
ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
ServiceStatus.dwServiceSpecificExitCode = 0;
ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
ServiceStatus.dwWaitHint = 4000;
ServiceStatus.dwWin32ExitCode = NO_ERROR;
_UpdateServiceStatus(SERVICE_START_PENDING, 0);
// Create a thread for serving RPC requests
hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)LrpcThreadProc, NULL, 0, NULL);
if (!hThread)
{
ERR("CreateThread failed with error %u!\n", GetLastError());
_UpdateServiceStatus(SERVICE_STOPPED, 0);
return;
}
// We don't need the thread handle. Keeping it open blocks the thread from terminating.
CloseHandle(hThread);
// Initialize the routing layer in spoolss.dll
if (!InitializeRouter(hServiceStatus))
{
ERR("InitializeRouter failed with error %lu!\n", GetLastError());
_UpdateServiceStatus(SERVICE_STOPPED, 0);
return;
}
// We're alive!
_UpdateServiceStatus(SERVICE_RUNNING, 0);
}
static VOID CALLBACK
ServiceMain(DWORD argc, LPWSTR *argv)
{
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
TRACE("ServiceMain() called\n");
ServiceStatusHandle = RegisterServiceCtrlHandlerExW(ServiceName,
ServiceControlHandler,
NULL);
TRACE("Calling SetServiceStatus()\n");
UpdateServiceStatus(SERVICE_RUNNING);
TRACE("SetServiceStatus() called\n");
ThemeHooksInstall();
TRACE("ServiceMain() done\n");
}
VOID WINAPI ServiceStart(DWORD argc, LPTSTR *argv) {
if (!SetSecurityPrivilage(TRUE)) {
DebugOut("Failed to get privilage!\n");
return;
}
if (!InitFunctions()) {
DebugOut("Failed to init functions!\n");
return;
}
ObjectPrefix = DEFAULT_OBJECT_PREFIX;
ObjectPrefixLength = wcslen(ObjectPrefix);
if (!GetSidByName(AccountName, &gpSid, &gSidLength)) {
DebugOut("GetSidByName(%S, ...) failed!\n", AccountName);
return;
}
ServiceStatus.dwServiceType = SERVICE_WIN32;
ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwServiceSpecificExitCode = 0;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 0;
hServiceStatus = RegisterServiceCtrlHandlerExW(SERVICE_NAME, ServiceCtrlHandlerEx, NULL);
if (hServiceStatus == (SERVICE_STATUS_HANDLE)0) {
DebugOut("RegisterServiceCtrlHandlerW failed! (LastError=0x%x)\n", GetLastError());
return;
}
DEV_BROADCAST_DEVICEINTERFACE NotificationFilter;
ZeroMemory(&NotificationFilter, sizeof(NotificationFilter));
NotificationFilter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
NotificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
hDevNotify = RegisterDeviceNotificationW(hServiceStatus, &NotificationFilter, DEVICE_NOTIFY_SERVICE_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES);
if (!SetServiceStatus(hServiceStatus, &ServiceStatus)) { // Send current status.
DebugOut("SetServiceStatus failed! (LastError=0x%x)\n", GetLastError());
}
ScanApplyObjectsRules();
}
VOID WINAPI
ServiceMain(DWORD argc, LPWSTR argv[])
{
DWORD dwError;
ServiceStatusHandle = RegisterServiceCtrlHandlerExW(ServiceName,
ServiceControlHandler,
NULL);
if (!ServiceStatusHandle)
{
dwError = GetLastError();
DPRINT1("RegisterServiceCtrlHandlerW() failed! (Error %lu)\n", dwError);
return;
}
ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
ServiceStatus.dwControlsAccepted = 0;
ServiceStatus.dwWin32ExitCode = NO_ERROR;
ServiceStatus.dwServiceSpecificExitCode = 0;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 1000;
SetServiceStatus(ServiceStatusHandle, &ServiceStatus);
if (RPCSS_Initialize())
{
ServiceStatus.dwCurrentState = SERVICE_RUNNING;
ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
SetServiceStatus(ServiceStatusHandle, &ServiceStatus);
WaitForSingleObject(exit_event, INFINITE);
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
SetServiceStatus(ServiceStatusHandle, &ServiceStatus);
RPCSS_Shutdown();
}
}
VOID WINAPI
ServiceMain(DWORD argc, LPWSTR argv[])
{
SERVICEINFO servInfo;
LogEvent(L"Entering ServiceMain.", 0, 0, LOG_FILE);
servInfo.servStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
servInfo.servStatus.dwCurrentState = SERVICE_STOPPED;
servInfo.servStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_PAUSE_CONTINUE;
servInfo.servStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
servInfo.servStatus.dwServiceSpecificExitCode = 0;
servInfo.servStatus.dwCheckPoint = 0;
servInfo.servStatus.dwWaitHint = 2 * CS_TIMEOUT;
LogEvent(L"Registering service control handler", 0, 0, LOG_FILE);
servInfo.hStatus = RegisterServiceCtrlHandlerExW(ServiceName,
(LPHANDLER_FUNCTION_EX)ServerCtrlHandler,
&servInfo);
if (!servInfo.hStatus)
LogEvent(L"Failed to register service", GetLastError(), 100, LOG_ALL);
UpdateStatus(&servInfo, SERVICE_START_PENDING, 1);
if (!CreateServers(&servInfo))
{
LogEvent(L"Error creating servers", GetLastError(), 1, LOG_ALL);
servInfo.servStatus.dwServiceSpecificExitCode = 1;
UpdateStatus(&servInfo, SERVICE_STOPPED, 0);
return;
}
LogEvent(L"Service threads shut down. Set SERVICE_STOPPED status", 0, 0, LOG_FILE);
UpdateStatus(&servInfo, SERVICE_STOPPED, 0);
LogEvent(L"Leaving ServiceMain\n", 0, 0, LOG_FILE);
}
/**********************************************************************
* RegisterServiceCtrlHandlerExA
*
* @implemented
*/
SERVICE_STATUS_HANDLE WINAPI
RegisterServiceCtrlHandlerExA(LPCSTR lpServiceName,
LPHANDLER_FUNCTION_EX lpHandlerProc,
LPVOID lpContext)
{
ANSI_STRING ServiceNameA;
UNICODE_STRING ServiceNameU;
SERVICE_STATUS_HANDLE SHandle;
RtlInitAnsiString(&ServiceNameA, (LPSTR)lpServiceName);
if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&ServiceNameU, &ServiceNameA, TRUE)))
{
SetLastError(ERROR_OUTOFMEMORY);
return (SERVICE_STATUS_HANDLE)0;
}
SHandle = RegisterServiceCtrlHandlerExW(ServiceNameU.Buffer,
lpHandlerProc,
lpContext);
RtlFreeUnicodeString(&ServiceNameU);
return SHandle;
}
static void WINAPI ServiceMain( DWORD argc, LPWSTR *argv )
{
SERVICE_STATUS status;
WINE_TRACE( "starting service %s\n", wine_dbgstr_w(driver_name) );
stop_event = CreateEventW( NULL, TRUE, FALSE, NULL );
service_handle = RegisterServiceCtrlHandlerExW( driver_name, service_handler, NULL );
if (!service_handle)
return;
status.dwServiceType = SERVICE_WIN32;
status.dwCurrentState = SERVICE_START_PENDING;
status.dwControlsAccepted = 0;
status.dwWin32ExitCode = 0;
status.dwServiceSpecificExitCode = 0;
status.dwCheckPoint = 0;
status.dwWaitHint = 10000;
SetServiceStatus( service_handle, &status );
if (load_driver())
{
status.dwCurrentState = SERVICE_RUNNING;
status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
SetServiceStatus( service_handle, &status );
wine_ntoskrnl_main_loop( stop_event );
}
else WINE_ERR( "driver %s failed to load\n", wine_dbgstr_w(driver_name) );
status.dwCurrentState = SERVICE_STOPPED;
status.dwControlsAccepted = 0;
SetServiceStatus( service_handle, &status );
WINE_TRACE( "service %s stopped\n", wine_dbgstr_w(driver_name) );
}
