[apple/network_cmds.git] / unbound / winrc / w_inst.c

/*
 * winrc/w_inst.h - install and remove functions
 *
 * Copyright (c) 2009, NLnet Labs. All rights reserved.
 *
 * This software is open source.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * 
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * 
 * Neither the name of the NLNET LABS nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * \file
 *
 * Contains install and remove functions that manipulate the
 * windows services API and windows registry.
 */
#include "config.h"
#include "winrc/w_inst.h"
#include "winrc/win_svc.h"

void wsvc_err2str(char* str, size_t len, const char* fixed, DWORD err)
{
	LPTSTR buf;
	if(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | 
		FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_ALLOCATE_BUFFER, 
		NULL, err, 0, (LPTSTR)&buf, 0, NULL) == 0) {
		/* could not format error message */
		snprintf(str, len, "%s GetLastError=%d", fixed, (int)err);
		return;
	}
	snprintf(str, len, "%s (err=%d): %s", fixed, (int)err, buf);
	LocalFree(buf);
}

/** exit with windows error */
static void
fatal_win(FILE* out, const char* str)
{
	char e[256];
	wsvc_err2str(e, sizeof(e), str, (int)GetLastError());
        if(out) fprintf(out, "%s\n", e);
        else fprintf(stderr, "%s\n", e);
        exit(1);
}

/** install registry entries for eventlog */
static void
event_reg_install(FILE* out, const char* pathname)
{
	char buf[1024];
	HKEY hk;
	DWORD t;
	if(out) fprintf(out, "install reg entries for %s\n", pathname);
	snprintf(buf, sizeof(buf), "SYSTEM\\CurrentControlSet\\Services"
		"\\EventLog\\Application\\%s", SERVICE_NAME);
	if(RegCreateKeyEx(HKEY_LOCAL_MACHINE, (LPCTSTR)buf,
		0, /* reserved, mustbezero */
		NULL, /* class of key, ignored */
		REG_OPTION_NON_VOLATILE, /* values saved on disk */
		KEY_WRITE, /* we want write permission */
		NULL, /* use default security descriptor */
		&hk, /* result */
		NULL)) /* not interested if key new or existing */
		fatal_win(out, "could not create registry key");
	
	/* message file */
	if(RegSetValueEx(hk, (LPCTSTR)"EventMessageFile", 
		0, /* reserved, mustbezero */
		REG_EXPAND_SZ, /* value type (string w env subst) */
		(BYTE*)pathname, /* data */
		(DWORD)strlen(pathname)+1)) /* length of data */
	{
		RegCloseKey(hk);
		fatal_win(out, "could not registry set EventMessageFile");
	}

	/* event types */
	t = EVENTLOG_SUCCESS | EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE
		| EVENTLOG_INFORMATION_TYPE;
	if(RegSetValueEx(hk, (LPCTSTR)"TypesSupported", 0, REG_DWORD, 
		(LPBYTE)&t, sizeof(t))) {
		RegCloseKey(hk);
		fatal_win(out, "could not registry set TypesSupported");
	}

	/* category message file */
	if(RegSetValueEx(hk, (LPCTSTR)"CategoryMessageFile", 0, REG_EXPAND_SZ, 
		(BYTE*)pathname, (DWORD)strlen(pathname)+1)) {
		RegCloseKey(hk);
		fatal_win(out, "could not registry set CategoryMessageFile");
	}
	t = 1;
	if(RegSetValueEx(hk, (LPCTSTR)"CategoryCount", 0, REG_DWORD, 
		(LPBYTE)&t, sizeof(t))) {
		RegCloseKey(hk);
		fatal_win(out, "could not registry set CategoryCount");
	}


	RegCloseKey(hk);
	if(out) fprintf(out, "installed reg entries\n");
}

/** remove registry entries for eventlog */
static void
event_reg_remove(FILE* out)
{
	char buf[1024];
	HKEY hk;
	if(out) fprintf(out, "remove reg entries\n");
	snprintf(buf, sizeof(buf), "SYSTEM\\CurrentControlSet\\Services"
		"\\EventLog\\Application");
	if(RegCreateKeyEx(HKEY_LOCAL_MACHINE, (LPCTSTR)buf,
		0, /* reserved, mustbezero */
		NULL, /* class of key, ignored */
		REG_OPTION_NON_VOLATILE, /* values saved on disk */
		DELETE, /* we want key delete permission */
		NULL, /* use default security descriptor */
		&hk, /* result */
		NULL)) /* not interested if key new or existing */
		fatal_win(out, "could not open registry key");
	if(RegDeleteKey(hk, (LPCTSTR)SERVICE_NAME)) {
		RegCloseKey(hk);
		fatal_win(out, "could not delete registry key");
	}
	RegCloseKey(hk);
	if(out) fprintf(out, "removed reg entries\n");
}

/** 
 * put quotes around string. Needs one space in front 
 * @param out: debugfile
 * @param str: to be quoted.
 * @param maxlen: max length of the string buffer.
 */
static void
quote_it(FILE* out, char* str, size_t maxlen)
{
        if(strlen(str) == maxlen) {
                if(out) fprintf(out, "string too long %s", str);
                exit(1);
        }
        str[0]='"';
        str[strlen(str)+1]=0;
        str[strlen(str)]='"';
}

/** change suffix */
static void
change(FILE* out, char* path, size_t max, const char* from, const char* to)
{
        size_t fromlen = strlen(from);
        size_t tolen = strlen(to);
        size_t pathlen = strlen(path);
        if(pathlen - fromlen + tolen >= max) {
                if(out) fprintf(out, "string too long %s", path);
                exit(1);
        }
        snprintf(path+pathlen-fromlen, max-(pathlen-fromlen), "%s", to);
}

/* Install service in servicecontrolmanager */
void
wsvc_install(FILE* out, const char* rename)
{
        SC_HANDLE scm;
        SC_HANDLE sv;
        TCHAR path[2*MAX_PATH+4+256];
        TCHAR path_config[2*MAX_PATH+4+256];
        if(out) fprintf(out, "installing unbound service\n");
        if(!GetModuleFileName(NULL, path+1, MAX_PATH))
                fatal_win(out, "could not GetModuleFileName");
        /* change 'unbound-service-install' to 'unbound' */
	if(rename) {
        	change(out, path+1, sizeof(path)-1, rename, "unbound.exe");
		memmove(path_config+1, path+1, sizeof(path)-1);
        	change(out, path_config+1, sizeof(path_config)-1,
			"unbound.exe", "service.conf");
	}

	event_reg_install(out, path+1);

        /* have to quote it because of spaces in directory names */
        /* could append arguments to be sent to ServiceMain */
        quote_it(out, path, sizeof(path));

	/* if we started in a different directory, also read config from it. */
	if(rename) {
        	quote_it(out, path_config, sizeof(path_config));
		strcat(path, " -c ");
		strcat(path, path_config);
	}

        strcat(path, " -w service");
        scm = OpenSCManager(NULL, NULL, (int)SC_MANAGER_CREATE_SERVICE);
        if(!scm) fatal_win(out, "could not OpenSCManager");
        sv = CreateService(
                scm,
                SERVICE_NAME, /* name of service */
                "Unbound DNS validator", /* display name */
                SERVICE_ALL_ACCESS, /* desired access */
                SERVICE_WIN32_OWN_PROCESS, /* service type */
                SERVICE_AUTO_START, /* start type */
                SERVICE_ERROR_NORMAL, /* error control type */
                path, /* path to service's binary */
                NULL, /* no load ordering group */
                NULL, /* no tag identifier */
                NULL, /* no deps */
                NULL, /* on LocalSystem */
                NULL /* no password */
                );
        if(!sv) {
                CloseServiceHandle(scm);
                fatal_win(out, "could not CreateService");
        }
        CloseServiceHandle(sv);
        CloseServiceHandle(scm);
        if(out) fprintf(out, "unbound service installed\n");
}


/* Remove installed service from servicecontrolmanager */
void
wsvc_remove(FILE* out)
{
        SC_HANDLE scm;
        SC_HANDLE sv;
        if(out) fprintf(out, "removing unbound service\n");
        scm = OpenSCManager(NULL, NULL, (int)SC_MANAGER_ALL_ACCESS);
        if(!scm) fatal_win(out, "could not OpenSCManager");
        sv = OpenService(scm, SERVICE_NAME, DELETE);
        if(!sv) {
                CloseServiceHandle(scm);
                fatal_win(out, "could not OpenService");
        }
        if(!DeleteService(sv)) {
		CloseServiceHandle(sv);
		CloseServiceHandle(scm);
                fatal_win(out, "could not DeleteService");
        }
        CloseServiceHandle(sv);
        CloseServiceHandle(scm);
	event_reg_remove(out);
        if(out) fprintf(out, "unbound service removed\n");
}


/* Start daemon */
void
wsvc_rc_start(FILE* out)
{
	SC_HANDLE scm;
	SC_HANDLE sv;
        if(out) fprintf(out, "start unbound service\n");
	scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
	if(!scm) fatal_win(out, "could not OpenSCManager");
	sv = OpenService(scm, SERVICE_NAME, SERVICE_START);
	if(!sv) {
		CloseServiceHandle(scm);
		fatal_win(out, "could not OpenService");
	}
	if(!StartService(sv, 0, NULL)) {
		CloseServiceHandle(sv);
		CloseServiceHandle(scm);
		fatal_win(out, "could not StartService");
	}
	CloseServiceHandle(sv);
	CloseServiceHandle(scm);
        if(out) fprintf(out, "unbound service started\n");
}


/* Stop daemon */
void
wsvc_rc_stop(FILE* out)
{
	SC_HANDLE scm;
	SC_HANDLE sv;
	SERVICE_STATUS st;
        if(out) fprintf(out, "stop unbound service\n");
	scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
	if(!scm) fatal_win(out, "could not OpenSCManager");
	sv = OpenService(scm, SERVICE_NAME, SERVICE_STOP);
	if(!sv) {
		CloseServiceHandle(scm);
		fatal_win(out, "could not OpenService");
	}
	if(!ControlService(sv, SERVICE_CONTROL_STOP, &st)) {
		CloseServiceHandle(sv);
		CloseServiceHandle(scm);
		fatal_win(out, "could not ControlService");
	}
	CloseServiceHandle(sv);
	CloseServiceHandle(scm);
        if(out) fprintf(out, "unbound service stopped\n");
}
Commit	Line	Data
89c4ed63 A	1	/*
	2	* winrc/w_inst.h - install and remove functions
	3	*
	4	* Copyright (c) 2009, NLnet Labs. All rights reserved.
	5	*
	6	* This software is open source.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions
	10	* are met:
	11	*
	12	* Redistributions of source code must retain the above copyright notice,
	13	* this list of conditions and the following disclaimer.
	14	*
	15	* Redistributions in binary form must reproduce the above copyright notice,
	16	* this list of conditions and the following disclaimer in the documentation
	17	* and/or other materials provided with the distribution.
	18	*
	19	* Neither the name of the NLNET LABS nor the names of its contributors may
	20	* be used to endorse or promote products derived from this software without
	21	* specific prior written permission.
	22	*
	23	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	24	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	25	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	26	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	27	* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	28	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
	29	* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	30	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
	31	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
	32	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	33	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	34	*/
	35
	36	/**
	37	* \file
	38	*
	39	* Contains install and remove functions that manipulate the
	40	* windows services API and windows registry.
	41	*/
	42	#include "config.h"
	43	#include "winrc/w_inst.h"
	44	#include "winrc/win_svc.h"
	45
	46	void wsvc_err2str(char* str, size_t len, const char* fixed, DWORD err)
	47	{
	48	LPTSTR buf;
	49	if(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM \|
	50	FORMAT_MESSAGE_IGNORE_INSERTS \| FORMAT_MESSAGE_ALLOCATE_BUFFER,
	51	NULL, err, 0, (LPTSTR)&buf, 0, NULL) == 0) {
	52	/* could not format error message */
	53	snprintf(str, len, "%s GetLastError=%d", fixed, (int)err);
	54	return;
	55	}
	56	snprintf(str, len, "%s (err=%d): %s", fixed, (int)err, buf);
	57	LocalFree(buf);
	58	}
	59
	60	/** exit with windows error */
	61	static void
	62	fatal_win(FILE* out, const char* str)
	63	{
	64	char e[256];
65	wsvc_err2str(e, sizeof(e), str, (int)GetLastError());
66	if(out) fprintf(out, "%s\n", e);
67	else fprintf(stderr, "%s\n", e);
68	exit(1);
69	}
70
71	/** install registry entries for eventlog */
72	static void
73	event_reg_install(FILE* out, const char* pathname)
74	{
75	char buf[1024];
76	HKEY hk;
77	DWORD t;
78	if(out) fprintf(out, "install reg entries for %s\n", pathname);
79	snprintf(buf, sizeof(buf), "SYSTEM\\CurrentControlSet\\Services"
80	"\\EventLog\\Application\\%s", SERVICE_NAME);
81	if(RegCreateKeyEx(HKEY_LOCAL_MACHINE, (LPCTSTR)buf,
82	0, /* reserved, mustbezero */
83	NULL, /* class of key, ignored */
84	REG_OPTION_NON_VOLATILE, /* values saved on disk */
85	KEY_WRITE, /* we want write permission */
86	NULL, /* use default security descriptor */
87	&hk, /* result */
88	NULL)) /* not interested if key new or existing */
89	fatal_win(out, "could not create registry key");
90
91	/* message file */
92	if(RegSetValueEx(hk, (LPCTSTR)"EventMessageFile",
93	0, /* reserved, mustbezero */
94	REG_EXPAND_SZ, /* value type (string w env subst) */
95	(BYTE)pathname, / data */
96	(DWORD)strlen(pathname)+1)) /* length of data */
97	{
98	RegCloseKey(hk);
99	fatal_win(out, "could not registry set EventMessageFile");
100	}
101
102	/* event types */
103	t = EVENTLOG_SUCCESS \| EVENTLOG_ERROR_TYPE \| EVENTLOG_WARNING_TYPE
104	\| EVENTLOG_INFORMATION_TYPE;
105	if(RegSetValueEx(hk, (LPCTSTR)"TypesSupported", 0, REG_DWORD,
106	(LPBYTE)&t, sizeof(t))) {
107	RegCloseKey(hk);
108	fatal_win(out, "could not registry set TypesSupported");
109	}
110
111	/* category message file */
112	if(RegSetValueEx(hk, (LPCTSTR)"CategoryMessageFile", 0, REG_EXPAND_SZ,
113	(BYTE*)pathname, (DWORD)strlen(pathname)+1)) {
114	RegCloseKey(hk);
115	fatal_win(out, "could not registry set CategoryMessageFile");
116	}
117	t = 1;
118	if(RegSetValueEx(hk, (LPCTSTR)"CategoryCount", 0, REG_DWORD,
119	(LPBYTE)&t, sizeof(t))) {
120	RegCloseKey(hk);
121	fatal_win(out, "could not registry set CategoryCount");
122	}
123
124
125	RegCloseKey(hk);
126	if(out) fprintf(out, "installed reg entries\n");
127	}
128
129	/** remove registry entries for eventlog */
130	static void
131	event_reg_remove(FILE* out)
132	{
133	char buf[1024];
134	HKEY hk;
135	if(out) fprintf(out, "remove reg entries\n");
136	snprintf(buf, sizeof(buf), "SYSTEM\\CurrentControlSet\\Services"
137	"\\EventLog\\Application");
138	if(RegCreateKeyEx(HKEY_LOCAL_MACHINE, (LPCTSTR)buf,
139	0, /* reserved, mustbezero */
140	NULL, /* class of key, ignored */
141	REG_OPTION_NON_VOLATILE, /* values saved on disk */
142	DELETE, /* we want key delete permission */
143	NULL, /* use default security descriptor */
144	&hk, /* result */
145	NULL)) /* not interested if key new or existing */
146	fatal_win(out, "could not open registry key");
147	if(RegDeleteKey(hk, (LPCTSTR)SERVICE_NAME)) {
148	RegCloseKey(hk);
149	fatal_win(out, "could not delete registry key");
150	}
151	RegCloseKey(hk);
152	if(out) fprintf(out, "removed reg entries\n");
153	}
154
155	/**
156	* put quotes around string. Needs one space in front
157	* @param out: debugfile
158	* @param str: to be quoted.
159	* @param maxlen: max length of the string buffer.
160	*/
161	static void
162	quote_it(FILE* out, char* str, size_t maxlen)
163	{
164	if(strlen(str) == maxlen) {
165	if(out) fprintf(out, "string too long %s", str);
166	exit(1);
167	}
168	str[0]='"';
169	str[strlen(str)+1]=0;
170	str[strlen(str)]='"';
171	}
172
173	/** change suffix */
174	static void
175	change(FILE* out, char* path, size_t max, const char* from, const char* to)
176	{
177	size_t fromlen = strlen(from);
178	size_t tolen = strlen(to);
179	size_t pathlen = strlen(path);
180	if(pathlen - fromlen + tolen >= max) {
181	if(out) fprintf(out, "string too long %s", path);
182	exit(1);
183	}
184	snprintf(path+pathlen-fromlen, max-(pathlen-fromlen), "%s", to);
185	}
186
187	/* Install service in servicecontrolmanager */
188	void
189	wsvc_install(FILE* out, const char* rename)
190	{
191	SC_HANDLE scm;
192	SC_HANDLE sv;
193	TCHAR path[2*MAX_PATH+4+256];
194	TCHAR path_config[2*MAX_PATH+4+256];
195	if(out) fprintf(out, "installing unbound service\n");
196	if(!GetModuleFileName(NULL, path+1, MAX_PATH))
197	fatal_win(out, "could not GetModuleFileName");
198	/* change 'unbound-service-install' to 'unbound' */
199	if(rename) {
200	change(out, path+1, sizeof(path)-1, rename, "unbound.exe");
201	memmove(path_config+1, path+1, sizeof(path)-1);
202	change(out, path_config+1, sizeof(path_config)-1,
203	"unbound.exe", "service.conf");
204	}
205
206	event_reg_install(out, path+1);
207
208	/* have to quote it because of spaces in directory names */
209	/* could append arguments to be sent to ServiceMain */
210	quote_it(out, path, sizeof(path));
211
212	/* if we started in a different directory, also read config from it. */
213	if(rename) {
214	quote_it(out, path_config, sizeof(path_config));
215	strcat(path, " -c ");
216	strcat(path, path_config);
217	}
218
219	strcat(path, " -w service");
220	scm = OpenSCManager(NULL, NULL, (int)SC_MANAGER_CREATE_SERVICE);
221	if(!scm) fatal_win(out, "could not OpenSCManager");
222	sv = CreateService(
223	scm,
224	SERVICE_NAME, /* name of service */
225	"Unbound DNS validator", /* display name */
226	SERVICE_ALL_ACCESS, /* desired access */
227	SERVICE_WIN32_OWN_PROCESS, /* service type */
228	SERVICE_AUTO_START, /* start type */
229	SERVICE_ERROR_NORMAL, /* error control type */
230	path, /* path to service's binary */
231	NULL, /* no load ordering group */
232	NULL, /* no tag identifier */
233	NULL, /* no deps */
234	NULL, /* on LocalSystem */
235	NULL /* no password */
236	);
237	if(!sv) {
238	CloseServiceHandle(scm);
239	fatal_win(out, "could not CreateService");
240	}
241	CloseServiceHandle(sv);
242	CloseServiceHandle(scm);
243	if(out) fprintf(out, "unbound service installed\n");
244	}
245
246
247	/* Remove installed service from servicecontrolmanager */
248	void
249	wsvc_remove(FILE* out)
250	{
251	SC_HANDLE scm;
252	SC_HANDLE sv;
253	if(out) fprintf(out, "removing unbound service\n");
254	scm = OpenSCManager(NULL, NULL, (int)SC_MANAGER_ALL_ACCESS);
255	if(!scm) fatal_win(out, "could not OpenSCManager");
256	sv = OpenService(scm, SERVICE_NAME, DELETE);
257	if(!sv) {
258	CloseServiceHandle(scm);
259	fatal_win(out, "could not OpenService");
260	}
261	if(!DeleteService(sv)) {
262	CloseServiceHandle(sv);
263	CloseServiceHandle(scm);
264	fatal_win(out, "could not DeleteService");
265	}
266	CloseServiceHandle(sv);
267	CloseServiceHandle(scm);
268	event_reg_remove(out);
269	if(out) fprintf(out, "unbound service removed\n");
270	}
271
272
273	/* Start daemon */
274	void
275	wsvc_rc_start(FILE* out)
276	{
277	SC_HANDLE scm;
278	SC_HANDLE sv;
279	if(out) fprintf(out, "start unbound service\n");
280	scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
281	if(!scm) fatal_win(out, "could not OpenSCManager");
282	sv = OpenService(scm, SERVICE_NAME, SERVICE_START);
283	if(!sv) {
284	CloseServiceHandle(scm);
285	fatal_win(out, "could not OpenService");
286	}
287	if(!StartService(sv, 0, NULL)) {
288	CloseServiceHandle(sv);
289	CloseServiceHandle(scm);
290	fatal_win(out, "could not StartService");
291	}
292	CloseServiceHandle(sv);
293	CloseServiceHandle(scm);
294	if(out) fprintf(out, "unbound service started\n");
295	}
296
297
298	/* Stop daemon */
299	void
300	wsvc_rc_stop(FILE* out)
301	{
302	SC_HANDLE scm;
303	SC_HANDLE sv;
304	SERVICE_STATUS st;
305	if(out) fprintf(out, "stop unbound service\n");
306	scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
307	if(!scm) fatal_win(out, "could not OpenSCManager");
308	sv = OpenService(scm, SERVICE_NAME, SERVICE_STOP);
309	if(!sv) {
310	CloseServiceHandle(scm);
311	fatal_win(out, "could not OpenService");
312	}
313	if(!ControlService(sv, SERVICE_CONTROL_STOP, &st)) {
314	CloseServiceHandle(sv);
315	CloseServiceHandle(scm);
316	fatal_win(out, "could not ControlService");
317	}
318	CloseServiceHandle(sv);
319	CloseServiceHandle(scm);
320	if(out) fprintf(out, "unbound service stopped\n");
321	}