Annotation of embedaddon/dhcp/omapip/connection.c, revision 1.1
1.1 ! misho 1: /* connection.c
! 2:
! 3: Subroutines for dealing with connections. */
! 4:
! 5: /*
! 6: * Copyright (c) 2009-2010 by Internet Systems Consortium, Inc. ("ISC")
! 7: * Copyright (c) 2004,2007 by Internet Systems Consortium, Inc. ("ISC")
! 8: * Copyright (c) 1999-2003 by Internet Software Consortium
! 9: *
! 10: * Permission to use, copy, modify, and distribute this software for any
! 11: * purpose with or without fee is hereby granted, provided that the above
! 12: * copyright notice and this permission notice appear in all copies.
! 13: *
! 14: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
! 15: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 16: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
! 17: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 18: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 19: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
! 20: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 21: *
! 22: * Internet Systems Consortium, Inc.
! 23: * 950 Charter Street
! 24: * Redwood City, CA 94063
! 25: * <info@isc.org>
! 26: * https://www.isc.org/
! 27: *
! 28: * This software has been written for Internet Systems Consortium
! 29: * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
! 30: * To learn more about Internet Systems Consortium, see
! 31: * ``https://www.isc.org/''. To learn more about Vixie Enterprises,
! 32: * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
! 33: * ``http://www.nominum.com''.
! 34: */
! 35:
! 36: #include "dhcpd.h"
! 37:
! 38: #include <omapip/omapip_p.h>
! 39: #include <arpa/inet.h>
! 40: #include <arpa/nameser.h>
! 41: #include <errno.h>
! 42:
! 43:
! 44: #if defined (TRACING)
! 45: static void trace_connect_input (trace_type_t *, unsigned, char *);
! 46: static void trace_connect_stop (trace_type_t *);
! 47: static void trace_disconnect_input (trace_type_t *, unsigned, char *);
! 48: static void trace_disconnect_stop (trace_type_t *);
! 49: trace_type_t *trace_connect;
! 50: trace_type_t *trace_disconnect;
! 51: extern omapi_array_t *trace_listeners;
! 52: #endif
! 53: static isc_result_t omapi_connection_connect_internal (omapi_object_t *);
! 54:
! 55: OMAPI_OBJECT_ALLOC (omapi_connection,
! 56: omapi_connection_object_t, omapi_type_connection)
! 57:
! 58: isc_result_t omapi_connect (omapi_object_t *c,
! 59: const char *server_name,
! 60: unsigned port)
! 61: {
! 62: struct hostent *he;
! 63: unsigned i, hix;
! 64: omapi_addr_list_t *addrs = (omapi_addr_list_t *)0;
! 65: struct in_addr foo;
! 66: isc_result_t status;
! 67:
! 68: #ifdef DEBUG_PROTOCOL
! 69: log_debug ("omapi_connect(%s, port=%d)", server_name, port);
! 70: #endif
! 71:
! 72: if (!inet_aton (server_name, &foo)) {
! 73: /* If we didn't get a numeric address, try for a domain
! 74: name. It's okay for this call to block. */
! 75: he = gethostbyname (server_name);
! 76: if (!he)
! 77: return ISC_R_HOSTUNKNOWN;
! 78: for (i = 0; he -> h_addr_list [i]; i++)
! 79: ;
! 80: if (i == 0)
! 81: return ISC_R_HOSTUNKNOWN;
! 82: hix = i;
! 83:
! 84: status = omapi_addr_list_new (&addrs, hix, MDL);
! 85: if (status != ISC_R_SUCCESS)
! 86: return status;
! 87: for (i = 0; i < hix; i++) {
! 88: addrs -> addresses [i].addrtype = he -> h_addrtype;
! 89: addrs -> addresses [i].addrlen = he -> h_length;
! 90: memcpy (addrs -> addresses [i].address,
! 91: he -> h_addr_list [i],
! 92: (unsigned)he -> h_length);
! 93: addrs -> addresses [i].port = port;
! 94: }
! 95: } else {
! 96: status = omapi_addr_list_new (&addrs, 1, MDL);
! 97: if (status != ISC_R_SUCCESS)
! 98: return status;
! 99: addrs -> addresses [0].addrtype = AF_INET;
! 100: addrs -> addresses [0].addrlen = sizeof foo;
! 101: memcpy (addrs -> addresses [0].address, &foo, sizeof foo);
! 102: addrs -> addresses [0].port = port;
! 103: hix = 1;
! 104: }
! 105: status = omapi_connect_list (c, addrs, (omapi_addr_t *)0);
! 106: omapi_addr_list_dereference (&addrs, MDL);
! 107: return status;
! 108: }
! 109:
! 110: isc_result_t omapi_connect_list (omapi_object_t *c,
! 111: omapi_addr_list_t *remote_addrs,
! 112: omapi_addr_t *local_addr)
! 113: {
! 114: isc_result_t status;
! 115: omapi_connection_object_t *obj;
! 116: int flag;
! 117: struct sockaddr_in local_sin;
! 118:
! 119: obj = (omapi_connection_object_t *)0;
! 120: status = omapi_connection_allocate (&obj, MDL);
! 121: if (status != ISC_R_SUCCESS)
! 122: return status;
! 123:
! 124: status = omapi_object_reference (&c -> outer, (omapi_object_t *)obj,
! 125: MDL);
! 126: if (status != ISC_R_SUCCESS) {
! 127: omapi_connection_dereference (&obj, MDL);
! 128: return status;
! 129: }
! 130: status = omapi_object_reference (&obj -> inner, c, MDL);
! 131: if (status != ISC_R_SUCCESS) {
! 132: omapi_connection_dereference (&obj, MDL);
! 133: return status;
! 134: }
! 135:
! 136: /* Store the address list on the object. */
! 137: omapi_addr_list_reference (&obj -> connect_list, remote_addrs, MDL);
! 138: obj -> cptr = 0;
! 139: obj -> state = omapi_connection_unconnected;
! 140:
! 141: #if defined (TRACING)
! 142: /* If we're playing back, don't actually try to connect - just leave
! 143: the object available for a subsequent connect or disconnect. */
! 144: if (!trace_playback ()) {
! 145: #endif
! 146: /* Create a socket on which to communicate. */
! 147: obj -> socket =
! 148: socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
! 149: if (obj -> socket < 0) {
! 150: omapi_connection_dereference (&obj, MDL);
! 151: if (errno == EMFILE || errno == ENFILE
! 152: || errno == ENOBUFS)
! 153: return ISC_R_NORESOURCES;
! 154: return ISC_R_UNEXPECTED;
! 155: }
! 156:
! 157: /* Set up the local address, if any. */
! 158: if (local_addr) {
! 159: /* Only do TCPv4 so far. */
! 160: if (local_addr -> addrtype != AF_INET) {
! 161: omapi_connection_dereference (&obj, MDL);
! 162: return ISC_R_INVALIDARG;
! 163: }
! 164: local_sin.sin_port = htons (local_addr -> port);
! 165: memcpy (&local_sin.sin_addr,
! 166: local_addr -> address,
! 167: local_addr -> addrlen);
! 168: #if defined (HAVE_SA_LEN)
! 169: local_sin.sin_len = sizeof local_addr;
! 170: #endif
! 171: local_sin.sin_family = AF_INET;
! 172: memset (&local_sin.sin_zero, 0,
! 173: sizeof local_sin.sin_zero);
! 174:
! 175: if (bind (obj -> socket, (struct sockaddr *)&local_sin,
! 176: sizeof local_sin) < 0) {
! 177: omapi_connection_object_t **objp = &obj;
! 178: omapi_object_t **o = (omapi_object_t **)objp;
! 179: omapi_object_dereference(o, MDL);
! 180: if (errno == EADDRINUSE)
! 181: return ISC_R_ADDRINUSE;
! 182: if (errno == EADDRNOTAVAIL)
! 183: return ISC_R_ADDRNOTAVAIL;
! 184: if (errno == EACCES)
! 185: return ISC_R_NOPERM;
! 186: return ISC_R_UNEXPECTED;
! 187: }
! 188: obj -> local_addr = local_sin;
! 189: }
! 190:
! 191: #if defined(F_SETFD)
! 192: if (fcntl (obj -> socket, F_SETFD, 1) < 0) {
! 193: close (obj -> socket);
! 194: omapi_connection_dereference (&obj, MDL);
! 195: return ISC_R_UNEXPECTED;
! 196: }
! 197: #endif
! 198:
! 199: /* Set the SO_REUSEADDR flag (this should not fail). */
! 200: flag = 1;
! 201: if (setsockopt (obj -> socket, SOL_SOCKET, SO_REUSEADDR,
! 202: (char *)&flag, sizeof flag) < 0) {
! 203: omapi_connection_dereference (&obj, MDL);
! 204: return ISC_R_UNEXPECTED;
! 205: }
! 206:
! 207: /* Set the file to nonblocking mode. */
! 208: if (fcntl (obj -> socket, F_SETFL, O_NONBLOCK) < 0) {
! 209: omapi_connection_dereference (&obj, MDL);
! 210: return ISC_R_UNEXPECTED;
! 211: }
! 212:
! 213: #ifdef SO_NOSIGPIPE
! 214: /*
! 215: * If available stop the OS from killing our
! 216: * program on a SIGPIPE failure
! 217: */
! 218: flag = 1;
! 219: if (setsockopt(obj->socket, SOL_SOCKET, SO_NOSIGPIPE,
! 220: (char *)&flag, sizeof(flag)) < 0) {
! 221: omapi_connection_dereference (&obj, MDL);
! 222: return ISC_R_UNEXPECTED;
! 223: }
! 224: #endif
! 225:
! 226: status = (omapi_register_io_object
! 227: ((omapi_object_t *)obj,
! 228: 0, omapi_connection_writefd,
! 229: 0, omapi_connection_connect,
! 230: omapi_connection_reaper));
! 231: if (status != ISC_R_SUCCESS)
! 232: goto out;
! 233: status = omapi_connection_connect_internal ((omapi_object_t *)
! 234: obj);
! 235: #if defined (TRACING)
! 236: }
! 237: omapi_connection_register (obj, MDL);
! 238: #endif
! 239:
! 240: out:
! 241: omapi_connection_dereference (&obj, MDL);
! 242: return status;
! 243: }
! 244:
! 245: #if defined (TRACING)
! 246: omapi_array_t *omapi_connections;
! 247:
! 248: OMAPI_ARRAY_TYPE(omapi_connection, omapi_connection_object_t)
! 249:
! 250: void omapi_connection_trace_setup (void) {
! 251: trace_connect = trace_type_register ("connect", (void *)0,
! 252: trace_connect_input,
! 253: trace_connect_stop, MDL);
! 254: trace_disconnect = trace_type_register ("disconnect", (void *)0,
! 255: trace_disconnect_input,
! 256: trace_disconnect_stop, MDL);
! 257: }
! 258:
! 259: void omapi_connection_register (omapi_connection_object_t *obj,
! 260: const char *file, int line)
! 261: {
! 262: isc_result_t status;
! 263: trace_iov_t iov [6];
! 264: int iov_count = 0;
! 265: int32_t connect_index, listener_index;
! 266: static int32_t index;
! 267:
! 268: if (!omapi_connections) {
! 269: status = omapi_connection_array_allocate (&omapi_connections,
! 270: file, line);
! 271: if (status != ISC_R_SUCCESS)
! 272: return;
! 273: }
! 274:
! 275: status = omapi_connection_array_extend (omapi_connections, obj,
! 276: (int *)0, file, line);
! 277: if (status != ISC_R_SUCCESS) {
! 278: obj -> index = -1;
! 279: return;
! 280: }
! 281:
! 282: #if defined (TRACING)
! 283: if (trace_record ()) {
! 284: /* Connection registration packet:
! 285:
! 286: int32_t index
! 287: int32_t listener_index [-1 means no listener]
! 288: u_int16_t remote_port
! 289: u_int16_t local_port
! 290: u_int32_t remote_addr
! 291: u_int32_t local_addr */
! 292:
! 293: connect_index = htonl (index);
! 294: index++;
! 295: if (obj -> listener)
! 296: listener_index = htonl (obj -> listener -> index);
! 297: else
! 298: listener_index = htonl (-1);
! 299: iov [iov_count].buf = (char *)&connect_index;
! 300: iov [iov_count++].len = sizeof connect_index;
! 301: iov [iov_count].buf = (char *)&listener_index;
! 302: iov [iov_count++].len = sizeof listener_index;
! 303: iov [iov_count].buf = (char *)&obj -> remote_addr.sin_port;
! 304: iov [iov_count++].len = sizeof obj -> remote_addr.sin_port;
! 305: iov [iov_count].buf = (char *)&obj -> local_addr.sin_port;
! 306: iov [iov_count++].len = sizeof obj -> local_addr.sin_port;
! 307: iov [iov_count].buf = (char *)&obj -> remote_addr.sin_addr;
! 308: iov [iov_count++].len = sizeof obj -> remote_addr.sin_addr;
! 309: iov [iov_count].buf = (char *)&obj -> local_addr.sin_addr;
! 310: iov [iov_count++].len = sizeof obj -> local_addr.sin_addr;
! 311:
! 312: status = trace_write_packet_iov (trace_connect,
! 313: iov_count, iov, file, line);
! 314: }
! 315: #endif
! 316: }
! 317:
! 318: static void trace_connect_input (trace_type_t *ttype,
! 319: unsigned length, char *buf)
! 320: {
! 321: struct sockaddr_in remote, local;
! 322: int32_t connect_index, listener_index;
! 323: char *s = buf;
! 324: omapi_connection_object_t *obj;
! 325: isc_result_t status;
! 326: int i;
! 327:
! 328: if (length != ((sizeof connect_index) +
! 329: (sizeof remote.sin_port) +
! 330: (sizeof remote.sin_addr)) * 2) {
! 331: log_error ("Trace connect: invalid length %d", length);
! 332: return;
! 333: }
! 334:
! 335: memset (&remote, 0, sizeof remote);
! 336: memset (&local, 0, sizeof local);
! 337: memcpy (&connect_index, s, sizeof connect_index);
! 338: s += sizeof connect_index;
! 339: memcpy (&listener_index, s, sizeof listener_index);
! 340: s += sizeof listener_index;
! 341: memcpy (&remote.sin_port, s, sizeof remote.sin_port);
! 342: s += sizeof remote.sin_port;
! 343: memcpy (&local.sin_port, s, sizeof local.sin_port);
! 344: s += sizeof local.sin_port;
! 345: memcpy (&remote.sin_addr, s, sizeof remote.sin_addr);
! 346: s += sizeof remote.sin_addr;
! 347: memcpy (&local.sin_addr, s, sizeof local.sin_addr);
! 348: s += sizeof local.sin_addr;
! 349:
! 350: connect_index = ntohl (connect_index);
! 351: listener_index = ntohl (listener_index);
! 352:
! 353: /* If this was a connect to a listener, then we just slap together
! 354: a new connection. */
! 355: if (listener_index != -1) {
! 356: omapi_listener_object_t *listener;
! 357: listener = (omapi_listener_object_t *)0;
! 358: omapi_array_foreach_begin (trace_listeners,
! 359: omapi_listener_object_t, lp) {
! 360: if (lp -> address.sin_port == local.sin_port) {
! 361: omapi_listener_reference (&listener, lp, MDL);
! 362: omapi_listener_dereference (&lp, MDL);
! 363: break;
! 364: }
! 365: } omapi_array_foreach_end (trace_listeners,
! 366: omapi_listener_object_t, lp);
! 367: if (!listener) {
! 368: log_error ("%s%ld, addr %s, port %d",
! 369: "Spurious traced listener connect - index ",
! 370: (long int)listener_index,
! 371: inet_ntoa (local.sin_addr),
! 372: ntohs (local.sin_port));
! 373: return;
! 374: }
! 375: obj = (omapi_connection_object_t *)0;
! 376: status = omapi_listener_connect (&obj, listener, -1, &remote);
! 377: if (status != ISC_R_SUCCESS) {
! 378: log_error ("traced listener connect: %s",
! 379: isc_result_totext (status));
! 380: }
! 381: if (obj)
! 382: omapi_connection_dereference (&obj, MDL);
! 383: omapi_listener_dereference (&listener, MDL);
! 384: return;
! 385: }
! 386:
! 387: /* Find the matching connect object, if there is one. */
! 388: omapi_array_foreach_begin (omapi_connections,
! 389: omapi_connection_object_t, lp) {
! 390: for (i = 0; (lp -> connect_list &&
! 391: i < lp -> connect_list -> count); i++) {
! 392: if (!memcmp (&remote.sin_addr,
! 393: &lp -> connect_list -> addresses [i].address,
! 394: sizeof remote.sin_addr) &&
! 395: (ntohs (remote.sin_port) ==
! 396: lp -> connect_list -> addresses [i].port))
! 397: lp -> state = omapi_connection_connected;
! 398: lp -> remote_addr = remote;
! 399: lp -> remote_addr.sin_family = AF_INET;
! 400: omapi_addr_list_dereference (&lp -> connect_list, MDL);
! 401: lp -> index = connect_index;
! 402: status = omapi_signal_in ((omapi_object_t *)lp,
! 403: "connect");
! 404: omapi_connection_dereference (&lp, MDL);
! 405: return;
! 406: }
! 407: } omapi_array_foreach_end (omapi_connections,
! 408: omapi_connection_object_t, lp);
! 409:
! 410: log_error ("Spurious traced connect - index %ld, addr %s, port %d",
! 411: (long int)connect_index, inet_ntoa (remote.sin_addr),
! 412: ntohs (remote.sin_port));
! 413: return;
! 414: }
! 415:
! 416: static void trace_connect_stop (trace_type_t *ttype) { }
! 417:
! 418: static void trace_disconnect_input (trace_type_t *ttype,
! 419: unsigned length, char *buf)
! 420: {
! 421: int32_t *index;
! 422: if (length != sizeof *index) {
! 423: log_error ("trace disconnect: wrong length %d", length);
! 424: return;
! 425: }
! 426:
! 427: index = (int32_t *)buf;
! 428:
! 429: omapi_array_foreach_begin (omapi_connections,
! 430: omapi_connection_object_t, lp) {
! 431: if (lp -> index == ntohl (*index)) {
! 432: omapi_disconnect ((omapi_object_t *)lp, 1);
! 433: omapi_connection_dereference (&lp, MDL);
! 434: return;
! 435: }
! 436: } omapi_array_foreach_end (omapi_connections,
! 437: omapi_connection_object_t, lp);
! 438:
! 439: log_error ("trace disconnect: no connection matching index %ld",
! 440: (long int)ntohl (*index));
! 441: }
! 442:
! 443: static void trace_disconnect_stop (trace_type_t *ttype) { }
! 444: #endif
! 445:
! 446: /* Disconnect a connection object from the remote end. If force is nonzero,
! 447: close the connection immediately. Otherwise, shut down the receiving end
! 448: but allow any unsent data to be sent before actually closing the socket. */
! 449:
! 450: isc_result_t omapi_disconnect (omapi_object_t *h,
! 451: int force)
! 452: {
! 453: omapi_connection_object_t *c;
! 454:
! 455: #ifdef DEBUG_PROTOCOL
! 456: log_debug ("omapi_disconnect(%s)", force ? "force" : "");
! 457: #endif
! 458:
! 459: c = (omapi_connection_object_t *)h;
! 460: if (c -> type != omapi_type_connection)
! 461: return ISC_R_INVALIDARG;
! 462:
! 463: #if defined (TRACING)
! 464: if (trace_record ()) {
! 465: isc_result_t status;
! 466: int32_t index;
! 467:
! 468: index = htonl (c -> index);
! 469: status = trace_write_packet (trace_disconnect,
! 470: sizeof index, (char *)&index,
! 471: MDL);
! 472: if (status != ISC_R_SUCCESS) {
! 473: trace_stop ();
! 474: log_error ("trace_write_packet: %s",
! 475: isc_result_totext (status));
! 476: }
! 477: }
! 478: if (!trace_playback ()) {
! 479: #endif
! 480: if (!force) {
! 481: /* If we're already disconnecting, we don't have to do
! 482: anything. */
! 483: if (c -> state == omapi_connection_disconnecting)
! 484: return ISC_R_SUCCESS;
! 485:
! 486: /* Try to shut down the socket - this sends a FIN to
! 487: the remote end, so that it won't send us any more
! 488: data. If the shutdown succeeds, and we still
! 489: have bytes left to write, defer closing the socket
! 490: until that's done. */
! 491: if (!shutdown (c -> socket, SHUT_RD)) {
! 492: if (c -> out_bytes > 0) {
! 493: c -> state =
! 494: omapi_connection_disconnecting;
! 495: return ISC_R_SUCCESS;
! 496: }
! 497: }
! 498: }
! 499: close (c -> socket);
! 500: #if defined (TRACING)
! 501: }
! 502: #endif
! 503: c -> state = omapi_connection_closed;
! 504:
! 505: /* Disconnect from I/O object, if any. */
! 506: if (h -> outer) {
! 507: if (h -> outer -> inner)
! 508: omapi_object_dereference (&h -> outer -> inner, MDL);
! 509: omapi_object_dereference (&h -> outer, MDL);
! 510: }
! 511:
! 512: /* If whatever created us registered a signal handler, send it
! 513: a disconnect signal. */
! 514: omapi_signal (h, "disconnect", h);
! 515:
! 516: /* Disconnect from protocol object, if any. */
! 517: if (h->inner != NULL) {
! 518: if (h->inner->outer != NULL) {
! 519: omapi_object_dereference(&h->inner->outer, MDL);
! 520: }
! 521: omapi_object_dereference(&h->inner, MDL);
! 522: }
! 523:
! 524: /* XXX: the code to free buffers should be in the dereference
! 525: function, but there is no special-purpose function to
! 526: dereference connections, so these just get leaked */
! 527: /* Free any buffers */
! 528: if (c->inbufs != NULL) {
! 529: omapi_buffer_dereference(&c->inbufs, MDL);
! 530: }
! 531: c->in_bytes = 0;
! 532: if (c->outbufs != NULL) {
! 533: omapi_buffer_dereference(&c->outbufs, MDL);
! 534: }
! 535: c->out_bytes = 0;
! 536:
! 537: return ISC_R_SUCCESS;
! 538: }
! 539:
! 540: isc_result_t omapi_connection_require (omapi_object_t *h, unsigned bytes)
! 541: {
! 542: omapi_connection_object_t *c;
! 543:
! 544: if (h -> type != omapi_type_connection)
! 545: return ISC_R_INVALIDARG;
! 546: c = (omapi_connection_object_t *)h;
! 547:
! 548: c -> bytes_needed = bytes;
! 549: if (c -> bytes_needed <= c -> in_bytes) {
! 550: return ISC_R_SUCCESS;
! 551: }
! 552: return ISC_R_NOTYET;
! 553: }
! 554:
! 555: /* Return the socket on which the dispatcher should wait for readiness
! 556: to read, for a connection object. If we already have more bytes than
! 557: we need to do the next thing, and we have at least a single full input
! 558: buffer, then don't indicate that we're ready to read. */
! 559: int omapi_connection_readfd (omapi_object_t *h)
! 560: {
! 561: omapi_connection_object_t *c;
! 562: if (h -> type != omapi_type_connection)
! 563: return -1;
! 564: c = (omapi_connection_object_t *)h;
! 565: if (c -> state != omapi_connection_connected)
! 566: return -1;
! 567: if (c -> in_bytes >= OMAPI_BUF_SIZE - 1 &&
! 568: c -> in_bytes > c -> bytes_needed)
! 569: return -1;
! 570: return c -> socket;
! 571: }
! 572:
! 573: /* Return the socket on which the dispatcher should wait for readiness
! 574: to write, for a connection object. If there are no bytes buffered
! 575: for writing, then don't indicate that we're ready to write. */
! 576: int omapi_connection_writefd (omapi_object_t *h)
! 577: {
! 578: omapi_connection_object_t *c;
! 579: if (h -> type != omapi_type_connection)
! 580: return -1;
! 581: c = (omapi_connection_object_t *)h;
! 582: if (c -> state == omapi_connection_connecting)
! 583: return c -> socket;
! 584: if (c -> out_bytes)
! 585: return c -> socket;
! 586: else
! 587: return -1;
! 588: }
! 589:
! 590: isc_result_t omapi_connection_connect (omapi_object_t *h)
! 591: {
! 592: isc_result_t status;
! 593:
! 594: status = omapi_connection_connect_internal (h);
! 595: if (status != ISC_R_SUCCESS)
! 596: omapi_signal (h, "status", status);
! 597: return ISC_R_SUCCESS;
! 598: }
! 599:
! 600: static isc_result_t omapi_connection_connect_internal (omapi_object_t *h)
! 601: {
! 602: int error;
! 603: omapi_connection_object_t *c;
! 604: socklen_t sl;
! 605: isc_result_t status;
! 606:
! 607: if (h -> type != omapi_type_connection)
! 608: return ISC_R_INVALIDARG;
! 609: c = (omapi_connection_object_t *)h;
! 610:
! 611: if (c -> state == omapi_connection_connecting) {
! 612: sl = sizeof error;
! 613: if (getsockopt (c -> socket, SOL_SOCKET, SO_ERROR,
! 614: (char *)&error, &sl) < 0) {
! 615: omapi_disconnect (h, 1);
! 616: return ISC_R_SUCCESS;
! 617: }
! 618: if (!error)
! 619: c -> state = omapi_connection_connected;
! 620: }
! 621: if (c -> state == omapi_connection_connecting ||
! 622: c -> state == omapi_connection_unconnected) {
! 623: if (c -> cptr >= c -> connect_list -> count) {
! 624: switch (error) {
! 625: case ECONNREFUSED:
! 626: status = ISC_R_CONNREFUSED;
! 627: break;
! 628: case ENETUNREACH:
! 629: status = ISC_R_NETUNREACH;
! 630: break;
! 631: default:
! 632: status = uerr2isc (error);
! 633: break;
! 634: }
! 635: omapi_disconnect (h, 1);
! 636: return status;
! 637: }
! 638:
! 639: if (c -> connect_list -> addresses [c -> cptr].addrtype !=
! 640: AF_INET) {
! 641: omapi_disconnect (h, 1);
! 642: return ISC_R_INVALIDARG;
! 643: }
! 644:
! 645: memcpy (&c -> remote_addr.sin_addr,
! 646: &c -> connect_list -> addresses [c -> cptr].address,
! 647: sizeof c -> remote_addr.sin_addr);
! 648: c -> remote_addr.sin_family = AF_INET;
! 649: c -> remote_addr.sin_port =
! 650: htons (c -> connect_list -> addresses [c -> cptr].port);
! 651: #if defined (HAVE_SA_LEN)
! 652: c -> remote_addr.sin_len = sizeof c -> remote_addr;
! 653: #endif
! 654: memset (&c -> remote_addr.sin_zero, 0,
! 655: sizeof c -> remote_addr.sin_zero);
! 656: ++c -> cptr;
! 657:
! 658: error = connect (c -> socket,
! 659: (struct sockaddr *)&c -> remote_addr,
! 660: sizeof c -> remote_addr);
! 661: if (error < 0) {
! 662: error = errno;
! 663: if (error != EINPROGRESS) {
! 664: omapi_disconnect (h, 1);
! 665: switch (error) {
! 666: case ECONNREFUSED:
! 667: status = ISC_R_CONNREFUSED;
! 668: break;
! 669: case ENETUNREACH:
! 670: status = ISC_R_NETUNREACH;
! 671: break;
! 672: default:
! 673: status = uerr2isc (error);
! 674: break;
! 675: }
! 676: return status;
! 677: }
! 678: c -> state = omapi_connection_connecting;
! 679: return ISC_R_INCOMPLETE;
! 680: }
! 681: c -> state = omapi_connection_connected;
! 682: }
! 683:
! 684: /* I don't know why this would fail, so I'm tempted not to test
! 685: the return value. */
! 686: sl = sizeof (c -> local_addr);
! 687: if (getsockname (c -> socket,
! 688: (struct sockaddr *)&c -> local_addr, &sl) < 0) {
! 689: }
! 690:
! 691: /* Reregister with the I/O object. If we don't already have an
! 692: I/O object this turns into a register call, otherwise we simply
! 693: modify the pointers in the I/O object. */
! 694:
! 695: status = omapi_reregister_io_object (h,
! 696: omapi_connection_readfd,
! 697: omapi_connection_writefd,
! 698: omapi_connection_reader,
! 699: omapi_connection_writer,
! 700: omapi_connection_reaper);
! 701:
! 702: if (status != ISC_R_SUCCESS) {
! 703: omapi_disconnect (h, 1);
! 704: return status;
! 705: }
! 706:
! 707: omapi_signal_in (h, "connect");
! 708: omapi_addr_list_dereference (&c -> connect_list, MDL);
! 709: return ISC_R_SUCCESS;
! 710: }
! 711:
! 712: /* Reaper function for connection - if the connection is completely closed,
! 713: reap it. If it's in the disconnecting state, there were bytes left
! 714: to write when the user closed it, so if there are now no bytes left to
! 715: write, we can close it. */
! 716: isc_result_t omapi_connection_reaper (omapi_object_t *h)
! 717: {
! 718: omapi_connection_object_t *c;
! 719:
! 720: if (h -> type != omapi_type_connection)
! 721: return ISC_R_INVALIDARG;
! 722:
! 723: c = (omapi_connection_object_t *)h;
! 724: if (c -> state == omapi_connection_disconnecting &&
! 725: c -> out_bytes == 0) {
! 726: #ifdef DEBUG_PROTOCOL
! 727: log_debug ("omapi_connection_reaper(): disconnect");
! 728: #endif
! 729: omapi_disconnect (h, 1);
! 730: }
! 731: if (c -> state == omapi_connection_closed) {
! 732: #ifdef DEBUG_PROTOCOL
! 733: log_debug ("omapi_connection_reaper(): closed");
! 734: #endif
! 735: return ISC_R_NOTCONNECTED;
! 736: }
! 737: return ISC_R_SUCCESS;
! 738: }
! 739:
! 740: static isc_result_t make_dst_key (DST_KEY **dst_key, omapi_object_t *a) {
! 741: omapi_value_t *name = (omapi_value_t *)0;
! 742: omapi_value_t *algorithm = (omapi_value_t *)0;
! 743: omapi_value_t *key = (omapi_value_t *)0;
! 744: int algorithm_id = UNKNOWN_KEYALG;
! 745: char *name_str = NULL;
! 746: isc_result_t status = ISC_R_SUCCESS;
! 747:
! 748: if (status == ISC_R_SUCCESS)
! 749: status = omapi_get_value_str
! 750: (a, (omapi_object_t *)0, "name", &name);
! 751:
! 752: if (status == ISC_R_SUCCESS)
! 753: status = omapi_get_value_str
! 754: (a, (omapi_object_t *)0, "algorithm", &algorithm);
! 755:
! 756: if (status == ISC_R_SUCCESS)
! 757: status = omapi_get_value_str
! 758: (a, (omapi_object_t *)0, "key", &key);
! 759:
! 760: if (status == ISC_R_SUCCESS) {
! 761: if ((algorithm -> value -> type == omapi_datatype_data ||
! 762: algorithm -> value -> type == omapi_datatype_string) &&
! 763: strncasecmp ((char *)algorithm -> value -> u.buffer.value,
! 764: NS_TSIG_ALG_HMAC_MD5 ".",
! 765: algorithm -> value -> u.buffer.len) == 0) {
! 766: algorithm_id = KEY_HMAC_MD5;
! 767: } else {
! 768: status = ISC_R_INVALIDARG;
! 769: }
! 770: }
! 771:
! 772: if (status == ISC_R_SUCCESS) {
! 773: name_str = dmalloc (name -> value -> u.buffer.len + 1, MDL);
! 774: if (!name_str)
! 775: status = ISC_R_NOMEMORY;
! 776: }
! 777:
! 778: if (status == ISC_R_SUCCESS) {
! 779: memcpy (name_str,
! 780: name -> value -> u.buffer.value,
! 781: name -> value -> u.buffer.len);
! 782: name_str [name -> value -> u.buffer.len] = 0;
! 783:
! 784: *dst_key = dst_buffer_to_key (name_str, algorithm_id, 0, 0,
! 785: key -> value -> u.buffer.value,
! 786: key -> value -> u.buffer.len);
! 787: if (!*dst_key)
! 788: status = ISC_R_NOMEMORY;
! 789: }
! 790:
! 791: if (name_str)
! 792: dfree (name_str, MDL);
! 793: if (key)
! 794: omapi_value_dereference (&key, MDL);
! 795: if (algorithm)
! 796: omapi_value_dereference (&algorithm, MDL);
! 797: if (name)
! 798: omapi_value_dereference (&name, MDL);
! 799:
! 800: return status;
! 801: }
! 802:
! 803: isc_result_t omapi_connection_sign_data (int mode,
! 804: DST_KEY *key,
! 805: void **context,
! 806: const unsigned char *data,
! 807: const unsigned len,
! 808: omapi_typed_data_t **result)
! 809: {
! 810: omapi_typed_data_t *td = (omapi_typed_data_t *)0;
! 811: isc_result_t status;
! 812: int r;
! 813:
! 814: if (mode & SIG_MODE_FINAL) {
! 815: status = omapi_typed_data_new (MDL, &td,
! 816: omapi_datatype_data,
! 817: dst_sig_size (key));
! 818: if (status != ISC_R_SUCCESS)
! 819: return status;
! 820: }
! 821:
! 822: r = dst_sign_data (mode, key, context, data, len,
! 823: td ? td -> u.buffer.value : (u_char *)0,
! 824: td ? td -> u.buffer.len : 0);
! 825:
! 826: /* dst_sign_data() really should do this for us, shouldn't it? */
! 827: if (mode & SIG_MODE_FINAL)
! 828: *context = (void *)0;
! 829:
! 830: if (r < 0) {
! 831: if (td)
! 832: omapi_typed_data_dereference (&td, MDL);
! 833: return ISC_R_INVALIDKEY;
! 834: }
! 835:
! 836: if (result && td) {
! 837: omapi_typed_data_reference (result, td, MDL);
! 838: }
! 839:
! 840: if (td)
! 841: omapi_typed_data_dereference (&td, MDL);
! 842:
! 843: return ISC_R_SUCCESS;
! 844: }
! 845:
! 846: isc_result_t omapi_connection_output_auth_length (omapi_object_t *h,
! 847: unsigned *l)
! 848: {
! 849: omapi_connection_object_t *c;
! 850:
! 851: if (h -> type != omapi_type_connection)
! 852: return ISC_R_INVALIDARG;
! 853: c = (omapi_connection_object_t *)h;
! 854:
! 855: if (!c -> out_key)
! 856: return ISC_R_NOTFOUND;
! 857:
! 858: *l = dst_sig_size (c -> out_key);
! 859: return ISC_R_SUCCESS;
! 860: }
! 861:
! 862: isc_result_t omapi_connection_set_value (omapi_object_t *h,
! 863: omapi_object_t *id,
! 864: omapi_data_string_t *name,
! 865: omapi_typed_data_t *value)
! 866: {
! 867: omapi_connection_object_t *c;
! 868: isc_result_t status;
! 869:
! 870: if (h -> type != omapi_type_connection)
! 871: return ISC_R_INVALIDARG;
! 872: c = (omapi_connection_object_t *)h;
! 873:
! 874: if (omapi_ds_strcmp (name, "input-authenticator") == 0) {
! 875: if (value && value -> type != omapi_datatype_object)
! 876: return ISC_R_INVALIDARG;
! 877:
! 878: if (c -> in_context) {
! 879: omapi_connection_sign_data (SIG_MODE_FINAL,
! 880: c -> in_key,
! 881: &c -> in_context,
! 882: 0, 0,
! 883: (omapi_typed_data_t **) 0);
! 884: }
! 885:
! 886: if (c -> in_key) {
! 887: dst_free_key (c -> in_key);
! 888: c -> in_key = (DST_KEY *)0;
! 889: }
! 890:
! 891: if (value) {
! 892: status = make_dst_key (&c -> in_key,
! 893: value -> u.object);
! 894: if (status != ISC_R_SUCCESS)
! 895: return status;
! 896: }
! 897:
! 898: return ISC_R_SUCCESS;
! 899: }
! 900: else if (omapi_ds_strcmp (name, "output-authenticator") == 0) {
! 901: if (value && value -> type != omapi_datatype_object)
! 902: return ISC_R_INVALIDARG;
! 903:
! 904: if (c -> out_context) {
! 905: omapi_connection_sign_data (SIG_MODE_FINAL,
! 906: c -> out_key,
! 907: &c -> out_context,
! 908: 0, 0,
! 909: (omapi_typed_data_t **) 0);
! 910: }
! 911:
! 912: if (c -> out_key) {
! 913: dst_free_key (c -> out_key);
! 914: c -> out_key = (DST_KEY *)0;
! 915: }
! 916:
! 917: if (value) {
! 918: status = make_dst_key (&c -> out_key,
! 919: value -> u.object);
! 920: if (status != ISC_R_SUCCESS)
! 921: return status;
! 922: }
! 923:
! 924: return ISC_R_SUCCESS;
! 925: }
! 926:
! 927: if (h -> inner && h -> inner -> type -> set_value)
! 928: return (*(h -> inner -> type -> set_value))
! 929: (h -> inner, id, name, value);
! 930: return ISC_R_NOTFOUND;
! 931: }
! 932:
! 933: isc_result_t omapi_connection_get_value (omapi_object_t *h,
! 934: omapi_object_t *id,
! 935: omapi_data_string_t *name,
! 936: omapi_value_t **value)
! 937: {
! 938: omapi_connection_object_t *c;
! 939: omapi_typed_data_t *td = (omapi_typed_data_t *)0;
! 940: isc_result_t status;
! 941:
! 942: if (h -> type != omapi_type_connection)
! 943: return ISC_R_INVALIDARG;
! 944: c = (omapi_connection_object_t *)h;
! 945:
! 946: if (omapi_ds_strcmp (name, "input-signature") == 0) {
! 947: if (!c -> in_key || !c -> in_context)
! 948: return ISC_R_NOTFOUND;
! 949:
! 950: status = omapi_connection_sign_data (SIG_MODE_FINAL,
! 951: c -> in_key,
! 952: &c -> in_context,
! 953: 0, 0, &td);
! 954: if (status != ISC_R_SUCCESS)
! 955: return status;
! 956:
! 957: status = omapi_make_value (value, name, td, MDL);
! 958: omapi_typed_data_dereference (&td, MDL);
! 959: return status;
! 960:
! 961: } else if (omapi_ds_strcmp (name, "input-signature-size") == 0) {
! 962: if (!c -> in_key)
! 963: return ISC_R_NOTFOUND;
! 964:
! 965: return omapi_make_int_value (value, name,
! 966: dst_sig_size (c -> in_key), MDL);
! 967:
! 968: } else if (omapi_ds_strcmp (name, "output-signature") == 0) {
! 969: if (!c -> out_key || !c -> out_context)
! 970: return ISC_R_NOTFOUND;
! 971:
! 972: status = omapi_connection_sign_data (SIG_MODE_FINAL,
! 973: c -> out_key,
! 974: &c -> out_context,
! 975: 0, 0, &td);
! 976: if (status != ISC_R_SUCCESS)
! 977: return status;
! 978:
! 979: status = omapi_make_value (value, name, td, MDL);
! 980: omapi_typed_data_dereference (&td, MDL);
! 981: return status;
! 982:
! 983: } else if (omapi_ds_strcmp (name, "output-signature-size") == 0) {
! 984: if (!c -> out_key)
! 985: return ISC_R_NOTFOUND;
! 986:
! 987: return omapi_make_int_value (value, name,
! 988: dst_sig_size (c -> out_key), MDL);
! 989: }
! 990:
! 991: if (h -> inner && h -> inner -> type -> get_value)
! 992: return (*(h -> inner -> type -> get_value))
! 993: (h -> inner, id, name, value);
! 994: return ISC_R_NOTFOUND;
! 995: }
! 996:
! 997: isc_result_t omapi_connection_destroy (omapi_object_t *h,
! 998: const char *file, int line)
! 999: {
! 1000: omapi_connection_object_t *c;
! 1001:
! 1002: #ifdef DEBUG_PROTOCOL
! 1003: log_debug ("omapi_connection_destroy()");
! 1004: #endif
! 1005:
! 1006: if (h -> type != omapi_type_connection)
! 1007: return ISC_R_UNEXPECTED;
! 1008: c = (omapi_connection_object_t *)(h);
! 1009: if (c -> state == omapi_connection_connected)
! 1010: omapi_disconnect (h, 1);
! 1011: if (c -> listener)
! 1012: omapi_listener_dereference (&c -> listener, file, line);
! 1013: if (c -> connect_list)
! 1014: omapi_addr_list_dereference (&c -> connect_list, file, line);
! 1015: return ISC_R_SUCCESS;
! 1016: }
! 1017:
! 1018: isc_result_t omapi_connection_signal_handler (omapi_object_t *h,
! 1019: const char *name, va_list ap)
! 1020: {
! 1021: if (h -> type != omapi_type_connection)
! 1022: return ISC_R_INVALIDARG;
! 1023:
! 1024: #ifdef DEBUG_PROTOCOL
! 1025: log_debug ("omapi_connection_signal_handler(%s)", name);
! 1026: #endif
! 1027:
! 1028: if (h -> inner && h -> inner -> type -> signal_handler)
! 1029: return (*(h -> inner -> type -> signal_handler)) (h -> inner,
! 1030: name, ap);
! 1031: return ISC_R_NOTFOUND;
! 1032: }
! 1033:
! 1034: /* Write all the published values associated with the object through the
! 1035: specified connection. */
! 1036:
! 1037: isc_result_t omapi_connection_stuff_values (omapi_object_t *c,
! 1038: omapi_object_t *id,
! 1039: omapi_object_t *m)
! 1040: {
! 1041: if (m -> type != omapi_type_connection)
! 1042: return ISC_R_INVALIDARG;
! 1043:
! 1044: if (m -> inner && m -> inner -> type -> stuff_values)
! 1045: return (*(m -> inner -> type -> stuff_values)) (c, id,
! 1046: m -> inner);
! 1047: return ISC_R_SUCCESS;
! 1048: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to connection.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / omapip