1/*
2 * Copyright (C) 2004-2006, 2008  Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1998-2003  Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
16 */
17
18#if !defined(lint) && !defined(SABER)
19static const char rcsid[] = "$Id: ctl_srvr.c,v 1.10 2008/11/14 02:36:51 marka Exp $";
20#endif /* not lint */
21
22/* Extern. */
23
24#include "port_before.h"
25
26#include <sys/param.h>
27#include <sys/file.h>
28#include <sys/socket.h>
29#include <sys/un.h>
30
31#include <netinet/in.h>
32#include <arpa/nameser.h>
33#include <arpa/inet.h>
34
35#include <ctype.h>
36#include <errno.h>
37#include <stdio.h>
38#include <stdlib.h>
39#include <string.h>
40#include <time.h>
41#include <unistd.h>
42#include <fcntl.h>
43#ifdef HAVE_MEMORY_H
44#include <memory.h>
45#endif
46
47#include <isc/assertions.h>
48#include <isc/ctl.h>
49#include <isc/eventlib.h>
50#include <isc/list.h>
51#include <isc/logging.h>
52#include <isc/memcluster.h>
53
54#include "ctl_p.h"
55
56#include "port_after.h"
57
58#ifdef SPRINTF_CHAR
59# define SPRINTF(x) strlen(sprintf/**/x)
60#else
61# define SPRINTF(x) ((size_t)sprintf x)
62#endif
63
64/* Macros. */
65
66#define	lastverb_p(verb)	(verb->name == NULL || verb->func == NULL)
67#define	address_expr		ctl_sa_ntop((struct sockaddr *)&sess->sa, \
68					    tmp, sizeof tmp, ctx->logger)
69
70/* Types. */
71
72enum state {
73	available = 0, initializing, writing, reading, reading_data,
74	processing, idling, quitting, closing
75};
76
77union sa_un {
78	struct sockaddr_in in;
79#ifndef NO_SOCKADDR_UN
80	struct sockaddr_un un;
81#endif
82};
83
84struct ctl_sess {
85	LINK(struct ctl_sess)	link;
86	struct ctl_sctx *	ctx;
87	enum state		state;
88	int			sock;
89	union sa_un		sa;
90	evFileID		rdID;
91	evStreamID		wrID;
92	evTimerID		rdtiID;
93	evTimerID		wrtiID;
94	struct ctl_buf		inbuf;
95	struct ctl_buf		outbuf;
96	const struct ctl_verb *	verb;
97	u_int			helpcode;
98	const void *		respctx;
99	u_int			respflags;
100	ctl_srvrdone		donefunc;
101	void *			uap;
102	void *			csctx;
103};
104
105struct ctl_sctx {
106	evContext		ev;
107	void *			uctx;
108	u_int			unkncode;
109	u_int			timeoutcode;
110	const struct ctl_verb *	verbs;
111	const struct ctl_verb *	connverb;
112	int			sock;
113	int			max_sess;
114	int			cur_sess;
115	struct timespec		timeout;
116	ctl_logfunc		logger;
117	evConnID		acID;
118	LIST(struct ctl_sess)	sess;
119};
120
121/* Forward. */
122
123static void			ctl_accept(evContext, void *, int,
124					   const void *, int,
125					   const void *, int);
126static void			ctl_close(struct ctl_sess *);
127static void			ctl_new_state(struct ctl_sess *,
128					      enum state,
129					      const char *);
130static void			ctl_start_read(struct ctl_sess *);
131static void			ctl_stop_read(struct ctl_sess *);
132static void			ctl_readable(evContext, void *, int, int);
133static void			ctl_rdtimeout(evContext, void *,
134					      struct timespec,
135					      struct timespec);
136static void			ctl_wrtimeout(evContext, void *,
137					      struct timespec,
138					      struct timespec);
139static void			ctl_docommand(struct ctl_sess *);
140static void			ctl_writedone(evContext, void *, int, int);
141static void			ctl_morehelp(struct ctl_sctx *,
142					     struct ctl_sess *,
143					     const struct ctl_verb *,
144					     const char *,
145					     u_int, const void *, void *);
146static void			ctl_signal_done(struct ctl_sctx *,
147						struct ctl_sess *);
148
149/* Private data. */
150
151static const char *		state_names[] = {
152	"available", "initializing", "writing", "reading",
153	"reading_data", "processing", "idling", "quitting", "closing"
154};
155
156static const char		space[] = " ";
157
158static const struct ctl_verb	fakehelpverb = {
159	"fakehelp", ctl_morehelp , NULL
160};
161
162/* Public. */
163
164/*%
165 * void
166 * ctl_server()
167 *	create, condition, and start a listener on the control port.
168 */
169struct ctl_sctx *
170ctl_server(evContext lev, const struct sockaddr *sap, size_t sap_len,
171	   const struct ctl_verb *verbs,
172	   u_int unkncode, u_int timeoutcode,
173	   u_int timeout, int backlog, int max_sess,
174	   ctl_logfunc logger, void *uctx)
175{
176	static const char me[] = "ctl_server";
177	static const int on = 1;
178	const struct ctl_verb *connverb;
179	struct ctl_sctx *ctx;
180	int save_errno;
181
182	if (logger == NULL)
183		logger = ctl_logger;
184	for (connverb = verbs;
185	     connverb->name != NULL && connverb->func != NULL;
186	     connverb++)
187		if (connverb->name[0] == '\0')
188			break;
189	if (connverb->func == NULL) {
190		(*logger)(ctl_error, "%s: no connection verb found", me);
191		return (NULL);
192	}
193	ctx = memget(sizeof *ctx);
194	if (ctx == NULL) {
195		(*logger)(ctl_error, "%s: getmem: %s", me, strerror(errno));
196		return (NULL);
197	}
198	ctx->ev = lev;
199	ctx->uctx = uctx;
200	ctx->unkncode = unkncode;
201	ctx->timeoutcode = timeoutcode;
202	ctx->verbs = verbs;
203	ctx->timeout = evConsTime(timeout, 0);
204	ctx->logger = logger;
205	ctx->connverb = connverb;
206	ctx->max_sess = max_sess;
207	ctx->cur_sess = 0;
208	INIT_LIST(ctx->sess);
209	ctx->sock = socket(sap->sa_family, SOCK_STREAM, PF_UNSPEC);
210	if (ctx->sock > evHighestFD(ctx->ev)) {
211		ctx->sock = -1;
212		errno = ENOTSOCK;
213	}
214	if (ctx->sock < 0) {
215		save_errno = errno;
216		(*ctx->logger)(ctl_error, "%s: socket: %s",
217			       me, strerror(errno));
218		memput(ctx, sizeof *ctx);
219		errno = save_errno;
220		return (NULL);
221	}
222	if (ctx->sock > evHighestFD(lev)) {
223		close(ctx->sock);
224		(*ctx->logger)(ctl_error, "%s: file descriptor > evHighestFD");
225		errno = ENFILE;
226		memput(ctx, sizeof *ctx);
227		return (NULL);
228	}
229#ifdef NO_UNIX_REUSEADDR
230	if (sap->sa_family != AF_UNIX)
231#endif
232		if (setsockopt(ctx->sock, SOL_SOCKET, SO_REUSEADDR,
233			       (const char *)&on, sizeof on) != 0) {
234			(*ctx->logger)(ctl_warning,
235				       "%s: setsockopt(REUSEADDR): %s",
236				       me, strerror(errno));
237		}
238	if (bind(ctx->sock, sap, sap_len) < 0) {
239		char tmp[MAX_NTOP];
240		save_errno = errno;
241		(*ctx->logger)(ctl_error, "%s: bind: %s: %s",
242			       me, ctl_sa_ntop((const struct sockaddr *)sap,
243			       tmp, sizeof tmp, ctx->logger),
244			       strerror(save_errno));
245		close(ctx->sock);
246		memput(ctx, sizeof *ctx);
247		errno = save_errno;
248		return (NULL);
249	}
250	if (fcntl(ctx->sock, F_SETFD, 1) < 0) {
251		(*ctx->logger)(ctl_warning, "%s: fcntl: %s", me,
252			       strerror(errno));
253	}
254	if (evListen(lev, ctx->sock, backlog, ctl_accept, ctx,
255		     &ctx->acID) < 0) {
256		save_errno = errno;
257		(*ctx->logger)(ctl_error, "%s: evListen(fd %d): %s",
258			       me, ctx->sock, strerror(errno));
259		close(ctx->sock);
260		memput(ctx, sizeof *ctx);
261		errno = save_errno;
262		return (NULL);
263	}
264	(*ctx->logger)(ctl_debug, "%s: new ctx %p, sock %d",
265		       me, ctx, ctx->sock);
266	return (ctx);
267}
268
269/*%
270 * void
271 * ctl_endserver(ctx)
272 *	if the control listener is open, close it.  clean out all eventlib
273 *	stuff.  close all active sessions.
274 */
275void
276ctl_endserver(struct ctl_sctx *ctx) {
277	static const char me[] = "ctl_endserver";
278	struct ctl_sess *this, *next;
279
280	(*ctx->logger)(ctl_debug, "%s: ctx %p, sock %d, acID %p, sess %p",
281		       me, ctx, ctx->sock, ctx->acID.opaque, ctx->sess.head);
282	if (ctx->acID.opaque != NULL) {
283		(void)evCancelConn(ctx->ev, ctx->acID);
284		ctx->acID.opaque = NULL;
285	}
286	if (ctx->sock != -1) {
287		(void) close(ctx->sock);
288		ctx->sock = -1;
289	}
290	for (this = HEAD(ctx->sess); this != NULL; this = next) {
291		next = NEXT(this, link);
292		ctl_close(this);
293	}
294	memput(ctx, sizeof *ctx);
295}
296
297/*%
298 * If body is non-NULL then it we add a "." line after it.
299 * Caller must have  escaped lines with leading ".".
300 */
301void
302ctl_response(struct ctl_sess *sess, u_int code, const char *text,
303	     u_int flags, const void *respctx, ctl_srvrdone donefunc,
304	     void *uap, const char *body, size_t bodylen)
305{
306	static const char me[] = "ctl_response";
307	struct iovec iov[3], *iovp = iov;
308	struct ctl_sctx *ctx = sess->ctx;
309	char tmp[MAX_NTOP], *pc;
310	int n;
311
312	REQUIRE(sess->state == initializing ||
313		sess->state == processing ||
314		sess->state == reading_data ||
315		sess->state == writing);
316	REQUIRE(sess->wrtiID.opaque == NULL);
317	REQUIRE(sess->wrID.opaque == NULL);
318	ctl_new_state(sess, writing, me);
319	sess->donefunc = donefunc;
320	sess->uap = uap;
321	if (!allocated_p(sess->outbuf) &&
322	    ctl_bufget(&sess->outbuf, ctx->logger) < 0) {
323		(*ctx->logger)(ctl_error, "%s: %s: cant get an output buffer",
324			       me, address_expr);
325		goto untimely;
326	}
327	if (sizeof "000-\r\n" + strlen(text) > (size_t)MAX_LINELEN) {
328		(*ctx->logger)(ctl_error, "%s: %s: output buffer ovf, closing",
329			       me, address_expr);
330		goto untimely;
331	}
332	sess->outbuf.used = SPRINTF((sess->outbuf.text, "%03d%c%s\r\n",
333				     code, (flags & CTL_MORE) != 0 ? '-' : ' ',
334				     text));
335	for (pc = sess->outbuf.text, n = 0;
336	     n < (int)sess->outbuf.used-2; pc++, n++)
337		if (!isascii((unsigned char)*pc) ||
338		    !isprint((unsigned char)*pc))
339			*pc = '\040';
340	*iovp++ = evConsIovec(sess->outbuf.text, sess->outbuf.used);
341	if (body != NULL) {
342		char *tmp;
343		DE_CONST(body, tmp);
344		*iovp++ = evConsIovec(tmp, bodylen);
345		DE_CONST(".\r\n", tmp);
346		*iovp++ = evConsIovec(tmp, 3);
347	}
348	(*ctx->logger)(ctl_debug, "%s: [%d] %s", me,
349		       sess->outbuf.used, sess->outbuf.text);
350	if (evWrite(ctx->ev, sess->sock, iov, iovp - iov,
351		    ctl_writedone, sess, &sess->wrID) < 0) {
352		(*ctx->logger)(ctl_error, "%s: %s: evWrite: %s", me,
353			       address_expr, strerror(errno));
354		goto untimely;
355	}
356	if (evSetIdleTimer(ctx->ev, ctl_wrtimeout, sess, ctx->timeout,
357			   &sess->wrtiID) < 0)
358	{
359		(*ctx->logger)(ctl_error, "%s: %s: evSetIdleTimer: %s", me,
360			       address_expr, strerror(errno));
361		goto untimely;
362	}
363	if (evTimeRW(ctx->ev, sess->wrID, sess->wrtiID) < 0) {
364		(*ctx->logger)(ctl_error, "%s: %s: evTimeRW: %s", me,
365			       address_expr, strerror(errno));
366 untimely:
367		ctl_signal_done(ctx, sess);
368		ctl_close(sess);
369		return;
370	}
371	sess->respctx = respctx;
372	sess->respflags = flags;
373}
374
375void
376ctl_sendhelp(struct ctl_sess *sess, u_int code) {
377	static const char me[] = "ctl_sendhelp";
378	struct ctl_sctx *ctx = sess->ctx;
379
380	sess->helpcode = code;
381	sess->verb = &fakehelpverb;
382	ctl_morehelp(ctx, sess, NULL, me, CTL_MORE,
383		     (const void *)ctx->verbs, NULL);
384}
385
386void *
387ctl_getcsctx(struct ctl_sess *sess) {
388	return (sess->csctx);
389}
390
391void *
392ctl_setcsctx(struct ctl_sess *sess, void *csctx) {
393	void *old = sess->csctx;
394
395	sess->csctx = csctx;
396	return (old);
397}
398
399/* Private functions. */
400
401static void
402ctl_accept(evContext lev, void *uap, int fd,
403	   const void *lav, int lalen,
404	   const void *rav, int ralen)
405{
406	static const char me[] = "ctl_accept";
407	struct ctl_sctx *ctx = uap;
408	struct ctl_sess *sess = NULL;
409	char tmp[MAX_NTOP];
410
411	UNUSED(lev);
412	UNUSED(lalen);
413	UNUSED(ralen);
414
415	if (fd < 0) {
416		(*ctx->logger)(ctl_error, "%s: accept: %s",
417			       me, strerror(errno));
418		return;
419	}
420	if (ctx->cur_sess == ctx->max_sess) {
421		(*ctx->logger)(ctl_error, "%s: %s: too many control sessions",
422			       me, ctl_sa_ntop((const struct sockaddr *)rav,
423					       tmp, sizeof tmp,
424					       ctx->logger));
425		(void) close(fd);
426		return;
427	}
428	sess = memget(sizeof *sess);
429	if (sess == NULL) {
430		(*ctx->logger)(ctl_error, "%s: memget: %s", me,
431			       strerror(errno));
432		(void) close(fd);
433		return;
434	}
435	if (fcntl(fd, F_SETFD, 1) < 0) {
436		(*ctx->logger)(ctl_warning, "%s: fcntl: %s", me,
437			       strerror(errno));
438	}
439	ctx->cur_sess++;
440	INIT_LINK(sess, link);
441	APPEND(ctx->sess, sess, link);
442	sess->ctx = ctx;
443	sess->sock = fd;
444	sess->wrID.opaque = NULL;
445	sess->rdID.opaque = NULL;
446	sess->wrtiID.opaque = NULL;
447	sess->rdtiID.opaque = NULL;
448	sess->respctx = NULL;
449	sess->csctx = NULL;
450	if (((const struct sockaddr *)rav)->sa_family == AF_UNIX)
451		ctl_sa_copy((const struct sockaddr *)lav,
452			    (struct sockaddr *)&sess->sa);
453	else
454		ctl_sa_copy((const struct sockaddr *)rav,
455			    (struct sockaddr *)&sess->sa);
456	sess->donefunc = NULL;
457	buffer_init(sess->inbuf);
458	buffer_init(sess->outbuf);
459	sess->state = available;
460	ctl_new_state(sess, initializing, me);
461	sess->verb = ctx->connverb;
462	(*ctx->logger)(ctl_debug, "%s: %s: accepting (fd %d)",
463		       me, address_expr, sess->sock);
464	(*ctx->connverb->func)(ctx, sess, ctx->connverb, "", 0,
465			       (const struct sockaddr *)rav, ctx->uctx);
466}
467
468static void
469ctl_new_state(struct ctl_sess *sess, enum state new_state, const char *reason)
470{
471	static const char me[] = "ctl_new_state";
472	struct ctl_sctx *ctx = sess->ctx;
473	char tmp[MAX_NTOP];
474
475	(*ctx->logger)(ctl_debug, "%s: %s: %s -> %s (%s)",
476		       me, address_expr,
477		       state_names[sess->state],
478		       state_names[new_state], reason);
479	sess->state = new_state;
480}
481
482static void
483ctl_close(struct ctl_sess *sess) {
484	static const char me[] = "ctl_close";
485	struct ctl_sctx *ctx = sess->ctx;
486	char tmp[MAX_NTOP];
487
488	REQUIRE(sess->state == initializing ||
489		sess->state == writing ||
490		sess->state == reading ||
491		sess->state == processing ||
492		sess->state == reading_data ||
493		sess->state == idling);
494	REQUIRE(sess->sock != -1);
495	if (sess->state == reading || sess->state == reading_data)
496		ctl_stop_read(sess);
497	else if (sess->state == writing) {
498		if (sess->wrID.opaque != NULL) {
499			(void) evCancelRW(ctx->ev, sess->wrID);
500			sess->wrID.opaque = NULL;
501		}
502		if (sess->wrtiID.opaque != NULL) {
503			(void) evClearIdleTimer(ctx->ev, sess->wrtiID);
504			sess->wrtiID.opaque = NULL;
505		}
506	}
507	ctl_new_state(sess, closing, me);
508	(void) close(sess->sock);
509	if (allocated_p(sess->inbuf))
510		ctl_bufput(&sess->inbuf);
511	if (allocated_p(sess->outbuf))
512		ctl_bufput(&sess->outbuf);
513	(*ctx->logger)(ctl_debug, "%s: %s: closed (fd %d)",
514		       me, address_expr, sess->sock);
515	UNLINK(ctx->sess, sess, link);
516	memput(sess, sizeof *sess);
517	ctx->cur_sess--;
518}
519
520static void
521ctl_start_read(struct ctl_sess *sess) {
522	static const char me[] = "ctl_start_read";
523	struct ctl_sctx *ctx = sess->ctx;
524	char tmp[MAX_NTOP];
525
526	REQUIRE(sess->state == initializing ||
527		sess->state == writing ||
528		sess->state == processing ||
529		sess->state == idling);
530	REQUIRE(sess->rdtiID.opaque == NULL);
531	REQUIRE(sess->rdID.opaque == NULL);
532	sess->inbuf.used = 0;
533	if (evSetIdleTimer(ctx->ev, ctl_rdtimeout, sess, ctx->timeout,
534			   &sess->rdtiID) < 0)
535	{
536		(*ctx->logger)(ctl_error, "%s: %s: evSetIdleTimer: %s", me,
537			       address_expr, strerror(errno));
538		ctl_close(sess);
539		return;
540	}
541	if (evSelectFD(ctx->ev, sess->sock, EV_READ,
542		       ctl_readable, sess, &sess->rdID) < 0) {
543		(*ctx->logger)(ctl_error, "%s: %s: evSelectFD: %s", me,
544			       address_expr, strerror(errno));
545		return;
546	}
547	ctl_new_state(sess, reading, me);
548}
549
550static void
551ctl_stop_read(struct ctl_sess *sess) {
552	static const char me[] = "ctl_stop_read";
553	struct ctl_sctx *ctx = sess->ctx;
554
555	REQUIRE(sess->state == reading || sess->state == reading_data);
556	REQUIRE(sess->rdID.opaque != NULL);
557	(void) evDeselectFD(ctx->ev, sess->rdID);
558	sess->rdID.opaque = NULL;
559	if (sess->rdtiID.opaque != NULL) {
560		(void) evClearIdleTimer(ctx->ev, sess->rdtiID);
561		sess->rdtiID.opaque = NULL;
562	}
563	ctl_new_state(sess, idling, me);
564}
565
566static void
567ctl_readable(evContext lev, void *uap, int fd, int evmask) {
568	static const char me[] = "ctl_readable";
569	struct ctl_sess *sess = uap;
570	struct ctl_sctx *ctx;
571	char *eos, tmp[MAX_NTOP];
572	ssize_t n;
573
574	REQUIRE(sess != NULL);
575	REQUIRE(fd >= 0);
576	REQUIRE(evmask == EV_READ);
577	REQUIRE(sess->state == reading || sess->state == reading_data);
578
579	ctx = sess->ctx;
580	evTouchIdleTimer(lev, sess->rdtiID);
581	if (!allocated_p(sess->inbuf) &&
582	    ctl_bufget(&sess->inbuf, ctx->logger) < 0) {
583		(*ctx->logger)(ctl_error, "%s: %s: cant get an input buffer",
584			       me, address_expr);
585		ctl_close(sess);
586		return;
587	}
588	n = read(sess->sock, sess->inbuf.text + sess->inbuf.used,
589		 MAX_LINELEN - sess->inbuf.used);
590	if (n <= 0) {
591		(*ctx->logger)(ctl_debug, "%s: %s: read: %s",
592			       me, address_expr,
593			       (n == 0) ? "Unexpected EOF" : strerror(errno));
594		ctl_close(sess);
595		return;
596	}
597	sess->inbuf.used += n;
598	eos = memchr(sess->inbuf.text, '\n', sess->inbuf.used);
599	if (eos != NULL && eos != sess->inbuf.text && eos[-1] == '\r') {
600		eos[-1] = '\0';
601		if ((sess->respflags & CTL_DATA) != 0) {
602			INSIST(sess->verb != NULL);
603			(*sess->verb->func)(sess->ctx, sess, sess->verb,
604					    sess->inbuf.text,
605					    CTL_DATA, sess->respctx,
606					    sess->ctx->uctx);
607		} else {
608			ctl_stop_read(sess);
609			ctl_docommand(sess);
610		}
611		sess->inbuf.used -= ((eos - sess->inbuf.text) + 1);
612		if (sess->inbuf.used == 0U)
613			ctl_bufput(&sess->inbuf);
614		else
615			memmove(sess->inbuf.text, eos + 1, sess->inbuf.used);
616		return;
617	}
618	if (sess->inbuf.used == (size_t)MAX_LINELEN) {
619		(*ctx->logger)(ctl_error, "%s: %s: line too long, closing",
620			       me, address_expr);
621		ctl_close(sess);
622	}
623}
624
625static void
626ctl_wrtimeout(evContext lev, void *uap,
627	      struct timespec due,
628	      struct timespec itv)
629{
630	static const char me[] = "ctl_wrtimeout";
631	struct ctl_sess *sess = uap;
632	struct ctl_sctx *ctx = sess->ctx;
633	char tmp[MAX_NTOP];
634
635	UNUSED(lev);
636	UNUSED(due);
637	UNUSED(itv);
638
639	REQUIRE(sess->state == writing);
640	sess->wrtiID.opaque = NULL;
641	(*ctx->logger)(ctl_warning, "%s: %s: write timeout, closing",
642		       me, address_expr);
643	if (sess->wrID.opaque != NULL) {
644		(void) evCancelRW(ctx->ev, sess->wrID);
645		sess->wrID.opaque = NULL;
646	}
647	ctl_signal_done(ctx, sess);
648	ctl_new_state(sess, processing, me);
649	ctl_close(sess);
650}
651
652static void
653ctl_rdtimeout(evContext lev, void *uap,
654	      struct timespec due,
655	      struct timespec itv)
656{
657	static const char me[] = "ctl_rdtimeout";
658	struct ctl_sess *sess = uap;
659	struct ctl_sctx *ctx = sess->ctx;
660	char tmp[MAX_NTOP];
661
662	UNUSED(lev);
663	UNUSED(due);
664	UNUSED(itv);
665
666	REQUIRE(sess->state == reading);
667	sess->rdtiID.opaque = NULL;
668	(*ctx->logger)(ctl_warning, "%s: %s: timeout, closing",
669		       me, address_expr);
670	if (sess->state == reading || sess->state == reading_data)
671		ctl_stop_read(sess);
672	ctl_signal_done(ctx, sess);
673	ctl_new_state(sess, processing, me);
674	ctl_response(sess, ctx->timeoutcode, "Timeout.", CTL_EXIT, NULL,
675		     NULL, NULL, NULL, 0);
676}
677
678static void
679ctl_docommand(struct ctl_sess *sess) {
680	static const char me[] = "ctl_docommand";
681	char *name, *rest, tmp[MAX_NTOP];
682	struct ctl_sctx *ctx = sess->ctx;
683	const struct ctl_verb *verb;
684
685	REQUIRE(allocated_p(sess->inbuf));
686	(*ctx->logger)(ctl_debug, "%s: %s: \"%s\" [%u]",
687		       me, address_expr,
688		       sess->inbuf.text, (u_int)sess->inbuf.used);
689	ctl_new_state(sess, processing, me);
690	name = sess->inbuf.text + strspn(sess->inbuf.text, space);
691	rest = name + strcspn(name, space);
692	if (*rest != '\0') {
693		*rest++ = '\0';
694		rest += strspn(rest, space);
695	}
696	for (verb = ctx->verbs;
697	     verb != NULL && verb->name != NULL && verb->func != NULL;
698	     verb++)
699		if (verb->name[0] != '\0' && strcasecmp(name, verb->name) == 0)
700			break;
701	if (verb != NULL && verb->name != NULL && verb->func != NULL) {
702		sess->verb = verb;
703		(*verb->func)(ctx, sess, verb, rest, 0, NULL, ctx->uctx);
704	} else {
705		char buf[1100];
706
707		if (sizeof "Unrecognized command \"\" (args \"\")" +
708		    strlen(name) + strlen(rest) > sizeof buf)
709			strcpy(buf, "Unrecognized command (buf ovf)");
710		else
711			sprintf(buf,
712				"Unrecognized command \"%s\" (args \"%s\")",
713				name, rest);
714		ctl_response(sess, ctx->unkncode, buf, 0, NULL, NULL, NULL,
715			     NULL, 0);
716	}
717}
718
719static void
720ctl_writedone(evContext lev, void *uap, int fd, int bytes) {
721	static const char me[] = "ctl_writedone";
722	struct ctl_sess *sess = uap;
723	struct ctl_sctx *ctx = sess->ctx;
724	char tmp[MAX_NTOP];
725	int save_errno = errno;
726
727	UNUSED(lev);
728	UNUSED(uap);
729
730	REQUIRE(sess->state == writing);
731	REQUIRE(fd == sess->sock);
732	REQUIRE(sess->wrtiID.opaque != NULL);
733	sess->wrID.opaque = NULL;
734	(void) evClearIdleTimer(ctx->ev, sess->wrtiID);
735	sess->wrtiID.opaque = NULL;
736	if (bytes < 0) {
737		(*ctx->logger)(ctl_error, "%s: %s: %s",
738			       me, address_expr, strerror(save_errno));
739		ctl_close(sess);
740		return;
741	}
742
743	INSIST(allocated_p(sess->outbuf));
744	ctl_bufput(&sess->outbuf);
745	if ((sess->respflags & CTL_EXIT) != 0) {
746		ctl_signal_done(ctx, sess);
747		ctl_close(sess);
748		return;
749	} else if ((sess->respflags & CTL_MORE) != 0) {
750		INSIST(sess->verb != NULL);
751		(*sess->verb->func)(sess->ctx, sess, sess->verb, "",
752				    CTL_MORE, sess->respctx, sess->ctx->uctx);
753	} else {
754		ctl_signal_done(ctx, sess);
755		ctl_start_read(sess);
756	}
757}
758
759static void
760ctl_morehelp(struct ctl_sctx *ctx, struct ctl_sess *sess,
761	     const struct ctl_verb *verb, const char *text,
762	     u_int respflags, const void *respctx, void *uctx)
763{
764	const struct ctl_verb *this = respctx, *next = this + 1;
765
766	UNUSED(ctx);
767	UNUSED(verb);
768	UNUSED(text);
769	UNUSED(uctx);
770
771	REQUIRE(!lastverb_p(this));
772	REQUIRE((respflags & CTL_MORE) != 0);
773	if (lastverb_p(next))
774		respflags &= ~CTL_MORE;
775	ctl_response(sess, sess->helpcode, this->help, respflags, next,
776		     NULL, NULL, NULL, 0);
777}
778
779static void
780ctl_signal_done(struct ctl_sctx *ctx, struct ctl_sess *sess) {
781	if (sess->donefunc != NULL) {
782		(*sess->donefunc)(ctx, sess, sess->uap);
783		sess->donefunc = NULL;
784	}
785}
786
787/*! \file */
788