contrib/dhcp-3.0/omapip/connection.c

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