[thirdparty/dhcp.git] / omapip / isclib.c

/*
 * Copyright(c) 2009-2010,2013-2014 by Internet Systems Consortium, Inc.("ISC")
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 *   Internet Systems Consortium, Inc.
 *   950 Charter Street
 *   Redwood City, CA 94063
 *   <info@isc.org>
 *   http://www.isc.org/
 *
 */

/*Trying to figure out what we need to define to get things to work.
  It looks like we want/need the export library but need the fdwatchcommand
  which may be a problem */

#include "dhcpd.h"

#include <sys/time.h>
#include <signal.h>

dhcp_context_t dhcp_gbl_ctx;
int shutdown_signal = 0;

#if defined (NSUPDATE)

/* This routine will open up the /etc/resolv.conf file and
 * send any nameservers it finds to the DNS client code.
 * It may be moved to be part of the dns client code instead
 * of being in the DHCP code
 */
isc_result_t 
dhcp_dns_client_setservers(void)
{
	isc_result_t result;
	irs_resconf_t *resconf = NULL;
	isc_sockaddrlist_t *nameservers;
	isc_sockaddr_t *sa;

	result = irs_resconf_load(dhcp_gbl_ctx.mctx, _PATH_RESOLV_CONF,
				  &resconf);
	if (result != ISC_R_SUCCESS && result != ISC_R_FILENOTFOUND) {
		log_error("irs_resconf_load failed: %d.", result);
		return (result);
	}

	nameservers = irs_resconf_getnameservers(resconf);

	/* Initialize port numbers */
	for (sa = ISC_LIST_HEAD(*nameservers);
	     sa != NULL;
	     sa = ISC_LIST_NEXT(sa, link)) {
		switch (sa->type.sa.sa_family) {
		case AF_INET:
			sa->type.sin.sin_port = htons(NS_DEFAULTPORT);
			break;
		case AF_INET6:
			sa->type.sin6.sin6_port = htons(NS_DEFAULTPORT);
			break;
		default:
			break;
		}
	}

	result = dns_client_setservers(dhcp_gbl_ctx.dnsclient,
				       dns_rdataclass_in,
				       NULL, nameservers);
	if (result != ISC_R_SUCCESS) {
		log_error("dns_client_setservers failed: %d.",
			  result);
	}
	return (result);
}
#endif

void
isclib_cleanup(void)
{
#if defined (NSUPDATE)
	if (dhcp_gbl_ctx.dnsclient != NULL)
		dns_client_destroy((dns_client_t **)&dhcp_gbl_ctx.dnsclient);
#endif

	if (dhcp_gbl_ctx.task != NULL) {
		isc_task_shutdown(dhcp_gbl_ctx.task);
		isc_task_detach(&dhcp_gbl_ctx.task);
	}

	if (dhcp_gbl_ctx.timermgr != NULL)
		isc_timermgr_destroy(&dhcp_gbl_ctx.timermgr);

	if (dhcp_gbl_ctx.socketmgr != NULL)
		isc_socketmgr_destroy(&dhcp_gbl_ctx.socketmgr);

	if (dhcp_gbl_ctx.taskmgr != NULL)
		isc_taskmgr_destroy(&dhcp_gbl_ctx.taskmgr);

	if (dhcp_gbl_ctx.actx_started != ISC_FALSE) {
		isc_app_ctxfinish(dhcp_gbl_ctx.actx);
		dhcp_gbl_ctx.actx_started = ISC_FALSE;
	}

	if (dhcp_gbl_ctx.actx != NULL)
		isc_appctx_destroy(&dhcp_gbl_ctx.actx);

	if (dhcp_gbl_ctx.mctx != NULL)
		isc_mem_detach(&dhcp_gbl_ctx.mctx);

	return;
}

isc_result_t
dhcp_context_create(int flags,
		    struct in_addr  *local4,
		    struct in6_addr *local6) {
	isc_result_t result;

	if ((flags & DHCP_CONTEXT_PRE_DB) != 0) {
		/*
		 * Set up the error messages, this isn't the right place
		 * for this call but it is convienent for now.
		 */
		result = dhcp_result_register();
		if (result != ISC_R_SUCCESS) {
			log_fatal("register_table() %s: %u", "failed", result);
		}

		memset(&dhcp_gbl_ctx, 0, sizeof (dhcp_gbl_ctx));
	
		isc_lib_register();

		/* get the current time for use as the random seed */
		gettimeofday(&cur_tv, (struct timezone *)0);
		isc_random_seed(cur_tv.tv_sec);

		/* we need to create the memory context before
		 * the lib inits in case we aren't doing NSUPDATE
		 * in which case dst needs a memory context
		 */
		result = isc_mem_create(0, 0, &dhcp_gbl_ctx.mctx);
		if (result != ISC_R_SUCCESS)
			goto cleanup;


#if defined (NSUPDATE)
		result = dns_lib_init();
		if (result != ISC_R_SUCCESS)
			goto cleanup;
#else
		/* The dst library is inited as part of dns_lib_init, we don't
		 * need it if NSUPDATE is enabled */
		result = dst_lib_init(dhcp_gbl_ctx.mctx, NULL, 0);
		if (result != ISC_R_SUCCESS)
			goto cleanup;

#endif

		result = isc_appctx_create(dhcp_gbl_ctx.mctx,
					   &dhcp_gbl_ctx.actx);
		if (result != ISC_R_SUCCESS)
			goto cleanup;

		result = isc_app_ctxstart(dhcp_gbl_ctx.actx);
		if (result != ISC_R_SUCCESS)
			return (result);
		dhcp_gbl_ctx.actx_started = ISC_TRUE;

		result = isc_taskmgr_createinctx(dhcp_gbl_ctx.mctx,
						 dhcp_gbl_ctx.actx,
						 1, 0,
						 &dhcp_gbl_ctx.taskmgr);
		if (result != ISC_R_SUCCESS)
			goto cleanup;

		result = isc_socketmgr_createinctx(dhcp_gbl_ctx.mctx,
						   dhcp_gbl_ctx.actx,
						   &dhcp_gbl_ctx.socketmgr);
		if (result != ISC_R_SUCCESS)
			goto cleanup;

		result = isc_timermgr_createinctx(dhcp_gbl_ctx.mctx,
						  dhcp_gbl_ctx.actx,
						  &dhcp_gbl_ctx.timermgr);
		if (result != ISC_R_SUCCESS)
			goto cleanup;

		result = isc_task_create(dhcp_gbl_ctx.taskmgr, 0, &dhcp_gbl_ctx.task);
		if (result != ISC_R_SUCCESS)
			goto cleanup;
	}

#if defined (NSUPDATE)
	if ((flags & DHCP_CONTEXT_POST_DB) != 0) {
		isc_sockaddr_t localaddr4, *localaddr4_ptr = NULL;
		isc_sockaddr_t localaddr6, *localaddr6_ptr = NULL;
		if (local4 != NULL) {
			isc_sockaddr_fromin(&localaddr4, local4, 0);
			localaddr4_ptr = &localaddr4;
		}
		if (local6 != NULL) {
			isc_sockaddr_fromin6(&localaddr6, local6, 0);
			localaddr6_ptr = &localaddr6;
		}

		result = dns_client_createx2(dhcp_gbl_ctx.mctx,
					     dhcp_gbl_ctx.actx,
					     dhcp_gbl_ctx.taskmgr,
					     dhcp_gbl_ctx.socketmgr,
					     dhcp_gbl_ctx.timermgr,
					     0,
					     &dhcp_gbl_ctx.dnsclient,
					     localaddr4_ptr,
					     localaddr6_ptr);
		if (result != ISC_R_SUCCESS)
			goto cleanup;

		result = dhcp_dns_client_setservers();
		if (result != ISC_R_SUCCESS)
			goto cleanup;
	}
#endif

	return(ISC_R_SUCCESS);

 cleanup:
	/*
	 * Currently we don't try and cleanup, just return an error
	 * expecting that our caller will log the error and exit.
	 */

	return(result);
}

/*
 * Convert a string name into the proper structure for the isc routines
 *
 * Previously we allowed names without a trailing '.' however the current
 * dns and dst code requires the names to end in a period.  If the
 * name doesn't have a trailing period add one as part of creating
 * the dns name.
 */

isc_result_t
dhcp_isc_name(unsigned char   *namestr,
	      dns_fixedname_t *namefix,
	      dns_name_t     **name)
{
	size_t namelen;
	isc_buffer_t b;
	isc_result_t result;

	namelen = strlen((char *)namestr); 
	isc_buffer_init(&b, namestr, namelen);
	isc_buffer_add(&b, namelen);
	dns_fixedname_init(namefix);
	*name = dns_fixedname_name(namefix);
	result = dns_name_fromtext(*name, &b, dns_rootname, 0, NULL);
	isc_buffer_invalidate(&b);
	return(result);
}

isc_result_t
isclib_make_dst_key(char          *inname,
		    char          *algorithm,
		    unsigned char *secret,
		    int            length,
		    dst_key_t    **dstkey)
{
	isc_result_t result;
	dns_name_t *name;
	dns_fixedname_t name0;
	isc_buffer_t b;

	isc_buffer_init(&b, secret, length);
	isc_buffer_add(&b, length);

	/* We only support HMAC_MD5 currently */
	if (strcasecmp(algorithm, DHCP_HMAC_MD5_NAME) != 0) {
		return(DHCP_R_INVALIDARG);
	}

	result = dhcp_isc_name((unsigned char *)inname, &name0, &name);
	if (result != ISC_R_SUCCESS) {
		return(result);
	}

	return(dst_key_frombuffer(name, DST_ALG_HMACMD5, DNS_KEYOWNER_ENTITY,
				  DNS_KEYPROTO_DNSSEC, dns_rdataclass_in,
				  &b, dhcp_gbl_ctx.mctx, dstkey));
}

/**
 * signal handler that initiates server shutdown
 *
 * @param signal signal code that we received
 */
void dhcp_signal_handler(int signal) {
	isc_appctx_t *ctx = dhcp_gbl_ctx.actx;
	int prev = shutdown_signal;

	if (prev != 0) {
		/* Already in shutdown. */
		return;
	}
	/* Possible race but does it matter? */
	shutdown_signal = signal;

	/* Use reload (aka suspend) for easier dispatch() reenter. */
	if (ctx && ctx->methods && ctx->methods->ctxsuspend) {
		(void) isc_app_ctxsuspend(ctx);
	}
}
Commit	Line	Data
98bf1607	1	/*
7dc4e69c	2	* Copyright(c) 2009-2010,2013-2014 by Internet Systems Consortium, Inc.("ISC")
98bf1607 SR	3	*
	4	* Permission to use, copy, modify, and distribute this software for any
	5	* purpose with or without fee is hereby granted, provided that the above
	6	* copyright notice and this permission notice appear in all copies.
	7	*
	8	* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
	9	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	10	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
	11	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	12	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	13	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
	14	* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	15	*
	16	* Internet Systems Consortium, Inc.
	17	* 950 Charter Street
	18	* Redwood City, CA 94063
	19	* <info@isc.org>
	20	* http://www.isc.org/
	21	*
	22	*/
	23
	24	/*Trying to figure out what we need to define to get things to work.
	25	It looks like we want/need the export library but need the fdwatchcommand
	26	which may be a problem */
	27
	28	#include "dhcpd.h"
	29
3ac2a573	30	#include <sys/time.h>
47e8308d	31	#include <signal.h>
3ac2a573	32
98bf1607	33	dhcp_context_t dhcp_gbl_ctx;
0895c955	34	int shutdown_signal = 0;
98bf1607	35
e54ff84f SR	36	#if defined (NSUPDATE)
	37
	38	/* This routine will open up the /etc/resolv.conf file and
	39	* send any nameservers it finds to the DNS client code.
	40	* It may be moved to be part of the dns client code instead
	41	* of being in the DHCP code
	42	*/
	43	isc_result_t
	44	dhcp_dns_client_setservers(void)
	45	{
	46	isc_result_t result;
	47	irs_resconf_t *resconf = NULL;
	48	isc_sockaddrlist_t *nameservers;
	49	isc_sockaddr_t *sa;
	50
	51	result = irs_resconf_load(dhcp_gbl_ctx.mctx, _PATH_RESOLV_CONF,
	52	&resconf);
22ceb8bb	53	if (result != ISC_R_SUCCESS && result != ISC_R_FILENOTFOUND) {
e54ff84f SR	54	log_error("irs_resconf_load failed: %d.", result);
	55	return (result);
	56	}
	57
	58	nameservers = irs_resconf_getnameservers(resconf);
	59
	60	/* Initialize port numbers */
	61	for (sa = ISC_LIST_HEAD(*nameservers);
	62	sa != NULL;
	63	sa = ISC_LIST_NEXT(sa, link)) {
	64	switch (sa->type.sa.sa_family) {
	65	case AF_INET:
	66	sa->type.sin.sin_port = htons(NS_DEFAULTPORT);
	67	break;
	68	case AF_INET6:
	69	sa->type.sin6.sin6_port = htons(NS_DEFAULTPORT);
	70	break;
	71	default:
	72	break;
	73	}
	74	}
	75
	76	result = dns_client_setservers(dhcp_gbl_ctx.dnsclient,
	77	dns_rdataclass_in,
	78	NULL, nameservers);
	79	if (result != ISC_R_SUCCESS) {
	80	log_error("dns_client_setservers failed: %d.",
	81	result);
	82	}
	83	return (result);
	84	}
	85	#endif
	86
98bf1607 SR	87	void
	88	isclib_cleanup(void)
	89	{
	90	#if defined (NSUPDATE)
	91	if (dhcp_gbl_ctx.dnsclient != NULL)
	92	dns_client_destroy((dns_client_t **)&dhcp_gbl_ctx.dnsclient);
	93	#endif
	94
	95	if (dhcp_gbl_ctx.task != NULL) {
98bf1607 SR	96	isc_task_shutdown(dhcp_gbl_ctx.task);
	97	isc_task_detach(&dhcp_gbl_ctx.task);
	98	}
	99
	100	if (dhcp_gbl_ctx.timermgr != NULL)
	101	isc_timermgr_destroy(&dhcp_gbl_ctx.timermgr);
	102
	103	if (dhcp_gbl_ctx.socketmgr != NULL)
	104	isc_socketmgr_destroy(&dhcp_gbl_ctx.socketmgr);
	105
	106	if (dhcp_gbl_ctx.taskmgr != NULL)
	107	isc_taskmgr_destroy(&dhcp_gbl_ctx.taskmgr);
	108
	109	if (dhcp_gbl_ctx.actx_started != ISC_FALSE) {
	110	isc_app_ctxfinish(dhcp_gbl_ctx.actx);
	111	dhcp_gbl_ctx.actx_started = ISC_FALSE;
	112	}
	113
	114	if (dhcp_gbl_ctx.actx != NULL)
	115	isc_appctx_destroy(&dhcp_gbl_ctx.actx);
	116
	117	if (dhcp_gbl_ctx.mctx != NULL)
	118	isc_mem_detach(&dhcp_gbl_ctx.mctx);
	119
	120	return;
	121	}
	122
	123	isc_result_t
61ef216b SR	124	dhcp_context_create(int flags,
	125	struct in_addr *local4,
	126	struct in6_addr *local6) {
98bf1607 SR	127	isc_result_t result;
98bf1607 SR	128
61ef216b SR	129	if ((flags & DHCP_CONTEXT_PRE_DB) != 0) {
	130	/*
	131	* Set up the error messages, this isn't the right place
	132	* for this call but it is convienent for now.
	133	*/
	134	result = dhcp_result_register();
	135	if (result != ISC_R_SUCCESS) {
	136	log_fatal("register_table() %s: %u", "failed", result);
	137	}
98bf1607	138
61ef216b	139	memset(&dhcp_gbl_ctx, 0, sizeof (dhcp_gbl_ctx));
98bf1607	140
61ef216b	141	isc_lib_register();
98bf1607	142
61ef216b SR	143	/* get the current time for use as the random seed */
	144	gettimeofday(&cur_tv, (struct timezone *)0);
	145	isc_random_seed(cur_tv.tv_sec);
98bf1607	146
158a34fb SR	147	/* we need to create the memory context before
	148	* the lib inits in case we aren't doing NSUPDATE
	149	* in which case dst needs a memory context
	150	*/
	151	result = isc_mem_create(0, 0, &dhcp_gbl_ctx.mctx);
	152	if (result != ISC_R_SUCCESS)
	153	goto cleanup;
	154
	155
98bf1607	156	#if defined (NSUPDATE)
61ef216b SR	157	result = dns_lib_init();
	158	if (result != ISC_R_SUCCESS)
	159	goto cleanup;
	160	#else
	161	/* The dst library is inited as part of dns_lib_init, we don't
	162	* need it if NSUPDATE is enabled */
	163	result = dst_lib_init(dhcp_gbl_ctx.mctx, NULL, 0);
	164	if (result != ISC_R_SUCCESS)
	165	goto cleanup;
98bf1607	166
61ef216b	167	#endif
61ef216b SR	168
	169	result = isc_appctx_create(dhcp_gbl_ctx.mctx,
	170	&dhcp_gbl_ctx.actx);
	171	if (result != ISC_R_SUCCESS)
	172	goto cleanup;
	173
	174	result = isc_app_ctxstart(dhcp_gbl_ctx.actx);
	175	if (result != ISC_R_SUCCESS)
	176	return (result);
	177	dhcp_gbl_ctx.actx_started = ISC_TRUE;
	178
	179	result = isc_taskmgr_createinctx(dhcp_gbl_ctx.mctx,
	180	dhcp_gbl_ctx.actx,
	181	1, 0,
	182	&dhcp_gbl_ctx.taskmgr);
	183	if (result != ISC_R_SUCCESS)
	184	goto cleanup;
	185
	186	result = isc_socketmgr_createinctx(dhcp_gbl_ctx.mctx,
	187	dhcp_gbl_ctx.actx,
	188	&dhcp_gbl_ctx.socketmgr);
	189	if (result != ISC_R_SUCCESS)
	190	goto cleanup;
	191
	192	result = isc_timermgr_createinctx(dhcp_gbl_ctx.mctx,
	193	dhcp_gbl_ctx.actx,
	194	&dhcp_gbl_ctx.timermgr);
	195	if (result != ISC_R_SUCCESS)
	196	goto cleanup;
	197
	198	result = isc_task_create(dhcp_gbl_ctx.taskmgr, 0, &dhcp_gbl_ctx.task);
	199	if (result != ISC_R_SUCCESS)
	200	goto cleanup;
	201	}
98bf1607 SR	202
98bf1607 SR	203	#if defined (NSUPDATE)
61ef216b SR	204	if ((flags & DHCP_CONTEXT_POST_DB) != 0) {
	205	isc_sockaddr_t localaddr4, *localaddr4_ptr = NULL;
	206	isc_sockaddr_t localaddr6, *localaddr6_ptr = NULL;
	207	if (local4 != NULL) {
	208	isc_sockaddr_fromin(&localaddr4, local4, 0);
	209	localaddr4_ptr = &localaddr4;
	210	}
	211	if (local6 != NULL) {
	212	isc_sockaddr_fromin6(&localaddr6, local6, 0);
	213	localaddr6_ptr = &localaddr6;
	214	}
98bf1607	215
61ef216b SR	216	result = dns_client_createx2(dhcp_gbl_ctx.mctx,
	217	dhcp_gbl_ctx.actx,
	218	dhcp_gbl_ctx.taskmgr,
	219	dhcp_gbl_ctx.socketmgr,
	220	dhcp_gbl_ctx.timermgr,
	221	0,
	222	&dhcp_gbl_ctx.dnsclient,
	223	localaddr4_ptr,
	224	localaddr6_ptr);
	225	if (result != ISC_R_SUCCESS)
	226	goto cleanup;
	227
	228	result = dhcp_dns_client_setservers();
	229	if (result != ISC_R_SUCCESS)
	230	goto cleanup;
	231	}
98bf1607	232	#endif
61ef216b	233
98bf1607 SR	234	return(ISC_R_SUCCESS);
	235
	236	cleanup:
d122accf SR	237	/*
	238	* Currently we don't try and cleanup, just return an error
	239	* expecting that our caller will log the error and exit.
	240	*/
98bf1607 SR	241
	242	return(result);
	243	}
	244
f4bc8261 SR	245	/*
	246	* Convert a string name into the proper structure for the isc routines
	247	*
	248	* Previously we allowed names without a trailing '.' however the current
	249	* dns and dst code requires the names to end in a period. If the
	250	* name doesn't have a trailing period add one as part of creating
	251	* the dns name.
	252	*/
	253
98bf1607 SR	254	isc_result_t
	255	dhcp_isc_name(unsigned char *namestr,
	256	dns_fixedname_t *namefix,
	257	dns_name_t **name)
	258	{
	259	size_t namelen;
	260	isc_buffer_t b;
	261	isc_result_t result;
f4bc8261	262
98bf1607 SR	263	namelen = strlen((char *)namestr);
	264	isc_buffer_init(&b, namestr, namelen);
	265	isc_buffer_add(&b, namelen);
	266	dns_fixedname_init(namefix);
	267	*name = dns_fixedname_name(namefix);
f4bc8261	268	result = dns_name_fromtext(*name, &b, dns_rootname, 0, NULL);
98bf1607 SR	269	isc_buffer_invalidate(&b);
	270	return(result);
	271	}
	272
	273	isc_result_t
	274	isclib_make_dst_key(char *inname,
	275	char *algorithm,
	276	unsigned char *secret,
	277	int length,
	278	dst_key_t **dstkey)
	279	{
	280	isc_result_t result;
	281	dns_name_t *name;
	282	dns_fixedname_t name0;
	283	isc_buffer_t b;
98bf1607 SR	284
	285	isc_buffer_init(&b, secret, length);
	286	isc_buffer_add(&b, length);
	287
	288	/* We only support HMAC_MD5 currently */
	289	if (strcasecmp(algorithm, DHCP_HMAC_MD5_NAME) != 0) {
	290	return(DHCP_R_INVALIDARG);
	291	}
	292
f4bc8261	293	result = dhcp_isc_name((unsigned char *)inname, &name0, &name);
98bf1607 SR	294	if (result != ISC_R_SUCCESS) {
	295	return(result);
	296	}
	297
	298	return(dst_key_frombuffer(name, DST_ALG_HMACMD5, DNS_KEYOWNER_ENTITY,
	299	DNS_KEYPROTO_DNSSEC, dns_rdataclass_in,
	300	&b, dhcp_gbl_ctx.mctx, dstkey));
	301	}
	302
47e8308d SR	303	/**
	304	* signal handler that initiates server shutdown
	305	*
	306	* @param signal signal code that we received
	307	*/
	308	void dhcp_signal_handler(int signal) {
	309	isc_appctx_t *ctx = dhcp_gbl_ctx.actx;
0895c955 SR	310	int prev = shutdown_signal;
	311
	312	if (prev != 0) {
	313	/* Already in shutdown. */
	314	return;
	315	}
	316	/* Possible race but does it matter? */
	317	shutdown_signal = signal;
	318
	319	/* Use reload (aka suspend) for easier dispatch() reenter. */
	320	if (ctx && ctx->methods && ctx->methods->ctxsuspend) {
	321	(void) isc_app_ctxsuspend(ctx);
47e8308d SR	322	}
47e8308d SR	323	}