src/win32/service.c

 /*
 * This program 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 program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include <windows.h>
#include <winsvc.h>
#include <stdlib.h>

#if !defined(WINADVAPI)
#if !defined(_ADVAPI32_)
#define WINADVAPI DECLSPEC_IMPORT
#else
#define WINADVAPI
#endif
#endif

extern char serviceLongName[];
extern char serviceName[];
extern char serviceDescription[];

extern int g_ServiceStatus;

#ifdef WIN32_GUI
extern int server_main(int argc, char *argv[]);
#else
extern int main(int argc, char *argv[]);
#endif

SERVICE_STATUS serviceStatus;
SERVICE_STATUS_HANDLE serviceStatusHandle = 0;

typedef WINADVAPI BOOL (WINAPI *CSD_T)(SC_HANDLE, DWORD, LPCVOID);

void Win32_ServiceInstall()
{
        SERVICE_DESCRIPTION sdBuf; 
    CSD_T ChangeServiceDescription;
    HANDLE advapi32;
        SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);

        if (serviceControlManager)
        {
                char path[_MAX_PATH + 10];
                if (GetModuleFileName( 0, path, sizeof(path)/sizeof(path[0]) ) > 0)
                {
                        SC_HANDLE service;
                        strcat(path, " --service");
                        service = CreateService(serviceControlManager,
                                                        serviceName, serviceLongName,
                                                        SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
                                                        SERVICE_AUTO_START, SERVICE_ERROR_IGNORE, path,
                                                        0, 0, 0, 0, 0);
                        if (service)
                        {
                                sdBuf.lpDescription = serviceDescription;

                                if (!(advapi32 = GetModuleHandle("ADVAPI32.DLL")))
                                {
                                        CloseServiceHandle(service);
                                        CloseServiceHandle(serviceControlManager);
                                        return;
                                }
                                
                                ;
                                if (!(ChangeServiceDescription = (CSD_T) GetProcAddress(advapi32, "ChangeServiceConfig2A")))
                                {
                                        CloseServiceHandle(service);
                                        CloseServiceHandle(serviceControlManager);
                                        return;
                                }
    
                                ChangeServiceDescription(  
                                                                                service,                // handle to service  
                                                                                SERVICE_CONFIG_DESCRIPTION, // change: description  
                                                                                &sdBuf);
                                CloseServiceHandle(service);
                        }
                }
                CloseServiceHandle(serviceControlManager);
        }
}

void Win32_ServiceUninstall()
{
        SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CONNECT);

        if (serviceControlManager)
        {
                SC_HANDLE service = OpenService(serviceControlManager,
                        serviceName, SERVICE_QUERY_STATUS | DELETE);
                if (service)
                {
                        SERVICE_STATUS serviceStatus;
                        if (QueryServiceStatus(service, &serviceStatus))
                        {
                                if (serviceStatus.dwCurrentState == SERVICE_STOPPED)
                                        DeleteService(service);
                        }
                        //DeleteService(service);

                        CloseServiceHandle(service);
                }

                CloseServiceHandle(serviceControlManager);
        }

}

void WINAPI ServiceControlHandler(DWORD controlCode)
{
        switch (controlCode)
        {
                case SERVICE_CONTROL_INTERROGATE:
                        break;

                case SERVICE_CONTROL_SHUTDOWN:
                case SERVICE_CONTROL_STOP:
                        serviceStatus.dwCurrentState = SERVICE_STOP_PENDING;
                        SetServiceStatus(serviceStatusHandle, &serviceStatus);

                        g_ServiceStatus = 0;
                        return;

                case SERVICE_CONTROL_PAUSE:
                        g_ServiceStatus = 2;
                        serviceStatus.dwCurrentState = SERVICE_PAUSED;
                        SetServiceStatus(serviceStatusHandle, &serviceStatus);
                        break;

                case SERVICE_CONTROL_CONTINUE:
                        serviceStatus.dwCurrentState = SERVICE_RUNNING;
                        SetServiceStatus(serviceStatusHandle, &serviceStatus);
                        g_ServiceStatus = 1;
                        break;

                default:
                        if ( controlCode >= 128 && controlCode <= 255 )
                                // user defined control code
                                break;
                        else
                                // unrecognized control code
                                break;
        }

        SetServiceStatus(serviceStatusHandle, &serviceStatus);
}

void WINAPI ServiceMain(DWORD argc, char *argv[])
{
        // initialise service status
        serviceStatus.dwServiceType = SERVICE_WIN32;
        serviceStatus.dwCurrentState = SERVICE_START_PENDING;
        serviceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | 
        SERVICE_ACCEPT_PAUSE_CONTINUE; 
        serviceStatus.dwWin32ExitCode = NO_ERROR;
        serviceStatus.dwServiceSpecificExitCode = NO_ERROR;
        serviceStatus.dwCheckPoint = 0;
        serviceStatus.dwWaitHint = 0;

        serviceStatusHandle = RegisterServiceCtrlHandler(serviceName, ServiceControlHandler);

        if ( serviceStatusHandle )
        {
                char path[_MAX_PATH + 1];
                int i, last_slash = 0;

                GetModuleFileName(0, path, sizeof(path)/sizeof(path[0]));

                for (i = 0; i < strlen(path); i++) {
                        if (path[i] == '\\') last_slash = i;
                }

                path[last_slash] = 0;

                // service is starting
                serviceStatus.dwCurrentState = SERVICE_START_PENDING;
                SetServiceStatus(serviceStatusHandle, &serviceStatus);

                // do initialisation here
                SetCurrentDirectory(path);

                // running
                serviceStatus.dwControlsAccepted |= (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
                serviceStatus.dwCurrentState = SERVICE_RUNNING;
                SetServiceStatus( serviceStatusHandle, &serviceStatus );

                ////////////////////////
                // service main cycle //
                ////////////////////////
                
                g_ServiceStatus = 1;
                argc = 1;

#ifdef WIN32_GUI
                server_main(argc, argv);
#else
                main(argc, argv);
#endif

                // service was stopped
                serviceStatus.dwCurrentState = SERVICE_STOP_PENDING;
                SetServiceStatus(serviceStatusHandle, &serviceStatus);

                // do cleanup here
                
                // service is now stopped
                serviceStatus.dwControlsAccepted &= ~(SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
                serviceStatus.dwCurrentState = SERVICE_STOPPED;
                SetServiceStatus(serviceStatusHandle, &serviceStatus);
        }
}

void Win32_ServiceRun()
{
        SERVICE_TABLE_ENTRY serviceTable[] =
        {
                { serviceName, ServiceMain },
                { 0, 0 }
        };

        if (!StartServiceCtrlDispatcher(serviceTable)) 
        {
        } 
}
1	/*
2	* This program is free software; you can redistribute it and/or
3	* modify it under the terms of the GNU General Public License
4	* as published by the Free Software Foundation; either version 2
5	* of the License, or (at your option) any later version.
6	*
7	* This program is distributed in the hope that it will be useful,
8	* but WITHOUT ANY WARRANTY; without even the implied warranty of
9	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10	* GNU General Public License for more details.
11	*
12	* You should have received a copy of the GNU General Public License
13	* along with this program; if not, write to the Free Software
14	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
15	*/
16
17	#include <windows.h>
18	#include <winsvc.h>
19	#include <stdlib.h>
20
21	#if !defined(WINADVAPI)
22	#if !defined(_ADVAPI32_)
23	#define WINADVAPI DECLSPEC_IMPORT
24	#else
25	#define WINADVAPI
26	#endif
27	#endif
28
29	extern char serviceLongName[];
30	extern char serviceName[];
31	extern char serviceDescription[];
32
33	extern int g_ServiceStatus;
34
35	#ifdef WIN32_GUI
36	extern int server_main(int argc, char *argv[]);
37	#else
38	extern int main(int argc, char *argv[]);
39	#endif
40
41	SERVICE_STATUS serviceStatus;
42	SERVICE_STATUS_HANDLE serviceStatusHandle = 0;
43
44	typedef WINADVAPI BOOL (WINAPI *CSD_T)(SC_HANDLE, DWORD, LPCVOID);
45
46	void Win32_ServiceInstall()
47	{
48	SERVICE_DESCRIPTION sdBuf;
49	CSD_T ChangeServiceDescription;
50	HANDLE advapi32;
51	SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);
52
53	if (serviceControlManager)
54	{
55	char path[_MAX_PATH + 10];
56	if (GetModuleFileName( 0, path, sizeof(path)/sizeof(path[0]) ) > 0)
57	{
58	SC_HANDLE service;
59	strcat(path, " --service");
60	service = CreateService(serviceControlManager,
61	serviceName, serviceLongName,
62	SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
63	SERVICE_AUTO_START, SERVICE_ERROR_IGNORE, path,
64	0, 0, 0, 0, 0);
65	if (service)
66	{
67	sdBuf.lpDescription = serviceDescription;
68
69	if (!(advapi32 = GetModuleHandle("ADVAPI32.DLL")))
70	{
71	CloseServiceHandle(service);
72	CloseServiceHandle(serviceControlManager);
73	return;
74	}
75
76	;
77	if (!(ChangeServiceDescription = (CSD_T) GetProcAddress(advapi32, "ChangeServiceConfig2A")))
78	{
79	CloseServiceHandle(service);
80	CloseServiceHandle(serviceControlManager);
81	return;
82	}
83
84	ChangeServiceDescription(
85	service, // handle to service
86	SERVICE_CONFIG_DESCRIPTION, // change: description
87	&sdBuf);
88	CloseServiceHandle(service);
89	}
90	}
91	CloseServiceHandle(serviceControlManager);
92	}
93	}
94
95	void Win32_ServiceUninstall()
96	{
97	SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CONNECT);
98
99	if (serviceControlManager)
100	{
101	SC_HANDLE service = OpenService(serviceControlManager,
102	serviceName, SERVICE_QUERY_STATUS \| DELETE);
103	if (service)
104	{
105	SERVICE_STATUS serviceStatus;
106	if (QueryServiceStatus(service, &serviceStatus))
107	{
108	if (serviceStatus.dwCurrentState == SERVICE_STOPPED)
109	DeleteService(service);
110	}
111	//DeleteService(service);
112
113	CloseServiceHandle(service);
114	}
115
116	CloseServiceHandle(serviceControlManager);
117	}
118
119	}
120
121	void WINAPI ServiceControlHandler(DWORD controlCode)
122	{
123	switch (controlCode)
124	{
125	case SERVICE_CONTROL_INTERROGATE:
126	break;
127
128	case SERVICE_CONTROL_SHUTDOWN:
129	case SERVICE_CONTROL_STOP:
130	serviceStatus.dwCurrentState = SERVICE_STOP_PENDING;
131	SetServiceStatus(serviceStatusHandle, &serviceStatus);
132
133	g_ServiceStatus = 0;
134	return;
135
136	case SERVICE_CONTROL_PAUSE:
137	g_ServiceStatus = 2;
138	serviceStatus.dwCurrentState = SERVICE_PAUSED;
139	SetServiceStatus(serviceStatusHandle, &serviceStatus);
140	break;
141
142	case SERVICE_CONTROL_CONTINUE:
143	serviceStatus.dwCurrentState = SERVICE_RUNNING;
144	SetServiceStatus(serviceStatusHandle, &serviceStatus);
145	g_ServiceStatus = 1;
146	break;
147
148	default:
149	if ( controlCode >= 128 && controlCode <= 255 )
150	// user defined control code
151	break;
152	else
153	// unrecognized control code
154	break;
155	}
156
157	SetServiceStatus(serviceStatusHandle, &serviceStatus);
158	}
159
160	void WINAPI ServiceMain(DWORD argc, char *argv[])
161	{
162	// initialise service status
163	serviceStatus.dwServiceType = SERVICE_WIN32;
164	serviceStatus.dwCurrentState = SERVICE_START_PENDING;
165	serviceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP \|
166	SERVICE_ACCEPT_PAUSE_CONTINUE;
167	serviceStatus.dwWin32ExitCode = NO_ERROR;
168	serviceStatus.dwServiceSpecificExitCode = NO_ERROR;
169	serviceStatus.dwCheckPoint = 0;
170	serviceStatus.dwWaitHint = 0;
171
172	serviceStatusHandle = RegisterServiceCtrlHandler(serviceName, ServiceControlHandler);
173
174	if ( serviceStatusHandle )
175	{
176	char path[_MAX_PATH + 1];
177	int i, last_slash = 0;
178
179	GetModuleFileName(0, path, sizeof(path)/sizeof(path[0]));
180
181	for (i = 0; i < strlen(path); i++) {
182	if (path[i] == '\\') last_slash = i;
183	}
184
185	path[last_slash] = 0;
186
187	// service is starting
188	serviceStatus.dwCurrentState = SERVICE_START_PENDING;
189	SetServiceStatus(serviceStatusHandle, &serviceStatus);
190
191	// do initialisation here
192	SetCurrentDirectory(path);
193
194	// running
195	serviceStatus.dwControlsAccepted \|= (SERVICE_ACCEPT_STOP \| SERVICE_ACCEPT_SHUTDOWN);
196	serviceStatus.dwCurrentState = SERVICE_RUNNING;
197	SetServiceStatus( serviceStatusHandle, &serviceStatus );
198
199	////////////////////////
200	// service main cycle //
201	////////////////////////
202
203	g_ServiceStatus = 1;
204	argc = 1;
205
206	#ifdef WIN32_GUI
207	server_main(argc, argv);
208	#else
209	main(argc, argv);
210	#endif
211
212	// service was stopped
213	serviceStatus.dwCurrentState = SERVICE_STOP_PENDING;
214	SetServiceStatus(serviceStatusHandle, &serviceStatus);
215
216	// do cleanup here
217
218	// service is now stopped
219	serviceStatus.dwControlsAccepted &= ~(SERVICE_ACCEPT_STOP \| SERVICE_ACCEPT_SHUTDOWN);
220	serviceStatus.dwCurrentState = SERVICE_STOPPED;
221	SetServiceStatus(serviceStatusHandle, &serviceStatus);
222	}
223	}
224
225	void Win32_ServiceRun()
226	{
227	SERVICE_TABLE_ENTRY serviceTable[] =
228	{
229	{ serviceName, ServiceMain },
230	{ 0, 0 }
231	};
232
233	if (!StartServiceCtrlDispatcher(serviceTable))
234	{
235	}
236	}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1