void SFServiceController::ServiceCtrlHandler(DWORD nControlCode)
{
BOOL success;
switch(nControlCode)
{
case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP:
nServiceCurrentStatus=SERVICE_STOP_PENDING;
success=UpdateServiceStatus(SERVICE_STOP_PENDING,NO_ERROR,0,1,3000);
KillService();
return;
default:
break;
}
UpdateServiceStatus(nServiceCurrentStatus,NO_ERROR,0,0,0);
}
VOID CALLBACK TimerHandler( HWND hWnd, UINT uMsg, UINT uEventId, DWORD dwSystemTime )
{
ALERT( "HandlerTimeoutTimer callback called." );
KillTimer();
gdwState = gdwTimeoutState;
UpdateServiceStatus( gdwTimeoutState );
}
//Terminate service
void __stdcall TerminateService()
{
bServiceRunning = FALSE;
SetEvent(hServiceEvent);
UpdateServiceStatus(SERVICE_STOPPED, NO_ERROR, 0, 0, 0);
return;
}
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");
}
//Terminate service
void WINAPI TerminateService(void)
{
IsServiceRunning = FALSE;
SetEvent(ServiceEvent);
UpdateServiceStatus(SERVICE_STOPPED, NO_ERROR, 0, 0, 0);
return;
}
//Service Main function
size_t WINAPI ServiceMain(DWORD argc, LPTSTR *argv)
{
hServiceStatus = RegisterServiceCtrlHandler(LOCALSERVERNAME, (LPHANDLER_FUNCTION)ServiceControl);
if(!hServiceStatus || !UpdateServiceStatus(SERVICE_START_PENDING, NO_ERROR, 0, 1, TIME_OUT*3))
return FALSE;
hServiceEvent = CreateEvent(0, TRUE, FALSE, 0);
if(!hServiceEvent || !UpdateServiceStatus(SERVICE_START_PENDING, NO_ERROR, 0, 2, TIME_OUT) || !ExecuteService())
return FALSE;
ServiceCurrentStatus = SERVICE_RUNNING;
if(!UpdateServiceStatus(SERVICE_RUNNING, NO_ERROR, 0, 0, 0))
return FALSE;
WaitForSingleObject(hServiceEvent, INFINITE);
CloseHandle(hServiceEvent);
return EXIT_SUCCESS;
}
//Service Main function
size_t WINAPI ServiceMain(DWORD argc, LPTSTR *argv)
{
ServiceStatusHandle = RegisterServiceCtrlHandlerW(DEFAULT_LOCAL_SERVICE_NAME, (LPHANDLER_FUNCTION)ServiceControl);
if (!ServiceStatusHandle || !UpdateServiceStatus(SERVICE_START_PENDING, NO_ERROR, 0, 1U, UPDATE_SERVICE_TIME * SECOND_TO_MILLISECOND))
return FALSE;
ServiceEvent = CreateEventW(0, TRUE, FALSE, 0);
if (!ServiceEvent || !UpdateServiceStatus(SERVICE_START_PENDING, NO_ERROR, 0, 2U, STANDARD_TIMEOUT) || !ExecuteService())
return FALSE;
ServiceCurrentStatus = SERVICE_RUNNING;
if (!UpdateServiceStatus(SERVICE_RUNNING, NO_ERROR, 0, 0, 0))
return FALSE;
WaitForSingleObject(ServiceEvent, INFINITE);
CloseHandle(ServiceEvent);
return EXIT_SUCCESS;
}
void DoDaemonTask ()
{
bool bGimuIsRuning = false;
ReadJobs ();
while (ctx.bNotStop) {
//
//
//
::Sleep (GimuJobScheduleDispersion * 1000);
if (IsGimuAppStart ()) {
bGimuIsRuning = true;
continue;
}
else {
//
// 之前软件在执行，现在已经不在执行了，所以先更新一下Job内容。
//
if (bGimuIsRuning) ReadJobs ();
bGimuIsRuning = false;
}
{
vector<GmJobItem*> & jobs = ctx.Jobs;
if (jobs.empty ()) continue;
wxString jobsname;
for (size_t index = 0; index < jobs.size (); ++index) {
if (IsThisJobAtScheduleTime (jobs[index])) {
jobsname += jobs[index]->Name ();
jobsname += wxT (" ");
}
}
//
// 如果没有任务需要执行，那么就不需要启动 Gimu。
//
if (jobsname.IsEmpty ()) continue;
wxString szExePath = GmAppInfo::GetAppPath ();
wxString gimuexe = AssemblePath (szExePath, GIMU_APP_NAME);
wxString format = wxT ("%s -");
format += START_MINIMIZE;
format += wxT (" -");
format += START_RUN_NAMED_JOBS;
format += wxT (" -");
format += EXIT_APP_AFTER_FINISH;
format += wxT (" ");
format += wxT ("%s");
wxString run = wxString::Format (format, gimuexe.c_str (), jobsname);
wxExecute (run);
}
}
UpdateServiceStatus (SERVICE_STOPPED, NO_ERROR, 0, 3000);
return;
}
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 DWORD WINAPI
ServiceControlHandler(DWORD dwControl,
DWORD dwEventType,
LPVOID lpEventData,
LPVOID lpContext)
{
DPRINT1("ServiceControlHandler() called\n");
switch (dwControl)
{
case SERVICE_CONTROL_STOP:
DPRINT1(" SERVICE_CONTROL_STOP received\n");
SetEvent(ShutdownEvent);
UpdateServiceStatus(SERVICE_STOP_PENDING);
return ERROR_SUCCESS;
case SERVICE_CONTROL_PAUSE:
DPRINT1(" SERVICE_CONTROL_PAUSE received\n");
UpdateServiceStatus(SERVICE_PAUSED);
return ERROR_SUCCESS;
case SERVICE_CONTROL_CONTINUE:
DPRINT1(" SERVICE_CONTROL_CONTINUE received\n");
UpdateServiceStatus(SERVICE_RUNNING);
return ERROR_SUCCESS;
case SERVICE_CONTROL_INTERROGATE:
DPRINT1(" SERVICE_CONTROL_INTERROGATE received\n");
SetServiceStatus(ServiceStatusHandle,
&ServiceStatus);
return ERROR_SUCCESS;
case SERVICE_CONTROL_SHUTDOWN:
DPRINT1(" SERVICE_CONTROL_SHUTDOWN received\n");
SetEvent(ShutdownEvent);
UpdateServiceStatus(SERVICE_STOP_PENDING);
return ERROR_SUCCESS;
default :
DPRINT1(" Control %lu received\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
}
static DWORD WINAPI
ServiceControlHandler(DWORD dwControl,
DWORD dwEventType,
LPVOID lpEventData,
LPVOID lpContext)
{
DPRINT("ServiceControlHandler() called\n");
switch (dwControl)
{
case SERVICE_CONTROL_STOP:
DPRINT(" SERVICE_CONTROL_STOP received\n");
/* Stop listening to incoming RPC messages */
RpcMgmtStopServerListening(NULL);
UpdateServiceStatus(SERVICE_STOPPED);
return ERROR_SUCCESS;
case SERVICE_CONTROL_PAUSE:
DPRINT(" SERVICE_CONTROL_PAUSE received\n");
UpdateServiceStatus(SERVICE_PAUSED);
return ERROR_SUCCESS;
case SERVICE_CONTROL_CONTINUE:
DPRINT(" SERVICE_CONTROL_CONTINUE received\n");
UpdateServiceStatus(SERVICE_RUNNING);
return ERROR_SUCCESS;
case SERVICE_CONTROL_INTERROGATE:
DPRINT(" SERVICE_CONTROL_INTERROGATE received\n");
SetServiceStatus(ServiceStatusHandle,
&ServiceStatus);
return ERROR_SUCCESS;
case SERVICE_CONTROL_SHUTDOWN:
DPRINT(" SERVICE_CONTROL_SHUTDOWN received\n");
UpdateServiceStatus(SERVICE_STOPPED);
return ERROR_SUCCESS;
default :
DPRINT1(" Control %lu received\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
}
static DWORD WINAPI
ServiceControlHandler(DWORD dwControl,
DWORD dwEventType,
LPVOID lpEventData,
LPVOID lpContext)
{
switch (dwControl)
{
case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP:
UpdateServiceStatus(ServiceStatusHandle, SERVICE_STOP_PENDING, 1);
RpcMgmtStopServerListening(NULL);
UpdateServiceStatus(ServiceStatusHandle, SERVICE_STOPPED, 0);
break;
case SERVICE_CONTROL_INTERROGATE:
return NO_ERROR;
default:
return ERROR_CALL_NOT_IMPLEMENTED;
}
return NO_ERROR;
}
void SFServiceController::ServiceMain(DWORD argc, LPTSTR *argv)
{
UNREFERENCED_PARAMETER(argc);
BOOL success;
nServiceStatusHandle = RegisterServiceCtrlHandler(argv[0],
(LPHANDLER_FUNCTION)ServiceCtrlHandler);
if(!nServiceStatusHandle)
{
return;
}
success=UpdateServiceStatus(SERVICE_START_PENDING,NO_ERROR,0,1,3000);
if(!success)
{
return;
}
killServiceEvent=CreateEvent(0,TRUE,FALSE,0);
if(killServiceEvent==NULL)
{
return;
}
success=UpdateServiceStatus(SERVICE_START_PENDING,NO_ERROR,0,2,1000);
if(!success)
{
return;
}
success=StartServiceThread();
if(!success)
{
return;
}
nServiceCurrentStatus=SERVICE_RUNNING;
success=UpdateServiceStatus(SERVICE_RUNNING,NO_ERROR,0,0,0);
if(!success)
{
return;
}
WaitForSingleObject(killServiceEvent,INFINITE);
CloseHandle(killServiceEvent);
}
void GimuDaemonCtrlHandler(DWORD nControlCode)
{
switch (nControlCode)
{
case SERVICE_CONTROL_SHUTDOWN:
if (!IsGimuAppStart ()) {
//
// 如果软件没有启动，需要启动备份完成后才能关机。
//
vector<GmJobItem*> & jobs = ctx.Jobs;
if (jobs.empty ()) break;
wxString jobsname;
for (size_t index = 0; index < jobs.size (); ++index) {
if (IsThisJobAtScheduleTime (jobs[index])) {
jobsname += jobs[index]->Name ();
jobsname += wxT (" ");
}
}
//
// 如果没有任务需要执行，那么就不需要启动 Gimu。
//
if (jobsname.IsEmpty ()) break;
AbortSystemShutdown (0);
wxString szExePath = GmAppInfo::GetAppPath ();
wxString gimuexe = AssemblePath (szExePath, GIMU_APP_NAME);
wxString format = wxT ("%s -");
format += START_MINIMIZE;
format += wxT (" -");
format += START_RUN_NAMED_JOBS;
format += wxT (" -");
format += SHUTDOWN_SYS_AFTER_FINISH;
format += wxT (" ");
format += wxT ("%s");
wxString run = wxString::Format (format, gimuexe.c_str (), jobsname);
wxExecute (run);
}
break;
case SERVICE_CONTROL_STOP:
UpdateServiceStatus (SERVICE_STOP_PENDING, NO_ERROR, 0, 3000);
KillService();
break;
default:
break;
}
return;
}
void GimuDaemonProc (DWORD argc, LPTSTR *argv)
{
DaemonHandle = RegisterServiceCtrlHandler (GimuDaemonService, (LPHANDLER_FUNCTION)GimuDaemonCtrlHandler);
if (DaemonHandle == 0) {
return;
}
BOOL success = UpdateServiceStatus (SERVICE_RUNNING, NO_ERROR, 0, 3000);
if(!success) {
return;
}
DoDaemonTask ();
}
/*
* To stop the service.
* If a stop function was registered, invoke it,
* otherwise terminate the worker thread.
* After stopping, Service status is set to STOP in
* main loop
*/
VOID
ProcessServiceStop (VOID)
{
UpdateServiceStatus (SERVICE_STOP_PENDING, NO_ERROR, SCM_WAIT_INTERVAL);
if (StopFunction != NULL)
{
(*StopFunction) ();
}
else
{
TerminateThread (hServiceThread, 0);
}
}
void WINAPI ServiceControlHandler(DWORD control_code) {
switch (control_code) {
case SERVICE_CONTROL_STOP:
case SERVICE_CONTROL_SHUTDOWN:
if (kServiceStatus.dwCurrentState != SERVICE_RUNNING) {
break;
}
UpdateServiceStatus(0, SERVICE_STOP_PENDING, 0, 4);
::SetEvent(kStopEvent);
break;
default:
break;
}
}
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");
}
DWORD WINAPI ServiceThread( LPVOID pVoid )
{
DWORD dwResult = 0;
ALERT( "ServiceThread: Starting. Calling StartServiceCtrlDispatcher()..." );
if( FALSE != StartServiceCtrlDispatcher( (LPSERVICE_TABLE_ENTRY) gpServiceTable ) )
{
// Successful
dwResult = 1;
}
else
{
dwResult = 0;
}
ALERT( "ServiceThread: Finished with StartServiceCtrlDispatcher()" );
UpdateServiceStatus( SERVICE_STOPPED );
ALERT( "ServiceThraed: ENDING THE SERVICE THREAD!!!!!!!!!!" );
return( dwResult );
}
void KillService ()
{
ctx.bNotStop = false;
UpdateServiceStatus (SERVICE_STOPPED, NO_ERROR, 0, 0);
}
VOID WINAPI ServiceHandler( DWORD dwControl )
{
const char *pszCommand = SERVICE_CONTROL_STRING_EMPTY;
DWORD dwState = gdwState;
BOOL fUseTimer = FALSE;
#ifdef _DEBUG
TCHAR szBuffer[ 256 ];
#endif // _DEBUG
ALERT( "ServiceHandler: Incoming service control message..." );
switch( dwControl )
{
case SERVICE_CONTROL_START:
pszCommand = SERVICE_CONTROL_STRING_START;
// This control message requires that we change the state...
dwState = SERVICE_START_PENDING;
fUseTimer = TRUE;
gdwTimeoutState = SERVICE_RUNNING;
break;
case SERVICE_CONTROL_STOP:
pszCommand = SERVICE_CONTROL_STRING_STOP;
// This control message requires that we change the state...
dwState = SERVICE_STOP_PENDING;
fUseTimer = TRUE;
gdwTimeoutState = SERVICE_STOPPED;
break;
case SERVICE_CONTROL_PAUSE:
pszCommand = SERVICE_CONTROL_STRING_PAUSE;
// This control message requires that we change the state...
// ...but if we are already paused then don't
if( SERVICE_PAUSED != gdwState )
{
dwState = SERVICE_PAUSE_PENDING;
}
fUseTimer = TRUE;
gdwTimeoutState = SERVICE_PAUSED;
break;
case SERVICE_CONTROL_CONTINUE:
pszCommand = SERVICE_CONTROL_STRING_CONTINUE;
// This control message requires that we change the state...
// ...but only if we are already paused.
if( SERVICE_PAUSED == gdwState )
{
dwState = SERVICE_CONTINUE_PENDING;
}
fUseTimer = TRUE;
gdwTimeoutState = SERVICE_RUNNING;
break;
case SERVICE_CONTROL_SHUTDOWN:
pszCommand = SERVICE_CONTROL_STRING_SHUTDOWN;
// No dwState value for this control message
// No gdwTimeoutState for this state
break;
///////////////////////////////////////////////////////////////
// Start nonstates (these are commands)
// Fix by Thomas Kratz [[email protected]]
// Control command messages have not associated state
// so don't set the dwState
case SERVICE_CONTROL_INTERROGATE:
pszCommand = SERVICE_CONTROL_STRING_INTERROGATE;
gdwLastControlMessage = dwControl;
// No dwState value for this control message
// No gdwTimoutState for this state
break;
// Win2k control codes...
case SERVICE_CONTROL_PARAMCHANGE:
pszCommand = SERVICE_CONTROL_STRING_PARAMCHANGE;
// No dwState value for this control message
break;
case SERVICE_CONTROL_NETBINDADD:
pszCommand = SERVICE_CONTROL_STRING_NETBINDADD;
// No dwState value for this control message
break;
case SERVICE_CONTROL_NETBINDREMOVE:
pszCommand = SERVICE_CONTROL_STRING_NETBINDREMOVE;
// No dwState value for this control message
break;
case SERVICE_CONTROL_NETBINDENABLE:
pszCommand = SERVICE_CONTROL_STRING_NETBINDENABLE;
// No dwState value for this control message
break;
case SERVICE_CONTROL_NETBINDDISABLE:
pszCommand = SERVICE_CONTROL_STRING_NETBINDDISABLE;
// No dwState value for this control message
break;
#ifdef SERVICE_CONTROL_PRESHUTDOWN
case SERVICE_CONTROL_PRESHUTDOWN :
pszCommand = SERVICE_CONTROL_STRING_PRESHUTDOWN ;
// No dwState value for this control message
break;
#endif
// User defined control codes...there are 128 of them
case SERVICE_CONTROL_USER_DEFINED:
case SERVICE_CONTROL_USER_DEFINED + 0x01:
case SERVICE_CONTROL_USER_DEFINED + 0x4f:
// No dwState value for this control message
break;
default:
pszCommand = SERVICE_CONTROL_STRING_DEFAULT;
// No dwState value for this control message
break;
}
// Set the last control message to what was received. Some control messages
// result in a state change but we should always report the message.
gdwLastControlMessage = dwControl;
#ifdef _DEBUG
wsprintf( szBuffer, "ServiceHandler: Received message => %s (0x%0x)\n", pszCommand, dwControl );
ALERT( szBuffer );
#endif // _DEBUG
// TODO:
// We should set an alarm to for some configurable timeout value so that
// in case the perl script does not process the request we will change
// the state automatically
if( FALSE != fUseTimer )
{
SetTimeoutTimer( gdwHandlerTimeout );
}
//
// Update the service status with the dwState. If there were
// control messages that warrant a state change then do it
// otherwise dwState was set (at beginning of this function)
// to be the same as the current state.
//
UpdateServiceStatus( dwState );
//
// This code is only used when in callback mode...
// Post a daemon state change message to the main Win32::Daemon
// thread so that it knows to callback into Perl.
//
if( FALSE != gfCallbackMode )
{
ALERT( "ServiceHandler: Posting message to main thread for callbacks\n" );
//
// Post to the main thread that we have a state change.
//
// Make sure to post the dwControl value (not dwState). This control value
// maps directly to callback index values!
//
PostThreadMessage( gMainThreadId, WM_DAEMON_STATE_CHANGE, (WORD) dwControl, 0 );
}
}
void SFServiceController::KillService()
{
nServiceRunning=false;
SetEvent(killServiceEvent);
UpdateServiceStatus(SERVICE_STOPPED,NO_ERROR,0,0,0);
}
/*
* ServiceMain function.
*/
VOID WINAPI
ServiceMain (DWORD argc, LPTSTR argv[])
{
SECURITY_ATTRIBUTES SecurityAttributes;
unsigned threadId;
/*
* Input arguments
*/
DWORD ArgCount = 0;
LPTSTR *ArgArray = NULL;
TCHAR szRegKey[512];
HKEY hParamKey = NULL;
DWORD TotalParams = 0;
DWORD i;
InputParams ThreadInputParams;
/*
* Build the Input parameters to pass to worker thread
*/
/*
* SCM sends Service Name as first arg, increment to point
* arguments user specified while starting control agent
*/
/*
* Read registry parameter
*/
ArgCount = 1;
/*
* Create registry key path
*/
_sntprintf (szRegKey, CountOf(szRegKey), _T("%s%s\\%s"),
_T ("SYSTEM\\CurrentControlSet\\Services\\"), app_name_long,
_T("Parameters"));
if (RegOpenKeyEx
(HKEY_LOCAL_MACHINE, szRegKey, 0, KEY_ALL_ACCESS, &hParamKey) == ERROR_SUCCESS)
{
/*
* Read startup configuration information
*/
/*
* Find number of subkeys inside parameters
*/
if (RegQueryInfoKey (hParamKey, NULL, NULL, 0,
NULL, NULL, NULL, &TotalParams,
NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
{
if (TotalParams != 0)
{
ArgCount += TotalParams;
/*
* Allocate memory to hold strings
*/
ArgArray = calloc(ArgCount, sizeof(ArgArray[0]));
if (ArgArray == 0)
{
WriteToEventLog (EVENTLOG_ERROR_TYPE,
_T ("Resource failure"));
return;
}
/*
* Copy first argument
*/
ArgArray[0] = _tcsdup (argv[0]);
for (i = 1; i <= TotalParams; i++)
{
DWORD dwErrorcode;
DWORD nSize;
DWORD nRegkeyType;
TCHAR *szValue;
/*
* Create Subkey value name
*/
_sntprintf (szRegKey, CountOf(szRegKey), _T("%s%d"), _T("Param"), i);
/*
* Query subkey.
*/
nSize = 0;
dwErrorcode = RegQueryValueEx(hParamKey, szRegKey, NULL,
&nRegkeyType, NULL, &nSize);
if (dwErrorcode == ERROR_SUCCESS) {
if (nRegkeyType == REG_SZ || nRegkeyType == REG_EXPAND_SZ) {
szValue = malloc(nSize + sizeof(szValue[0]));
if (szValue) {
dwErrorcode = RegQueryValueEx(hParamKey, szRegKey, NULL,
&nRegkeyType, (LPBYTE)szValue, &nSize);
if (dwErrorcode == ERROR_SUCCESS) {
szValue[nSize] = 0;
ArgArray[i] = szValue;
} else {
free(szValue);
WriteToEventLog(EVENTLOG_ERROR_TYPE, _T("Querying registry key %s failed: error code %ld"), szRegKey, dwErrorcode);
}
} else
WriteToEventLog(EVENTLOG_ERROR_TYPE, _T("Querying registry key %s failed: out of memory"), szRegKey);
} else
WriteToEventLog(EVENTLOG_ERROR_TYPE, _T("Type %ld of registry key %s is incorrect"), nRegkeyType, szRegKey);
} else
WriteToEventLog(EVENTLOG_ERROR_TYPE, _T("Querying registry key %s failed: error code %ld"), szRegKey, dwErrorcode);
if (!ArgArray[i]) {
TotalParams = ArgCount = i;
break;
}
}
}
}
RegCloseKey (hParamKey);
}
if (ArgCount == 1)
{
/*
* No startup args are given
*/
ThreadInputParams.Argc = argc;
ThreadInputParams.Argv = argv;
}
else
{
ThreadInputParams.Argc = ArgCount;
ThreadInputParams.Argv = ArgArray;
}
/*
* Register Service Control Handler
*/
hServiceStatus = RegisterServiceCtrlHandler (app_name_long, ControlHandler);
if (hServiceStatus == 0)
{
WriteToEventLog (EVENTLOG_ERROR_TYPE,
_T ("RegisterServiceCtrlHandler failed"));
return;
}
/*
* Update the service status to START_PENDING.
*/
UpdateServiceStatus (SERVICE_START_PENDING, NO_ERROR, SCM_WAIT_INTERVAL);
/*
* Start the worker thread, which does the majority of the work .
*/
TRY
{
if (SetSimpleSecurityAttributes (&SecurityAttributes) == FALSE)
{
WriteToEventLog (EVENTLOG_ERROR_TYPE,
_T ("Couldn't init security attributes"));
LEAVE;
}
hServiceThread =
(void *) _beginthreadex (&SecurityAttributes, 0,
ThreadFunction,
(void *) &ThreadInputParams, 0, &threadId);
if (hServiceThread == NULL)
{
WriteToEventLog (EVENTLOG_ERROR_TYPE, _T ("Couldn't start worker thread"));
LEAVE;
}
/*
* Set service status to SERVICE_RUNNING.
*/
UpdateServiceStatus (SERVICE_RUNNING, NO_ERROR, SCM_WAIT_INTERVAL);
/*
* Wait until the worker thread finishes.
*/
WaitForSingleObject (hServiceThread, INFINITE);
}
FINALLY
{
/*
* Release resources
*/
UpdateServiceStatus (SERVICE_STOPPED, NO_ERROR, SCM_WAIT_INTERVAL);
if (hServiceThread)
CloseHandle (hServiceThread);
FreeSecurityAttributes (&SecurityAttributes);
/*
* Free allocated argument list
*/
if (ArgCount > 1 && ArgArray != NULL)
{
/*
* Free all strings
*/
for (i = 0; i < ArgCount; i++)
{
free (ArgArray[i]);
}
free (ArgArray);
}
}
}
void daemonEntry(int argc, char* argv[]) {
osquery::Initializer runner(argc, argv, osquery::ToolType::DAEMON);
// Options for installing or uninstalling the osqueryd as a service
if (osquery::FLAGS_install) {
if (osquery::installService(argv[0]).getCode()) {
LOG(ERROR) << "Unable to install the osqueryd service";
}
return;
} else if (osquery::FLAGS_uninstall) {
if (osquery::uninstallService().getCode()) {
LOG(ERROR) << "Unable to uninstall the osqueryd service";
}
return;
}
if (!runner.isWorker()) {
runner.initDaemon();
}
// When a watchdog is used, the current daemon will fork/exec into a worker.
// In either case the watcher may start optionally loaded extensions.
if (runner.isWorker()) {
runner.initWorker(kWatcherWorkerName);
} else {
runner.initWatcher();
// The event only gets initialized in the entry point of the service. Child
// processes and those run from the commandline will have kStopEvent as a
// nullptr
if (kStopEvent != nullptr) {
::WaitForSingleObject(kStopEvent, INFINITE);
UpdateServiceStatus(0, SERVICE_STOPPED, 0, 3);
runner.requestShutdown();
}
runner.waitForWatcher();
}
// Start osquery work.
runner.start();
// Conditionally begin the distributed query service
auto s = osquery::startDistributed();
if (!s.ok()) {
VLOG(1) << "Not starting the distributed query service: " << s.toString();
}
// Begin the schedule runloop.
osquery::startScheduler();
// kStopEvent is nullptr if not run from the service control manager
if (kStopEvent != nullptr) {
::WaitForSingleObject(kStopEvent, INFINITE);
UpdateServiceStatus(0, SERVICE_STOPPED, 0, 3);
runner.requestShutdown();
}
// Finally wait for a signal / interrupt to shutdown.
runner.waitForShutdown();
}
/*
* The ServiceMain function to start service.
*/
VOID WINAPI
ServiceMain (DWORD argc, LPTSTR argv[])
{
SECURITY_ATTRIBUTES SecurityAttributes;
DWORD dwThreadId;
/*
* Input Arguments to function startup
*/
DWORD ArgCount = 0;
LPTSTR *ArgArray = NULL;
TCHAR szRegKey[512];
TCHAR szValue[128];
DWORD nSize;
HKEY hParamKey = NULL; /* To read startup parameters */
DWORD TotalParams = 0;
DWORD i;
InputParams ThreadInputParams;
/*
* Build the Input parameters to pass to worker thread
*/
/*
* SCM sends Service Name as first arg, increment to point
* arguments user specified while starting contorl agent
*/
/*
* Read registry parameter
*/
ArgCount = 1;
/*
* Create Registry Key path
*/
_snprintf (szRegKey, sizeof(szRegKey), "%s%s\\%s",
_T ("SYSTEM\\CurrentControlSet\\Services\\"), app_name,
"Parameters");
if (RegOpenKeyEx
(HKEY_LOCAL_MACHINE, szRegKey, 0, KEY_ALL_ACCESS, &hParamKey) == ERROR_SUCCESS)
{
/*
* Read startup Configuration information
*/
/*
* Find number of subkeys inside parameters
*/
if (RegQueryInfoKey (hParamKey, NULL, NULL, 0,
NULL, NULL, NULL, &TotalParams,
NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
{
if (TotalParams != 0)
{
ArgCount += TotalParams;
/*
* Allocate memory to hold strings
*/
ArgArray = (LPTSTR *) malloc (sizeof (LPTSTR) * ArgCount);
/*
* Copy first argument
*/
ArgArray[0] = _tcsdup (argv[0]);
for (i = 1; i <= TotalParams; i++)
{
/*
* Create Subkey value name
*/
_snprintf (szRegKey, sizeof(szRegKey), "%s%d", "Param", i);
/*
* Set size
*/
nSize = 128;
RegQueryValueEx (hParamKey, szRegKey, 0, NULL,
(LPBYTE) & szValue, &nSize);
ArgArray[i] = _tcsdup (szValue);
}
}
}
RegCloseKey (hParamKey);
}
if (ArgCount == 1)
{
/*
* No statup agrs are given
*/
ThreadInputParams.Argc = argc;
ThreadInputParams.Argv = argv;
}
else
{
ThreadInputParams.Argc = ArgCount;
ThreadInputParams.Argv = ArgArray;
}
/*
* Register Service Control Handler
*/
hServiceStatus = RegisterServiceCtrlHandler (app_name, ControlHandler);
if (hServiceStatus == 0)
{
WriteToEventLog (EVENTLOG_ERROR_TYPE,
_T ("RegisterServiceCtrlHandler failed"));
return;
}
/*
* Update the service status to START_PENDING
*/
UpdateServiceStatus (SERVICE_START_PENDING, NO_ERROR, SCM_WAIT_INTERVAL);
/*
* Spin of worker thread, which does majority of the work
*/
TRY
{
if (SetSimpleSecurityAttributes (&SecurityAttributes) == FALSE)
{
WriteToEventLog (EVENTLOG_ERROR_TYPE,
_T ("Couldn't init security attributes"));
LEAVE;
}
hServiceThread =
(void *) _beginthreadex (&SecurityAttributes, 0,
ThreadFunction,
(void *) &ThreadInputParams, 0, &dwThreadId);
if (hServiceThread == NULL)
{
WriteToEventLog (EVENTLOG_ERROR_TYPE, _T ("Couldn't start worker thread"));
LEAVE;
}
/*
* Set Service Status to Running
*/
UpdateServiceStatus (SERVICE_RUNNING, NO_ERROR, SCM_WAIT_INTERVAL);
/*
* Wait for termination event and worker thread to
* * spin down.
*/
WaitForSingleObject (hServiceThread, INFINITE);
}
FINALLY
{
/*
* Release resources
*/
UpdateServiceStatus (SERVICE_STOPPED, NO_ERROR, SCM_WAIT_INTERVAL);
if (hServiceThread)
CloseHandle (hServiceThread);
FreeSecurityAttributes (&SecurityAttributes);
/*
* Delete allocated argument list
*/
if (ArgCount > 1 && ArgArray != NULL)
{
/*
* Delete all strings
*/
for (i = 0; i < ArgCount; i++)
{
free (ArgArray[i]);
}
free (ArgArray);
}
}
}
static VOID
MainWndCommand(PMAIN_WND_INFO Info,
WORD CmdId,
HWND hControl)
{
UNREFERENCED_PARAMETER(hControl);
switch (CmdId)
{
case ID_PROP:
{
if (Info->SelectedItem != NO_ITEM_SELECTED)
{
Info->bDlgOpen = TRUE;
OpenPropSheet(Info);
Info->bDlgOpen = FALSE;
SetMenuAndButtonStates(Info);
}
}
break;
case ID_REFRESH:
{
RefreshServiceList(Info);
Info->SelectedItem = NO_ITEM_SELECTED;
/* disable menus and buttons */
SetMenuAndButtonStates(Info);
/* clear the service in the status bar */
SendMessage(Info->hStatus,
SB_SETTEXT,
1,
_T('\0'));
}
break;
case ID_EXPORT:
{
ExportFile(Info);
SetFocus(Info->hListView);
}
break;
case ID_CREATE:
{
INT ret;
ret = DialogBoxParam(hInstance,
MAKEINTRESOURCE(IDD_DLG_CREATE),
Info->hMainWnd,
CreateDialogProc,
(LPARAM)Info);
if (ret == IDOK)
RefreshServiceList(Info);
SetFocus(Info->hListView);
}
break;
case ID_DELETE:
{
if (Info->pCurrentService->ServiceStatusProcess.dwCurrentState != SERVICE_RUNNING)
{
DialogBoxParam(hInstance,
MAKEINTRESOURCE(IDD_DLG_DELETE),
Info->hMainWnd,
DeleteDialogProc,
(LPARAM)Info);
}
else
{
TCHAR Buf[60];
LoadString(hInstance,
IDS_DELETE_STOP,
Buf,
sizeof(Buf) / sizeof(TCHAR));
DisplayString(Buf);
}
SetFocus(Info->hListView);
}
break;
case ID_START:
{
if (DoStart(Info, NULL))
{
UpdateServiceStatus(Info->pCurrentService);
ChangeListViewText(Info, Info->pCurrentService, LVSTATUS);
SetMenuAndButtonStates(Info);
SetFocus(Info->hListView);
}
}
break;
case ID_STOP:
if (DoStop(Info))
{
UpdateServiceStatus(Info->pCurrentService);
ChangeListViewText(Info, Info->pCurrentService, LVSTATUS);
SetMenuAndButtonStates(Info);
SetFocus(Info->hListView);
}
break;
case ID_PAUSE:
DoPause(Info);
break;
case ID_RESUME:
DoResume(Info);
break;
case ID_RESTART:
if (DoStop(Info))
{
DoStart(Info, NULL);
UpdateServiceStatus(Info->pCurrentService);
ChangeListViewText(Info, Info->pCurrentService, LVSTATUS);
SetMenuAndButtonStates(Info);
SetFocus(Info->hListView);
}
break;
case ID_HELP:
MessageBox(NULL,
_T("Help is not yet implemented\n"),
_T("Note!"),
MB_OK | MB_ICONINFORMATION);
SetFocus(Info->hListView);
break;
case ID_EXIT:
PostMessage(Info->hMainWnd,
WM_CLOSE,
0,
0);
break;
case ID_VIEW_LARGE:
SetListViewStyle(Info->hListView,
LVS_ICON);
CheckMenuRadioItem(GetMenu(Info->hMainWnd),
ID_VIEW_LARGE,
ID_VIEW_DETAILS,
ID_VIEW_LARGE,
MF_BYCOMMAND);
break;
case ID_VIEW_SMALL:
SetListViewStyle(Info->hListView,
LVS_SMALLICON);
CheckMenuRadioItem(GetMenu(Info->hMainWnd),
ID_VIEW_LARGE,
ID_VIEW_DETAILS,
ID_VIEW_SMALL,
MF_BYCOMMAND);
break;
case ID_VIEW_LIST:
SetListViewStyle(Info->hListView,
LVS_LIST);
CheckMenuRadioItem(GetMenu(Info->hMainWnd),
ID_VIEW_LARGE,
ID_VIEW_DETAILS,
ID_VIEW_LIST,
MF_BYCOMMAND);
break;
case ID_VIEW_DETAILS:
SetListViewStyle(Info->hListView,
LVS_REPORT);
CheckMenuRadioItem(GetMenu(Info->hMainWnd),
ID_VIEW_LARGE,
ID_VIEW_DETAILS,
ID_VIEW_DETAILS,
MF_BYCOMMAND);
break;
case ID_VIEW_CUST:
break;
case ID_ABOUT:
DialogBox(hInstance,
MAKEINTRESOURCE(IDD_ABOUTBOX),
Info->hMainWnd,
AboutDialogProc);
SetFocus(Info->hListView);
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TfrmMainFormServer::tmrMainTimer(TObject *Sender)
{
UpdateServiceStatus();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMainFormServer::FormShow(TObject *Sender)
{
UpdateServiceStatus();
LoadModuleNames();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ServiceMain()
// Called by the Service Manager.
VOID WINAPI ServiceMain( DWORD dwArgs, LPTSTR *ppszArgs)
{
HWND hWnd = NULL;
LPCTSTR pszServiceName = ppszArgs[0];
//
// Record this ServiceMain's thread ID for other threads to use.
//
gServiceMainThreadID = GetCurrentThreadId();
ALERT( "ServiceMain: function started. Passed inn Name is...\n" );
ALERT( pszServiceName );
ALERT( "ServiceMain: About to call RegisterServiceCtrlHandler()...\n" );
// Test to see if we can cause the message loop to start queuing...
SetTimeoutTimer( 10 );
CleanStatusStruct( &gServiceStatus );
gServiceStatus.dwCurrentState = SERVICE_START_PENDING;
ghService = RegisterServiceCtrlHandler( pszServiceName, ServiceHandler );
if( 0 != ghService )
{
ALERT( "ServiceMain: Just came out of RegisterServiceCtrlHandler()" );
// If the state has not yet changed then push start everything...
if( 0 == gdwState )
{
gdwState = SERVICE_START_PENDING;
//
// If we are in callback mode then make sure to
// start by posting a SERVICE_START_PENDING message
// (even though one does not exist in the Win32 API)
// so the script has a chance to start.
//
if( FALSE != gfCallbackMode )
{
//
// Call the service handler indicating that the "fake"
// SERVICE_CONTROL_START event has been received.
//
ServiceHandler( SERVICE_CONTROL_START );
}
}
{
char szBuffer[256];
sprintf( szBuffer, "ServiceMain: About to call My_SetServiceBits with gdwServiceBits=0x%08x", gdwServiceBits );
ALERT( szBuffer );
}
if( 0 != gdwServiceBits )
{
My_SetServiceBits( ghService, gdwServiceBits, TRUE, TRUE );
}
ALERT( "ServiceMain: Entering message loop" );
// Call a Win32 User level function to create a message queue
GetDesktopWindow();
GetWindow( NULL, GW_HWNDFIRST );
if( 1 )
{
MSG Message;
BOOL fContinueProcessing = TRUE;
while( TRUE == fContinueProcessing )
{
ALERT( "ServiceMain: Just enetered the message loop" );
try
{
fContinueProcessing = (BOOL) GetMessage( &Message, (HWND) NULL, 0, 0 );
#ifdef _DEBUG
TCHAR szBuffer[256];
wsprintf( szBuffer, "Got message: 0x%08x", Message.message );
ALERT( szBuffer );
#endif // _DEBUG
}
catch (...)
{
ALERT( "ServiceMain: Ouch!!! We caught an exception!" );
}
switch( Message.message )
{
case WM_USER_SET_TIMER:
ALERT( "ServiceMain: Setting timer" );
ghTimer = ::SetTimer( NULL, SERVICE_THREAD_TIMER_ID, (UINT)Message.wParam * DEFAULT_HANDLER_TIMEOUT_SCALE, (TIMERPROC)TimerHandler );
break;
case WM_QUIT:
fContinueProcessing = FALSE;
break;
case WM_QUERYENDSESSION:
case WM_ENDSESSION:
case WM_TIMER:
ALERT( "ServiceMain: HandlerTimeoutTimer due to WM_TIMER." );
KillTimer();
gdwState = gdwTimeoutState;
UpdateServiceStatus( gdwTimeoutState );
default:
ALERT( "ServiceMain: Dispatching message." );
TranslateMessage( &Message );
//
// Calling DispatchMessage() is probably foolish since
// there is no window associated with this thread.
// Per MSDN: messages that are not associated with a window cannot be dispatched by the DispatchMessage function
DispatchMessage( &Message );
}
}
}
ALERT( "ServiceMain: Just left the message loop." );
UpdateServiceStatus( gdwState );
}
else
{
gdwState = SERVICE_STOPPED;
#ifdef _DEBUG
TCHAR szBuffer[ 100 ];
wsprintf( szBuffer, TEXT( "ServiceMain: ERROR! 0x08x" ), GetLastError() );
ALERT( szBuffer );
#endif // _DEBUG
}
ALERT( "ServiceMain: Shutting down ServiceMain()!" );
return;
}
