Annotation of embedaddon/dhcp/omapip/protocol.c, revision 1.1
1.1 ! misho 1: /* protocol.c
! 2:
! 3: Functions supporting the object management protocol... */
! 4:
! 5: /*
! 6: * Copyright (c) 2004-2007,2009 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: * https://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: * ``https://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 "dhcpd.h"
! 36:
! 37: #include <omapip/omapip_p.h>
! 38:
! 39: OMAPI_OBJECT_ALLOC (omapi_protocol, omapi_protocol_object_t,
! 40: omapi_type_protocol)
! 41: OMAPI_OBJECT_ALLOC (omapi_protocol_listener, omapi_protocol_listener_object_t,
! 42: omapi_type_protocol_listener)
! 43:
! 44: isc_result_t omapi_protocol_connect (omapi_object_t *h,
! 45: const char *server_name,
! 46: unsigned port,
! 47: omapi_object_t *a)
! 48: {
! 49: isc_result_t rstatus, status;
! 50: omapi_protocol_object_t *obj;
! 51:
! 52: #ifdef DEBUG_PROTOCOL
! 53: log_debug ("omapi_protocol_connect(%s port=%d)", server_name, port);
! 54: #endif
! 55:
! 56: obj = (omapi_protocol_object_t *)0;
! 57: status = omapi_protocol_allocate (&obj, MDL);
! 58: if (status != ISC_R_SUCCESS)
! 59: return status;
! 60:
! 61: rstatus = omapi_connect ((omapi_object_t *)obj, server_name, port);
! 62: if (rstatus != ISC_R_SUCCESS && rstatus != ISC_R_INCOMPLETE) {
! 63: omapi_protocol_dereference (&obj, MDL);
! 64: return rstatus;
! 65: }
! 66: status = omapi_object_reference (&h -> outer,
! 67: (omapi_object_t *)obj, MDL);
! 68: if (status != ISC_R_SUCCESS) {
! 69: omapi_protocol_dereference (&obj, MDL);
! 70: return status;
! 71: }
! 72: status = omapi_object_reference (&obj -> inner, h, MDL);
! 73: if (status != ISC_R_SUCCESS) {
! 74: omapi_protocol_dereference (&obj, MDL);
! 75: return status;
! 76: }
! 77:
! 78: /* If we were passed a default authenticator, store it now. We'll
! 79: open it once we're connected. */
! 80: if (a) {
! 81: obj -> default_auth =
! 82: dmalloc (sizeof(omapi_remote_auth_t), MDL);
! 83: if (!obj -> default_auth) {
! 84: omapi_protocol_dereference (&obj, MDL);
! 85: return ISC_R_NOMEMORY;
! 86: }
! 87:
! 88: obj -> default_auth -> next = (omapi_remote_auth_t *)0;
! 89: status = omapi_object_reference (&obj -> default_auth -> a,
! 90: a, MDL);
! 91: if (status != ISC_R_SUCCESS) {
! 92: dfree (obj -> default_auth, MDL);
! 93: omapi_protocol_dereference (&obj, MDL);
! 94: return status;
! 95: }
! 96:
! 97: obj -> insecure = 0;
! 98: rstatus = ISC_R_INCOMPLETE;
! 99: } else {
! 100: obj -> insecure = 1;
! 101: #if 0
! 102: status = ISC_R_SUCCESS;
! 103: #endif
! 104: }
! 105:
! 106: omapi_protocol_dereference (&obj, MDL);
! 107: return rstatus;
! 108: }
! 109:
! 110: /* Send the protocol introduction message. */
! 111: isc_result_t omapi_protocol_send_intro (omapi_object_t *h,
! 112: unsigned ver,
! 113: unsigned hsize)
! 114: {
! 115: isc_result_t status;
! 116: omapi_protocol_object_t *p;
! 117:
! 118: #ifdef DEBUG_PROTOCOL
! 119: log_debug ("omapi_protocol_send_intro()");
! 120: #endif
! 121:
! 122: if (h -> type != omapi_type_protocol)
! 123: return ISC_R_INVALIDARG;
! 124: p = (omapi_protocol_object_t *)h;
! 125:
! 126: if (!h -> outer || h -> outer -> type != omapi_type_connection)
! 127: return ISC_R_NOTCONNECTED;
! 128:
! 129: status = omapi_connection_put_uint32 (h -> outer, ver);
! 130: if (status != ISC_R_SUCCESS)
! 131: return status;
! 132:
! 133: status = omapi_connection_put_uint32 (h -> outer, hsize);
! 134:
! 135: if (status != ISC_R_SUCCESS)
! 136: return status;
! 137:
! 138: /* Require the other end to send an intro - this kicks off the
! 139: protocol input state machine. */
! 140: p -> state = omapi_protocol_intro_wait;
! 141: status = omapi_connection_require (h -> outer, 8);
! 142: if (status != ISC_R_SUCCESS && status != ISC_R_NOTYET)
! 143: return status;
! 144:
! 145: /* Make up an initial transaction ID for this connection. */
! 146: p -> next_xid = random ();
! 147: return ISC_R_SUCCESS;
! 148: }
! 149:
! 150: #ifdef DEBUG_PROTOCOL
! 151: extern const char *omapi_message_op_name(int);
! 152: #endif /* DEBUG_PROTOCOL */
! 153:
! 154: isc_result_t omapi_protocol_send_message (omapi_object_t *po,
! 155: omapi_object_t *id,
! 156: omapi_object_t *mo,
! 157: omapi_object_t *omo)
! 158: {
! 159: omapi_protocol_object_t *p;
! 160: omapi_object_t *c;
! 161: omapi_message_object_t *m, *om;
! 162: omapi_remote_auth_t *ra;
! 163: omapi_value_t *signature;
! 164: isc_result_t status;
! 165: unsigned auth_len;
! 166:
! 167: if (po -> type != omapi_type_protocol ||
! 168: !po -> outer || po -> outer -> type != omapi_type_connection ||
! 169: mo -> type != omapi_type_message)
! 170: return ISC_R_INVALIDARG;
! 171: if (omo && omo -> type != omapi_type_message)
! 172: return ISC_R_INVALIDARG;
! 173: p = (omapi_protocol_object_t *)po;
! 174: c = (omapi_object_t *)(po -> outer);
! 175: m = (omapi_message_object_t *)mo;
! 176: om = (omapi_message_object_t *)omo;
! 177:
! 178: #ifdef DEBUG_PROTOCOL
! 179: log_debug ("omapi_protocol_send_message(): "
! 180: "op=%s handle=%#lx id=%#lx rid=%#lx",
! 181: omapi_message_op_name (m->op),
! 182: (long)(m -> object ? m -> object -> handle : m -> handle),
! 183: (long)p -> next_xid, (long)m -> rid);
! 184: #endif
! 185:
! 186: /* Find the authid to use for this message. */
! 187: if (id) {
! 188: for (ra = p -> remote_auth_list; ra; ra = ra -> next) {
! 189: if (ra -> a == id) {
! 190: break;
! 191: }
! 192: }
! 193:
! 194: if (!ra)
! 195: return ISC_R_KEY_UNKNOWN;
! 196: } else if (p -> remote_auth_list) {
! 197: ra = p -> default_auth;
! 198: } else {
! 199: ra = (omapi_remote_auth_t *)0;
! 200: }
! 201:
! 202: if (ra) {
! 203: m -> authid = ra -> remote_handle;
! 204: status = omapi_object_reference (&m -> id_object,
! 205: ra -> a, MDL);
! 206: if (status != ISC_R_SUCCESS)
! 207: return status;
! 208: }
! 209:
! 210: /* Write the ID of the authentication key we're using. */
! 211: status = omapi_connection_put_uint32 (c, ra ? ra -> remote_handle : 0);
! 212: if (status != ISC_R_SUCCESS) {
! 213: omapi_disconnect (c, 1);
! 214: return status;
! 215: }
! 216:
! 217: /* Activate the authentication key on the connection. */
! 218: auth_len = 0;
! 219: if (ra) {
! 220: status = omapi_set_object_value (c, (omapi_object_t *)0,
! 221: "output-authenticator",
! 222: ra -> a);
! 223: if (status != ISC_R_SUCCESS) {
! 224: omapi_disconnect (c, 1);
! 225: return status;
! 226: }
! 227:
! 228: status = omapi_connection_output_auth_length (c, &auth_len);
! 229: if (status != ISC_R_SUCCESS) {
! 230: omapi_disconnect (c, 1);
! 231: return status;
! 232: }
! 233: }
! 234:
! 235: /* Write the authenticator length */
! 236: status = omapi_connection_put_uint32 (c, auth_len);
! 237: if (status != ISC_R_SUCCESS) {
! 238: omapi_disconnect (c, 1);
! 239: return status;
! 240: }
! 241:
! 242: /* Write the opcode. */
! 243: status = omapi_connection_put_uint32 (c, m -> op);
! 244: if (status != ISC_R_SUCCESS) {
! 245: omapi_disconnect (c, 1);
! 246: return status;
! 247: }
! 248:
! 249: /* Write the handle. If we've been given an explicit handle, use
! 250: that. Otherwise, use the handle of the object we're sending.
! 251: The caller is responsible for arranging for one of these handles
! 252: to be set (or not). */
! 253: status = omapi_connection_put_uint32 (c, (m -> h
! 254: ? m -> h
! 255: : (m -> object
! 256: ? m -> object -> handle
! 257: : 0)));
! 258: if (status != ISC_R_SUCCESS) {
! 259: omapi_disconnect (c, 1);
! 260: return status;
! 261: }
! 262:
! 263: /* Set and write the transaction ID. */
! 264: m -> id = p -> next_xid++;
! 265: status = omapi_connection_put_uint32 (c, m -> id);
! 266: if (status != ISC_R_SUCCESS) {
! 267: omapi_disconnect (c, 1);
! 268: return status;
! 269: }
! 270:
! 271: /* Write the transaction ID of the message to which this is a
! 272: response, if there is such a message. */
! 273: status = omapi_connection_put_uint32 (c, om ? om -> id : m -> rid);
! 274: if (status != ISC_R_SUCCESS) {
! 275: omapi_disconnect (c, 1);
! 276: return status;
! 277: }
! 278:
! 279: /* Stuff out the name/value pairs specific to this message. */
! 280: status = omapi_stuff_values (c, id, (omapi_object_t *)m);
! 281: if (status != ISC_R_SUCCESS) {
! 282: omapi_disconnect (c, 1);
! 283: return status;
! 284: }
! 285:
! 286: /* Write the zero-length name that terminates the list of name/value
! 287: pairs specific to the message. */
! 288: status = omapi_connection_put_uint16 (c, 0);
! 289: if (status != ISC_R_SUCCESS) {
! 290: omapi_disconnect (c, 1);
! 291: return status;
! 292: }
! 293:
! 294: /* Stuff out all the published name/value pairs in the object that's
! 295: being sent in the message, if there is one. */
! 296: if (m -> object) {
! 297: status = omapi_stuff_values (c, id, m -> object);
! 298: if (status != ISC_R_SUCCESS) {
! 299: omapi_disconnect (c, 1);
! 300: return status;
! 301: }
! 302: }
! 303:
! 304: /* Write the zero-length name that terminates the list of name/value
! 305: pairs for the associated object. */
! 306: status = omapi_connection_put_uint16 (c, 0);
! 307: if (status != ISC_R_SUCCESS) {
! 308: omapi_disconnect (c, 1);
! 309: return status;
! 310: }
! 311:
! 312: if (ra) {
! 313: /* Calculate the message signature. */
! 314: signature = (omapi_value_t *)0;
! 315: status = omapi_get_value_str (c, (omapi_object_t *)0,
! 316: "output-signature", &signature);
! 317: if (status != ISC_R_SUCCESS) {
! 318: omapi_disconnect (c, 1);
! 319: return status;
! 320: }
! 321:
! 322: /* Write the authenticator... */
! 323: status = (omapi_connection_copyin
! 324: (c, signature -> value -> u.buffer.value,
! 325: signature -> value -> u.buffer.len));
! 326: omapi_value_dereference (&signature, MDL);
! 327: if (status != ISC_R_SUCCESS) {
! 328: omapi_disconnect (c, 1);
! 329: return status;
! 330: }
! 331:
! 332: /* Dectivate the authentication key on the connection. */
! 333: status = omapi_set_value_str (c, (omapi_object_t *)0,
! 334: "output-authenticator",
! 335: (omapi_typed_data_t *)0);
! 336: if (status != ISC_R_SUCCESS) {
! 337: omapi_disconnect (c, 1);
! 338: return status;
! 339: }
! 340: }
! 341:
! 342: if (!omo) {
! 343: omapi_protocol_reference (&m -> protocol_object, p, MDL);
! 344: }
! 345: return ISC_R_SUCCESS;
! 346: }
! 347:
! 348:
! 349: isc_result_t omapi_protocol_signal_handler (omapi_object_t *h,
! 350: const char *name, va_list ap)
! 351: {
! 352: isc_result_t status;
! 353: omapi_protocol_object_t *p;
! 354: omapi_object_t *c;
! 355: omapi_message_object_t *m;
! 356: omapi_value_t *signature;
! 357: u_int16_t nlen;
! 358: u_int32_t vlen;
! 359: u_int32_t th;
! 360: #if defined (DEBUG_MEMORY_LEAKAGE)
! 361: unsigned long previous_outstanding = 0xDEADBEEF;
! 362: unsigned long connect_outstanding = 0xDEADBEEF;
! 363: #endif
! 364:
! 365: if (h -> type != omapi_type_protocol) {
! 366: /* XXX shouldn't happen. Put an assert here? */
! 367: return ISC_R_UNEXPECTED;
! 368: }
! 369: p = (omapi_protocol_object_t *)h;
! 370:
! 371: if (!strcmp (name, "connect")) {
! 372: #if defined (DEBUG_MEMORY_LEAKAGE)
! 373: connect_outstanding = dmalloc_outstanding;
! 374: #endif
! 375: /* Send the introductory message. */
! 376: status = omapi_protocol_send_intro
! 377: (h, OMAPI_PROTOCOL_VERSION,
! 378: sizeof (omapi_protocol_header_t));
! 379: if (status != ISC_R_SUCCESS) {
! 380: omapi_disconnect (p -> outer, 1);
! 381: return status;
! 382: }
! 383: return ISC_R_SUCCESS;
! 384: }
! 385:
! 386: /* Should only receive these when opening the initial authenticator. */
! 387: if (!strcmp (name, "status")) {
! 388: status = va_arg (ap, isc_result_t);
! 389: if (status != ISC_R_SUCCESS) {
! 390: omapi_signal_in (h -> inner, "status", status,
! 391: (omapi_object_t *)0);
! 392: omapi_disconnect (p -> outer, 1);
! 393: return status;
! 394: } else {
! 395: return omapi_signal_in (h -> inner, "ready");
! 396: }
! 397: }
! 398:
! 399: /* If we get a disconnect, dump memory usage. */
! 400: if (!strcmp (name, "disconnect")) {
! 401: #if defined (DEBUG_MEMORY_LEAKAGE)
! 402: if (connect_outstanding != 0xDEADBEEF) {
! 403: log_info ("generation %ld: %ld new, %ld outstanding, %ld%s",
! 404: dmalloc_generation,
! 405: dmalloc_outstanding - previous_outstanding,
! 406: dmalloc_outstanding, dmalloc_longterm, " long-term");
! 407: }
! 408: #endif
! 409: #if defined (DEBUG_MEMORY_LEAKAGE)
! 410: dmalloc_dump_outstanding ();
! 411: #endif
! 412: #if defined (DEBUG_RC_HISTORY_EXHAUSTIVELY)
! 413: dump_rc_history (h);
! 414: #endif
! 415: for (m = omapi_registered_messages; m; m = m -> next) {
! 416: if (m -> protocol_object == p) {
! 417: if (m -> object)
! 418: omapi_signal (m -> object, "disconnect");
! 419: }
! 420: }
! 421:
! 422: /* XXX */
! 423: return ISC_R_SUCCESS;
! 424: }
! 425:
! 426: /* Not a signal we recognize? */
! 427: if (strcmp (name, "ready")) {
! 428: if (p -> inner && p -> inner -> type -> signal_handler)
! 429: return (*(p -> inner -> type -> signal_handler)) (h,
! 430: name,
! 431: ap);
! 432: return ISC_R_NOTFOUND;
! 433: }
! 434:
! 435: if (!p -> outer || p -> outer -> type != omapi_type_connection)
! 436: return ISC_R_INVALIDARG;
! 437: c = p -> outer;
! 438:
! 439: /* We get here because we requested that we be woken up after
! 440: some number of bytes were read, and that number of bytes
! 441: has in fact been read. */
! 442: switch (p -> state) {
! 443: case omapi_protocol_intro_wait:
! 444: /* Get protocol version and header size in network
! 445: byte order. */
! 446: omapi_connection_get_uint32 (c, &p -> protocol_version);
! 447: omapi_connection_get_uint32 (c, &p -> header_size);
! 448:
! 449: /* We currently only support the current protocol version. */
! 450: if (p -> protocol_version != OMAPI_PROTOCOL_VERSION) {
! 451: omapi_disconnect (c, 1);
! 452: return ISC_R_VERSIONMISMATCH;
! 453: }
! 454:
! 455: if (p -> header_size < sizeof (omapi_protocol_header_t)) {
! 456: omapi_disconnect (c, 1);
! 457: return ISC_R_PROTOCOLERROR;
! 458: }
! 459:
! 460: if (p -> default_auth) {
! 461: status = omapi_protocol_send_open
! 462: (h, (omapi_object_t *)0, "authenticator",
! 463: p -> default_auth -> a,
! 464: OMAPI_NOTIFY_PROTOCOL);
! 465: if (status != ISC_R_SUCCESS) {
! 466: omapi_disconnect (c, 1);
! 467: return status;
! 468: }
! 469: } else {
! 470: status = omapi_signal_in (h -> inner, "ready");
! 471: }
! 472:
! 473: to_header_wait:
! 474: /* The next thing we're expecting is a message header. */
! 475: p -> state = omapi_protocol_header_wait;
! 476:
! 477: /* Register a need for the number of bytes in a
! 478: header, and if we already have that many, process
! 479: them immediately. */
! 480: if ((omapi_connection_require (c, p -> header_size)) !=
! 481: ISC_R_SUCCESS)
! 482: break;
! 483: /* If we already have the data, fall through. */
! 484:
! 485: case omapi_protocol_header_wait:
! 486: #if defined (DEBUG_MEMORY_LEAKAGE)
! 487: if (previous_outstanding != 0xDEADBEEF) {
! 488: log_info ("%s %ld: %ld new, %ld outstanding, %ld%s",
! 489: "generation", dmalloc_generation,
! 490: dmalloc_outstanding - previous_outstanding,
! 491: dmalloc_outstanding, dmalloc_longterm,
! 492: " long-term");
! 493: #endif
! 494: #if (defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL))
! 495: dmalloc_dump_outstanding ();
! 496: #endif
! 497: #if defined (DEBUG_RC_HISTORY_EXHAUSTIVELY)
! 498: dump_rc_history (h);
! 499: #endif
! 500: #if defined (DEBUG_MEMORY_LEAKAGE)
! 501: }
! 502: previous_outstanding = dmalloc_outstanding;
! 503: #endif
! 504: status = omapi_message_new ((omapi_object_t **)&p -> message,
! 505: MDL);
! 506: if (status != ISC_R_SUCCESS) {
! 507: omapi_disconnect (c, 1);
! 508: return status;
! 509: }
! 510:
! 511: p -> verify_result = ISC_R_SUCCESS;
! 512:
! 513: /* Swap in the header... */
! 514: omapi_connection_get_uint32 (c, &p -> message -> authid);
! 515:
! 516: /* Bind the authenticator to the message object. */
! 517: if (p -> message -> authid) {
! 518: status = (omapi_protocol_lookup_auth
! 519: (&p -> message -> id_object, h,
! 520: p -> message -> authid));
! 521: if (status != ISC_R_SUCCESS)
! 522: p -> verify_result = status;
! 523:
! 524: /* Activate the authentication key. */
! 525: status = omapi_set_object_value
! 526: (c, (omapi_object_t *)0, "input-authenticator",
! 527: p -> message -> id_object);
! 528: if (status != ISC_R_SUCCESS) {
! 529: omapi_disconnect (c, 1);
! 530: return status;
! 531: }
! 532: }
! 533:
! 534: omapi_connection_get_uint32 (c, &p -> message -> authlen);
! 535: omapi_connection_get_uint32 (c, &p -> message -> op);
! 536: omapi_connection_get_uint32 (c, &th);
! 537: p -> message -> h = th;
! 538: omapi_connection_get_uint32 (c, &p -> message -> id);
! 539: omapi_connection_get_uint32 (c, &p -> message -> rid);
! 540:
! 541: /* If there was any extra header data, skip over it. */
! 542: if (p -> header_size > sizeof (omapi_protocol_header_t)) {
! 543: omapi_connection_copyout
! 544: (0, c, (p -> header_size -
! 545: sizeof (omapi_protocol_header_t)));
! 546: }
! 547:
! 548: /* XXX must compute partial signature across the
! 549: XXX preceding bytes. Also, if authenticator
! 550: specifies encryption as well as signing, we may
! 551: have to decrypt the data on the way in. */
! 552:
! 553: /* First we read in message-specific values, then object
! 554: values. */
! 555: p -> reading_message_values = 1;
! 556:
! 557: need_name_length:
! 558: /* The next thing we're expecting is length of the
! 559: first name. */
! 560: p -> state = omapi_protocol_name_length_wait;
! 561:
! 562: /* Wait for a 16-bit length. */
! 563: if ((omapi_connection_require (c, 2)) != ISC_R_SUCCESS)
! 564: break;
! 565: /* If it's already here, fall through. */
! 566:
! 567: case omapi_protocol_name_length_wait:
! 568: omapi_connection_get_uint16 (c, &nlen);
! 569: /* A zero-length name means that we're done reading name+value
! 570: pairs. */
! 571: if (nlen == 0) {
! 572: /* If we've already read in the object, we are
! 573: done reading the message, but if we've just
! 574: finished reading in the values associated
! 575: with the message, we need to read the
! 576: object. */
! 577: if (p -> reading_message_values) {
! 578: p -> reading_message_values = 0;
! 579: goto need_name_length;
! 580: }
! 581:
! 582: /* If the authenticator length is zero, there's no
! 583: signature to read in, so go straight to processing
! 584: the message. */
! 585: if (p -> message -> authlen == 0)
! 586: goto message_done;
! 587:
! 588: /* The next thing we're expecting is the
! 589: message signature. */
! 590: p -> state = omapi_protocol_signature_wait;
! 591:
! 592: /* Wait for the number of bytes specified for
! 593: the authenticator. If we already have it,
! 594: go read it in. */
! 595: if (omapi_connection_require
! 596: (c, p -> message -> authlen) == ISC_R_SUCCESS)
! 597: goto signature_wait;
! 598: break;
! 599: }
! 600:
! 601: /* Allocate a buffer for the name. */
! 602: status = (omapi_data_string_new (&p -> name, nlen, MDL));
! 603: if (status != ISC_R_SUCCESS) {
! 604: omapi_disconnect (c, 1);
! 605: return ISC_R_NOMEMORY;
! 606: }
! 607: p -> state = omapi_protocol_name_wait;
! 608: if (omapi_connection_require (c, nlen) != ISC_R_SUCCESS)
! 609: break;
! 610: /* If it's already here, fall through. */
! 611:
! 612: case omapi_protocol_name_wait:
! 613: omapi_connection_copyout (p -> name -> value, c,
! 614: p -> name -> len);
! 615: /* Wait for a 32-bit length. */
! 616: p -> state = omapi_protocol_value_length_wait;
! 617: if ((omapi_connection_require (c, 4)) != ISC_R_SUCCESS)
! 618: break;
! 619: /* If it's already here, fall through. */
! 620:
! 621: case omapi_protocol_value_length_wait:
! 622: omapi_connection_get_uint32 (c, &vlen);
! 623:
! 624: /* Zero-length values are allowed - if we get one, we
! 625: don't have to read any data for the value - just
! 626: get the next one, if there is a next one. */
! 627: if (!vlen)
! 628: goto insert_new_value;
! 629:
! 630: status = omapi_typed_data_new (MDL, &p -> value,
! 631: omapi_datatype_data,
! 632: vlen);
! 633: if (status != ISC_R_SUCCESS) {
! 634: omapi_disconnect (c, 1);
! 635: return ISC_R_NOMEMORY;
! 636: }
! 637:
! 638: p -> state = omapi_protocol_value_wait;
! 639: if (omapi_connection_require (c, vlen) != ISC_R_SUCCESS)
! 640: break;
! 641: /* If it's already here, fall through. */
! 642:
! 643: case omapi_protocol_value_wait:
! 644: omapi_connection_copyout (p -> value -> u.buffer.value, c,
! 645: p -> value -> u.buffer.len);
! 646:
! 647: insert_new_value:
! 648: if (p -> reading_message_values) {
! 649: status = (omapi_set_value
! 650: ((omapi_object_t *)p -> message,
! 651: p -> message -> id_object,
! 652: p -> name, p -> value));
! 653: } else {
! 654: if (!p -> message -> object) {
! 655: /* We need a generic object to hang off of the
! 656: incoming message. */
! 657: status = (omapi_generic_new
! 658: (&p -> message -> object, MDL));
! 659: if (status != ISC_R_SUCCESS) {
! 660: omapi_disconnect (c, 1);
! 661: return status;
! 662: }
! 663: }
! 664: status = (omapi_set_value
! 665: ((omapi_object_t *)p -> message -> object,
! 666: p -> message -> id_object,
! 667: p -> name, p -> value));
! 668: }
! 669: if (status != ISC_R_SUCCESS) {
! 670: omapi_disconnect (c, 1);
! 671: return status;
! 672: }
! 673: omapi_data_string_dereference (&p -> name, MDL);
! 674: if (p -> value)
! 675: omapi_typed_data_dereference (&p -> value, MDL);
! 676: goto need_name_length;
! 677:
! 678: signature_wait:
! 679: case omapi_protocol_signature_wait:
! 680: if (p -> message -> id_object) {
! 681: /* Compute the signature of the message. */
! 682: signature = (omapi_value_t *)0;
! 683: status = omapi_get_value_str (c, (omapi_object_t *)0,
! 684: "input-signature",
! 685: &signature);
! 686: if (status != ISC_R_SUCCESS) {
! 687: omapi_disconnect (c, 1);
! 688: return status;
! 689: }
! 690:
! 691: /* Disable the authentication key on the connection. */
! 692: status = omapi_set_value_str (c, (omapi_object_t *)0,
! 693: "input-authenticator",
! 694: (omapi_typed_data_t *)0);
! 695: if (status != ISC_R_SUCCESS) {
! 696: omapi_value_dereference (&signature, MDL);
! 697: omapi_disconnect (c, 1);
! 698: return status;
! 699: }
! 700: }
! 701:
! 702: /* Read the authenticator. */
! 703: status = omapi_typed_data_new (MDL,
! 704: &p -> message -> authenticator,
! 705: omapi_datatype_data,
! 706: p -> message -> authlen);
! 707:
! 708: if (status != ISC_R_SUCCESS) {
! 709: omapi_value_dereference (&signature, MDL);
! 710: omapi_disconnect (c, 1);
! 711: return ISC_R_NOMEMORY;
! 712: }
! 713: omapi_connection_copyout
! 714: (p -> message -> authenticator -> u.buffer.value, c,
! 715: p -> message -> authlen);
! 716:
! 717: /* Verify the signature. */
! 718: if (p -> message -> id_object &&
! 719: ((signature -> value -> u.buffer.len !=
! 720: p -> message -> authlen) ||
! 721: (memcmp (signature -> value -> u.buffer.value,
! 722: p -> message -> authenticator -> u.buffer.value,
! 723: p -> message -> authlen) != 0))) {
! 724: /* Invalid signature. */
! 725: p -> verify_result = ISC_R_INVALIDKEY;
! 726: }
! 727:
! 728: omapi_value_dereference (&signature, MDL);
! 729:
! 730: /* Process the message. */
! 731: message_done:
! 732: if (p -> verify_result != ISC_R_SUCCESS) {
! 733: status = omapi_protocol_send_status
! 734: (h, (omapi_object_t *)0, p -> verify_result,
! 735: p -> message -> id, (char *)0);
! 736: } else {
! 737: status = omapi_message_process
! 738: ((omapi_object_t *)p -> message, h);
! 739: }
! 740: if (status != ISC_R_SUCCESS) {
! 741: omapi_disconnect (c, 1);
! 742: return ISC_R_NOMEMORY;
! 743: }
! 744:
! 745: omapi_message_dereference (&p -> message, MDL);
! 746: #if defined (DEBUG_MEMORY_LEAKAGE)
! 747: log_info ("generation %ld: %ld new, %ld outstanding, %ld%s",
! 748: dmalloc_generation,
! 749: dmalloc_outstanding - previous_outstanding,
! 750: dmalloc_outstanding, dmalloc_longterm, " long-term");
! 751: #endif
! 752: #if (defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL))
! 753: dmalloc_dump_outstanding ();
! 754: #endif
! 755: #if defined (DEBUG_RC_HISTORY_EXHAUSTIVELY)
! 756: dump_rc_history (h);
! 757: #endif
! 758: #if defined (DEBUG_MEMORY_LEAKAGE)
! 759: previous_outstanding = 0xDEADBEEF;
! 760: #endif
! 761: /* Now wait for the next message. */
! 762: goto to_header_wait;
! 763:
! 764: default:
! 765: /* XXX should never get here. Assertion? */
! 766: break;
! 767: }
! 768: return ISC_R_SUCCESS;
! 769: }
! 770:
! 771: isc_result_t omapi_protocol_add_auth (omapi_object_t *po,
! 772: omapi_object_t *ao,
! 773: omapi_handle_t handle)
! 774: {
! 775: omapi_protocol_object_t *p;
! 776: omapi_remote_auth_t *r;
! 777: isc_result_t status;
! 778:
! 779: if (ao -> type != omapi_type_auth_key &&
! 780: (!ao -> inner || ao -> inner -> type != omapi_type_auth_key))
! 781: return ISC_R_INVALIDARG;
! 782:
! 783: if (po -> type != omapi_type_protocol)
! 784: return ISC_R_INVALIDARG;
! 785: p = (omapi_protocol_object_t *)po;
! 786:
! 787: #ifdef DEBUG_PROTOCOL
! 788: log_debug ("omapi_protocol_add_auth(name=%s)",
! 789: ((omapi_auth_key_t *)ao) -> name);
! 790: #endif
! 791:
! 792: if (p -> verify_auth) {
! 793: status = (p -> verify_auth) (po, (omapi_auth_key_t *)ao);
! 794: if (status != ISC_R_SUCCESS)
! 795: return status;
! 796: }
! 797:
! 798: /* If omapi_protocol_connect() was called with a default
! 799: authenticator, p -> default_auth will already be set,
! 800: but p -> remote_auth_list will not yet be initialized. */
! 801: if (p -> default_auth && !p -> remote_auth_list) {
! 802: if (p -> default_auth -> a != ao) {
! 803: /* Something just went horribly wrong. */
! 804: omapi_disconnect (p -> outer, 1);
! 805: return ISC_R_UNEXPECTED;
! 806: }
! 807:
! 808: p -> remote_auth_list = p -> default_auth;
! 809: p -> default_auth -> remote_handle = handle;
! 810:
! 811: return omapi_signal_in (p -> inner, "ready");
! 812: }
! 813:
! 814: r = dmalloc (sizeof(*r), MDL);
! 815: if (!r)
! 816: return ISC_R_NOMEMORY;
! 817:
! 818: status = omapi_object_reference (&r -> a, ao, MDL);
! 819: if (status != ISC_R_SUCCESS) {
! 820: dfree (r, MDL);
! 821: return status;
! 822: }
! 823:
! 824: r -> remote_handle = handle;
! 825: r -> next = p -> remote_auth_list;
! 826: p -> remote_auth_list = r;
! 827:
! 828: return ISC_R_SUCCESS;
! 829: }
! 830:
! 831: isc_result_t omapi_protocol_lookup_auth (omapi_object_t **a,
! 832: omapi_object_t *po,
! 833: omapi_handle_t handle)
! 834: {
! 835: omapi_protocol_object_t *p;
! 836: omapi_remote_auth_t *r;
! 837:
! 838: if (po -> type != omapi_type_protocol)
! 839: return ISC_R_INVALIDARG;
! 840: p = (omapi_protocol_object_t *)po;
! 841:
! 842: for (r = p -> remote_auth_list; r; r = r -> next)
! 843: if (r -> remote_handle == handle)
! 844: return omapi_object_reference (a, r -> a, MDL);
! 845:
! 846: return ISC_R_KEY_UNKNOWN;
! 847: }
! 848:
! 849: isc_result_t omapi_protocol_set_value (omapi_object_t *h,
! 850: omapi_object_t *id,
! 851: omapi_data_string_t *name,
! 852: omapi_typed_data_t *value)
! 853: {
! 854: omapi_protocol_object_t *p;
! 855: omapi_remote_auth_t *r;
! 856:
! 857: if (h -> type != omapi_type_protocol)
! 858: return ISC_R_INVALIDARG;
! 859: p = (omapi_protocol_object_t *)h;
! 860:
! 861: if (omapi_ds_strcmp (name, "default-authenticator") == 0) {
! 862: if (value -> type != omapi_datatype_object)
! 863: return ISC_R_INVALIDARG;
! 864:
! 865: if (!value || !value -> u.object) {
! 866: p -> default_auth = (omapi_remote_auth_t *)0;
! 867: } else {
! 868: for (r = p -> remote_auth_list; r; r = r -> next)
! 869: if (r -> a == value -> u.object)
! 870: break;
! 871:
! 872: if (!r)
! 873: return ISC_R_KEY_UNKNOWN;
! 874:
! 875: p -> default_auth = r;
! 876: }
! 877:
! 878: return ISC_R_SUCCESS;
! 879: }
! 880:
! 881: if (h -> inner && h -> inner -> type -> set_value)
! 882: return (*(h -> inner -> type -> set_value))
! 883: (h -> inner, id, name, value);
! 884: return ISC_R_NOTFOUND;
! 885: }
! 886:
! 887: isc_result_t omapi_protocol_get_value (omapi_object_t *h,
! 888: omapi_object_t *id,
! 889: omapi_data_string_t *name,
! 890: omapi_value_t **value)
! 891: {
! 892: omapi_protocol_object_t *p;
! 893:
! 894: if (h -> type != omapi_type_protocol)
! 895: return ISC_R_INVALIDARG;
! 896: p = (omapi_protocol_object_t *)h;
! 897:
! 898: if (omapi_ds_strcmp (name, "default-authenticator") == 0) {
! 899: if (!p -> default_auth)
! 900: return ISC_R_NOTFOUND;
! 901:
! 902: return omapi_make_object_value (value, name,
! 903: p -> default_auth -> a, MDL);
! 904: }
! 905:
! 906: if (h -> inner && h -> inner -> type -> get_value)
! 907: return (*(h -> inner -> type -> get_value))
! 908: (h -> inner, id, name, value);
! 909: return ISC_R_NOTFOUND;
! 910: }
! 911:
! 912: isc_result_t omapi_protocol_destroy (omapi_object_t *h,
! 913: const char *file, int line)
! 914: {
! 915: omapi_protocol_object_t *p;
! 916: if (h -> type != omapi_type_protocol)
! 917: return ISC_R_INVALIDARG;
! 918: p = (omapi_protocol_object_t *)h;
! 919: if (p -> message)
! 920: omapi_message_dereference (&p -> message, file, line);
! 921:
! 922: /* This will happen if: 1) A default authenticator is supplied to
! 923: omapi_protocol_connect(), and 2) something goes wrong before
! 924: the authenticator can be opened. */
! 925: if (p -> default_auth && !p -> remote_auth_list)
! 926: dfree (p -> default_auth, file, line);
! 927:
! 928: while (p -> remote_auth_list) {
! 929: omapi_remote_auth_t *r = p -> remote_auth_list -> next;
! 930: p -> remote_auth_list = r;
! 931: if (r) {
! 932: omapi_object_dereference (&r -> a, file, line);
! 933: dfree (r, file, line);
! 934: }
! 935: }
! 936: return ISC_R_SUCCESS;
! 937: }
! 938:
! 939: /* Write all the published values associated with the object through the
! 940: specified connection. */
! 941:
! 942: isc_result_t omapi_protocol_stuff_values (omapi_object_t *c,
! 943: omapi_object_t *id,
! 944: omapi_object_t *p)
! 945: {
! 946: if (p -> type != omapi_type_protocol)
! 947: return ISC_R_INVALIDARG;
! 948:
! 949: if (p -> inner && p -> inner -> type -> stuff_values)
! 950: return (*(p -> inner -> type -> stuff_values)) (c, id,
! 951: p -> inner);
! 952: return ISC_R_SUCCESS;
! 953: }
! 954:
! 955: /* Returns a boolean indicating whether this protocol requires that
! 956: messages be authenticated or not. */
! 957:
! 958: isc_boolean_t omapi_protocol_authenticated (omapi_object_t *h)
! 959: {
! 960: if (h -> type != omapi_type_protocol)
! 961: return isc_boolean_false;
! 962: if (((omapi_protocol_object_t *)h) -> insecure)
! 963: return isc_boolean_false;
! 964: else
! 965: return isc_boolean_true;
! 966: }
! 967:
! 968: /* Sets the address and authenticator verification callbacks. The handle
! 969: is to a listener object, not a protocol object. */
! 970:
! 971: isc_result_t omapi_protocol_configure_security (omapi_object_t *h,
! 972: isc_result_t (*verify_addr)
! 973: (omapi_object_t *,
! 974: omapi_addr_t *),
! 975: isc_result_t (*verify_auth)
! 976: (omapi_object_t *,
! 977: omapi_auth_key_t *))
! 978: {
! 979: omapi_protocol_listener_object_t *l;
! 980:
! 981: if (h -> outer && h -> outer -> type == omapi_type_protocol_listener)
! 982: h = h -> outer;
! 983:
! 984: if (h -> type != omapi_type_protocol_listener)
! 985: return ISC_R_INVALIDARG;
! 986: l = (omapi_protocol_listener_object_t *)h;
! 987:
! 988: l -> verify_auth = verify_auth;
! 989: l -> insecure = 0;
! 990:
! 991: return omapi_listener_configure_security (h -> outer, verify_addr);
! 992: }
! 993:
! 994:
! 995: /* Set up a listener for the omapi protocol. The handle stored points to
! 996: a listener object, not a protocol object. */
! 997:
! 998: isc_result_t omapi_protocol_listen (omapi_object_t *h,
! 999: unsigned port,
! 1000: int max)
! 1001: {
! 1002: isc_result_t status;
! 1003: omapi_protocol_listener_object_t *obj;
! 1004:
! 1005: obj = (omapi_protocol_listener_object_t *)0;
! 1006: status = omapi_protocol_listener_allocate (&obj, MDL);
! 1007: if (status != ISC_R_SUCCESS)
! 1008: return status;
! 1009:
! 1010: status = omapi_object_reference (&h -> outer,
! 1011: (omapi_object_t *)obj, MDL);
! 1012: if (status != ISC_R_SUCCESS) {
! 1013: omapi_protocol_listener_dereference (&obj, MDL);
! 1014: return status;
! 1015: }
! 1016: status = omapi_object_reference (&obj -> inner, h, MDL);
! 1017: if (status != ISC_R_SUCCESS) {
! 1018: omapi_protocol_listener_dereference (&obj, MDL);
! 1019: return status;
! 1020: }
! 1021:
! 1022: /* What a terrible default. */
! 1023: obj -> insecure = 1;
! 1024:
! 1025: status = omapi_listen ((omapi_object_t *)obj, port, max);
! 1026: omapi_protocol_listener_dereference (&obj, MDL);
! 1027: return status;
! 1028: }
! 1029:
! 1030: /* Signal handler for protocol listener - if we get a connect signal,
! 1031: create a new protocol connection, otherwise pass the signal down. */
! 1032:
! 1033: isc_result_t omapi_protocol_listener_signal (omapi_object_t *o,
! 1034: const char *name, va_list ap)
! 1035: {
! 1036: isc_result_t status;
! 1037: omapi_object_t *c;
! 1038: omapi_protocol_object_t *obj;
! 1039: omapi_protocol_listener_object_t *p;
! 1040:
! 1041: if (!o || o -> type != omapi_type_protocol_listener)
! 1042: return ISC_R_INVALIDARG;
! 1043: p = (omapi_protocol_listener_object_t *)o;
! 1044:
! 1045: /* Not a signal we recognize? */
! 1046: if (strcmp (name, "connect")) {
! 1047: if (p -> inner && p -> inner -> type -> signal_handler)
! 1048: return (*(p -> inner -> type -> signal_handler))
! 1049: (p -> inner, name, ap);
! 1050: return ISC_R_NOTFOUND;
! 1051: }
! 1052:
! 1053: c = va_arg (ap, omapi_object_t *);
! 1054: if (!c || c -> type != omapi_type_connection)
! 1055: return ISC_R_INVALIDARG;
! 1056:
! 1057: obj = (omapi_protocol_object_t *)0;
! 1058: status = omapi_protocol_allocate (&obj, MDL);
! 1059: if (status != ISC_R_SUCCESS)
! 1060: return status;
! 1061:
! 1062: obj -> verify_auth = p -> verify_auth;
! 1063: obj -> insecure = p -> insecure;
! 1064:
! 1065: status = omapi_object_reference (&obj -> outer, c, MDL);
! 1066: if (status != ISC_R_SUCCESS) {
! 1067: lose:
! 1068: omapi_protocol_dereference (&obj, MDL);
! 1069: omapi_disconnect (c, 1);
! 1070: return status;
! 1071: }
! 1072:
! 1073: status = omapi_object_reference (&c -> inner,
! 1074: (omapi_object_t *)obj, MDL);
! 1075: if (status != ISC_R_SUCCESS)
! 1076: goto lose;
! 1077:
! 1078: /* Send the introductory message. */
! 1079: status = omapi_protocol_send_intro ((omapi_object_t *)obj,
! 1080: OMAPI_PROTOCOL_VERSION,
! 1081: sizeof (omapi_protocol_header_t));
! 1082: if (status != ISC_R_SUCCESS)
! 1083: goto lose;
! 1084:
! 1085: omapi_protocol_dereference (&obj, MDL);
! 1086: return status;
! 1087: }
! 1088:
! 1089: isc_result_t omapi_protocol_listener_set_value (omapi_object_t *h,
! 1090: omapi_object_t *id,
! 1091: omapi_data_string_t *name,
! 1092: omapi_typed_data_t *value)
! 1093: {
! 1094: if (h -> type != omapi_type_protocol_listener)
! 1095: return ISC_R_INVALIDARG;
! 1096:
! 1097: if (h -> inner && h -> inner -> type -> set_value)
! 1098: return (*(h -> inner -> type -> set_value))
! 1099: (h -> inner, id, name, value);
! 1100: return ISC_R_NOTFOUND;
! 1101: }
! 1102:
! 1103: isc_result_t omapi_protocol_listener_get_value (omapi_object_t *h,
! 1104: omapi_object_t *id,
! 1105: omapi_data_string_t *name,
! 1106: omapi_value_t **value)
! 1107: {
! 1108: if (h -> type != omapi_type_protocol_listener)
! 1109: return ISC_R_INVALIDARG;
! 1110:
! 1111: if (h -> inner && h -> inner -> type -> get_value)
! 1112: return (*(h -> inner -> type -> get_value))
! 1113: (h -> inner, id, name, value);
! 1114: return ISC_R_NOTFOUND;
! 1115: }
! 1116:
! 1117: isc_result_t omapi_protocol_listener_destroy (omapi_object_t *h,
! 1118: const char *file, int line)
! 1119: {
! 1120: if (h -> type != omapi_type_protocol_listener)
! 1121: return ISC_R_INVALIDARG;
! 1122: return ISC_R_SUCCESS;
! 1123: }
! 1124:
! 1125: /* Write all the published values associated with the object through the
! 1126: specified connection. */
! 1127:
! 1128: isc_result_t omapi_protocol_listener_stuff (omapi_object_t *c,
! 1129: omapi_object_t *id,
! 1130: omapi_object_t *p)
! 1131: {
! 1132: if (p -> type != omapi_type_protocol_listener)
! 1133: return ISC_R_INVALIDARG;
! 1134:
! 1135: if (p -> inner && p -> inner -> type -> stuff_values)
! 1136: return (*(p -> inner -> type -> stuff_values)) (c, id,
! 1137: p -> inner);
! 1138: return ISC_R_SUCCESS;
! 1139: }
! 1140:
! 1141: isc_result_t omapi_protocol_send_status (omapi_object_t *po,
! 1142: omapi_object_t *id,
! 1143: isc_result_t waitstatus,
! 1144: unsigned rid, const char *msg)
! 1145: {
! 1146: isc_result_t status;
! 1147: omapi_message_object_t *message = (omapi_message_object_t *)0;
! 1148: omapi_object_t *mo;
! 1149:
! 1150: if (po -> type != omapi_type_protocol)
! 1151: return ISC_R_INVALIDARG;
! 1152:
! 1153: status = omapi_message_new ((omapi_object_t **)&message, MDL);
! 1154: if (status != ISC_R_SUCCESS)
! 1155: return status;
! 1156: mo = (omapi_object_t *)message;
! 1157:
! 1158: status = omapi_set_int_value (mo, (omapi_object_t *)0,
! 1159: "op", OMAPI_OP_STATUS);
! 1160: if (status != ISC_R_SUCCESS) {
! 1161: omapi_message_dereference (&message, MDL);
! 1162: return status;
! 1163: }
! 1164:
! 1165: status = omapi_set_int_value (mo, (omapi_object_t *)0,
! 1166: "rid", (int)rid);
! 1167: if (status != ISC_R_SUCCESS) {
! 1168: omapi_message_dereference (&message, MDL);
! 1169: return status;
! 1170: }
! 1171:
! 1172: status = omapi_set_int_value (mo, (omapi_object_t *)0,
! 1173: "result", (int)waitstatus);
! 1174: if (status != ISC_R_SUCCESS) {
! 1175: omapi_message_dereference (&message, MDL);
! 1176: return status;
! 1177: }
! 1178:
! 1179: /* If a message has been provided, send it. */
! 1180: if (msg) {
! 1181: status = omapi_set_string_value (mo, (omapi_object_t *)0,
! 1182: "message", msg);
! 1183: if (status != ISC_R_SUCCESS) {
! 1184: omapi_message_dereference (&message, MDL);
! 1185: return status;
! 1186: }
! 1187: }
! 1188:
! 1189: status = omapi_protocol_send_message (po, id, mo, (omapi_object_t *)0);
! 1190: omapi_message_dereference (&message, MDL);
! 1191: return status;
! 1192: }
! 1193:
! 1194: /* The OMAPI_NOTIFY_PROTOCOL flag will cause the notify-object for the
! 1195: message to be set to the protocol object. This is used when opening
! 1196: the default authenticator. */
! 1197:
! 1198: isc_result_t omapi_protocol_send_open (omapi_object_t *po,
! 1199: omapi_object_t *id,
! 1200: const char *type,
! 1201: omapi_object_t *object,
! 1202: unsigned flags)
! 1203: {
! 1204: isc_result_t status;
! 1205: omapi_message_object_t *message = (omapi_message_object_t *)0;
! 1206: omapi_object_t *mo;
! 1207:
! 1208: if (po -> type != omapi_type_protocol)
! 1209: return ISC_R_INVALIDARG;
! 1210:
! 1211: status = omapi_message_new ((omapi_object_t **)&message, MDL);
! 1212: mo = (omapi_object_t *)message;
! 1213:
! 1214: if (status == ISC_R_SUCCESS)
! 1215: status = omapi_set_int_value (mo, (omapi_object_t *)0,
! 1216: "op", OMAPI_OP_OPEN);
! 1217:
! 1218: if (status == ISC_R_SUCCESS)
! 1219: status = omapi_set_object_value (mo, (omapi_object_t *)0,
! 1220: "object", object);
! 1221:
! 1222: if ((flags & OMAPI_CREATE) && (status == ISC_R_SUCCESS))
! 1223: status = omapi_set_boolean_value (mo, (omapi_object_t *)0,
! 1224: "create", 1);
! 1225:
! 1226: if ((flags & OMAPI_UPDATE) && (status == ISC_R_SUCCESS))
! 1227: status = omapi_set_boolean_value (mo, (omapi_object_t *)0,
! 1228: "update", 1);
! 1229:
! 1230: if ((flags & OMAPI_EXCL) && (status == ISC_R_SUCCESS))
! 1231: status = omapi_set_boolean_value (mo, (omapi_object_t *)0,
! 1232: "exclusive", 1);
! 1233:
! 1234: if ((flags & OMAPI_NOTIFY_PROTOCOL) && (status == ISC_R_SUCCESS))
! 1235: status = omapi_set_object_value (mo, (omapi_object_t *)0,
! 1236: "notify-object", po);
! 1237:
! 1238: if (type && (status == ISC_R_SUCCESS))
! 1239: status = omapi_set_string_value (mo, (omapi_object_t *)0,
! 1240: "type", type);
! 1241:
! 1242: if (status == ISC_R_SUCCESS)
! 1243: status = omapi_message_register (mo);
! 1244:
! 1245: if (status == ISC_R_SUCCESS) {
! 1246: status = omapi_protocol_send_message (po, id, mo,
! 1247: (omapi_object_t *)0);
! 1248: if (status != ISC_R_SUCCESS)
! 1249: omapi_message_unregister (mo);
! 1250: }
! 1251:
! 1252: if (message)
! 1253: omapi_message_dereference (&message, MDL);
! 1254:
! 1255: return status;
! 1256: }
! 1257:
! 1258: isc_result_t omapi_protocol_send_update (omapi_object_t *po,
! 1259: omapi_object_t *id,
! 1260: unsigned rid,
! 1261: omapi_object_t *object)
! 1262: {
! 1263: isc_result_t status;
! 1264: omapi_message_object_t *message = (omapi_message_object_t *)0;
! 1265: omapi_object_t *mo;
! 1266:
! 1267: if (po -> type != omapi_type_protocol)
! 1268: return ISC_R_INVALIDARG;
! 1269:
! 1270: status = omapi_message_new ((omapi_object_t **)&message, MDL);
! 1271: if (status != ISC_R_SUCCESS)
! 1272: return status;
! 1273: mo = (omapi_object_t *)message;
! 1274:
! 1275: status = omapi_set_int_value (mo, (omapi_object_t *)0,
! 1276: "op", OMAPI_OP_UPDATE);
! 1277: if (status != ISC_R_SUCCESS) {
! 1278: omapi_message_dereference (&message, MDL);
! 1279: return status;
! 1280: }
! 1281:
! 1282: if (rid) {
! 1283: omapi_handle_t handle;
! 1284: status = omapi_set_int_value (mo, (omapi_object_t *)0,
! 1285: "rid", (int)rid);
! 1286: if (status != ISC_R_SUCCESS) {
! 1287: omapi_message_dereference (&message, MDL);
! 1288: return status;
! 1289: }
! 1290:
! 1291: status = omapi_object_handle (&handle, object);
! 1292: if (status != ISC_R_SUCCESS) {
! 1293: omapi_message_dereference (&message, MDL);
! 1294: return status;
! 1295: }
! 1296: status = omapi_set_int_value (mo, (omapi_object_t *)0,
! 1297: "handle", (int)handle);
! 1298: if (status != ISC_R_SUCCESS) {
! 1299: omapi_message_dereference (&message, MDL);
! 1300: return status;
! 1301: }
! 1302: }
! 1303:
! 1304: status = omapi_set_object_value (mo, (omapi_object_t *)0,
! 1305: "object", object);
! 1306: if (status != ISC_R_SUCCESS) {
! 1307: omapi_message_dereference (&message, MDL);
! 1308: return status;
! 1309: }
! 1310:
! 1311: status = omapi_protocol_send_message (po, id, mo, (omapi_object_t *)0);
! 1312: omapi_message_dereference (&message, MDL);
! 1313: return status;
! 1314: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to protocol.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