1 /* $NetBSD: ctl_clnt.c,v 1.1.1.2 2012/09/09 16:08:03 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
Indexes created Thu Jun 11 00:25:07 UTC 2026