Mix/Src/service.c

// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (C) 1993-1997  Microsoft Corporation.  All Rights Reserved.
//
//  MODULE:   service.c
//
//  PURPOSE:  Implements functions required by all services
//            windows.
//
//  FUNCTIONS:
//    main(int argc, char **argv);
//    service_ctrl(DWORD dwCtrlCode);
//    service_main(DWORD dwArgc, LPTSTR *lpszArgv);
//    CmdInstallService();
//    CmdRemoveService();
//    CmdDebugService(int argc, char **argv);
//    ControlHandler ( DWORD dwCtrlType );
//    GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize );
//
//  COMMENTS:
//
//  AUTHOR: Craig Link - Microsoft Developer Support
//


#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <tchar.h>

#include "service.h"


// internal variables
SERVICE_STATUS          ssStatus;       // current status of the service
SERVICE_STATUS_HANDLE   sshStatusHandle;
DWORD                   dwErr = 0;
BOOL                    bDebug = FALSE;
TCHAR                   szErr[256];

// internal function prototypes
VOID WINAPI service_ctrl(DWORD dwCtrlCode);
VOID WINAPI service_main(DWORD dwArgc, LPTSTR *lpszArgv);
VOID CmdInstallService();
VOID CmdRemoveService();
VOID CmdDebugService(int argc, char **argv);
BOOL WINAPI ControlHandler ( DWORD dwCtrlType );
LPTSTR GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize );

//
//  FUNCTION: main
//
//  PURPOSE: entrypoint for service
//
//  PARAMETERS:
//    argc - number of command line arguments
//    argv - array of command line arguments
//
//  RETURN VALUE:
//    none
//
//  COMMENTS:
//    main() either performs the command line task, or
//    call StartServiceCtrlDispatcher to register the
//    main service thread.  When the this call returns,
//    the service has stopped, so exit.
//
void _CRTAPI1 main(int argc, char **argv)
{
    SERVICE_TABLE_ENTRY dispatchTable[] =
    {
        { TEXT(SZSERVICENAME), (LPSERVICE_MAIN_FUNCTION)service_main },
        { NULL, NULL }
    };

    if ( (argc > 1) &&
         ((*argv[1] == '-') || (*argv[1] == '/')) )
    {
        if ( _stricmp( "install", argv[1]+1 ) == 0 )
        {
            CmdInstallService();
        }
        else if ( _stricmp( "remove", argv[1]+1 ) == 0 )
        {
            CmdRemoveService();
        }
        else if ( _stricmp( "debug", argv[1]+1 ) == 0 )
        {
            bDebug = TRUE;
            CmdDebugService(argc, argv);
        }
        else
        {
            goto dispatch;
        }
        exit(0);
    }

    // if it doesn't match any of the above parameters
    // the service control manager may be starting the service
    // so we must call StartServiceCtrlDispatcher
    dispatch:
        // this is just to be friendly
        printf( "%s -install          to install the service\n", SZAPPNAME );
        printf( "%s -remove           to remove the service\n", SZAPPNAME );
        printf( "%s -debug <params>   to run as a console app for debugging\n", SZAPPNAME );
        printf( "\nStartServiceCtrlDispatcher being called.\n" );
        printf( "This may take several seconds.  Please wait.\n" );

        if (!StartServiceCtrlDispatcher(dispatchTable))
            AddToMessageLog(TEXT("StartServiceCtrlDispatcher failed."));
}


//
//  FUNCTION: service_main
//
//  PURPOSE: To perform actual initialization of the service
//
//  PARAMETERS:
//    dwArgc   - number of command line arguments
//    lpszArgv - array of command line arguments
//
//  RETURN VALUE:
//    none
//
//  COMMENTS:
//    This routine performs the service initialization and then calls
//    the user defined ServiceStart() routine to perform majority
//    of the work.
//
void WINAPI service_main(DWORD dwArgc, LPTSTR *lpszArgv)
{

    // register our service control handler:
    //
    sshStatusHandle = RegisterServiceCtrlHandler( TEXT(SZSERVICENAME), service_ctrl);

    if (!sshStatusHandle)
        goto cleanup;

    // SERVICE_STATUS members that don't change in example
    //
    ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
    ssStatus.dwServiceSpecificExitCode = 0;


    // report the status to the service control manager.
    //
    if (!ReportStatusToSCMgr(
        SERVICE_START_PENDING, // service state
        NO_ERROR,              // exit code
        3000))                 // wait hint
        goto cleanup;


    ServiceStart( dwArgc, lpszArgv );

cleanup:

    // try to report the stopped status to the service control manager.
    //
    if (sshStatusHandle)
        (VOID)ReportStatusToSCMgr(
                            SERVICE_STOPPED,
                            dwErr,
                            0);

    return;
}


//
//  FUNCTION: service_ctrl
//
//  PURPOSE: This function is called by the SCM whenever
//           ControlService() is called on this service.
//
//  PARAMETERS:
//    dwCtrlCode - type of control requested
//
//  RETURN VALUE:
//    none
//
//  COMMENTS:
//
VOID WINAPI service_ctrl(DWORD dwCtrlCode)
{
    // Handle the requested control code.
    //
    switch(dwCtrlCode)
    {
        // Stop the service.
        //
        // SERVICE_STOP_PENDING should be reported before
        // setting the Stop Event - hServerStopEvent - in
        // ServiceStop().  This avoids a race condition
        // which may result in a 1053 - The Service did not respond...
        // error.
        case SERVICE_CONTROL_STOP:
            ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0);
            ServiceStop();
            return;

        // Update the service status.
        //
        case SERVICE_CONTROL_INTERROGATE:
            break;

        // invalid control code
        //
        default:
            break;

    }

    ReportStatusToSCMgr(ssStatus.dwCurrentState, NO_ERROR, 0);
}


//
//  FUNCTION: ReportStatusToSCMgr()
//
//  PURPOSE: Sets the current status of the service and
//           reports it to the Service Control Manager
//
//  PARAMETERS:
//    dwCurrentState - the state of the service
//    dwWin32ExitCode - error code to report
//    dwWaitHint - worst case estimate to next checkpoint
//
//  RETURN VALUE:
//    TRUE  - success
//    FALSE - failure
//
//  COMMENTS:
//
BOOL ReportStatusToSCMgr(DWORD dwCurrentState,
                         DWORD dwWin32ExitCode,
                         DWORD dwWaitHint)
{
    static DWORD dwCheckPoint = 1;
    BOOL fResult = TRUE;


    if ( !bDebug ) // when debugging we don't report to the SCM
    {
        if (dwCurrentState == SERVICE_START_PENDING)
            ssStatus.dwControlsAccepted = 0;
        else
            ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;

        ssStatus.dwCurrentState = dwCurrentState;
        ssStatus.dwWin32ExitCode = dwWin32ExitCode;
        ssStatus.dwWaitHint = dwWaitHint;

        if ( ( dwCurrentState == SERVICE_RUNNING ) ||
             ( dwCurrentState == SERVICE_STOPPED ) )
            ssStatus.dwCheckPoint = 0;
        else
            ssStatus.dwCheckPoint = dwCheckPoint++;


        // Report the status of the service to the service control manager.
        //
        if (!(fResult = SetServiceStatus( sshStatusHandle, &ssStatus))) {
            AddToMessageLog(TEXT("SetServiceStatus"));
        }
    }
    return fResult;
}


//
//  FUNCTION: AddToMessageLog(LPTSTR lpszMsg)
//
//  PURPOSE: Allows any thread to log an error message
//
//  PARAMETERS:
//    lpszMsg - text for message
//
//  RETURN VALUE:
//    none
//
//  COMMENTS:
//
VOID AddToMessageLog(LPTSTR lpszMsg)
{
    TCHAR   szMsg[256];
    HANDLE  hEventSource;
    LPTSTR  lpszStrings[2];


    if ( !bDebug )
    {
        dwErr = GetLastError();

        // Use event logging to log the error.
        //
        hEventSource = RegisterEventSource(NULL, TEXT(SZSERVICENAME));

        _stprintf(szMsg, TEXT("%s error: %d"), TEXT(SZSERVICENAME), dwErr);
        lpszStrings[0] = szMsg;
        lpszStrings[1] = lpszMsg;

        if (hEventSource != NULL) {
            ReportEvent(hEventSource, // handle of event source
                EVENTLOG_ERROR_TYPE,  // event type
                0,                    // event category
                0,                    // event ID
                NULL,                 // current user's SID
                2,                    // strings in lpszStrings
                0,                    // no bytes of raw data
                lpszStrings,          // array of error strings
                NULL);                // no raw data

            (VOID) DeregisterEventSource(hEventSource);
        }
    }
}


///////////////////////////////////////////////////////////////////
//
//  The following code handles service installation and removal
//


//
//  FUNCTION: CmdInstallService()
//
//  PURPOSE: Installs the service
//
//  PARAMETERS:
//    none
//
//  RETURN VALUE:
//    none
//
//  COMMENTS:
//
void CmdInstallService()
{
    SC_HANDLE   schService;
    SC_HANDLE   schSCManager;

    TCHAR szPath[512];

    if ( GetModuleFileName( NULL, szPath, 512 ) == 0 )
    {
        _tprintf(TEXT("Unable to install %s - %s\n"), TEXT(SZSERVICEDISPLAYNAME), GetLastErrorText(szErr, 256));
        return;
    }

    schSCManager = OpenSCManager(
                        NULL,                   // machine (NULL == local)
                        NULL,                   // database (NULL == default)
                        SC_MANAGER_ALL_ACCESS   // access required
                        );
    if ( schSCManager )
    {
        schService = CreateService(
            schSCManager,               // SCManager database
            TEXT(SZSERVICENAME),        // name of service
            TEXT(SZSERVICEDISPLAYNAME), // name to display
            SERVICE_ALL_ACCESS,         // desired access
            SERVICE_WIN32_OWN_PROCESS,  // service type
            SERVICE_DEMAND_START,       // start type
            SERVICE_ERROR_NORMAL,       // error control type
            szPath,                     // service's binary
            NULL,                       // no load ordering group
            NULL,                       // no tag identifier
            TEXT(SZDEPENDENCIES),       // dependencies
            NULL,                       // LocalSystem account
            NULL);                      // no password

        if ( schService )
        {
            _tprintf(TEXT("%s installed.\n"), TEXT(SZSERVICEDISPLAYNAME) );
            CloseServiceHandle(schService);
        }
        else
        {
            _tprintf(TEXT("CreateService failed - %s\n"), GetLastErrorText(szErr, 256));
        }

        CloseServiceHandle(schSCManager);
    }
    else
        _tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
}


//
//  FUNCTION: CmdRemoveService()
//
//  PURPOSE: Stops and removes the service
//
//  PARAMETERS:
//    none
//
//  RETURN VALUE:
//    none
//
//  COMMENTS:
//
void CmdRemoveService()
{
    SC_HANDLE   schService;
    SC_HANDLE   schSCManager;

    schSCManager = OpenSCManager(
                        NULL,                   // machine (NULL == local)
                        NULL,                   // database (NULL == default)
                        SC_MANAGER_ALL_ACCESS   // access required
                        );
    if ( schSCManager )
    {
        schService = OpenService(schSCManager, TEXT(SZSERVICENAME), SERVICE_ALL_ACCESS);

        if (schService)
        {
            // try to stop the service
            if ( ControlService( schService, SERVICE_CONTROL_STOP, &ssStatus ) )
            {
                _tprintf(TEXT("Stopping %s."), TEXT(SZSERVICEDISPLAYNAME));
                Sleep( 1000 );

                while( QueryServiceStatus( schService, &ssStatus ) )
                {
                    if ( ssStatus.dwCurrentState == SERVICE_STOP_PENDING )
                    {
                        _tprintf(TEXT("."));
                        Sleep( 1000 );
                    }
                    else
                        break;
                }

                if ( ssStatus.dwCurrentState == SERVICE_STOPPED )
                    _tprintf(TEXT("\n%s stopped.\n"), TEXT(SZSERVICEDISPLAYNAME) );
                else
                    _tprintf(TEXT("\n%s failed to stop.\n"), TEXT(SZSERVICEDISPLAYNAME) );

            }

            // now remove the service
            if( DeleteService(schService) )
                _tprintf(TEXT("%s removed.\n"), TEXT(SZSERVICEDISPLAYNAME) );
            else
                _tprintf(TEXT("DeleteService failed - %s\n"), GetLastErrorText(szErr,256));


            CloseServiceHandle(schService);
        }
        else
            _tprintf(TEXT("OpenService failed - %s\n"), GetLastErrorText(szErr,256));

        CloseServiceHandle(schSCManager);
    }
    else
        _tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
}


///////////////////////////////////////////////////////////////////
//
//  The following code is for running the service as a console app
//


//
//  FUNCTION: CmdDebugService(int argc, char ** argv)
//
//  PURPOSE: Runs the service as a console application
//
//  PARAMETERS:
//    argc - number of command line arguments
//    argv - array of command line arguments
//
//  RETURN VALUE:
//    none
//
//  COMMENTS:
//
void CmdDebugService(int argc, char ** argv)
{
    DWORD dwArgc;
    LPTSTR *lpszArgv;

#ifdef UNICODE
    lpszArgv = CommandLineToArgvW(GetCommandLineW(), &(dwArgc) );
#else
    dwArgc   = (DWORD) argc;
    lpszArgv = argv;
#endif

    _tprintf(TEXT("Debugging %s.\n"), TEXT(SZSERVICEDISPLAYNAME));

    SetConsoleCtrlHandler( ControlHandler, TRUE );

    ServiceStart( dwArgc, lpszArgv );
}


//
//  FUNCTION: ControlHandler ( DWORD dwCtrlType )
//
//  PURPOSE: Handled console control events
//
//  PARAMETERS:
//    dwCtrlType - type of control event
//
//  RETURN VALUE:
//    True - handled
//    False - unhandled
//
//  COMMENTS:
//
BOOL WINAPI ControlHandler ( DWORD dwCtrlType )
{
    switch( dwCtrlType )
    {
        case CTRL_BREAK_EVENT:  // use Ctrl+C or Ctrl+Break to simulate
        case CTRL_C_EVENT:      // SERVICE_CONTROL_STOP in debug mode
            _tprintf(TEXT("Stopping %s.\n"), TEXT(SZSERVICEDISPLAYNAME));
            ServiceStop();
            return TRUE;
            break;

    }
    return FALSE;
}

//
//  FUNCTION: GetLastErrorText
//
//  PURPOSE: copies error message text to string
//
//  PARAMETERS:
//    lpszBuf - destination buffer
//    dwSize - size of buffer
//
//  RETURN VALUE:
//    destination buffer
//
//  COMMENTS:
//
LPTSTR GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize )
{
    DWORD dwRet;
    LPTSTR lpszTemp = NULL;

    dwRet = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY,
                           NULL,
                           GetLastError(),
                           LANG_NEUTRAL,
                           (LPTSTR)&lpszTemp,
                           0,
                           NULL );

    // supplied buffer is not long enough
    if ( !dwRet || ( (long)dwSize < (long)dwRet+14 ) )
        lpszBuf[0] = TEXT('\0');
    else
    {
        lpszTemp[lstrlen(lpszTemp)-2] = TEXT('\0');  //remove cr and newline character
        _stprintf( lpszBuf, TEXT("%s (0x%x)"), lpszTemp, GetLastError() );
    }

    if ( lpszTemp )
        LocalFree((HLOCAL) lpszTemp );

    return lpszBuf;
}
1	// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
2	// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
3	// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
4	// PARTICULAR PURPOSE.
5	//
6	// Copyright (C) 1993-1997 Microsoft Corporation. All Rights Reserved.
7	//
8	// MODULE: service.c
9	//
10	// PURPOSE: Implements functions required by all services
11	// windows.
12	//
13	// FUNCTIONS:
14	// main(int argc, char **argv);
15	// service_ctrl(DWORD dwCtrlCode);
16	// service_main(DWORD dwArgc, LPTSTR *lpszArgv);
17	// CmdInstallService();
18	// CmdRemoveService();
19	// CmdDebugService(int argc, char **argv);
20	// ControlHandler ( DWORD dwCtrlType );
21	// GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize );
22	//
23	// COMMENTS:
24	//
25	// AUTHOR: Craig Link - Microsoft Developer Support
26	//
27
28
29	#include <windows.h>
30	#include <stdio.h>
31	#include <stdlib.h>
32	#include <process.h>
33	#include <tchar.h>
34
35	#include "service.h"
36
37
38
39	// internal variables
40	SERVICE_STATUS ssStatus; // current status of the service
41	SERVICE_STATUS_HANDLE sshStatusHandle;
42	DWORD dwErr = 0;
43	BOOL bDebug = FALSE;
44	TCHAR szErr[256];
45
46	// internal function prototypes
47	VOID WINAPI service_ctrl(DWORD dwCtrlCode);
48	VOID WINAPI service_main(DWORD dwArgc, LPTSTR *lpszArgv);
49	VOID CmdInstallService();
50	VOID CmdRemoveService();
51	VOID CmdDebugService(int argc, char **argv);
52	BOOL WINAPI ControlHandler ( DWORD dwCtrlType );
53	LPTSTR GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize );
54
55	//
56	// FUNCTION: main
57	//
58	// PURPOSE: entrypoint for service
59	//
60	// PARAMETERS:
61	// argc - number of command line arguments
62	// argv - array of command line arguments
63	//
64	// RETURN VALUE:
65	// none
66	//
67	// COMMENTS:
68	// main() either performs the command line task, or
69	// call StartServiceCtrlDispatcher to register the
70	// main service thread. When the this call returns,
71	// the service has stopped, so exit.
72	//
73	void _CRTAPI1 main(int argc, char **argv)
74	{
75	SERVICE_TABLE_ENTRY dispatchTable[] =
76	{
77	{ TEXT(SZSERVICENAME), (LPSERVICE_MAIN_FUNCTION)service_main },
78	{ NULL, NULL }
79	};
80
81	if ( (argc > 1) &&
82	((argv[1] == '-') \|\| (argv[1] == '/')) )
83	{
84	if ( _stricmp( "install", argv[1]+1 ) == 0 )
85	{
86	CmdInstallService();
87	}
88	else if ( _stricmp( "remove", argv[1]+1 ) == 0 )
89	{
90	CmdRemoveService();
91	}
92	else if ( _stricmp( "debug", argv[1]+1 ) == 0 )
93	{
94	bDebug = TRUE;
95	CmdDebugService(argc, argv);
96	}
97	else
98	{
99	goto dispatch;
100	}
101	exit(0);
102	}
103
104	// if it doesn't match any of the above parameters
105	// the service control manager may be starting the service
106	// so we must call StartServiceCtrlDispatcher
107	dispatch:
108	// this is just to be friendly
109	printf( "%s -install to install the service\n", SZAPPNAME );
110	printf( "%s -remove to remove the service\n", SZAPPNAME );
111	printf( "%s -debug <params> to run as a console app for debugging\n", SZAPPNAME );
112	printf( "\nStartServiceCtrlDispatcher being called.\n" );
113	printf( "This may take several seconds. Please wait.\n" );
114
115	if (!StartServiceCtrlDispatcher(dispatchTable))
116	AddToMessageLog(TEXT("StartServiceCtrlDispatcher failed."));
117	}
118
119
120
121	//
122	// FUNCTION: service_main
123	//
124	// PURPOSE: To perform actual initialization of the service
125	//
126	// PARAMETERS:
127	// dwArgc - number of command line arguments
128	// lpszArgv - array of command line arguments
129	//
130	// RETURN VALUE:
131	// none
132	//
133	// COMMENTS:
134	// This routine performs the service initialization and then calls
135	// the user defined ServiceStart() routine to perform majority
136	// of the work.
137	//
138	void WINAPI service_main(DWORD dwArgc, LPTSTR *lpszArgv)
139	{
140
141	// register our service control handler:
142	//
143	sshStatusHandle = RegisterServiceCtrlHandler( TEXT(SZSERVICENAME), service_ctrl);
144
145	if (!sshStatusHandle)
146	goto cleanup;
147
148	// SERVICE_STATUS members that don't change in example
149	//
150	ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
151	ssStatus.dwServiceSpecificExitCode = 0;
152
153
154	// report the status to the service control manager.
155	//
156	if (!ReportStatusToSCMgr(
157	SERVICE_START_PENDING, // service state
158	NO_ERROR, // exit code
159	3000)) // wait hint
160	goto cleanup;
161
162
163	ServiceStart( dwArgc, lpszArgv );
164
165	cleanup:
166
167	// try to report the stopped status to the service control manager.
168	//
169	if (sshStatusHandle)
170	(VOID)ReportStatusToSCMgr(
171	SERVICE_STOPPED,
172	dwErr,
173	0);
174
175	return;
176	}
177
178
179
180	//
181	// FUNCTION: service_ctrl
182	//
183	// PURPOSE: This function is called by the SCM whenever
184	// ControlService() is called on this service.
185	//
186	// PARAMETERS:
187	// dwCtrlCode - type of control requested
188	//
189	// RETURN VALUE:
190	// none
191	//
192	// COMMENTS:
193	//
194	VOID WINAPI service_ctrl(DWORD dwCtrlCode)
195	{
196	// Handle the requested control code.
197	//
198	switch(dwCtrlCode)
199	{
200	// Stop the service.
201	//
202	// SERVICE_STOP_PENDING should be reported before
203	// setting the Stop Event - hServerStopEvent - in
204	// ServiceStop(). This avoids a race condition
205	// which may result in a 1053 - The Service did not respond...
206	// error.
207	case SERVICE_CONTROL_STOP:
208	ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0);
209	ServiceStop();
210	return;
211
212	// Update the service status.
213	//
214	case SERVICE_CONTROL_INTERROGATE:
215	break;
216
217	// invalid control code
218	//
219	default:
220	break;
221
222	}
223
224	ReportStatusToSCMgr(ssStatus.dwCurrentState, NO_ERROR, 0);
225	}
226
227
228
229	//
230	// FUNCTION: ReportStatusToSCMgr()
231	//
232	// PURPOSE: Sets the current status of the service and
233	// reports it to the Service Control Manager
234	//
235	// PARAMETERS:
236	// dwCurrentState - the state of the service
237	// dwWin32ExitCode - error code to report
238	// dwWaitHint - worst case estimate to next checkpoint
239	//
240	// RETURN VALUE:
241	// TRUE - success
242	// FALSE - failure
243	//
244	// COMMENTS:
245	//
246	BOOL ReportStatusToSCMgr(DWORD dwCurrentState,
247	DWORD dwWin32ExitCode,
248	DWORD dwWaitHint)
249	{
250	static DWORD dwCheckPoint = 1;
251	BOOL fResult = TRUE;
252
253
254	if ( !bDebug ) // when debugging we don't report to the SCM
255	{
256	if (dwCurrentState == SERVICE_START_PENDING)
257	ssStatus.dwControlsAccepted = 0;
258	else
259	ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
260
261	ssStatus.dwCurrentState = dwCurrentState;
262	ssStatus.dwWin32ExitCode = dwWin32ExitCode;
263	ssStatus.dwWaitHint = dwWaitHint;
264
265	if ( ( dwCurrentState == SERVICE_RUNNING ) \|\|
266	( dwCurrentState == SERVICE_STOPPED ) )
267	ssStatus.dwCheckPoint = 0;
268	else
269	ssStatus.dwCheckPoint = dwCheckPoint++;
270
271
272	// Report the status of the service to the service control manager.
273	//
274	if (!(fResult = SetServiceStatus( sshStatusHandle, &ssStatus))) {
275	AddToMessageLog(TEXT("SetServiceStatus"));
276	}
277	}
278	return fResult;
279	}
280
281
282
283	//
284	// FUNCTION: AddToMessageLog(LPTSTR lpszMsg)
285	//
286	// PURPOSE: Allows any thread to log an error message
287	//
288	// PARAMETERS:
289	// lpszMsg - text for message
290	//
291	// RETURN VALUE:
292	// none
293	//
294	// COMMENTS:
295	//
296	VOID AddToMessageLog(LPTSTR lpszMsg)
297	{
298	TCHAR szMsg[256];
299	HANDLE hEventSource;
300	LPTSTR lpszStrings[2];
301
302
303	if ( !bDebug )
304	{
305	dwErr = GetLastError();
306
307	// Use event logging to log the error.
308	//
309	hEventSource = RegisterEventSource(NULL, TEXT(SZSERVICENAME));
310
311	_stprintf(szMsg, TEXT("%s error: %d"), TEXT(SZSERVICENAME), dwErr);
312	lpszStrings[0] = szMsg;
313	lpszStrings[1] = lpszMsg;
314
315	if (hEventSource != NULL) {
316	ReportEvent(hEventSource, // handle of event source
317	EVENTLOG_ERROR_TYPE, // event type
318	0, // event category
319	0, // event ID
320	NULL, // current user's SID
321	2, // strings in lpszStrings
322	0, // no bytes of raw data
323	lpszStrings, // array of error strings
324	NULL); // no raw data
325
326	(VOID) DeregisterEventSource(hEventSource);
327	}
328	}
329	}
330
331
332
333
334	///////////////////////////////////////////////////////////////////
335	//
336	// The following code handles service installation and removal
337	//
338
339
340	//
341	// FUNCTION: CmdInstallService()
342	//
343	// PURPOSE: Installs the service
344	//
345	// PARAMETERS:
346	// none
347	//
348	// RETURN VALUE:
349	// none
350	//
351	// COMMENTS:
352	//
353	void CmdInstallService()
354	{
355	SC_HANDLE schService;
356	SC_HANDLE schSCManager;
357
358	TCHAR szPath[512];
359
360	if ( GetModuleFileName( NULL, szPath, 512 ) == 0 )
361	{
362	_tprintf(TEXT("Unable to install %s - %s\n"), TEXT(SZSERVICEDISPLAYNAME), GetLastErrorText(szErr, 256));
363	return;
364	}
365
366	schSCManager = OpenSCManager(
367	NULL, // machine (NULL == local)
368	NULL, // database (NULL == default)
369	SC_MANAGER_ALL_ACCESS // access required
370	);
371	if ( schSCManager )
372	{
373	schService = CreateService(
374	schSCManager, // SCManager database
375	TEXT(SZSERVICENAME), // name of service
376	TEXT(SZSERVICEDISPLAYNAME), // name to display
377	SERVICE_ALL_ACCESS, // desired access
378	SERVICE_WIN32_OWN_PROCESS, // service type
379	SERVICE_DEMAND_START, // start type
380	SERVICE_ERROR_NORMAL, // error control type
381	szPath, // service's binary
382	NULL, // no load ordering group
383	NULL, // no tag identifier
384	TEXT(SZDEPENDENCIES), // dependencies
385	NULL, // LocalSystem account
386	NULL); // no password
387
388	if ( schService )
389	{
390	_tprintf(TEXT("%s installed.\n"), TEXT(SZSERVICEDISPLAYNAME) );
391	CloseServiceHandle(schService);
392	}
393	else
394	{
395	_tprintf(TEXT("CreateService failed - %s\n"), GetLastErrorText(szErr, 256));
396	}
397
398	CloseServiceHandle(schSCManager);
399	}
400	else
401	_tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
402	}
403
404
405
406	//
407	// FUNCTION: CmdRemoveService()
408	//
409	// PURPOSE: Stops and removes the service
410	//
411	// PARAMETERS:
412	// none
413	//
414	// RETURN VALUE:
415	// none
416	//
417	// COMMENTS:
418	//
419	void CmdRemoveService()
420	{
421	SC_HANDLE schService;
422	SC_HANDLE schSCManager;
423
424	schSCManager = OpenSCManager(
425	NULL, // machine (NULL == local)
426	NULL, // database (NULL == default)
427	SC_MANAGER_ALL_ACCESS // access required
428	);
429	if ( schSCManager )
430	{
431	schService = OpenService(schSCManager, TEXT(SZSERVICENAME), SERVICE_ALL_ACCESS);
432
433	if (schService)
434	{
435	// try to stop the service
436	if ( ControlService( schService, SERVICE_CONTROL_STOP, &ssStatus ) )
437	{
438	_tprintf(TEXT("Stopping %s."), TEXT(SZSERVICEDISPLAYNAME));
439	Sleep( 1000 );
440
441	while( QueryServiceStatus( schService, &ssStatus ) )
442	{
443	if ( ssStatus.dwCurrentState == SERVICE_STOP_PENDING )
444	{
445	_tprintf(TEXT("."));
446	Sleep( 1000 );
447	}
448	else
449	break;
450	}
451
452	if ( ssStatus.dwCurrentState == SERVICE_STOPPED )
453	_tprintf(TEXT("\n%s stopped.\n"), TEXT(SZSERVICEDISPLAYNAME) );
454	else
455	_tprintf(TEXT("\n%s failed to stop.\n"), TEXT(SZSERVICEDISPLAYNAME) );
456
457	}
458
459	// now remove the service
460	if( DeleteService(schService) )
461	_tprintf(TEXT("%s removed.\n"), TEXT(SZSERVICEDISPLAYNAME) );
462	else
463	_tprintf(TEXT("DeleteService failed - %s\n"), GetLastErrorText(szErr,256));
464
465
466	CloseServiceHandle(schService);
467	}
468	else
469	_tprintf(TEXT("OpenService failed - %s\n"), GetLastErrorText(szErr,256));
470
471	CloseServiceHandle(schSCManager);
472	}
473	else
474	_tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
475	}
476
477
478
479
480	///////////////////////////////////////////////////////////////////
481	//
482	// The following code is for running the service as a console app
483	//
484
485
486	//
487	// FUNCTION: CmdDebugService(int argc, char ** argv)
488	//
489	// PURPOSE: Runs the service as a console application
490	//
491	// PARAMETERS:
492	// argc - number of command line arguments
493	// argv - array of command line arguments
494	//
495	// RETURN VALUE:
496	// none
497	//
498	// COMMENTS:
499	//
500	void CmdDebugService(int argc, char ** argv)
501	{
502	DWORD dwArgc;
503	LPTSTR *lpszArgv;
504
505	#ifdef UNICODE
506	lpszArgv = CommandLineToArgvW(GetCommandLineW(), &(dwArgc) );
507	#else
508	dwArgc = (DWORD) argc;
509	lpszArgv = argv;
510	#endif
511
512	_tprintf(TEXT("Debugging %s.\n"), TEXT(SZSERVICEDISPLAYNAME));
513
514	SetConsoleCtrlHandler( ControlHandler, TRUE );
515
516	ServiceStart( dwArgc, lpszArgv );
517	}
518
519
520	//
521	// FUNCTION: ControlHandler ( DWORD dwCtrlType )
522	//
523	// PURPOSE: Handled console control events
524	//
525	// PARAMETERS:
526	// dwCtrlType - type of control event
527	//
528	// RETURN VALUE:
529	// True - handled
530	// False - unhandled
531	//
532	// COMMENTS:
533	//
534	BOOL WINAPI ControlHandler ( DWORD dwCtrlType )
535	{
536	switch( dwCtrlType )
537	{
538	case CTRL_BREAK_EVENT: // use Ctrl+C or Ctrl+Break to simulate
539	case CTRL_C_EVENT: // SERVICE_CONTROL_STOP in debug mode
540	_tprintf(TEXT("Stopping %s.\n"), TEXT(SZSERVICEDISPLAYNAME));
541	ServiceStop();
542	return TRUE;
543	break;
544
545	}
546	return FALSE;
547	}
548
549	//
550	// FUNCTION: GetLastErrorText
551	//
552	// PURPOSE: copies error message text to string
553	//
554	// PARAMETERS:
555	// lpszBuf - destination buffer
556	// dwSize - size of buffer
557	//
558	// RETURN VALUE:
559	// destination buffer
560	//
561	// COMMENTS:
562	//
563	LPTSTR GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize )
564	{
565	DWORD dwRet;
566	LPTSTR lpszTemp = NULL;
567
568	dwRet = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER \| FORMAT_MESSAGE_FROM_SYSTEM \|FORMAT_MESSAGE_ARGUMENT_ARRAY,
569	NULL,
570	GetLastError(),
571	LANG_NEUTRAL,
572	(LPTSTR)&lpszTemp,
573	0,
574	NULL );
575
576	// supplied buffer is not long enough
577	if ( !dwRet \|\| ( (long)dwSize < (long)dwRet+14 ) )
578	lpszBuf[0] = TEXT('\0');
579	else
580	{
581	lpszTemp[lstrlen(lpszTemp)-2] = TEXT('\0'); //remove cr and newline character
582	_stprintf( lpszBuf, TEXT("%s (0x%x)"), lpszTemp, GetLastError() );
583	}
584
585	if ( lpszTemp )
586	LocalFree((HLOCAL) lpszTemp );
587
588	return lpszBuf;
589	}