xref: /netbsd/external/bsd/libbind/dist/isc/ctl_clnt.c (revision 6550d01e) 
1 /*	$NetBSD: ctl_clnt.c,v 1.1.1.1 2009/04/12 15:33:49 christos Exp $	*/
2 
3 /*
4  * Copyright (C) 2004, 2005, 2007, 2008  Internet Systems Consortium, Inc. ("ISC")
5  * Copyright (C) 1998-2003  Internet Software Consortium.
6  *
7  * Permission to use, copy, modify, and/or distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
12  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
13  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
14  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
15  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
16  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17  * PERFORMANCE OF THIS SOFTWARE.
18  */
19 
20 #if !defined(lint) && !defined(SABER)
21 static const char rcsid[] = "Id: ctl_clnt.c,v 1.11 2008/11/14 02:36:51 marka Exp";
22 #endif /* not lint */
23 
24 /* Extern. */
25 
26 #include "port_before.h"
27 
28 #include <sys/param.h>
29 #include <sys/file.h>
30 #include <sys/socket.h>
31 
32 #include <netinet/in.h>
33 #include <arpa/nameser.h>
34 #include <arpa/inet.h>
35 
36 #include <ctype.h>
37 #include <errno.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <time.h>
42 #include <unistd.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/memcluster.h>
52 
53 #include "ctl_p.h"
54 
55 #include "port_after.h"
56 
57 /* Constants. */
58 
59 
60 /* Macros. */
61 
62 #define donefunc_p(ctx) ((ctx).donefunc != NULL)
63 #define arpacode_p(line) (isdigit((unsigned char)(line[0])) && \
64 			  isdigit((unsigned char)(line[1])) && \
65 			  isdigit((unsigned char)(line[2])))
66 #define arpacont_p(line) (line[3] == '-')
67 #define arpadone_p(line) (line[3] == ' ' || line[3] == '\t' || \
68 			  line[3] == '\r' || line[3] == '\0')
69 
70 /* Types. */
71 
72 enum state {
73 	initializing = 0, connecting, connected, destroyed
74 };
75 
76 struct ctl_tran {
77 	LINK(struct ctl_tran)	link;
78 	LINK(struct ctl_tran)	wlink;
79 	struct ctl_cctx *	ctx;
80 	struct ctl_buf		outbuf;
81 	ctl_clntdone		donefunc;
82 	void *			uap;
83 };
84 
85 struct ctl_cctx {
86 	enum state		state;
87 	evContext		ev;
88 	int			sock;
89 	ctl_logfunc		logger;
90 	ctl_clntdone		donefunc;
91 	void *			uap;
92 	evConnID		coID;
93 	evTimerID		tiID;
94 	evFileID		rdID;
95 	evStreamID		wrID;
96 	struct ctl_buf		inbuf;
97 	struct timespec		timeout;
98 	LIST(struct ctl_tran)	tran;
99 	LIST(struct ctl_tran)	wtran;
100 };
101 
102 /* Forward. */
103 
104 static struct ctl_tran *new_tran(struct ctl_cctx *, ctl_clntdone, void *, int);
105 static void		start_write(struct ctl_cctx *);
106 static void		destroy(struct ctl_cctx *, int);
107 static void		error(struct ctl_cctx *);
108 static void		new_state(struct ctl_cctx *, enum state);
109 static void		conn_done(evContext, void *, int,
110 				  const void *, int,
111 				  const void *, int);
112 static void		write_done(evContext, void *, int, int);
113 static void		start_read(struct ctl_cctx *);
114 static void		stop_read(struct ctl_cctx *);
115 static void		readable(evContext, void *, int, int);
116 static void		start_timer(struct ctl_cctx *);
117 static void		stop_timer(struct ctl_cctx *);
118 static void		touch_timer(struct ctl_cctx *);
119 static void		timer(evContext, void *,
120 			      struct timespec, struct timespec);
121 
122 #ifndef HAVE_MEMCHR
123 static void *
124 memchr(const void *b, int c, size_t len) {
125 	const unsigned char *p = b;
126 	size_t i;
127 
128 	for (i = 0; i < len; i++, p++)
129 		if (*p == (unsigned char)c)
130 			return ((void *)p);
131 	return (NULL);
132 }
133 #endif
134 
135 /* Private data. */
136 
137 static const char * const state_names[] = {
138 	"initializing", "connecting", "connected", "destroyed"
139 };
140 
141 /* Public. */
142 
143 /*%
144  * void
145  * ctl_client()
146  *	create, condition, and connect to a listener on the control port.
147  */
148 struct ctl_cctx *
149 ctl_client(evContext lev, const struct sockaddr *cap, size_t cap_len,
150 	   const struct sockaddr *sap, size_t sap_len,
151 	   ctl_clntdone donefunc, void *uap,
152 	   u_int timeout, ctl_logfunc logger)
153 {
154 	static const char me[] = "ctl_client";
155 	static const int on = 1;
156 	struct ctl_cctx *ctx;
157 	struct sockaddr *captmp;
158 
159 	if (logger == NULL)
160 		logger = ctl_logger;
161 	ctx = memget(sizeof *ctx);
162 	if (ctx == NULL) {
163 		(*logger)(ctl_error, "%s: getmem: %s", me, strerror(errno));
164 		goto fatal;
165 	}
166 	ctx->state = initializing;
167 	ctx->ev = lev;
168 	ctx->logger = logger;
169 	ctx->timeout = evConsTime(timeout, 0);
170 	ctx->donefunc = donefunc;
171 	ctx->uap = uap;
172 	ctx->coID.opaque = NULL;
173 	ctx->tiID.opaque = NULL;
174 	ctx->rdID.opaque = NULL;
175 	ctx->wrID.opaque = NULL;
176 	buffer_init(ctx->inbuf);
177 	INIT_LIST(ctx->tran);
178 	INIT_LIST(ctx->wtran);
179 	ctx->sock = socket(sap->sa_family, SOCK_STREAM, PF_UNSPEC);
180 	if (ctx->sock > evHighestFD(ctx->ev)) {
181 		ctx->sock = -1;
182 		errno = ENOTSOCK;
183 	}
184 	if (ctx->sock < 0) {
185 		(*ctx->logger)(ctl_error, "%s: socket: %s",
186 			       me, strerror(errno));
187 		goto fatal;
188 	}
189 	if (cap != NULL) {
190 		if (setsockopt(ctx->sock, SOL_SOCKET, SO_REUSEADDR,
191 			       (const char *)&on, sizeof on) != 0) {
192 			(*ctx->logger)(ctl_warning,
193 				       "%s: setsockopt(REUSEADDR): %s",
194 				       me, strerror(errno));
195 		}
196 		DE_CONST(cap, captmp);
197 		if (bind(ctx->sock, captmp, cap_len) < 0) {
198 			(*ctx->logger)(ctl_error, "%s: bind: %s", me,
199 				       strerror(errno));
200 			goto fatal;
201 		}
202 	}
203 	if (evConnect(lev, ctx->sock, (const struct sockaddr *)sap, sap_len,
204 		      conn_done, ctx, &ctx->coID) < 0) {
205 		(*ctx->logger)(ctl_error, "%s: evConnect(fd %d): %s",
206 			       me, ctx->sock, strerror(errno));
207  fatal:
208 		if (ctx != NULL) {
209 			if (ctx->sock >= 0)
210 				close(ctx->sock);
211 			memput(ctx, sizeof *ctx);
212 		}
213 		return (NULL);
214 	}
215 	new_state(ctx, connecting);
216 	return (ctx);
217 }
218 
219 /*%
220  * void
221  * ctl_endclient(ctx)
222  *	close a client and release all of its resources.
223  */
224 void
225 ctl_endclient(struct ctl_cctx *ctx) {
226 	if (ctx->state != destroyed)
227 		destroy(ctx, 0);
228 	memput(ctx, sizeof *ctx);
229 }
230 
231 /*%
232  * int
233  * ctl_command(ctx, cmd, len, donefunc, uap)
234  *	Queue a transaction, which will begin with sending cmd
235  *	and complete by calling donefunc with the answer.
236  */
237 int
238 ctl_command(struct ctl_cctx *ctx, const char *cmd, size_t len,
239 	    ctl_clntdone donefunc, void *uap)
240 {
241 	struct ctl_tran *tran;
242 	char *pc;
243 	unsigned int n;
244 
245 	switch (ctx->state) {
246 	case destroyed:
247 		errno = ENOTCONN;
248 		return (-1);
249 	case connecting:
250 	case connected:
251 		break;
252 	default:
253 		abort();
254 	}
255 	if (len >= (size_t)MAX_LINELEN) {
256 		errno = EMSGSIZE;
257 		return (-1);
258 	}
259 	tran = new_tran(ctx, donefunc, uap, 1);
260 	if (tran == NULL)
261 		return (-1);
262 	if (ctl_bufget(&tran->outbuf, ctx->logger) < 0)
263 		return (-1);
264 	memcpy(tran->outbuf.text, cmd, len);
265 	tran->outbuf.used = len;
266 	for (pc = tran->outbuf.text, n = 0; n < tran->outbuf.used; pc++, n++)
267 		if (!isascii((unsigned char)*pc) ||
268 		    !isprint((unsigned char)*pc))
269 			*pc = '\040';
270 	start_write(ctx);
271 	return (0);
272 }
273 
274 /* Private. */
275 
276 static struct ctl_tran *
277 new_tran(struct ctl_cctx *ctx, ctl_clntdone donefunc, void *uap, int w) {
278 	struct ctl_tran *new = memget(sizeof *new);
279 
280 	if (new == NULL)
281 		return (NULL);
282 	new->ctx = ctx;
283 	buffer_init(new->outbuf);
284 	new->donefunc = donefunc;
285 	new->uap = uap;
286 	INIT_LINK(new, link);
287 	INIT_LINK(new, wlink);
288 	APPEND(ctx->tran, new, link);
289 	if (w)
290 		APPEND(ctx->wtran, new, wlink);
291 	return (new);
292 }
293 
294 static void
295 start_write(struct ctl_cctx *ctx) {
296 	static const char me[] = "isc/ctl_clnt::start_write";
297 	struct ctl_tran *tran;
298 	struct iovec iov[2], *iovp = iov;
299 	char * tmp;
300 
301 	REQUIRE(ctx->state == connecting || ctx->state == connected);
302 	/* If there is a write in progress, don't try to write more yet. */
303 	if (ctx->wrID.opaque != NULL)
304 		return;
305 	/* If there are no trans, make sure timer is off, and we're done. */
306 	if (EMPTY(ctx->wtran)) {
307 		if (ctx->tiID.opaque != NULL)
308 			stop_timer(ctx);
309 		return;
310 	}
311 	/* Pull it off the head of the write queue. */
312 	tran = HEAD(ctx->wtran);
313 	UNLINK(ctx->wtran, tran, wlink);
314 	/* Since there are some trans, make sure timer is successfully "on". */
315 	if (ctx->tiID.opaque != NULL)
316 		touch_timer(ctx);
317 	else
318 		start_timer(ctx);
319 	if (ctx->state == destroyed)
320 		return;
321 	/* Marshall a newline-terminated message and clock it out. */
322 	*iovp++ = evConsIovec(tran->outbuf.text, tran->outbuf.used);
323 	DE_CONST("\r\n", tmp);
324 	*iovp++ = evConsIovec(tmp, 2);
325 	if (evWrite(ctx->ev, ctx->sock, iov, iovp - iov,
326 		    write_done, tran, &ctx->wrID) < 0) {
327 		(*ctx->logger)(ctl_error, "%s: evWrite: %s", me,
328 			       strerror(errno));
329 		error(ctx);
330 		return;
331 	}
332 	if (evTimeRW(ctx->ev, ctx->wrID, ctx->tiID) < 0) {
333 		(*ctx->logger)(ctl_error, "%s: evTimeRW: %s", me,
334 			       strerror(errno));
335 		error(ctx);
336 		return;
337 	}
338 }
339 
340 static void
341 destroy(struct ctl_cctx *ctx, int notify) {
342 	struct ctl_tran *this, *next;
343 
344 	if (ctx->sock != -1) {
345 		(void) close(ctx->sock);
346 		ctx->sock = -1;
347 	}
348 	switch (ctx->state) {
349 	case connecting:
350 		REQUIRE(ctx->wrID.opaque == NULL);
351 		REQUIRE(EMPTY(ctx->tran));
352 		/*
353 		 * This test is nec'y since destroy() can be called from
354 		 * start_read() while the state is still "connecting".
355 		 */
356 		if (ctx->coID.opaque != NULL) {
357 			(void)evCancelConn(ctx->ev, ctx->coID);
358 			ctx->coID.opaque = NULL;
359 		}
360 		break;
361 	case connected:
362 		REQUIRE(ctx->coID.opaque == NULL);
363 		if (ctx->wrID.opaque != NULL) {
364 			(void)evCancelRW(ctx->ev, ctx->wrID);
365 			ctx->wrID.opaque = NULL;
366 		}
367 		if (ctx->rdID.opaque != NULL)
368 			stop_read(ctx);
369 		break;
370 	case destroyed:
371 		break;
372 	default:
373 		abort();
374 	}
375 	if (allocated_p(ctx->inbuf))
376 		ctl_bufput(&ctx->inbuf);
377 	for (this = HEAD(ctx->tran); this != NULL; this = next) {
378 		next = NEXT(this, link);
379 		if (allocated_p(this->outbuf))
380 			ctl_bufput(&this->outbuf);
381 		if (notify && this->donefunc != NULL)
382 			(*this->donefunc)(ctx, this->uap, NULL, 0);
383 		memput(this, sizeof *this);
384 	}
385 	if (ctx->tiID.opaque != NULL)
386 		stop_timer(ctx);
387 	new_state(ctx, destroyed);
388 }
389 
390 static void
391 error(struct ctl_cctx *ctx) {
392 	REQUIRE(ctx->state != destroyed);
393 	destroy(ctx, 1);
394 }
395 
396 static void
397 new_state(struct ctl_cctx *ctx, enum state new_state) {
398 	static const char me[] = "isc/ctl_clnt::new_state";
399 
400 	(*ctx->logger)(ctl_debug, "%s: %s -> %s", me,
401 		       state_names[ctx->state], state_names[new_state]);
402 	ctx->state = new_state;
403 }
404 
405 static void
406 conn_done(evContext ev, void *uap, int fd,
407 	  const void *la, int lalen,
408 	  const void *ra, int ralen)
409 {
410 	static const char me[] = "isc/ctl_clnt::conn_done";
411 	struct ctl_cctx *ctx = uap;
412 	struct ctl_tran *tran;
413 
414 	UNUSED(ev);
415 	UNUSED(la);
416 	UNUSED(lalen);
417 	UNUSED(ra);
418 	UNUSED(ralen);
419 
420 	ctx->coID.opaque = NULL;
421 	if (fd < 0) {
422 		(*ctx->logger)(ctl_error, "%s: evConnect: %s", me,
423 			       strerror(errno));
424 		error(ctx);
425 		return;
426 	}
427 	new_state(ctx, connected);
428 	tran = new_tran(ctx, ctx->donefunc, ctx->uap, 0);
429 	if (tran == NULL) {
430 		(*ctx->logger)(ctl_error, "%s: new_tran failed: %s", me,
431 			       strerror(errno));
432 		error(ctx);
433 		return;
434 	}
435 	start_read(ctx);
436 	if (ctx->state == destroyed) {
437 		(*ctx->logger)(ctl_error, "%s: start_read failed: %s",
438 			       me, strerror(errno));
439 		error(ctx);
440 		return;
441 	}
442 }
443 
444 static void
445 write_done(evContext lev, void *uap, int fd, int bytes) {
446 	struct ctl_tran *tran = (struct ctl_tran *)uap;
447 	struct ctl_cctx *ctx = tran->ctx;
448 
449 	UNUSED(lev);
450 	UNUSED(fd);
451 
452 	ctx->wrID.opaque = NULL;
453 	if (ctx->tiID.opaque != NULL)
454 		touch_timer(ctx);
455 	ctl_bufput(&tran->outbuf);
456 	start_write(ctx);
457 	if (bytes < 0)
458 		destroy(ctx, 1);
459 	else
460 		start_read(ctx);
461 }
462 
463 static void
464 start_read(struct ctl_cctx *ctx) {
465 	static const char me[] = "isc/ctl_clnt::start_read";
466 
467 	REQUIRE(ctx->state == connecting || ctx->state == connected);
468 	REQUIRE(ctx->rdID.opaque == NULL);
469 	if (evSelectFD(ctx->ev, ctx->sock, EV_READ, readable, ctx,
470 		       &ctx->rdID) < 0)
471 	{
472 		(*ctx->logger)(ctl_error, "%s: evSelect(fd %d): %s", me,
473 			       ctx->sock, strerror(errno));
474 		error(ctx);
475 		return;
476 	}
477 }
478 
479 static void
480 stop_read(struct ctl_cctx *ctx) {
481 	REQUIRE(ctx->coID.opaque == NULL);
482 	REQUIRE(ctx->rdID.opaque != NULL);
483 	(void)evDeselectFD(ctx->ev, ctx->rdID);
484 	ctx->rdID.opaque = NULL;
485 }
486 
487 static void
488 readable(evContext ev, void *uap, int fd, int evmask) {
489 	static const char me[] = "isc/ctl_clnt::readable";
490 	struct ctl_cctx *ctx = uap;
491 	struct ctl_tran *tran;
492 	ssize_t n;
493 	char *eos;
494 
495 	UNUSED(ev);
496 
497 	REQUIRE(ctx != NULL);
498 	REQUIRE(fd >= 0);
499 	REQUIRE(evmask == EV_READ);
500 	REQUIRE(ctx->state == connected);
501 	REQUIRE(!EMPTY(ctx->tran));
502 	tran = HEAD(ctx->tran);
503 	if (!allocated_p(ctx->inbuf) &&
504 	    ctl_bufget(&ctx->inbuf, ctx->logger) < 0) {
505 		(*ctx->logger)(ctl_error, "%s: can't get an input buffer", me);
506 		error(ctx);
507 		return;
508 	}
509 	n = read(ctx->sock, ctx->inbuf.text + ctx->inbuf.used,
510 		 MAX_LINELEN - ctx->inbuf.used);
511 	if (n <= 0) {
512 		(*ctx->logger)(ctl_warning, "%s: read: %s", me,
513 			       (n == 0) ? "Unexpected EOF" : strerror(errno));
514 		error(ctx);
515 		return;
516 	}
517 	if (ctx->tiID.opaque != NULL)
518 		touch_timer(ctx);
519 	ctx->inbuf.used += n;
520 	(*ctx->logger)(ctl_debug, "%s: read %d, used %d", me,
521 		       n, ctx->inbuf.used);
522  again:
523 	eos = memchr(ctx->inbuf.text, '\n', ctx->inbuf.used);
524 	if (eos != NULL && eos != ctx->inbuf.text && eos[-1] == '\r') {
525 		int done = 0;
526 
527 		eos[-1] = '\0';
528 		if (!arpacode_p(ctx->inbuf.text)) {
529 			/* XXX Doesn't FTP do this sometimes? Is it legal? */
530 			(*ctx->logger)(ctl_error, "%s: no arpa code (%s)", me,
531 				       ctx->inbuf.text);
532 			error(ctx);
533 			return;
534 		}
535 		if (arpadone_p(ctx->inbuf.text))
536 			done = 1;
537 		else if (arpacont_p(ctx->inbuf.text))
538 			done = 0;
539 		else {
540 			/* XXX Doesn't FTP do this sometimes? Is it legal? */
541 			(*ctx->logger)(ctl_error, "%s: no arpa flag (%s)", me,
542 				       ctx->inbuf.text);
543 			error(ctx);
544 			return;
545 		}
546 		(*tran->donefunc)(ctx, tran->uap, ctx->inbuf.text,
547 				  (done ? 0 : CTL_MORE));
548 		ctx->inbuf.used -= ((eos - ctx->inbuf.text) + 1);
549 		if (ctx->inbuf.used == 0U)
550 			ctl_bufput(&ctx->inbuf);
551 		else
552 			memmove(ctx->inbuf.text, eos + 1, ctx->inbuf.used);
553 		if (done) {
554 			UNLINK(ctx->tran, tran, link);
555 			memput(tran, sizeof *tran);
556 			stop_read(ctx);
557 			start_write(ctx);
558 			return;
559 		}
560 		if (allocated_p(ctx->inbuf))
561 			goto again;
562 		return;
563 	}
564 	if (ctx->inbuf.used == (size_t)MAX_LINELEN) {
565 		(*ctx->logger)(ctl_error, "%s: line too long (%-10s...)", me,
566 			       ctx->inbuf.text);
567 		error(ctx);
568 	}
569 }
570 
571 /* Timer related stuff. */
572 
573 static void
574 start_timer(struct ctl_cctx *ctx) {
575 	static const char me[] = "isc/ctl_clnt::start_timer";
576 
577 	REQUIRE(ctx->tiID.opaque == NULL);
578 	if (evSetIdleTimer(ctx->ev, timer, ctx, ctx->timeout, &ctx->tiID) < 0){
579 		(*ctx->logger)(ctl_error, "%s: evSetIdleTimer: %s", me,
580 			       strerror(errno));
581 		error(ctx);
582 		return;
583 	}
584 }
585 
586 static void
587 stop_timer(struct ctl_cctx *ctx) {
588 	static const char me[] = "isc/ctl_clnt::stop_timer";
589 
590 	REQUIRE(ctx->tiID.opaque != NULL);
591 	if (evClearIdleTimer(ctx->ev, ctx->tiID) < 0) {
592 		(*ctx->logger)(ctl_error, "%s: evClearIdleTimer: %s", me,
593 			       strerror(errno));
594 		error(ctx);
595 		return;
596 	}
597 	ctx->tiID.opaque = NULL;
598 }
599 
600 static void
601 touch_timer(struct ctl_cctx *ctx) {
602 	REQUIRE(ctx->tiID.opaque != NULL);
603 
604 	evTouchIdleTimer(ctx->ev, ctx->tiID);
605 }
606 
607 static void
608 timer(evContext ev, void *uap, struct timespec due, struct timespec itv) {
609 	static const char me[] = "isc/ctl_clnt::timer";
610 	struct ctl_cctx *ctx = uap;
611 
612 	UNUSED(ev);
613 	UNUSED(due);
614 	UNUSED(itv);
615 
616 	ctx->tiID.opaque = NULL;
617 	(*ctx->logger)(ctl_error, "%s: timeout after %u seconds while %s", me,
618 		       ctx->timeout.tv_sec, state_names[ctx->state]);
619 	error(ctx);
620 }
621 
622 /*! \file */
623