Annotation of embedaddon/dhcp/server/omapi.c, revision 1.1
1.1 ! misho 1: /* omapi.c
! 2:
! 3: OMAPI object interfaces for the DHCP server. */
! 4:
! 5: /*
! 6: * Copyright (c) 2004-2010 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: /* Many, many thanks to Brian Murrell and BCtel for this code - BCtel
! 36: provided the funding that resulted in this code and the entire
! 37: OMAPI support library being written, and Brian helped brainstorm
! 38: and refine the requirements. To the extent that this code is
! 39: useful, you have Brian and BCtel to thank. Any limitations in the
! 40: code are a result of mistakes on my part. -- Ted Lemon */
! 41:
! 42: #include "dhcpd.h"
! 43: #include <omapip/omapip_p.h>
! 44:
! 45: static isc_result_t class_lookup (omapi_object_t **,
! 46: omapi_object_t *, omapi_object_t *,
! 47: omapi_object_type_t *);
! 48:
! 49: omapi_object_type_t *dhcp_type_lease;
! 50: omapi_object_type_t *dhcp_type_pool;
! 51: omapi_object_type_t *dhcp_type_class;
! 52: omapi_object_type_t *dhcp_type_subclass;
! 53: omapi_object_type_t *dhcp_type_host;
! 54: #if defined (FAILOVER_PROTOCOL)
! 55: omapi_object_type_t *dhcp_type_failover_state;
! 56: omapi_object_type_t *dhcp_type_failover_link;
! 57: omapi_object_type_t *dhcp_type_failover_listener;
! 58: #endif
! 59:
! 60: void dhcp_db_objects_setup ()
! 61: {
! 62: isc_result_t status;
! 63:
! 64: status = omapi_object_type_register (&dhcp_type_lease,
! 65: "lease",
! 66: dhcp_lease_set_value,
! 67: dhcp_lease_get_value,
! 68: dhcp_lease_destroy,
! 69: dhcp_lease_signal_handler,
! 70: dhcp_lease_stuff_values,
! 71: dhcp_lease_lookup,
! 72: dhcp_lease_create,
! 73: dhcp_lease_remove,
! 74: #if defined (COMPACT_LEASES)
! 75: dhcp_lease_free,
! 76: dhcp_lease_get,
! 77: #else
! 78: 0, 0,
! 79: #endif
! 80: 0,
! 81: sizeof (struct lease),
! 82: 0, RC_LEASE);
! 83: if (status != ISC_R_SUCCESS)
! 84: log_fatal ("Can't register lease object type: %s",
! 85: isc_result_totext (status));
! 86:
! 87: status = omapi_object_type_register (&dhcp_type_class,
! 88: "class",
! 89: dhcp_class_set_value,
! 90: dhcp_class_get_value,
! 91: dhcp_class_destroy,
! 92: dhcp_class_signal_handler,
! 93: dhcp_class_stuff_values,
! 94: dhcp_class_lookup,
! 95: dhcp_class_create,
! 96: dhcp_class_remove, 0, 0, 0,
! 97: sizeof (struct class), 0,
! 98: RC_MISC);
! 99: if (status != ISC_R_SUCCESS)
! 100: log_fatal ("Can't register class object type: %s",
! 101: isc_result_totext (status));
! 102:
! 103: status = omapi_object_type_register (&dhcp_type_subclass,
! 104: "subclass",
! 105: dhcp_subclass_set_value,
! 106: dhcp_subclass_get_value,
! 107: dhcp_class_destroy,
! 108: dhcp_subclass_signal_handler,
! 109: dhcp_subclass_stuff_values,
! 110: dhcp_subclass_lookup,
! 111: dhcp_subclass_create,
! 112: dhcp_subclass_remove, 0, 0, 0,
! 113: sizeof (struct class), 0, RC_MISC);
! 114: if (status != ISC_R_SUCCESS)
! 115: log_fatal ("Can't register subclass object type: %s",
! 116: isc_result_totext (status));
! 117:
! 118: status = omapi_object_type_register (&dhcp_type_pool,
! 119: "pool",
! 120: dhcp_pool_set_value,
! 121: dhcp_pool_get_value,
! 122: dhcp_pool_destroy,
! 123: dhcp_pool_signal_handler,
! 124: dhcp_pool_stuff_values,
! 125: dhcp_pool_lookup,
! 126: dhcp_pool_create,
! 127: dhcp_pool_remove, 0, 0, 0,
! 128: sizeof (struct pool), 0, RC_MISC);
! 129:
! 130: if (status != ISC_R_SUCCESS)
! 131: log_fatal ("Can't register pool object type: %s",
! 132: isc_result_totext (status));
! 133:
! 134: status = omapi_object_type_register (&dhcp_type_host,
! 135: "host",
! 136: dhcp_host_set_value,
! 137: dhcp_host_get_value,
! 138: dhcp_host_destroy,
! 139: dhcp_host_signal_handler,
! 140: dhcp_host_stuff_values,
! 141: dhcp_host_lookup,
! 142: dhcp_host_create,
! 143: dhcp_host_remove, 0, 0, 0,
! 144: sizeof (struct host_decl),
! 145: 0, RC_MISC);
! 146:
! 147: if (status != ISC_R_SUCCESS)
! 148: log_fatal ("Can't register host object type: %s",
! 149: isc_result_totext (status));
! 150:
! 151: #if defined (FAILOVER_PROTOCOL)
! 152: status = omapi_object_type_register (&dhcp_type_failover_state,
! 153: "failover-state",
! 154: dhcp_failover_state_set_value,
! 155: dhcp_failover_state_get_value,
! 156: dhcp_failover_state_destroy,
! 157: dhcp_failover_state_signal,
! 158: dhcp_failover_state_stuff,
! 159: dhcp_failover_state_lookup,
! 160: dhcp_failover_state_create,
! 161: dhcp_failover_state_remove,
! 162: 0, 0, 0,
! 163: sizeof (dhcp_failover_state_t),
! 164: 0, RC_MISC);
! 165:
! 166: if (status != ISC_R_SUCCESS)
! 167: log_fatal ("Can't register failover state object type: %s",
! 168: isc_result_totext (status));
! 169:
! 170: status = omapi_object_type_register (&dhcp_type_failover_link,
! 171: "failover-link",
! 172: dhcp_failover_link_set_value,
! 173: dhcp_failover_link_get_value,
! 174: dhcp_failover_link_destroy,
! 175: dhcp_failover_link_signal,
! 176: dhcp_failover_link_stuff_values,
! 177: 0, 0, 0, 0, 0, 0,
! 178: sizeof (dhcp_failover_link_t), 0,
! 179: RC_MISC);
! 180:
! 181: if (status != ISC_R_SUCCESS)
! 182: log_fatal ("Can't register failover link object type: %s",
! 183: isc_result_totext (status));
! 184:
! 185: status = omapi_object_type_register (&dhcp_type_failover_listener,
! 186: "failover-listener",
! 187: dhcp_failover_listener_set_value,
! 188: dhcp_failover_listener_get_value,
! 189: dhcp_failover_listener_destroy,
! 190: dhcp_failover_listener_signal,
! 191: dhcp_failover_listener_stuff,
! 192: 0, 0, 0, 0, 0, 0,
! 193: sizeof
! 194: (dhcp_failover_listener_t), 0,
! 195: RC_MISC);
! 196:
! 197: if (status != ISC_R_SUCCESS)
! 198: log_fatal ("Can't register failover listener object type: %s",
! 199: isc_result_totext (status));
! 200: #endif /* FAILOVER_PROTOCOL */
! 201: }
! 202:
! 203: isc_result_t dhcp_lease_set_value (omapi_object_t *h,
! 204: omapi_object_t *id,
! 205: omapi_data_string_t *name,
! 206: omapi_typed_data_t *value)
! 207: {
! 208: struct lease *lease;
! 209: isc_result_t status;
! 210:
! 211: if (h -> type != dhcp_type_lease)
! 212: return ISC_R_INVALIDARG;
! 213: lease = (struct lease *)h;
! 214:
! 215: /* We're skipping a lot of things it might be interesting to
! 216: set - for now, we just make it possible to whack the state. */
! 217: if (!omapi_ds_strcmp (name, "state")) {
! 218: unsigned long bar;
! 219: const char *ols, *nls;
! 220: status = omapi_get_int_value (&bar, value);
! 221: if (status != ISC_R_SUCCESS)
! 222: return status;
! 223:
! 224: if (bar < 1 || bar > FTS_LAST)
! 225: return ISC_R_INVALIDARG;
! 226: nls = binding_state_names [bar - 1];
! 227: if (lease -> binding_state >= 1 &&
! 228: lease -> binding_state <= FTS_LAST)
! 229: ols = binding_state_names [lease -> binding_state - 1];
! 230: else
! 231: ols = "unknown state";
! 232:
! 233: if (lease -> binding_state != bar) {
! 234: lease -> next_binding_state = bar;
! 235: if (supersede_lease (lease, 0, 1, 1, 1)) {
! 236: log_info ("lease %s state changed from %s to %s",
! 237: piaddr(lease->ip_addr), ols, nls);
! 238: return ISC_R_SUCCESS;
! 239: }
! 240: log_info ("lease %s state change from %s to %s failed.",
! 241: piaddr (lease -> ip_addr), ols, nls);
! 242: return ISC_R_IOERROR;
! 243: }
! 244: return ISC_R_UNCHANGED;
! 245: } else if (!omapi_ds_strcmp (name, "ip-address")) {
! 246: return ISC_R_NOPERM;
! 247: } else if (!omapi_ds_strcmp (name, "dhcp-client-identifier")) {
! 248: return ISC_R_UNCHANGED; /* XXX take change. */
! 249: } else if (!omapi_ds_strcmp (name, "hostname")) {
! 250: return ISC_R_UNCHANGED; /* XXX take change. */
! 251: } else if (!omapi_ds_strcmp (name, "client-hostname")) {
! 252: return ISC_R_UNCHANGED; /* XXX take change. */
! 253: } else if (!omapi_ds_strcmp (name, "host")) {
! 254: return ISC_R_UNCHANGED; /* XXX take change. */
! 255: } else if (!omapi_ds_strcmp (name, "subnet")) {
! 256: return ISC_R_INVALIDARG;
! 257: } else if (!omapi_ds_strcmp (name, "pool")) {
! 258: return ISC_R_NOPERM;
! 259: } else if (!omapi_ds_strcmp (name, "starts")) {
! 260: return ISC_R_NOPERM;
! 261: } else if (!omapi_ds_strcmp (name, "ends")) {
! 262: unsigned long lease_end, old_lease_end;
! 263: status = omapi_get_int_value (&lease_end, value);
! 264: if (status != ISC_R_SUCCESS)
! 265: return status;
! 266: old_lease_end = lease->ends;
! 267: lease->ends = lease_end;
! 268: if (supersede_lease (lease, 0, 1, 1, 1)) {
! 269: log_info ("lease %s end changed from %lu to %lu",
! 270: piaddr(lease->ip_addr), old_lease_end, lease_end);
! 271: return ISC_R_SUCCESS;
! 272: }
! 273: log_info ("lease %s end change from %lu to %lu failed",
! 274: piaddr(lease->ip_addr), old_lease_end, lease_end);
! 275: return ISC_R_IOERROR;
! 276: } else if (!omapi_ds_strcmp(name, "flags")) {
! 277: u_int8_t oldflags;
! 278:
! 279: if (value->type != omapi_datatype_data)
! 280: return ISC_R_INVALIDARG;
! 281:
! 282: oldflags = lease->flags;
! 283: lease->flags = (value->u.buffer.value[0] & EPHEMERAL_FLAGS) |
! 284: (lease->flags & ~EPHEMERAL_FLAGS);
! 285: if(oldflags == lease->flags)
! 286: return ISC_R_SUCCESS;
! 287: if (!supersede_lease(lease, NULL, 1, 1, 1)) {
! 288: log_error("Failed to update flags for lease %s.",
! 289: piaddr(lease->ip_addr));
! 290: return ISC_R_IOERROR;
! 291: }
! 292: return ISC_R_SUCCESS;
! 293: } else if (!omapi_ds_strcmp (name, "billing-class")) {
! 294: return ISC_R_UNCHANGED; /* XXX carefully allow change. */
! 295: } else if (!omapi_ds_strcmp (name, "hardware-address")) {
! 296: return ISC_R_UNCHANGED; /* XXX take change. */
! 297: } else if (!omapi_ds_strcmp (name, "hardware-type")) {
! 298: return ISC_R_UNCHANGED; /* XXX take change. */
! 299: } else if (lease -> scope) {
! 300: status = binding_scope_set_value (lease -> scope, 0, name, value);
! 301: if (status == ISC_R_SUCCESS) {
! 302: if (write_lease (lease) && commit_leases ())
! 303: return ISC_R_SUCCESS;
! 304: return ISC_R_IOERROR;
! 305: }
! 306: }
! 307:
! 308: /* Try to find some inner object that can take the value. */
! 309: if (h -> inner && h -> inner -> type -> set_value) {
! 310: status = ((*(h -> inner -> type -> set_value))
! 311: (h -> inner, id, name, value));
! 312: if (status == ISC_R_SUCCESS || status == ISC_R_UNCHANGED)
! 313: return status;
! 314: }
! 315:
! 316: if (!lease -> scope) {
! 317: if (!binding_scope_allocate (&lease -> scope, MDL))
! 318: return ISC_R_NOMEMORY;
! 319: }
! 320: status = binding_scope_set_value (lease -> scope, 1, name, value);
! 321: if (status != ISC_R_SUCCESS)
! 322: return status;
! 323:
! 324: if (write_lease (lease) && commit_leases ())
! 325: return ISC_R_SUCCESS;
! 326: return ISC_R_IOERROR;
! 327: }
! 328:
! 329:
! 330: isc_result_t dhcp_lease_get_value (omapi_object_t *h, omapi_object_t *id,
! 331: omapi_data_string_t *name,
! 332: omapi_value_t **value)
! 333: {
! 334: struct lease *lease;
! 335: isc_result_t status;
! 336:
! 337: if (h -> type != dhcp_type_lease)
! 338: return ISC_R_INVALIDARG;
! 339: lease = (struct lease *)h;
! 340:
! 341: if (!omapi_ds_strcmp (name, "state"))
! 342: return omapi_make_int_value (value, name,
! 343: (int)lease -> binding_state, MDL);
! 344: else if (!omapi_ds_strcmp (name, "ip-address"))
! 345: return omapi_make_const_value (value, name,
! 346: lease -> ip_addr.iabuf,
! 347: lease -> ip_addr.len, MDL);
! 348: else if (!omapi_ds_strcmp (name, "dhcp-client-identifier")) {
! 349: return omapi_make_const_value (value, name,
! 350: lease -> uid,
! 351: lease -> uid_len, MDL);
! 352: } else if (!omapi_ds_strcmp (name, "client-hostname")) {
! 353: if (lease -> client_hostname)
! 354: return omapi_make_string_value
! 355: (value, name, lease -> client_hostname, MDL);
! 356: return ISC_R_NOTFOUND;
! 357: } else if (!omapi_ds_strcmp (name, "host")) {
! 358: if (lease -> host)
! 359: return omapi_make_handle_value
! 360: (value, name,
! 361: ((omapi_object_t *)lease -> host), MDL);
! 362: } else if (!omapi_ds_strcmp (name, "subnet"))
! 363: return omapi_make_handle_value (value, name,
! 364: ((omapi_object_t *)
! 365: lease -> subnet), MDL);
! 366: else if (!omapi_ds_strcmp (name, "pool"))
! 367: return omapi_make_handle_value (value, name,
! 368: ((omapi_object_t *)
! 369: lease -> pool), MDL);
! 370: else if (!omapi_ds_strcmp (name, "billing-class")) {
! 371: if (lease -> billing_class)
! 372: return omapi_make_handle_value
! 373: (value, name,
! 374: ((omapi_object_t *)lease -> billing_class),
! 375: MDL);
! 376: return ISC_R_NOTFOUND;
! 377: } else if (!omapi_ds_strcmp (name, "hardware-address")) {
! 378: if (lease -> hardware_addr.hlen)
! 379: return omapi_make_const_value
! 380: (value, name, &lease -> hardware_addr.hbuf [1],
! 381: (unsigned)(lease -> hardware_addr.hlen - 1),
! 382: MDL);
! 383: return ISC_R_NOTFOUND;
! 384: } else if (!omapi_ds_strcmp (name, "hardware-type")) {
! 385: if (lease -> hardware_addr.hlen)
! 386: return omapi_make_int_value
! 387: (value, name, lease -> hardware_addr.hbuf [0],
! 388: MDL);
! 389: return ISC_R_NOTFOUND;
! 390: } else if (lease -> scope) {
! 391: status = binding_scope_get_value (value, lease -> scope, name);
! 392: if (status != ISC_R_NOTFOUND)
! 393: return status;
! 394: }
! 395:
! 396: /* Try to find some inner object that can take the value. */
! 397: if (h -> inner && h -> inner -> type -> get_value) {
! 398: status = ((*(h -> inner -> type -> get_value))
! 399: (h -> inner, id, name, value));
! 400: if (status == ISC_R_SUCCESS)
! 401: return status;
! 402: }
! 403: return ISC_R_UNKNOWNATTRIBUTE;
! 404: }
! 405:
! 406: isc_result_t dhcp_lease_destroy (omapi_object_t *h, const char *file, int line)
! 407: {
! 408: struct lease *lease;
! 409:
! 410: if (h -> type != dhcp_type_lease)
! 411: return ISC_R_INVALIDARG;
! 412: lease = (struct lease *)h;
! 413:
! 414: if (lease -> uid)
! 415: uid_hash_delete (lease);
! 416: hw_hash_delete (lease);
! 417:
! 418: if (lease -> on_release)
! 419: executable_statement_dereference (&lease -> on_release,
! 420: file, line);
! 421: if (lease -> on_expiry)
! 422: executable_statement_dereference (&lease -> on_expiry,
! 423: file, line);
! 424: if (lease -> on_commit)
! 425: executable_statement_dereference (&lease -> on_commit,
! 426: file, line);
! 427: if (lease -> scope)
! 428: binding_scope_dereference (&lease -> scope, file, line);
! 429:
! 430: if (lease -> agent_options)
! 431: option_chain_head_dereference (&lease -> agent_options,
! 432: file, line);
! 433: if (lease -> uid && lease -> uid != lease -> uid_buf) {
! 434: dfree (lease -> uid, MDL);
! 435: lease -> uid = &lease -> uid_buf [0];
! 436: lease -> uid_len = 0;
! 437: }
! 438:
! 439: if (lease -> client_hostname) {
! 440: dfree (lease -> client_hostname, MDL);
! 441: lease -> client_hostname = (char *)0;
! 442: }
! 443:
! 444: if (lease -> host)
! 445: host_dereference (&lease -> host, file, line);
! 446: if (lease -> subnet)
! 447: subnet_dereference (&lease -> subnet, file, line);
! 448: if (lease -> pool)
! 449: pool_dereference (&lease -> pool, file, line);
! 450:
! 451: if (lease -> state) {
! 452: free_lease_state (lease -> state, file, line);
! 453: lease -> state = (struct lease_state *)0;
! 454:
! 455: cancel_timeout (lease_ping_timeout, lease);
! 456: --outstanding_pings; /* XXX */
! 457: }
! 458:
! 459: if (lease -> billing_class)
! 460: class_dereference
! 461: (&lease -> billing_class, file, line);
! 462:
! 463: #if defined (DEBUG_MEMORY_LEAKAGE) || \
! 464: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
! 465: /* XXX we should never be destroying a lease with a next
! 466: XXX pointer except on exit... */
! 467: if (lease -> next)
! 468: lease_dereference (&lease -> next, file, line);
! 469: if (lease -> n_hw)
! 470: lease_dereference (&lease -> n_hw, file, line);
! 471: if (lease -> n_uid)
! 472: lease_dereference (&lease -> n_uid, file, line);
! 473: if (lease -> next_pending)
! 474: lease_dereference (&lease -> next_pending, file, line);
! 475: #endif
! 476:
! 477: return ISC_R_SUCCESS;
! 478: }
! 479:
! 480: isc_result_t dhcp_lease_signal_handler (omapi_object_t *h,
! 481: const char *name, va_list ap)
! 482: {
! 483: struct lease *lease;
! 484: isc_result_t status;
! 485:
! 486: if (h -> type != dhcp_type_lease)
! 487: return ISC_R_INVALIDARG;
! 488: lease = (struct lease *)h;
! 489:
! 490: if (!strcmp (name, "updated"))
! 491: return ISC_R_SUCCESS;
! 492:
! 493: /* Try to find some inner object that can take the value. */
! 494: if (h -> inner && h -> inner -> type -> signal_handler) {
! 495: status = ((*(h -> inner -> type -> signal_handler))
! 496: (h -> inner, name, ap));
! 497: if (status == ISC_R_SUCCESS)
! 498: return status;
! 499: }
! 500: return ISC_R_NOTFOUND;
! 501: }
! 502:
! 503: isc_result_t dhcp_lease_stuff_values (omapi_object_t *c,
! 504: omapi_object_t *id,
! 505: omapi_object_t *h)
! 506: {
! 507: u_int32_t bouncer;
! 508: struct lease *lease;
! 509: isc_result_t status;
! 510: u_int8_t flagbuf;
! 511:
! 512: if (h -> type != dhcp_type_lease)
! 513: return ISC_R_INVALIDARG;
! 514: lease = (struct lease *)h;
! 515:
! 516: /* Write out all the values. */
! 517:
! 518: status = omapi_connection_put_name (c, "state");
! 519: if (status != ISC_R_SUCCESS)
! 520: return status;
! 521: status = omapi_connection_put_uint32 (c, sizeof (int));
! 522: if (status != ISC_R_SUCCESS)
! 523: return status;
! 524: status = omapi_connection_put_uint32 (c, lease -> binding_state);
! 525: if (status != ISC_R_SUCCESS)
! 526: return status;
! 527:
! 528: status = omapi_connection_put_name (c, "ip-address");
! 529: if (status != ISC_R_SUCCESS)
! 530: return status;
! 531: status = omapi_connection_put_uint32 (c, lease -> ip_addr.len);
! 532: if (status != ISC_R_SUCCESS)
! 533: return status;
! 534: status = omapi_connection_copyin (c, lease -> ip_addr.iabuf,
! 535: lease -> ip_addr.len);
! 536: if (status != ISC_R_SUCCESS)
! 537: return status;
! 538:
! 539: if (lease -> uid_len) {
! 540: status = omapi_connection_put_name (c,
! 541: "dhcp-client-identifier");
! 542: if (status != ISC_R_SUCCESS)
! 543: return status;
! 544: status = omapi_connection_put_uint32 (c, lease -> uid_len);
! 545: if (status != ISC_R_SUCCESS)
! 546: return status;
! 547: if (lease -> uid_len) {
! 548: status = omapi_connection_copyin (c, lease -> uid,
! 549: lease -> uid_len);
! 550: if (status != ISC_R_SUCCESS)
! 551: return status;
! 552: }
! 553: }
! 554:
! 555: if (lease -> client_hostname) {
! 556: status = omapi_connection_put_name (c, "client-hostname");
! 557: if (status != ISC_R_SUCCESS)
! 558: return status;
! 559: status =
! 560: omapi_connection_put_string (c,
! 561: lease -> client_hostname);
! 562: if (status != ISC_R_SUCCESS)
! 563: return status;
! 564: }
! 565:
! 566: if (lease -> host) {
! 567: status = omapi_connection_put_name (c, "host");
! 568: if (status != ISC_R_SUCCESS)
! 569: return status;
! 570: status = omapi_connection_put_handle (c,
! 571: (omapi_object_t *)
! 572: lease -> host);
! 573: if (status != ISC_R_SUCCESS)
! 574: return status;
! 575: }
! 576:
! 577: status = omapi_connection_put_name (c, "subnet");
! 578: if (status != ISC_R_SUCCESS)
! 579: return status;
! 580: status = omapi_connection_put_handle
! 581: (c, (omapi_object_t *)lease -> subnet);
! 582: if (status != ISC_R_SUCCESS)
! 583: return status;
! 584:
! 585: status = omapi_connection_put_name (c, "pool");
! 586: if (status != ISC_R_SUCCESS)
! 587: return status;
! 588: status = omapi_connection_put_handle (c,
! 589: (omapi_object_t *)lease -> pool);
! 590: if (status != ISC_R_SUCCESS)
! 591: return status;
! 592:
! 593: if (lease -> billing_class) {
! 594: status = omapi_connection_put_name (c, "billing-class");
! 595: if (status != ISC_R_SUCCESS)
! 596: return status;
! 597: status = omapi_connection_put_handle
! 598: (c, (omapi_object_t *)lease -> billing_class);
! 599: if (status != ISC_R_SUCCESS)
! 600: return status;
! 601: }
! 602:
! 603: if (lease -> hardware_addr.hlen) {
! 604: status = omapi_connection_put_name (c, "hardware-address");
! 605: if (status != ISC_R_SUCCESS)
! 606: return status;
! 607: status = (omapi_connection_put_uint32
! 608: (c,
! 609: (unsigned long)(lease -> hardware_addr.hlen - 1)));
! 610: if (status != ISC_R_SUCCESS)
! 611: return status;
! 612: status = (omapi_connection_copyin
! 613: (c, &lease -> hardware_addr.hbuf [1],
! 614: (unsigned long)(lease -> hardware_addr.hlen - 1)));
! 615:
! 616: if (status != ISC_R_SUCCESS)
! 617: return status;
! 618:
! 619: status = omapi_connection_put_name (c, "hardware-type");
! 620: if (status != ISC_R_SUCCESS)
! 621: return status;
! 622: status = omapi_connection_put_uint32 (c, sizeof (int));
! 623: if (status != ISC_R_SUCCESS)
! 624: return status;
! 625: status = omapi_connection_put_uint32
! 626: (c, lease -> hardware_addr.hbuf [0]);
! 627: if (status != ISC_R_SUCCESS)
! 628: return status;
! 629: }
! 630:
! 631: /* TIME values may be 64-bit, depending on system architecture.
! 632: * OMAPI must be system independent, both in terms of transmitting
! 633: * bytes on the wire in network byte order, and in terms of being
! 634: * readable and usable by both systems.
! 635: *
! 636: * XXX: In a future feature release, a put_int64() should be made
! 637: * to exist, and perhaps a put_time() wrapper that selects which
! 638: * to use based upon sizeof(TIME). In the meantime, use existing,
! 639: * 32-bit, code.
! 640: */
! 641: bouncer = (u_int32_t)lease->ends;
! 642: status = omapi_connection_put_name(c, "ends");
! 643: if (status != ISC_R_SUCCESS)
! 644: return status;
! 645: status = omapi_connection_put_uint32(c, sizeof(bouncer));
! 646: if (status != ISC_R_SUCCESS)
! 647: return status;
! 648: status = omapi_connection_put_uint32(c, bouncer);
! 649: if (status != ISC_R_SUCCESS)
! 650: return status;
! 651:
! 652: bouncer = (u_int32_t)lease->starts;
! 653: status = omapi_connection_put_name(c, "starts");
! 654: if (status != ISC_R_SUCCESS)
! 655: return status;
! 656: status = omapi_connection_put_uint32(c, sizeof(bouncer));
! 657: if (status != ISC_R_SUCCESS)
! 658: return status;
! 659: status = omapi_connection_put_uint32(c, bouncer);
! 660: if (status != ISC_R_SUCCESS)
! 661: return status;
! 662:
! 663: bouncer = (u_int32_t)lease->tstp;
! 664: status = omapi_connection_put_name(c, "tstp");
! 665: if (status != ISC_R_SUCCESS)
! 666: return status;
! 667: status = omapi_connection_put_uint32(c, sizeof(bouncer));
! 668: if (status != ISC_R_SUCCESS)
! 669: return status;
! 670: status = omapi_connection_put_uint32(c, bouncer);
! 671: if (status != ISC_R_SUCCESS)
! 672: return status;
! 673:
! 674: bouncer = (u_int32_t)lease->tsfp;
! 675: status = omapi_connection_put_name(c, "tsfp");
! 676: if (status != ISC_R_SUCCESS)
! 677: return status;
! 678: status = omapi_connection_put_uint32(c, sizeof(bouncer));
! 679: if (status != ISC_R_SUCCESS)
! 680: return status;
! 681: status = omapi_connection_put_uint32(c, bouncer);
! 682: if (status != ISC_R_SUCCESS)
! 683: return status;
! 684:
! 685: bouncer = (u_int32_t)lease->atsfp;
! 686: status = omapi_connection_put_name(c, "atsfp");
! 687: if (status != ISC_R_SUCCESS)
! 688: return status;
! 689: status = omapi_connection_put_uint32(c, sizeof(bouncer));
! 690: if (status != ISC_R_SUCCESS)
! 691: return status;
! 692: status = omapi_connection_put_uint32(c, bouncer);
! 693: if (status != ISC_R_SUCCESS)
! 694: return status;
! 695:
! 696: bouncer = (u_int32_t)lease->cltt;
! 697: status = omapi_connection_put_name(c, "cltt");
! 698: if (status != ISC_R_SUCCESS)
! 699: return status;
! 700: status = omapi_connection_put_uint32(c, sizeof(bouncer));
! 701: if (status != ISC_R_SUCCESS)
! 702: return status;
! 703: status = omapi_connection_put_uint32(c, bouncer);
! 704: if (status != ISC_R_SUCCESS)
! 705: return status;
! 706:
! 707: status = omapi_connection_put_name (c, "flags");
! 708: if (status != ISC_R_SUCCESS)
! 709: return status;
! 710: status = omapi_connection_put_uint32(c, sizeof(flagbuf));
! 711: if (status != ISC_R_SUCCESS)
! 712: return status;
! 713: flagbuf = lease->flags & EPHEMERAL_FLAGS;
! 714: status = omapi_connection_copyin(c, &flagbuf, sizeof(flagbuf));
! 715: if (status != ISC_R_SUCCESS)
! 716: return status;
! 717:
! 718: if (lease -> scope) {
! 719: status = binding_scope_stuff_values (c, lease -> scope);
! 720: if (status != ISC_R_SUCCESS)
! 721: return status;
! 722: }
! 723:
! 724: /* Write out the inner object, if any. */
! 725: if (h -> inner && h -> inner -> type -> stuff_values) {
! 726: status = ((*(h -> inner -> type -> stuff_values))
! 727: (c, id, h -> inner));
! 728: if (status == ISC_R_SUCCESS)
! 729: return status;
! 730: }
! 731:
! 732: return ISC_R_SUCCESS;
! 733: }
! 734:
! 735: isc_result_t dhcp_lease_lookup (omapi_object_t **lp,
! 736: omapi_object_t *id, omapi_object_t *ref)
! 737: {
! 738: omapi_value_t *tv = (omapi_value_t *)0;
! 739: isc_result_t status;
! 740: struct lease *lease;
! 741:
! 742: if (!ref)
! 743: return ISC_R_NOKEYS;
! 744:
! 745: /* First see if we were sent a handle. */
! 746: status = omapi_get_value_str (ref, id, "handle", &tv);
! 747: if (status == ISC_R_SUCCESS) {
! 748: status = omapi_handle_td_lookup (lp, tv -> value);
! 749:
! 750: omapi_value_dereference (&tv, MDL);
! 751: if (status != ISC_R_SUCCESS)
! 752: return status;
! 753:
! 754: /* Don't return the object if the type is wrong. */
! 755: if ((*lp) -> type != dhcp_type_lease) {
! 756: omapi_object_dereference (lp, MDL);
! 757: return ISC_R_INVALIDARG;
! 758: }
! 759: }
! 760:
! 761: /* Now look for an IP address. */
! 762: status = omapi_get_value_str (ref, id, "ip-address", &tv);
! 763: if (status == ISC_R_SUCCESS) {
! 764: lease = (struct lease *)0;
! 765: lease_ip_hash_lookup(&lease, lease_ip_addr_hash,
! 766: tv->value->u.buffer.value,
! 767: tv->value->u.buffer.len, MDL);
! 768:
! 769: omapi_value_dereference (&tv, MDL);
! 770:
! 771: /* If we already have a lease, and it's not the same one,
! 772: then the query was invalid. */
! 773: if (*lp && *lp != (omapi_object_t *)lease) {
! 774: omapi_object_dereference (lp, MDL);
! 775: lease_dereference (&lease, MDL);
! 776: return ISC_R_KEYCONFLICT;
! 777: } else if (!lease) {
! 778: if (*lp)
! 779: omapi_object_dereference (lp, MDL);
! 780: return ISC_R_NOTFOUND;
! 781: } else if (!*lp) {
! 782: /* XXX fix so that hash lookup itself creates
! 783: XXX the reference. */
! 784: omapi_object_reference (lp,
! 785: (omapi_object_t *)lease, MDL);
! 786: lease_dereference (&lease, MDL);
! 787: }
! 788: }
! 789:
! 790: /* Now look for a client identifier. */
! 791: status = omapi_get_value_str (ref, id, "dhcp-client-identifier", &tv);
! 792: if (status == ISC_R_SUCCESS) {
! 793: lease = (struct lease *)0;
! 794: lease_id_hash_lookup(&lease, lease_uid_hash,
! 795: tv->value->u.buffer.value,
! 796: tv->value->u.buffer.len, MDL);
! 797: omapi_value_dereference (&tv, MDL);
! 798:
! 799: if (*lp && *lp != (omapi_object_t *)lease) {
! 800: omapi_object_dereference (lp, MDL);
! 801: lease_dereference (&lease, MDL);
! 802: return ISC_R_KEYCONFLICT;
! 803: } else if (!lease) {
! 804: if (*lp)
! 805: omapi_object_dereference (lp, MDL);
! 806: return ISC_R_NOTFOUND;
! 807: } else if (lease -> n_uid) {
! 808: if (*lp)
! 809: omapi_object_dereference (lp, MDL);
! 810: return ISC_R_MULTIPLE;
! 811: } else if (!*lp) {
! 812: /* XXX fix so that hash lookup itself creates
! 813: XXX the reference. */
! 814: omapi_object_reference (lp,
! 815: (omapi_object_t *)lease, MDL);
! 816: lease_dereference (&lease, MDL);
! 817: }
! 818: }
! 819:
! 820: /* Now look for a hardware address. */
! 821: status = omapi_get_value_str (ref, id, "hardware-address", &tv);
! 822: if (status == ISC_R_SUCCESS) {
! 823: unsigned char *haddr;
! 824: unsigned int len;
! 825:
! 826: len = tv -> value -> u.buffer.len + 1;
! 827: haddr = dmalloc (len, MDL);
! 828: if (!haddr) {
! 829: omapi_value_dereference (&tv, MDL);
! 830: return ISC_R_NOMEMORY;
! 831: }
! 832:
! 833: memcpy (haddr + 1, tv -> value -> u.buffer.value, len - 1);
! 834: omapi_value_dereference (&tv, MDL);
! 835:
! 836: status = omapi_get_value_str (ref, id, "hardware-type", &tv);
! 837: if (status == ISC_R_SUCCESS) {
! 838: if (tv -> value -> type == omapi_datatype_data) {
! 839: if ((tv -> value -> u.buffer.len != 4) ||
! 840: (tv -> value -> u.buffer.value[0] != 0) ||
! 841: (tv -> value -> u.buffer.value[1] != 0) ||
! 842: (tv -> value -> u.buffer.value[2] != 0)) {
! 843: omapi_value_dereference (&tv, MDL);
! 844: dfree (haddr, MDL);
! 845: return ISC_R_INVALIDARG;
! 846: }
! 847:
! 848: haddr[0] = tv -> value -> u.buffer.value[3];
! 849: } else if (tv -> value -> type == omapi_datatype_int) {
! 850: haddr[0] = (unsigned char)
! 851: tv -> value -> u.integer;
! 852: } else {
! 853: omapi_value_dereference (&tv, MDL);
! 854: dfree (haddr, MDL);
! 855: return ISC_R_INVALIDARG;
! 856: }
! 857:
! 858: omapi_value_dereference (&tv, MDL);
! 859: } else {
! 860: /* If no hardware-type is specified, default to
! 861: ethernet. This may or may not be a good idea,
! 862: but Telus is currently relying on this behavior.
! 863: - DPN */
! 864: haddr[0] = HTYPE_ETHER;
! 865: }
! 866:
! 867: lease = (struct lease *)0;
! 868: lease_id_hash_lookup(&lease, lease_hw_addr_hash, haddr, len,
! 869: MDL);
! 870: dfree (haddr, MDL);
! 871:
! 872: if (*lp && *lp != (omapi_object_t *)lease) {
! 873: omapi_object_dereference (lp, MDL);
! 874: lease_dereference (&lease, MDL);
! 875: return ISC_R_KEYCONFLICT;
! 876: } else if (!lease) {
! 877: if (*lp)
! 878: omapi_object_dereference (lp, MDL);
! 879: return ISC_R_NOTFOUND;
! 880: } else if (lease -> n_hw) {
! 881: if (*lp)
! 882: omapi_object_dereference (lp, MDL);
! 883: lease_dereference (&lease, MDL);
! 884: return ISC_R_MULTIPLE;
! 885: } else if (!*lp) {
! 886: /* XXX fix so that hash lookup itself creates
! 887: XXX the reference. */
! 888: omapi_object_reference (lp,
! 889: (omapi_object_t *)lease, MDL);
! 890: lease_dereference (&lease, MDL);
! 891: }
! 892: }
! 893:
! 894: /* If we get to here without finding a lease, no valid key was
! 895: specified. */
! 896: if (!*lp)
! 897: return ISC_R_NOKEYS;
! 898: return ISC_R_SUCCESS;
! 899: }
! 900:
! 901: isc_result_t dhcp_lease_create (omapi_object_t **lp,
! 902: omapi_object_t *id)
! 903: {
! 904: return ISC_R_NOTIMPLEMENTED;
! 905: }
! 906:
! 907: isc_result_t dhcp_lease_remove (omapi_object_t *lp,
! 908: omapi_object_t *id)
! 909: {
! 910: return ISC_R_NOTIMPLEMENTED;
! 911: }
! 912:
! 913: isc_result_t dhcp_host_set_value (omapi_object_t *h,
! 914: omapi_object_t *id,
! 915: omapi_data_string_t *name,
! 916: omapi_typed_data_t *value)
! 917: {
! 918: struct host_decl *host;
! 919: isc_result_t status;
! 920:
! 921: if (h -> type != dhcp_type_host)
! 922: return ISC_R_INVALIDARG;
! 923: host = (struct host_decl *)h;
! 924:
! 925: /* XXX For now, we can only set these values on new host objects.
! 926: XXX Soon, we need to be able to update host objects. */
! 927: if (!omapi_ds_strcmp (name, "name")) {
! 928: if (host -> name)
! 929: return ISC_R_EXISTS;
! 930: if (value && (value -> type == omapi_datatype_data ||
! 931: value -> type == omapi_datatype_string)) {
! 932: host -> name = dmalloc (value -> u.buffer.len + 1,
! 933: MDL);
! 934: if (!host -> name)
! 935: return ISC_R_NOMEMORY;
! 936: memcpy (host -> name,
! 937: value -> u.buffer.value,
! 938: value -> u.buffer.len);
! 939: host -> name [value -> u.buffer.len] = 0;
! 940: } else
! 941: return ISC_R_INVALIDARG;
! 942: return ISC_R_SUCCESS;
! 943: }
! 944:
! 945: if (!omapi_ds_strcmp (name, "group")) {
! 946: if (value && (value -> type == omapi_datatype_data ||
! 947: value -> type == omapi_datatype_string)) {
! 948: struct group_object *group;
! 949: group = (struct group_object *)0;
! 950: group_hash_lookup (&group, group_name_hash,
! 951: (char *)value -> u.buffer.value,
! 952: value -> u.buffer.len, MDL);
! 953: if (!group || (group -> flags & GROUP_OBJECT_DELETED))
! 954: return ISC_R_NOTFOUND;
! 955: if (host -> group)
! 956: group_dereference (&host -> group, MDL);
! 957: group_reference (&host -> group, group -> group, MDL);
! 958: if (host -> named_group)
! 959: group_object_dereference (&host -> named_group,
! 960: MDL);
! 961: group_object_reference (&host -> named_group,
! 962: group, MDL);
! 963: group_object_dereference (&group, MDL);
! 964: } else
! 965: return ISC_R_INVALIDARG;
! 966: return ISC_R_SUCCESS;
! 967: }
! 968:
! 969: if (!omapi_ds_strcmp (name, "hardware-address")) {
! 970: if (host -> interface.hlen)
! 971: return ISC_R_EXISTS;
! 972: if (value && (value -> type == omapi_datatype_data ||
! 973: value -> type == omapi_datatype_string)) {
! 974: if (value -> u.buffer.len >
! 975: (sizeof host -> interface.hbuf) - 1)
! 976: return ISC_R_INVALIDARG;
! 977: memcpy (&host -> interface.hbuf [1],
! 978: value -> u.buffer.value,
! 979: value -> u.buffer.len);
! 980: host -> interface.hlen = value -> u.buffer.len + 1;
! 981: } else
! 982: return ISC_R_INVALIDARG;
! 983: return ISC_R_SUCCESS;
! 984: }
! 985:
! 986: if (!omapi_ds_strcmp (name, "hardware-type")) {
! 987: int type;
! 988: if (value && (value -> type == omapi_datatype_data &&
! 989: value -> u.buffer.len == sizeof type)) {
! 990: if (value -> u.buffer.len > sizeof type)
! 991: return ISC_R_INVALIDARG;
! 992: memcpy (&type,
! 993: value -> u.buffer.value,
! 994: value -> u.buffer.len);
! 995: type = ntohl (type);
! 996: } else if (value -> type == omapi_datatype_int)
! 997: type = value -> u.integer;
! 998: else
! 999: return ISC_R_INVALIDARG;
! 1000: host -> interface.hbuf [0] = type;
! 1001: return ISC_R_SUCCESS;
! 1002: }
! 1003:
! 1004: if (!omapi_ds_strcmp (name, "dhcp-client-identifier")) {
! 1005: if (host -> client_identifier.data)
! 1006: return ISC_R_EXISTS;
! 1007: if (value && (value -> type == omapi_datatype_data ||
! 1008: value -> type == omapi_datatype_string)) {
! 1009: if (!buffer_allocate (&host -> client_identifier.buffer,
! 1010: value -> u.buffer.len, MDL))
! 1011: return ISC_R_NOMEMORY;
! 1012: host -> client_identifier.data =
! 1013: &host -> client_identifier.buffer -> data [0];
! 1014: memcpy (host -> client_identifier.buffer -> data,
! 1015: value -> u.buffer.value,
! 1016: value -> u.buffer.len);
! 1017: host -> client_identifier.len = value -> u.buffer.len;
! 1018: } else
! 1019: return ISC_R_INVALIDARG;
! 1020: return ISC_R_SUCCESS;
! 1021: }
! 1022:
! 1023: if (!omapi_ds_strcmp (name, "ip-address")) {
! 1024: if (host -> fixed_addr)
! 1025: option_cache_dereference (&host -> fixed_addr, MDL);
! 1026: if (!value)
! 1027: return ISC_R_SUCCESS;
! 1028: if (value && (value -> type == omapi_datatype_data ||
! 1029: value -> type == omapi_datatype_string)) {
! 1030: struct data_string ds;
! 1031: memset (&ds, 0, sizeof ds);
! 1032: ds.len = value -> u.buffer.len;
! 1033: if (!buffer_allocate (&ds.buffer, ds.len, MDL))
! 1034: return ISC_R_NOMEMORY;
! 1035: ds.data = (&ds.buffer -> data [0]);
! 1036: memcpy (ds.buffer -> data,
! 1037: value -> u.buffer.value, ds.len);
! 1038: if (!option_cache (&host -> fixed_addr,
! 1039: &ds, (struct expression *)0,
! 1040: (struct option *)0, MDL)) {
! 1041: data_string_forget (&ds, MDL);
! 1042: return ISC_R_NOMEMORY;
! 1043: }
! 1044: data_string_forget (&ds, MDL);
! 1045: } else
! 1046: return ISC_R_INVALIDARG;
! 1047: return ISC_R_SUCCESS;
! 1048: }
! 1049:
! 1050: if (!omapi_ds_strcmp (name, "statements")) {
! 1051: if (!host -> group) {
! 1052: if (!clone_group (&host -> group, root_group, MDL))
! 1053: return ISC_R_NOMEMORY;
! 1054: } else {
! 1055: if (host -> group -> statements &&
! 1056: (!host -> named_group ||
! 1057: host -> group != host -> named_group -> group) &&
! 1058: host -> group != root_group)
! 1059: return ISC_R_EXISTS;
! 1060: if (!clone_group (&host -> group, host -> group, MDL))
! 1061: return ISC_R_NOMEMORY;
! 1062: }
! 1063: if (!host -> group)
! 1064: return ISC_R_NOMEMORY;
! 1065: if (value && (value -> type == omapi_datatype_data ||
! 1066: value -> type == omapi_datatype_string)) {
! 1067: struct parse *parse;
! 1068: int lose = 0;
! 1069: parse = (struct parse *)0;
! 1070: status = new_parse(&parse, -1,
! 1071: (char *) value->u.buffer.value,
! 1072: value->u.buffer.len,
! 1073: "network client", 0);
! 1074: if (status != ISC_R_SUCCESS || parse == NULL)
! 1075: return status;
! 1076:
! 1077: if (!(parse_executable_statements
! 1078: (&host -> group -> statements, parse, &lose,
! 1079: context_any))) {
! 1080: end_parse (&parse);
! 1081: return ISC_R_BADPARSE;
! 1082: }
! 1083: end_parse (&parse);
! 1084: } else
! 1085: return ISC_R_INVALIDARG;
! 1086: return ISC_R_SUCCESS;
! 1087: }
! 1088:
! 1089: /* The "known" flag isn't supported in the database yet, but it's
! 1090: legitimate. */
! 1091: if (!omapi_ds_strcmp (name, "known")) {
! 1092: return ISC_R_SUCCESS;
! 1093: }
! 1094:
! 1095: /* Try to find some inner object that can take the value. */
! 1096: if (h -> inner && h -> inner -> type -> set_value) {
! 1097: status = ((*(h -> inner -> type -> set_value))
! 1098: (h -> inner, id, name, value));
! 1099: if (status == ISC_R_SUCCESS || status == ISC_R_UNCHANGED)
! 1100: return status;
! 1101: }
! 1102:
! 1103: return ISC_R_UNKNOWNATTRIBUTE;
! 1104: }
! 1105:
! 1106:
! 1107: isc_result_t dhcp_host_get_value (omapi_object_t *h, omapi_object_t *id,
! 1108: omapi_data_string_t *name,
! 1109: omapi_value_t **value)
! 1110: {
! 1111: struct host_decl *host;
! 1112: isc_result_t status;
! 1113: struct data_string ip_addrs;
! 1114:
! 1115: if (h -> type != dhcp_type_host)
! 1116: return ISC_R_INVALIDARG;
! 1117: host = (struct host_decl *)h;
! 1118:
! 1119: if (!omapi_ds_strcmp (name, "ip-addresses")) {
! 1120: memset (&ip_addrs, 0, sizeof ip_addrs);
! 1121: if (host -> fixed_addr &&
! 1122: evaluate_option_cache (&ip_addrs, (struct packet *)0,
! 1123: (struct lease *)0,
! 1124: (struct client_state *)0,
! 1125: (struct option_state *)0,
! 1126: (struct option_state *)0,
! 1127: &global_scope,
! 1128: host -> fixed_addr, MDL)) {
! 1129: status = omapi_make_const_value (value, name,
! 1130: ip_addrs.data,
! 1131: ip_addrs.len, MDL);
! 1132: data_string_forget (&ip_addrs, MDL);
! 1133: return status;
! 1134: }
! 1135: return ISC_R_NOTFOUND;
! 1136: }
! 1137:
! 1138: if (!omapi_ds_strcmp (name, "dhcp-client-identifier")) {
! 1139: if (!host -> client_identifier.len)
! 1140: return ISC_R_NOTFOUND;
! 1141: return omapi_make_const_value (value, name,
! 1142: host -> client_identifier.data,
! 1143: host -> client_identifier.len,
! 1144: MDL);
! 1145: }
! 1146:
! 1147: if (!omapi_ds_strcmp (name, "name"))
! 1148: return omapi_make_string_value (value, name, host -> name,
! 1149: MDL);
! 1150:
! 1151: if (!omapi_ds_strcmp (name, "hardware-address")) {
! 1152: if (!host -> interface.hlen)
! 1153: return ISC_R_NOTFOUND;
! 1154: return (omapi_make_const_value
! 1155: (value, name, &host -> interface.hbuf [1],
! 1156: (unsigned long)(host -> interface.hlen - 1), MDL));
! 1157: }
! 1158:
! 1159: if (!omapi_ds_strcmp (name, "hardware-type")) {
! 1160: if (!host -> interface.hlen)
! 1161: return ISC_R_NOTFOUND;
! 1162: return omapi_make_int_value (value, name,
! 1163: host -> interface.hbuf [0], MDL);
! 1164: }
! 1165:
! 1166: /* Try to find some inner object that can take the value. */
! 1167: if (h -> inner && h -> inner -> type -> get_value) {
! 1168: status = ((*(h -> inner -> type -> get_value))
! 1169: (h -> inner, id, name, value));
! 1170: if (status == ISC_R_SUCCESS)
! 1171: return status;
! 1172: }
! 1173: return ISC_R_UNKNOWNATTRIBUTE;
! 1174: }
! 1175:
! 1176: isc_result_t dhcp_host_destroy (omapi_object_t *h, const char *file, int line)
! 1177: {
! 1178: struct host_decl *host;
! 1179:
! 1180: if (h -> type != dhcp_type_host)
! 1181: return ISC_R_INVALIDARG;
! 1182: host = (struct host_decl *)h;
! 1183:
! 1184: #if defined (DEBUG_MEMORY_LEAKAGE) || \
! 1185: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
! 1186: if (host -> n_ipaddr)
! 1187: host_dereference (&host -> n_ipaddr, file, line);
! 1188: if (host -> n_dynamic)
! 1189: host_dereference (&host -> n_dynamic, file, line);
! 1190: if (host -> name) {
! 1191: dfree (host -> name, file, line);
! 1192: host -> name = (char *)0;
! 1193: }
! 1194: data_string_forget (&host -> client_identifier, file, line);
! 1195: if (host -> fixed_addr)
! 1196: option_cache_dereference (&host -> fixed_addr, file, line);
! 1197: if (host -> group)
! 1198: group_dereference (&host -> group, file, line);
! 1199: if (host -> named_group)
! 1200: omapi_object_dereference ((omapi_object_t **)
! 1201: &host -> named_group, file, line);
! 1202: data_string_forget (&host -> auth_key_id, file, line);
! 1203: #endif
! 1204:
! 1205: return ISC_R_SUCCESS;
! 1206: }
! 1207:
! 1208: isc_result_t dhcp_host_signal_handler (omapi_object_t *h,
! 1209: const char *name, va_list ap)
! 1210: {
! 1211: struct host_decl *host;
! 1212: isc_result_t status;
! 1213: int updatep = 0;
! 1214:
! 1215: if (h -> type != dhcp_type_host)
! 1216: return ISC_R_INVALIDARG;
! 1217: host = (struct host_decl *)h;
! 1218:
! 1219: if (!strcmp (name, "updated")) {
! 1220: /* There must be a client identifier of some sort. */
! 1221: if (host -> interface.hlen == 0 &&
! 1222: !host -> client_identifier.len)
! 1223: return ISC_R_INVALIDARG;
! 1224:
! 1225: if (!host -> name) {
! 1226: char hnbuf [64];
! 1227: sprintf (hnbuf, "nh%08lx%08lx",
! 1228: (unsigned long)cur_time, (unsigned long)host);
! 1229: host -> name = dmalloc (strlen (hnbuf) + 1, MDL);
! 1230: if (!host -> name)
! 1231: return ISC_R_NOMEMORY;
! 1232: strcpy (host -> name, hnbuf);
! 1233: }
! 1234:
! 1235: #ifdef DEBUG_OMAPI
! 1236: log_debug ("OMAPI added host %s", host -> name);
! 1237: #endif
! 1238: status = enter_host (host, 1, 1);
! 1239: if (status != ISC_R_SUCCESS)
! 1240: return status;
! 1241: updatep = 1;
! 1242: }
! 1243:
! 1244: /* Try to find some inner object that can take the value. */
! 1245: if (h -> inner && h -> inner -> type -> signal_handler) {
! 1246: status = ((*(h -> inner -> type -> signal_handler))
! 1247: (h -> inner, name, ap));
! 1248: if (status == ISC_R_SUCCESS)
! 1249: return status;
! 1250: }
! 1251: if (updatep)
! 1252: return ISC_R_SUCCESS;
! 1253: return ISC_R_NOTFOUND;
! 1254: }
! 1255:
! 1256: isc_result_t dhcp_host_stuff_values (omapi_object_t *c,
! 1257: omapi_object_t *id,
! 1258: omapi_object_t *h)
! 1259: {
! 1260: struct host_decl *host;
! 1261: isc_result_t status;
! 1262: struct data_string ip_addrs;
! 1263:
! 1264: if (h -> type != dhcp_type_host)
! 1265: return ISC_R_INVALIDARG;
! 1266: host = (struct host_decl *)h;
! 1267:
! 1268: /* Write out all the values. */
! 1269:
! 1270: memset (&ip_addrs, 0, sizeof ip_addrs);
! 1271: if (host -> fixed_addr &&
! 1272: evaluate_option_cache (&ip_addrs, (struct packet *)0,
! 1273: (struct lease *)0,
! 1274: (struct client_state *)0,
! 1275: (struct option_state *)0,
! 1276: (struct option_state *)0,
! 1277: &global_scope,
! 1278: host -> fixed_addr, MDL)) {
! 1279: status = omapi_connection_put_name (c, "ip-address");
! 1280: if (status != ISC_R_SUCCESS)
! 1281: return status;
! 1282: status = omapi_connection_put_uint32 (c, ip_addrs.len);
! 1283: if (status != ISC_R_SUCCESS)
! 1284: return status;
! 1285: status = omapi_connection_copyin (c,
! 1286: ip_addrs.data, ip_addrs.len);
! 1287: if (status != ISC_R_SUCCESS)
! 1288: return status;
! 1289: }
! 1290:
! 1291: if (host -> client_identifier.len) {
! 1292: status = omapi_connection_put_name (c,
! 1293: "dhcp-client-identifier");
! 1294: if (status != ISC_R_SUCCESS)
! 1295: return status;
! 1296: status = (omapi_connection_put_uint32
! 1297: (c, host -> client_identifier.len));
! 1298: if (status != ISC_R_SUCCESS)
! 1299: return status;
! 1300: status = (omapi_connection_copyin
! 1301: (c,
! 1302: host -> client_identifier.data,
! 1303: host -> client_identifier.len));
! 1304: if (status != ISC_R_SUCCESS)
! 1305: return status;
! 1306: }
! 1307:
! 1308: if (host -> name) {
! 1309: status = omapi_connection_put_name (c, "name");
! 1310: if (status != ISC_R_SUCCESS)
! 1311: return status;
! 1312: status = omapi_connection_put_string (c, host -> name);
! 1313: if (status != ISC_R_SUCCESS)
! 1314: return status;
! 1315: }
! 1316:
! 1317: if (host -> interface.hlen) {
! 1318: status = omapi_connection_put_name (c, "hardware-address");
! 1319: if (status != ISC_R_SUCCESS)
! 1320: return status;
! 1321: status = (omapi_connection_put_uint32
! 1322: (c, (unsigned long)(host -> interface.hlen - 1)));
! 1323: if (status != ISC_R_SUCCESS)
! 1324: return status;
! 1325: status = (omapi_connection_copyin
! 1326: (c, &host -> interface.hbuf [1],
! 1327: (unsigned long)(host -> interface.hlen - 1)));
! 1328: if (status != ISC_R_SUCCESS)
! 1329: return status;
! 1330:
! 1331: status = omapi_connection_put_name (c, "hardware-type");
! 1332: if (status != ISC_R_SUCCESS)
! 1333: return status;
! 1334: status = omapi_connection_put_uint32 (c, sizeof (int));
! 1335: if (status != ISC_R_SUCCESS)
! 1336: return status;
! 1337: status = (omapi_connection_put_uint32
! 1338: (c, host -> interface.hbuf [0]));
! 1339: if (status != ISC_R_SUCCESS)
! 1340: return status;
! 1341: }
! 1342:
! 1343: /* Write out the inner object, if any. */
! 1344: if (h -> inner && h -> inner -> type -> stuff_values) {
! 1345: status = ((*(h -> inner -> type -> stuff_values))
! 1346: (c, id, h -> inner));
! 1347: if (status == ISC_R_SUCCESS)
! 1348: return status;
! 1349: }
! 1350:
! 1351: return ISC_R_SUCCESS;
! 1352: }
! 1353:
! 1354: isc_result_t dhcp_host_lookup (omapi_object_t **lp,
! 1355: omapi_object_t *id, omapi_object_t *ref)
! 1356: {
! 1357: omapi_value_t *tv = (omapi_value_t *)0;
! 1358: isc_result_t status;
! 1359: struct host_decl *host;
! 1360:
! 1361: if (!ref)
! 1362: return ISC_R_NOKEYS;
! 1363:
! 1364: /* First see if we were sent a handle. */
! 1365: status = omapi_get_value_str (ref, id, "handle", &tv);
! 1366: if (status == ISC_R_SUCCESS) {
! 1367: status = omapi_handle_td_lookup (lp, tv -> value);
! 1368:
! 1369: omapi_value_dereference (&tv, MDL);
! 1370: if (status != ISC_R_SUCCESS)
! 1371: return status;
! 1372:
! 1373: /* Don't return the object if the type is wrong. */
! 1374: if ((*lp) -> type != dhcp_type_host) {
! 1375: omapi_object_dereference (lp, MDL);
! 1376: return ISC_R_INVALIDARG;
! 1377: }
! 1378: if (((struct host_decl *)(*lp)) -> flags & HOST_DECL_DELETED) {
! 1379: omapi_object_dereference (lp, MDL);
! 1380: }
! 1381: }
! 1382:
! 1383: /* Now look for a client identifier. */
! 1384: status = omapi_get_value_str (ref, id, "dhcp-client-identifier", &tv);
! 1385: if (status == ISC_R_SUCCESS) {
! 1386: host = (struct host_decl *)0;
! 1387: host_hash_lookup (&host, host_uid_hash,
! 1388: tv -> value -> u.buffer.value,
! 1389: tv -> value -> u.buffer.len, MDL);
! 1390: omapi_value_dereference (&tv, MDL);
! 1391:
! 1392: if (*lp && *lp != (omapi_object_t *)host) {
! 1393: omapi_object_dereference (lp, MDL);
! 1394: if (host)
! 1395: host_dereference (&host, MDL);
! 1396: return ISC_R_KEYCONFLICT;
! 1397: } else if (!host || (host -> flags & HOST_DECL_DELETED)) {
! 1398: if (*lp)
! 1399: omapi_object_dereference (lp, MDL);
! 1400: if (host)
! 1401: host_dereference (&host, MDL);
! 1402: return ISC_R_NOTFOUND;
! 1403: } else if (!*lp) {
! 1404: /* XXX fix so that hash lookup itself creates
! 1405: XXX the reference. */
! 1406: omapi_object_reference (lp,
! 1407: (omapi_object_t *)host, MDL);
! 1408: host_dereference (&host, MDL);
! 1409: }
! 1410: }
! 1411:
! 1412: /* Now look for a hardware address. */
! 1413: status = omapi_get_value_str (ref, id, "hardware-address", &tv);
! 1414: if (status == ISC_R_SUCCESS) {
! 1415: unsigned char *haddr;
! 1416: unsigned int len;
! 1417:
! 1418: len = tv -> value -> u.buffer.len + 1;
! 1419: haddr = dmalloc (len, MDL);
! 1420: if (!haddr) {
! 1421: omapi_value_dereference (&tv, MDL);
! 1422: return ISC_R_NOMEMORY;
! 1423: }
! 1424:
! 1425: memcpy (haddr + 1, tv -> value -> u.buffer.value, len - 1);
! 1426: omapi_value_dereference (&tv, MDL);
! 1427:
! 1428: status = omapi_get_value_str (ref, id, "hardware-type", &tv);
! 1429: if (status == ISC_R_SUCCESS) {
! 1430: if (tv -> value -> type == omapi_datatype_data) {
! 1431: if ((tv -> value -> u.buffer.len != 4) ||
! 1432: (tv -> value -> u.buffer.value[0] != 0) ||
! 1433: (tv -> value -> u.buffer.value[1] != 0) ||
! 1434: (tv -> value -> u.buffer.value[2] != 0)) {
! 1435: omapi_value_dereference (&tv, MDL);
! 1436: dfree (haddr, MDL);
! 1437: return ISC_R_INVALIDARG;
! 1438: }
! 1439:
! 1440: haddr[0] = tv -> value -> u.buffer.value[3];
! 1441: } else if (tv -> value -> type == omapi_datatype_int) {
! 1442: haddr[0] = (unsigned char)
! 1443: tv -> value -> u.integer;
! 1444: } else {
! 1445: omapi_value_dereference (&tv, MDL);
! 1446: dfree (haddr, MDL);
! 1447: return ISC_R_INVALIDARG;
! 1448: }
! 1449:
! 1450: omapi_value_dereference (&tv, MDL);
! 1451: } else {
! 1452: /* If no hardware-type is specified, default to
! 1453: ethernet. This may or may not be a good idea,
! 1454: but Telus is currently relying on this behavior.
! 1455: - DPN */
! 1456: haddr[0] = HTYPE_ETHER;
! 1457: }
! 1458:
! 1459: host = (struct host_decl *)0;
! 1460: host_hash_lookup (&host, host_hw_addr_hash, haddr, len, MDL);
! 1461: dfree (haddr, MDL);
! 1462:
! 1463: if (*lp && *lp != (omapi_object_t *)host) {
! 1464: omapi_object_dereference (lp, MDL);
! 1465: if (host)
! 1466: host_dereference (&host, MDL);
! 1467: return ISC_R_KEYCONFLICT;
! 1468: } else if (!host || (host -> flags & HOST_DECL_DELETED)) {
! 1469: if (*lp)
! 1470: omapi_object_dereference (lp, MDL);
! 1471: if (host)
! 1472: host_dereference (&host, MDL);
! 1473: return ISC_R_NOTFOUND;
! 1474: } else if (!*lp) {
! 1475: /* XXX fix so that hash lookup itself creates
! 1476: XXX the reference. */
! 1477: omapi_object_reference (lp,
! 1478: (omapi_object_t *)host, MDL);
! 1479: host_dereference (&host, MDL);
! 1480: }
! 1481: }
! 1482:
! 1483: /* Now look for an ip address. */
! 1484: status = omapi_get_value_str (ref, id, "ip-address", &tv);
! 1485: if (status == ISC_R_SUCCESS) {
! 1486: struct lease *l;
! 1487:
! 1488: /* first find the lease for this ip address */
! 1489: l = (struct lease *)0;
! 1490: lease_ip_hash_lookup(&l, lease_ip_addr_hash,
! 1491: tv->value->u.buffer.value,
! 1492: tv->value->u.buffer.len, MDL);
! 1493: omapi_value_dereference (&tv, MDL);
! 1494:
! 1495: if (!l && !*lp)
! 1496: return ISC_R_NOTFOUND;
! 1497:
! 1498: if (l) {
! 1499: /* now use that to get a host */
! 1500: host = (struct host_decl *)0;
! 1501: host_hash_lookup (&host, host_hw_addr_hash,
! 1502: l -> hardware_addr.hbuf,
! 1503: l -> hardware_addr.hlen, MDL);
! 1504:
! 1505: if (host && *lp && *lp != (omapi_object_t *)host) {
! 1506: omapi_object_dereference (lp, MDL);
! 1507: if (host)
! 1508: host_dereference (&host, MDL);
! 1509: return ISC_R_KEYCONFLICT;
! 1510: } else if (!host || (host -> flags &
! 1511: HOST_DECL_DELETED)) {
! 1512: if (host)
! 1513: host_dereference (&host, MDL);
! 1514: if (!*lp)
! 1515: return ISC_R_NOTFOUND;
! 1516: } else if (!*lp) {
! 1517: /* XXX fix so that hash lookup itself creates
! 1518: XXX the reference. */
! 1519: omapi_object_reference (lp, (omapi_object_t *)host,
! 1520: MDL);
! 1521: host_dereference (&host, MDL);
! 1522: }
! 1523: lease_dereference (&l, MDL);
! 1524: }
! 1525: }
! 1526:
! 1527: /* Now look for a name. */
! 1528: status = omapi_get_value_str (ref, id, "name", &tv);
! 1529: if (status == ISC_R_SUCCESS) {
! 1530: host = (struct host_decl *)0;
! 1531: host_hash_lookup (&host, host_name_hash,
! 1532: tv -> value -> u.buffer.value,
! 1533: tv -> value -> u.buffer.len, MDL);
! 1534: omapi_value_dereference (&tv, MDL);
! 1535:
! 1536: if (*lp && *lp != (omapi_object_t *)host) {
! 1537: omapi_object_dereference (lp, MDL);
! 1538: if (host)
! 1539: host_dereference (&host, MDL);
! 1540: return ISC_R_KEYCONFLICT;
! 1541: } else if (!host || (host -> flags & HOST_DECL_DELETED)) {
! 1542: if (host)
! 1543: host_dereference (&host, MDL);
! 1544: return ISC_R_NOTFOUND;
! 1545: } else if (!*lp) {
! 1546: /* XXX fix so that hash lookup itself creates
! 1547: XXX the reference. */
! 1548: omapi_object_reference (lp,
! 1549: (omapi_object_t *)host, MDL);
! 1550: host_dereference (&host, MDL);
! 1551: }
! 1552: }
! 1553:
! 1554: /* If we get to here without finding a host, no valid key was
! 1555: specified. */
! 1556: if (!*lp)
! 1557: return ISC_R_NOKEYS;
! 1558: return ISC_R_SUCCESS;
! 1559: }
! 1560:
! 1561: isc_result_t dhcp_host_create (omapi_object_t **lp,
! 1562: omapi_object_t *id)
! 1563: {
! 1564: struct host_decl *hp;
! 1565: isc_result_t status;
! 1566: hp = (struct host_decl *)0;
! 1567: status = host_allocate (&hp, MDL);
! 1568: if (status != ISC_R_SUCCESS)
! 1569: return status;
! 1570: group_reference (&hp -> group, root_group, MDL);
! 1571: hp -> flags = HOST_DECL_DYNAMIC;
! 1572: status = omapi_object_reference (lp, (omapi_object_t *)hp, MDL);
! 1573: host_dereference (&hp, MDL);
! 1574: return status;
! 1575: }
! 1576:
! 1577: isc_result_t dhcp_host_remove (omapi_object_t *lp,
! 1578: omapi_object_t *id)
! 1579: {
! 1580: struct host_decl *hp;
! 1581: if (lp -> type != dhcp_type_host)
! 1582: return ISC_R_INVALIDARG;
! 1583: hp = (struct host_decl *)lp;
! 1584:
! 1585: #ifdef DEBUG_OMAPI
! 1586: log_debug ("OMAPI delete host %s", hp -> name);
! 1587: #endif
! 1588: delete_host (hp, 1);
! 1589: return ISC_R_SUCCESS;
! 1590: }
! 1591:
! 1592: isc_result_t dhcp_pool_set_value (omapi_object_t *h,
! 1593: omapi_object_t *id,
! 1594: omapi_data_string_t *name,
! 1595: omapi_typed_data_t *value)
! 1596: {
! 1597: struct pool *pool;
! 1598: isc_result_t status;
! 1599:
! 1600: if (h -> type != dhcp_type_pool)
! 1601: return ISC_R_INVALIDARG;
! 1602: pool = (struct pool *)h;
! 1603:
! 1604: /* No values to set yet. */
! 1605:
! 1606: /* Try to find some inner object that can take the value. */
! 1607: if (h -> inner && h -> inner -> type -> set_value) {
! 1608: status = ((*(h -> inner -> type -> set_value))
! 1609: (h -> inner, id, name, value));
! 1610: if (status == ISC_R_SUCCESS || status == ISC_R_UNCHANGED)
! 1611: return status;
! 1612: }
! 1613:
! 1614: return ISC_R_UNKNOWNATTRIBUTE;
! 1615: }
! 1616:
! 1617:
! 1618: isc_result_t dhcp_pool_get_value (omapi_object_t *h, omapi_object_t *id,
! 1619: omapi_data_string_t *name,
! 1620: omapi_value_t **value)
! 1621: {
! 1622: struct pool *pool;
! 1623: isc_result_t status;
! 1624:
! 1625: if (h -> type != dhcp_type_pool)
! 1626: return ISC_R_INVALIDARG;
! 1627: pool = (struct pool *)h;
! 1628:
! 1629: /* No values to get yet. */
! 1630:
! 1631: /* Try to find some inner object that can provide the value. */
! 1632: if (h -> inner && h -> inner -> type -> get_value) {
! 1633: status = ((*(h -> inner -> type -> get_value))
! 1634: (h -> inner, id, name, value));
! 1635: if (status == ISC_R_SUCCESS)
! 1636: return status;
! 1637: }
! 1638: return ISC_R_UNKNOWNATTRIBUTE;
! 1639: }
! 1640:
! 1641: isc_result_t dhcp_pool_destroy (omapi_object_t *h, const char *file, int line)
! 1642: {
! 1643: struct pool *pool;
! 1644: #if defined (DEBUG_MEMORY_LEAKAGE) || \
! 1645: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
! 1646: struct permit *pc, *pn;
! 1647: #endif
! 1648:
! 1649: if (h -> type != dhcp_type_pool)
! 1650: return ISC_R_INVALIDARG;
! 1651: pool = (struct pool *)h;
! 1652:
! 1653: #if defined (DEBUG_MEMORY_LEAKAGE) || \
! 1654: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
! 1655: if (pool -> next)
! 1656: pool_dereference (&pool -> next, file, line);
! 1657: if (pool -> group)
! 1658: group_dereference (&pool -> group, file, line);
! 1659: if (pool -> shared_network)
! 1660: shared_network_dereference (&pool -> shared_network, file, line);
! 1661: if (pool -> active)
! 1662: lease_dereference (&pool -> active, file, line);
! 1663: if (pool -> expired)
! 1664: lease_dereference (&pool -> expired, file, line);
! 1665: if (pool -> free)
! 1666: lease_dereference (&pool -> free, file, line);
! 1667: if (pool -> backup)
! 1668: lease_dereference (&pool -> backup, file, line);
! 1669: if (pool -> abandoned)
! 1670: lease_dereference (&pool -> abandoned, file, line);
! 1671: #if defined (FAILOVER_PROTOCOL)
! 1672: if (pool -> failover_peer)
! 1673: dhcp_failover_state_dereference (&pool -> failover_peer,
! 1674: file, line);
! 1675: #endif
! 1676: for (pc = pool -> permit_list; pc; pc = pn) {
! 1677: pn = pc -> next;
! 1678: free_permit (pc, file, line);
! 1679: }
! 1680: pool -> permit_list = (struct permit *)0;
! 1681:
! 1682: for (pc = pool -> prohibit_list; pc; pc = pn) {
! 1683: pn = pc -> next;
! 1684: free_permit (pc, file, line);
! 1685: }
! 1686: pool -> prohibit_list = (struct permit *)0;
! 1687: #endif
! 1688:
! 1689: return ISC_R_SUCCESS;
! 1690: }
! 1691:
! 1692: isc_result_t dhcp_pool_signal_handler (omapi_object_t *h,
! 1693: const char *name, va_list ap)
! 1694: {
! 1695: struct pool *pool;
! 1696: isc_result_t status;
! 1697: int updatep = 0;
! 1698:
! 1699: if (h -> type != dhcp_type_pool)
! 1700: return ISC_R_INVALIDARG;
! 1701: pool = (struct pool *)h;
! 1702:
! 1703: /* Can't write pools yet. */
! 1704:
! 1705: /* Try to find some inner object that can take the value. */
! 1706: if (h -> inner && h -> inner -> type -> signal_handler) {
! 1707: status = ((*(h -> inner -> type -> signal_handler))
! 1708: (h -> inner, name, ap));
! 1709: if (status == ISC_R_SUCCESS)
! 1710: return status;
! 1711: }
! 1712: if (updatep)
! 1713: return ISC_R_SUCCESS;
! 1714: return ISC_R_NOTFOUND;
! 1715: }
! 1716:
! 1717: isc_result_t dhcp_pool_stuff_values (omapi_object_t *c,
! 1718: omapi_object_t *id,
! 1719: omapi_object_t *h)
! 1720: {
! 1721: struct pool *pool;
! 1722: isc_result_t status;
! 1723:
! 1724: if (h -> type != dhcp_type_pool)
! 1725: return ISC_R_INVALIDARG;
! 1726: pool = (struct pool *)h;
! 1727:
! 1728: /* Can't stuff pool values yet. */
! 1729:
! 1730: /* Write out the inner object, if any. */
! 1731: if (h -> inner && h -> inner -> type -> stuff_values) {
! 1732: status = ((*(h -> inner -> type -> stuff_values))
! 1733: (c, id, h -> inner));
! 1734: if (status == ISC_R_SUCCESS)
! 1735: return status;
! 1736: }
! 1737:
! 1738: return ISC_R_SUCCESS;
! 1739: }
! 1740:
! 1741: isc_result_t dhcp_pool_lookup (omapi_object_t **lp,
! 1742: omapi_object_t *id, omapi_object_t *ref)
! 1743: {
! 1744: /* Can't look up pools yet. */
! 1745:
! 1746: /* If we get to here without finding a pool, no valid key was
! 1747: specified. */
! 1748: if (!*lp)
! 1749: return ISC_R_NOKEYS;
! 1750: return ISC_R_SUCCESS;
! 1751: }
! 1752:
! 1753: isc_result_t dhcp_pool_create (omapi_object_t **lp,
! 1754: omapi_object_t *id)
! 1755: {
! 1756: return ISC_R_NOTIMPLEMENTED;
! 1757: }
! 1758:
! 1759: isc_result_t dhcp_pool_remove (omapi_object_t *lp,
! 1760: omapi_object_t *id)
! 1761: {
! 1762: return ISC_R_NOTIMPLEMENTED;
! 1763: }
! 1764:
! 1765: static isc_result_t
! 1766: class_set_value (omapi_object_t *h,
! 1767: omapi_object_t *id,
! 1768: omapi_data_string_t *name,
! 1769: omapi_typed_data_t *value)
! 1770: {
! 1771: struct class *class;
! 1772: struct class *superclass = 0;
! 1773: isc_result_t status;
! 1774: int issubclass = (h -> type == dhcp_type_subclass);
! 1775:
! 1776: class = (struct class *)h;
! 1777:
! 1778: if (!omapi_ds_strcmp(name, "name")) {
! 1779: char *tname;
! 1780:
! 1781: if (class->name)
! 1782: return ISC_R_EXISTS;
! 1783:
! 1784: if ((tname = dmalloc(value->u.buffer.len + 1, MDL)) == NULL) {
! 1785: return ISC_R_NOMEMORY;
! 1786: }
! 1787:
! 1788: /* tname is null terminated from dmalloc() */
! 1789: memcpy(tname, value->u.buffer.value, value->u.buffer.len);
! 1790:
! 1791: if (issubclass) {
! 1792: status = find_class(&superclass, tname, MDL);
! 1793: dfree(tname, MDL);
! 1794:
! 1795: if (status == ISC_R_NOTFOUND)
! 1796: return status;
! 1797:
! 1798: if (class->superclass != NULL)
! 1799: class_dereference(&class->superclass, MDL);
! 1800:
! 1801: class_reference(&class->superclass, superclass, MDL);
! 1802: } else if (value -> type == omapi_datatype_data ||
! 1803: value -> type == omapi_datatype_string) {
! 1804: class->name = dmalloc(value->u.buffer.len + 1, MDL);
! 1805: if (!class->name)
! 1806: return ISC_R_NOMEMORY;
! 1807:
! 1808: /* class->name is null-terminated from dmalloc() */
! 1809: memcpy(class->name, value->u.buffer.value,
! 1810: value->u.buffer.len);
! 1811: } else
! 1812: return ISC_R_INVALIDARG;
! 1813:
! 1814: return ISC_R_SUCCESS;
! 1815: }
! 1816:
! 1817:
! 1818: if (issubclass && !omapi_ds_strcmp(name, "hashstring")) {
! 1819: if (class->hash_string.data)
! 1820: return ISC_R_EXISTS;
! 1821:
! 1822: if (value->type == omapi_datatype_data ||
! 1823: value->type == omapi_datatype_string) {
! 1824: if (!buffer_allocate(&class->hash_string.buffer,
! 1825: value->u.buffer.len, MDL))
! 1826: return ISC_R_NOMEMORY;
! 1827: class->hash_string.data =
! 1828: class->hash_string.buffer->data;
! 1829: memcpy(class->hash_string.buffer->data,
! 1830: value->u.buffer.value, value->u.buffer.len);
! 1831: class->hash_string.len = value->u.buffer.len;
! 1832: } else
! 1833: return ISC_R_INVALIDARG;
! 1834:
! 1835: return ISC_R_SUCCESS;
! 1836: }
! 1837:
! 1838: if (!omapi_ds_strcmp(name, "group")) {
! 1839: if (value->type == omapi_datatype_data ||
! 1840: value->type == omapi_datatype_string) {
! 1841: struct group_object *group = NULL;
! 1842:
! 1843: group_hash_lookup(&group, group_name_hash,
! 1844: (char *)value->u.buffer.value,
! 1845: value->u.buffer.len, MDL);
! 1846: if (!group || (group->flags & GROUP_OBJECT_DELETED))
! 1847: return ISC_R_NOTFOUND;
! 1848: if (class->group)
! 1849: group_dereference(&class->group, MDL);
! 1850: group_reference(&class->group, group->group, MDL);
! 1851: group_object_dereference(&group, MDL);
! 1852: } else
! 1853: return ISC_R_INVALIDARG;
! 1854:
! 1855: return ISC_R_SUCCESS;
! 1856: }
! 1857:
! 1858:
! 1859: /* note we do not support full expressions via omapi because the
! 1860: expressions parser needs to be re-done to support parsing from
! 1861: strings and not just files. */
! 1862:
! 1863: if (!omapi_ds_strcmp(name, "match")) {
! 1864: if (value->type == omapi_datatype_data ||
! 1865: value->type == omapi_datatype_string) {
! 1866: unsigned minlen = (value->u.buffer.len > 8 ?
! 1867: 8 : value->u.buffer.len);
! 1868:
! 1869: if (!strncmp("hardware",
! 1870: (char *)value->u.buffer.value, minlen))
! 1871: {
! 1872: if (!expression_allocate(&class->submatch, MDL))
! 1873: return ISC_R_NOMEMORY;
! 1874:
! 1875: class->submatch->op = expr_hardware;
! 1876: } else
! 1877: return ISC_R_INVALIDARG;
! 1878: } else
! 1879: return ISC_R_INVALIDARG;
! 1880:
! 1881: return ISC_R_SUCCESS;
! 1882: }
! 1883:
! 1884:
! 1885: if (!omapi_ds_strcmp(name, "option")) {
! 1886: if (value->type == omapi_datatype_data ||
! 1887: value->type == omapi_datatype_string) {
! 1888: /* XXXJAB support 'options' here. */
! 1889: /* XXXJAB specifically 'bootfile-name' */
! 1890: return ISC_R_INVALIDARG; /* XXX tmp */
! 1891: } else
! 1892: return ISC_R_INVALIDARG;
! 1893:
! 1894: /*
! 1895: * Currently no way to get here, if we update the above
! 1896: * code so that we do get here this return needs to be
! 1897: * uncommented.
! 1898: * return ISC_R_SUCCESS;
! 1899: */
! 1900: }
! 1901:
! 1902:
! 1903: /* Try to find some inner object that can take the value. */
! 1904: if (h->inner && h->inner->type->set_value) {
! 1905: status = ((*(h->inner->type->set_value))
! 1906: (h->inner, id, name, value));
! 1907: if (status == ISC_R_SUCCESS || status == ISC_R_UNCHANGED)
! 1908: return status;
! 1909: }
! 1910:
! 1911: return ISC_R_UNKNOWNATTRIBUTE;
! 1912: }
! 1913:
! 1914:
! 1915:
! 1916: isc_result_t dhcp_class_set_value (omapi_object_t *h,
! 1917: omapi_object_t *id,
! 1918: omapi_data_string_t *name,
! 1919: omapi_typed_data_t *value)
! 1920: {
! 1921: if (h -> type != dhcp_type_class)
! 1922: return ISC_R_INVALIDARG;
! 1923:
! 1924: return class_set_value(h, id, name, value);
! 1925: }
! 1926:
! 1927: isc_result_t dhcp_class_get_value (omapi_object_t *h, omapi_object_t *id,
! 1928: omapi_data_string_t *name,
! 1929: omapi_value_t **value)
! 1930: {
! 1931: struct class *class;
! 1932: isc_result_t status;
! 1933:
! 1934: if (h -> type != dhcp_type_class)
! 1935: return ISC_R_INVALIDARG;
! 1936: class = (struct class *)h;
! 1937:
! 1938: if (!omapi_ds_strcmp (name, "name"))
! 1939: return omapi_make_string_value (value, name, class -> name,
! 1940: MDL);
! 1941:
! 1942: /* Try to find some inner object that can provide the value. */
! 1943: if (h -> inner && h -> inner -> type -> get_value) {
! 1944: status = ((*(h -> inner -> type -> get_value))
! 1945: (h -> inner, id, name, value));
! 1946: if (status == ISC_R_SUCCESS)
! 1947: return status;
! 1948: }
! 1949: return ISC_R_UNKNOWNATTRIBUTE;
! 1950: }
! 1951:
! 1952: isc_result_t dhcp_class_destroy (omapi_object_t *h, const char *file, int line)
! 1953: {
! 1954: struct class *class;
! 1955:
! 1956: if (h -> type != dhcp_type_class && h -> type != dhcp_type_subclass)
! 1957: return ISC_R_INVALIDARG;
! 1958: class = (struct class *)h;
! 1959:
! 1960: #if defined (DEBUG_MEMORY_LEAKAGE) || \
! 1961: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
! 1962: if (class -> nic)
! 1963: class_dereference (&class -> nic, file, line);
! 1964: if (class -> superclass)
! 1965: class_dereference (&class -> superclass, file, line);
! 1966: if (class -> name) {
! 1967: dfree (class -> name, file, line);
! 1968: class -> name = (char *)0;
! 1969: }
! 1970: if (class -> billed_leases) {
! 1971: int i;
! 1972: for (i = 0; i < class -> lease_limit; i++) {
! 1973: if (class -> billed_leases [i]) {
! 1974: lease_dereference (&class -> billed_leases [i],
! 1975: file, line);
! 1976: }
! 1977: }
! 1978: dfree (class -> billed_leases, file, line);
! 1979: class -> billed_leases = (struct lease **)0;
! 1980: }
! 1981: if (class -> hash) {
! 1982: class_free_hash_table (&class -> hash, file, line);
! 1983: class -> hash = (class_hash_t *)0;
! 1984: }
! 1985: data_string_forget (&class -> hash_string, file, line);
! 1986:
! 1987: if (class -> expr)
! 1988: expression_dereference (&class -> expr, file, line);
! 1989: if (class -> submatch)
! 1990: expression_dereference (&class -> submatch, file, line);
! 1991: if (class -> group)
! 1992: group_dereference (&class -> group, file, line);
! 1993: if (class -> statements)
! 1994: executable_statement_dereference (&class -> statements,
! 1995: file, line);
! 1996: if (class -> superclass)
! 1997: class_dereference (&class -> superclass, file, line);
! 1998: #endif
! 1999:
! 2000: return ISC_R_SUCCESS;
! 2001: }
! 2002:
! 2003: static isc_result_t
! 2004: class_signal_handler(omapi_object_t *h,
! 2005: const char *name, va_list ap)
! 2006: {
! 2007: struct class *class = (struct class *)h;
! 2008: isc_result_t status;
! 2009: int updatep = 0;
! 2010: int issubclass;
! 2011:
! 2012: issubclass = (h -> type == dhcp_type_subclass);
! 2013:
! 2014: if (!strcmp (name, "updated")) {
! 2015:
! 2016: if (!issubclass) {
! 2017: if (class -> name == 0 || strlen(class -> name) == 0) {
! 2018: return ISC_R_INVALIDARG;
! 2019: }
! 2020: } else {
! 2021: if (class -> superclass == 0) {
! 2022: return ISC_R_INVALIDARG; /* didn't give name */
! 2023: }
! 2024:
! 2025: if (class -> hash_string.data == NULL) {
! 2026: return ISC_R_INVALIDARG;
! 2027: }
! 2028: }
! 2029:
! 2030:
! 2031: if (issubclass) {
! 2032: if (!class -> superclass -> hash)
! 2033: class_new_hash(&class->superclass->hash,
! 2034: SCLASS_HASH_SIZE, MDL);
! 2035:
! 2036: add_hash (class -> superclass -> hash,
! 2037: class -> hash_string.data,
! 2038: class -> hash_string.len,
! 2039: (void *)class, MDL);
! 2040: }
! 2041:
! 2042:
! 2043: #ifdef DEBUG_OMAPI
! 2044: if (issubclass) {
! 2045: log_debug ("OMAPI added subclass %s",
! 2046: class -> superclass -> name);
! 2047: } else {
! 2048: log_debug ("OMAPI added class %s", class -> name);
! 2049: }
! 2050: #endif
! 2051:
! 2052: status = enter_class (class, 1, 1);
! 2053: if (status != ISC_R_SUCCESS)
! 2054: return status;
! 2055: updatep = 1;
! 2056: }
! 2057:
! 2058: /* Try to find some inner object that can take the value. */
! 2059: if (h -> inner && h -> inner -> type -> signal_handler) {
! 2060: status = ((*(h -> inner -> type -> signal_handler))
! 2061: (h -> inner, name, ap));
! 2062: if (status == ISC_R_SUCCESS)
! 2063: return status;
! 2064: }
! 2065:
! 2066: if (updatep)
! 2067: return ISC_R_SUCCESS;
! 2068:
! 2069: return ISC_R_NOTFOUND;
! 2070: }
! 2071:
! 2072:
! 2073: isc_result_t dhcp_class_signal_handler (omapi_object_t *h,
! 2074: const char *name, va_list ap)
! 2075: {
! 2076: if (h -> type != dhcp_type_class)
! 2077: return ISC_R_INVALIDARG;
! 2078:
! 2079: return class_signal_handler(h, name, ap);
! 2080: }
! 2081:
! 2082: isc_result_t dhcp_class_stuff_values (omapi_object_t *c,
! 2083: omapi_object_t *id,
! 2084: omapi_object_t *h)
! 2085: {
! 2086: struct class *class;
! 2087: isc_result_t status;
! 2088:
! 2089: if (h -> type != dhcp_type_class)
! 2090: return ISC_R_INVALIDARG;
! 2091: class = (struct class *)h;
! 2092:
! 2093: /* Can't stuff class values yet. */
! 2094:
! 2095: /* Write out the inner object, if any. */
! 2096: if (h -> inner && h -> inner -> type -> stuff_values) {
! 2097: status = ((*(h -> inner -> type -> stuff_values))
! 2098: (c, id, h -> inner));
! 2099: if (status == ISC_R_SUCCESS)
! 2100: return status;
! 2101: }
! 2102:
! 2103: return ISC_R_SUCCESS;
! 2104: }
! 2105:
! 2106: static isc_result_t class_lookup (omapi_object_t **lp,
! 2107: omapi_object_t *id, omapi_object_t *ref,
! 2108: omapi_object_type_t *typewanted)
! 2109: {
! 2110: omapi_value_t *nv = (omapi_value_t *)0;
! 2111: omapi_value_t *hv = (omapi_value_t *)0;
! 2112: isc_result_t status;
! 2113: struct class *class = 0;
! 2114: struct class *subclass = 0;
! 2115:
! 2116: *lp = NULL;
! 2117:
! 2118: /* see if we have a name */
! 2119: status = omapi_get_value_str (ref, id, "name", &nv);
! 2120: if (status == ISC_R_SUCCESS) {
! 2121: char *name = dmalloc(nv -> value -> u.buffer.len + 1, MDL);
! 2122: memcpy (name,
! 2123: nv -> value -> u.buffer.value,
! 2124: nv -> value -> u.buffer.len);
! 2125:
! 2126: omapi_value_dereference (&nv, MDL);
! 2127:
! 2128: find_class(&class, name, MDL);
! 2129:
! 2130: dfree(name, MDL);
! 2131:
! 2132: if (class == NULL) {
! 2133: return ISC_R_NOTFOUND;
! 2134: }
! 2135:
! 2136: if (typewanted == dhcp_type_subclass) {
! 2137: status = omapi_get_value_str (ref, id,
! 2138: "hashstring", &hv);
! 2139: if (status != ISC_R_SUCCESS) {
! 2140: class_dereference(&class, MDL);
! 2141: return ISC_R_NOKEYS;
! 2142: }
! 2143:
! 2144: if (hv -> value -> type != omapi_datatype_data &&
! 2145: hv -> value -> type != omapi_datatype_string) {
! 2146: class_dereference(&class, MDL);
! 2147: omapi_value_dereference (&hv, MDL);
! 2148: return ISC_R_NOKEYS;
! 2149: }
! 2150:
! 2151: class_hash_lookup (&subclass, class -> hash,
! 2152: (const char *)
! 2153: hv -> value -> u.buffer.value,
! 2154: hv -> value -> u.buffer.len, MDL);
! 2155:
! 2156: omapi_value_dereference (&hv, MDL);
! 2157:
! 2158: class_dereference(&class, MDL);
! 2159:
! 2160: if (subclass == NULL) {
! 2161: return ISC_R_NOTFOUND;
! 2162: }
! 2163:
! 2164: class_reference(&class, subclass, MDL);
! 2165: class_dereference(&subclass, MDL);
! 2166: }
! 2167:
! 2168:
! 2169: /* Don't return the object if the type is wrong. */
! 2170: if (class -> type != typewanted) {
! 2171: class_dereference (&class, MDL);
! 2172: return ISC_R_INVALIDARG;
! 2173: }
! 2174:
! 2175: if (class -> flags & CLASS_DECL_DELETED) {
! 2176: class_dereference (&class, MDL);
! 2177: }
! 2178:
! 2179: omapi_object_reference(lp, (omapi_object_t *)class, MDL);
! 2180:
! 2181: return ISC_R_SUCCESS;
! 2182: }
! 2183:
! 2184: return ISC_R_NOKEYS;
! 2185: }
! 2186:
! 2187:
! 2188: isc_result_t dhcp_class_lookup (omapi_object_t **lp,
! 2189: omapi_object_t *id, omapi_object_t *ref)
! 2190: {
! 2191: return class_lookup(lp, id, ref, dhcp_type_class);
! 2192: }
! 2193:
! 2194: isc_result_t dhcp_class_create (omapi_object_t **lp,
! 2195: omapi_object_t *id)
! 2196: {
! 2197: struct class *cp = 0;
! 2198: isc_result_t status;
! 2199:
! 2200: status = class_allocate(&cp, MDL);
! 2201: if (status != ISC_R_SUCCESS)
! 2202: return status;
! 2203:
! 2204: group_reference (&cp -> group, root_group, MDL);
! 2205: cp -> flags = CLASS_DECL_DYNAMIC;
! 2206: status = omapi_object_reference (lp, (omapi_object_t *)cp, MDL);
! 2207: class_dereference (&cp, MDL);
! 2208: return status;
! 2209: }
! 2210:
! 2211: isc_result_t dhcp_class_remove (omapi_object_t *lp,
! 2212: omapi_object_t *id)
! 2213: {
! 2214: struct class *cp;
! 2215: if (lp -> type != dhcp_type_class)
! 2216: return ISC_R_INVALIDARG;
! 2217: cp = (struct class *)lp;
! 2218:
! 2219: #ifdef DEBUG_OMAPI
! 2220: log_debug ("OMAPI delete class %s", cp -> name);
! 2221: #endif
! 2222:
! 2223: delete_class (cp, 1);
! 2224: return ISC_R_SUCCESS;
! 2225: }
! 2226:
! 2227: isc_result_t dhcp_subclass_set_value (omapi_object_t *h,
! 2228: omapi_object_t *id,
! 2229: omapi_data_string_t *name,
! 2230: omapi_typed_data_t *value)
! 2231: {
! 2232: if (h -> type != dhcp_type_subclass)
! 2233: return ISC_R_INVALIDARG;
! 2234:
! 2235: return class_set_value(h, id, name, value);
! 2236: }
! 2237:
! 2238:
! 2239: isc_result_t dhcp_subclass_get_value (omapi_object_t *h, omapi_object_t *id,
! 2240: omapi_data_string_t *name,
! 2241: omapi_value_t **value)
! 2242: {
! 2243: struct class *subclass;
! 2244: isc_result_t status;
! 2245:
! 2246: if (h -> type != dhcp_type_class)
! 2247: return ISC_R_INVALIDARG;
! 2248: subclass = (struct class *)h;
! 2249: if (subclass -> name != 0)
! 2250: return ISC_R_INVALIDARG;
! 2251:
! 2252: /* XXXJAB No values to get yet. */
! 2253:
! 2254: /* Try to find some inner object that can provide the value. */
! 2255: if (h -> inner && h -> inner -> type -> get_value) {
! 2256: status = ((*(h -> inner -> type -> get_value))
! 2257: (h -> inner, id, name, value));
! 2258: if (status == ISC_R_SUCCESS)
! 2259: return status;
! 2260: }
! 2261: return ISC_R_UNKNOWNATTRIBUTE;
! 2262: }
! 2263:
! 2264: isc_result_t dhcp_subclass_signal_handler (omapi_object_t *h,
! 2265: const char *name, va_list ap)
! 2266: {
! 2267: if (h -> type != dhcp_type_subclass)
! 2268: return ISC_R_INVALIDARG;
! 2269:
! 2270: return class_signal_handler(h, name, ap);
! 2271: }
! 2272:
! 2273:
! 2274: isc_result_t dhcp_subclass_stuff_values (omapi_object_t *c,
! 2275: omapi_object_t *id,
! 2276: omapi_object_t *h)
! 2277: {
! 2278: struct class *subclass;
! 2279: isc_result_t status;
! 2280:
! 2281: if (h -> type != dhcp_type_class)
! 2282: return ISC_R_INVALIDARG;
! 2283: subclass = (struct class *)h;
! 2284: if (subclass -> name != 0)
! 2285: return ISC_R_INVALIDARG;
! 2286:
! 2287:
! 2288: /* Can't stuff subclass values yet. */
! 2289:
! 2290: /* Write out the inner object, if any. */
! 2291: if (h -> inner && h -> inner -> type -> stuff_values) {
! 2292: status = ((*(h -> inner -> type -> stuff_values))
! 2293: (c, id, h -> inner));
! 2294: if (status == ISC_R_SUCCESS)
! 2295: return status;
! 2296: }
! 2297:
! 2298: return ISC_R_SUCCESS;
! 2299: }
! 2300:
! 2301: isc_result_t dhcp_subclass_lookup (omapi_object_t **lp,
! 2302: omapi_object_t *id, omapi_object_t *ref)
! 2303: {
! 2304: return class_lookup(lp, id, ref, dhcp_type_subclass);
! 2305: }
! 2306:
! 2307:
! 2308:
! 2309:
! 2310: isc_result_t dhcp_subclass_create (omapi_object_t **lp,
! 2311: omapi_object_t *id)
! 2312: {
! 2313: struct class *cp = 0;
! 2314: isc_result_t status;
! 2315:
! 2316: /*
! 2317: * XXX
! 2318: * NOTE: subclasses and classes have the same internal type, which makes it
! 2319: * difficult to tell them apart. Specifically, in this function we need to
! 2320: * create a class object (because there is no such thing as a subclass
! 2321: * object), but one field of the class object is the type (which has the
! 2322: * value dhcp_type_class), and it is from here that all the other omapi
! 2323: * functions are accessed. So, even though there's a whole suite of
! 2324: * subclass functions registered, they won't get used. Now we could change
! 2325: * the type pointer after creating the class object, but I'm not certain
! 2326: * that won't break something else.
! 2327: */
! 2328:
! 2329: status = subclass_allocate(&cp, MDL);
! 2330: if (status != ISC_R_SUCCESS)
! 2331: return status;
! 2332: group_reference (&cp -> group, root_group, MDL);
! 2333:
! 2334: cp -> flags = CLASS_DECL_DYNAMIC;
! 2335:
! 2336: status = omapi_object_reference (lp, (omapi_object_t *)cp, MDL);
! 2337: subclass_dereference (&cp, MDL);
! 2338: return status;
! 2339: }
! 2340:
! 2341: isc_result_t dhcp_subclass_remove (omapi_object_t *lp,
! 2342: omapi_object_t *id)
! 2343: {
! 2344: #if 1
! 2345:
! 2346: log_fatal("calling dhcp_subclass_set_value");
! 2347: /* this should never be called see dhcp_subclass_create for why */
! 2348:
! 2349: #else
! 2350:
! 2351: struct class *cp;
! 2352: if (lp -> type != dhcp_type_subclass)
! 2353: return ISC_R_INVALIDARG;
! 2354: cp = (struct class *)lp;
! 2355:
! 2356: #ifdef DEBUG_OMAPI
! 2357: log_debug ("OMAPI delete subclass %s", cp -> name);
! 2358: #endif
! 2359:
! 2360: delete_class (cp, 1);
! 2361:
! 2362: #endif
! 2363:
! 2364: return ISC_R_SUCCESS;
! 2365: }
! 2366:
! 2367: isc_result_t binding_scope_set_value (struct binding_scope *scope, int createp,
! 2368: omapi_data_string_t *name,
! 2369: omapi_typed_data_t *value)
! 2370: {
! 2371: struct binding *bp;
! 2372: char *nname;
! 2373: struct binding_value *nv;
! 2374: nname = dmalloc (name -> len + 1, MDL);
! 2375: if (!nname)
! 2376: return ISC_R_NOMEMORY;
! 2377: memcpy (nname, name -> value, name -> len);
! 2378: nname [name -> len] = 0;
! 2379: bp = find_binding (scope, nname);
! 2380: if (!bp && !createp) {
! 2381: dfree (nname, MDL);
! 2382: return ISC_R_UNKNOWNATTRIBUTE;
! 2383: }
! 2384: if (!value) {
! 2385: dfree (nname, MDL);
! 2386: if (!bp)
! 2387: return ISC_R_UNKNOWNATTRIBUTE;
! 2388: binding_value_dereference (&bp -> value, MDL);
! 2389: return ISC_R_SUCCESS;
! 2390: }
! 2391:
! 2392: nv = (struct binding_value *)0;
! 2393: if (!binding_value_allocate (&nv, MDL)) {
! 2394: dfree (nname, MDL);
! 2395: return ISC_R_NOMEMORY;
! 2396: }
! 2397: switch (value -> type) {
! 2398: case omapi_datatype_int:
! 2399: nv -> type = binding_numeric;
! 2400: nv -> value.intval = value -> u.integer;
! 2401: break;
! 2402:
! 2403: case omapi_datatype_string:
! 2404: case omapi_datatype_data:
! 2405: if (!buffer_allocate (&nv -> value.data.buffer,
! 2406: value -> u.buffer.len, MDL)) {
! 2407: binding_value_dereference (&nv, MDL);
! 2408: dfree (nname, MDL);
! 2409: return ISC_R_NOMEMORY;
! 2410: }
! 2411: memcpy (&nv -> value.data.buffer -> data [1],
! 2412: value -> u.buffer.value, value -> u.buffer.len);
! 2413: nv -> value.data.len = value -> u.buffer.len;
! 2414: break;
! 2415:
! 2416: case omapi_datatype_object:
! 2417: binding_value_dereference (&nv, MDL);
! 2418: dfree (nname, MDL);
! 2419: return ISC_R_INVALIDARG;
! 2420: }
! 2421:
! 2422: if (!bp) {
! 2423: bp = dmalloc (sizeof *bp, MDL);
! 2424: if (!bp) {
! 2425: binding_value_dereference (&nv, MDL);
! 2426: dfree (nname, MDL);
! 2427: return ISC_R_NOMEMORY;
! 2428: }
! 2429: memset (bp, 0, sizeof *bp);
! 2430: bp -> name = nname;
! 2431: nname = (char *)0;
! 2432: bp -> next = scope -> bindings;
! 2433: scope -> bindings = bp;
! 2434: } else {
! 2435: if (bp -> value)
! 2436: binding_value_dereference (&bp -> value, MDL);
! 2437: dfree (nname, MDL);
! 2438: }
! 2439: binding_value_reference (&bp -> value, nv, MDL);
! 2440: binding_value_dereference (&nv, MDL);
! 2441: return ISC_R_SUCCESS;
! 2442: }
! 2443:
! 2444: isc_result_t binding_scope_get_value (omapi_value_t **value,
! 2445: struct binding_scope *scope,
! 2446: omapi_data_string_t *name)
! 2447: {
! 2448: struct binding *bp;
! 2449: omapi_typed_data_t *td;
! 2450: isc_result_t status;
! 2451: char *nname;
! 2452: nname = dmalloc (name -> len + 1, MDL);
! 2453: if (!nname)
! 2454: return ISC_R_NOMEMORY;
! 2455: memcpy (nname, name -> value, name -> len);
! 2456: nname [name -> len] = 0;
! 2457: bp = find_binding (scope, nname);
! 2458: dfree (nname, MDL);
! 2459: if (!bp)
! 2460: return ISC_R_UNKNOWNATTRIBUTE;
! 2461: if (!bp -> value)
! 2462: return ISC_R_UNKNOWNATTRIBUTE;
! 2463:
! 2464: switch (bp -> value -> type) {
! 2465: case binding_boolean:
! 2466: td = (omapi_typed_data_t *)0;
! 2467: status = omapi_typed_data_new (MDL, &td, omapi_datatype_int,
! 2468: bp -> value -> value.boolean);
! 2469: break;
! 2470:
! 2471: case binding_numeric:
! 2472: td = (omapi_typed_data_t *)0;
! 2473: status = omapi_typed_data_new (MDL, &td, omapi_datatype_int,
! 2474: (int)
! 2475: bp -> value -> value.intval);
! 2476: break;
! 2477:
! 2478: case binding_data:
! 2479: td = (omapi_typed_data_t *)0;
! 2480: status = omapi_typed_data_new (MDL, &td, omapi_datatype_data,
! 2481: bp -> value -> value.data.len);
! 2482: if (status != ISC_R_SUCCESS)
! 2483: return status;
! 2484: memcpy (&td -> u.buffer.value [0],
! 2485: bp -> value -> value.data.data,
! 2486: bp -> value -> value.data.len);
! 2487: break;
! 2488:
! 2489: /* Can't return values for these two (yet?). */
! 2490: case binding_dns:
! 2491: case binding_function:
! 2492: return ISC_R_INVALIDARG;
! 2493:
! 2494: default:
! 2495: log_fatal ("Impossible case at %s:%d.", MDL);
! 2496: return ISC_R_FAILURE;
! 2497: }
! 2498:
! 2499: if (status != ISC_R_SUCCESS)
! 2500: return status;
! 2501: status = omapi_value_new (value, MDL);
! 2502: if (status != ISC_R_SUCCESS) {
! 2503: omapi_typed_data_dereference (&td, MDL);
! 2504: return status;
! 2505: }
! 2506:
! 2507: omapi_data_string_reference (&(*value) -> name, name, MDL);
! 2508: omapi_typed_data_reference (&(*value) -> value, td, MDL);
! 2509: omapi_typed_data_dereference (&td, MDL);
! 2510:
! 2511: return ISC_R_SUCCESS;
! 2512: }
! 2513:
! 2514: isc_result_t binding_scope_stuff_values (omapi_object_t *c,
! 2515: struct binding_scope *scope)
! 2516: {
! 2517: struct binding *bp;
! 2518: unsigned len;
! 2519: isc_result_t status;
! 2520:
! 2521: for (bp = scope -> bindings; bp; bp = bp -> next) {
! 2522: if (bp -> value) {
! 2523: if (bp -> value -> type == binding_dns ||
! 2524: bp -> value -> type == binding_function)
! 2525: continue;
! 2526:
! 2527: /* Stuff the name. */
! 2528: len = strlen (bp -> name);
! 2529: status = omapi_connection_put_uint16 (c, len);
! 2530: if (status != ISC_R_SUCCESS)
! 2531: return status;
! 2532: status = omapi_connection_copyin (c,
! 2533: (unsigned char *)bp -> name,
! 2534: len);
! 2535: if (status != ISC_R_SUCCESS)
! 2536: return status;
! 2537:
! 2538: switch (bp -> value -> type) {
! 2539: case binding_boolean:
! 2540: status = omapi_connection_put_uint32 (c,
! 2541: sizeof (u_int32_t));
! 2542: if (status != ISC_R_SUCCESS)
! 2543: return status;
! 2544: status = (omapi_connection_put_uint32
! 2545: (c,
! 2546: ((u_int32_t)(bp -> value -> value.boolean))));
! 2547: break;
! 2548:
! 2549: case binding_data:
! 2550: status = (omapi_connection_put_uint32
! 2551: (c, bp -> value -> value.data.len));
! 2552: if (status != ISC_R_SUCCESS)
! 2553: return status;
! 2554: if (bp -> value -> value.data.len) {
! 2555: status = (omapi_connection_copyin
! 2556: (c, bp -> value -> value.data.data,
! 2557: bp -> value -> value.data.len));
! 2558: if (status != ISC_R_SUCCESS)
! 2559: return status;
! 2560: }
! 2561: break;
! 2562:
! 2563: case binding_numeric:
! 2564: status = (omapi_connection_put_uint32
! 2565: (c, sizeof (u_int32_t)));
! 2566: if (status != ISC_R_SUCCESS)
! 2567: return status;
! 2568: status = (omapi_connection_put_uint32
! 2569: (c, ((u_int32_t)
! 2570: (bp -> value -> value.intval))));
! 2571: break;
! 2572:
! 2573:
! 2574: /* NOTREACHED */
! 2575: case binding_dns:
! 2576: case binding_function:
! 2577: break;
! 2578: }
! 2579: }
! 2580: }
! 2581: return ISC_R_SUCCESS;
! 2582: }
! 2583:
! 2584: /* vim: set tabstop=8: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to omapi.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 / server