aboutsummaryrefslogtreecommitdiff
path: root/contrib/isc-dhcp/omapip/support.c
diff options
context:
space:
mode:
authorMurray Stokely <murray@FreeBSD.org>2002-02-19 11:04:34 +0000
committerMurray Stokely <murray@FreeBSD.org>2002-02-19 11:04:34 +0000
commitce99b771f886a2c842db7aa803c9a5a5918f42c8 (patch)
tree229464d9b3244ab78e2784c9a0a1f78de317089a /contrib/isc-dhcp/omapip/support.c
parent7657fb140fbd218ea326d55bd3c43c4077f03d9a (diff)
downloadsrc-ce99b771f886a2c842db7aa803c9a5a5918f42c8.tar.gz
src-ce99b771f886a2c842db7aa803c9a5a5918f42c8.zip
Import ISC DHCP 3.0.1 RC6 client.
Notes
Notes: svn path=/vendor/isc-dhcp/dist/; revision=90908
Diffstat (limited to 'contrib/isc-dhcp/omapip/support.c')
-rw-r--r--contrib/isc-dhcp/omapip/support.c872
1 files changed, 872 insertions, 0 deletions
diff --git a/contrib/isc-dhcp/omapip/support.c b/contrib/isc-dhcp/omapip/support.c
new file mode 100644
index 000000000000..1fb98032aa81
--- /dev/null
+++ b/contrib/isc-dhcp/omapip/support.c
@@ -0,0 +1,872 @@
+/* support.c
+
+ Subroutines providing general support for objects. */
+
+/*
+ * Copyright (c) 1999-2001 Internet Software Consortium.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of The Internet Software Consortium nor the names
+ * of its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
+ * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This software has been written for the Internet Software Consortium
+ * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
+ * To learn more about the Internet Software Consortium, see
+ * ``http://www.isc.org/''. To learn more about Vixie Enterprises,
+ * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
+ * ``http://www.nominum.com''.
+ */
+
+#include <omapip/omapip_p.h>
+
+omapi_object_type_t *omapi_type_connection;
+omapi_object_type_t *omapi_type_listener;
+omapi_object_type_t *omapi_type_io_object;
+omapi_object_type_t *omapi_type_datagram;
+omapi_object_type_t *omapi_type_generic;
+omapi_object_type_t *omapi_type_protocol;
+omapi_object_type_t *omapi_type_protocol_listener;
+omapi_object_type_t *omapi_type_waiter;
+omapi_object_type_t *omapi_type_remote;
+omapi_object_type_t *omapi_type_message;
+omapi_object_type_t *omapi_type_auth_key;
+
+omapi_object_type_t *omapi_object_types;
+int omapi_object_type_count;
+static int ot_max;
+
+#if defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
+void omapi_type_relinquish ()
+{
+ omapi_object_type_t *t, *n;
+
+ for (t = omapi_object_types; t; t = n) {
+ n = t -> next;
+ dfree (t, MDL);
+ }
+ omapi_object_types = (omapi_object_type_t *)0;
+}
+#endif
+
+isc_result_t omapi_init (void)
+{
+ isc_result_t status;
+
+ dst_init();
+
+ /* Register all the standard object types... */
+ status = omapi_object_type_register (&omapi_type_connection,
+ "connection",
+ omapi_connection_set_value,
+ omapi_connection_get_value,
+ omapi_connection_destroy,
+ omapi_connection_signal_handler,
+ omapi_connection_stuff_values,
+ 0, 0, 0, 0, 0, 0,
+ sizeof
+ (omapi_connection_object_t), 0,
+ RC_MISC);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_object_type_register (&omapi_type_listener,
+ "listener",
+ omapi_listener_set_value,
+ omapi_listener_get_value,
+ omapi_listener_destroy,
+ omapi_listener_signal_handler,
+ omapi_listener_stuff_values,
+ 0, 0, 0, 0, 0, 0,
+ sizeof (omapi_listener_object_t),
+ 0, RC_MISC);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_object_type_register (&omapi_type_io_object,
+ "io",
+ omapi_io_set_value,
+ omapi_io_get_value,
+ omapi_io_destroy,
+ omapi_io_signal_handler,
+ omapi_io_stuff_values,
+ 0, 0, 0, 0, 0, 0,
+ sizeof (omapi_io_object_t),
+ 0, RC_MISC);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_object_type_register (&omapi_type_generic,
+ "generic",
+ omapi_generic_set_value,
+ omapi_generic_get_value,
+ omapi_generic_destroy,
+ omapi_generic_signal_handler,
+ omapi_generic_stuff_values,
+ 0, 0, 0, 0, 0, 0,
+ sizeof (omapi_generic_object_t),
+ 0, RC_MISC);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_object_type_register (&omapi_type_protocol,
+ "protocol",
+ omapi_protocol_set_value,
+ omapi_protocol_get_value,
+ omapi_protocol_destroy,
+ omapi_protocol_signal_handler,
+ omapi_protocol_stuff_values,
+ 0, 0, 0, 0, 0, 0,
+ sizeof (omapi_protocol_object_t),
+ 0, RC_MISC);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = (omapi_object_type_register
+ (&omapi_type_protocol_listener, "protocol-listener",
+ omapi_protocol_listener_set_value,
+ omapi_protocol_listener_get_value,
+ omapi_protocol_listener_destroy,
+ omapi_protocol_listener_signal,
+ omapi_protocol_listener_stuff,
+ 0, 0, 0, 0, 0, 0,
+ sizeof (omapi_protocol_listener_object_t), 0, RC_MISC));
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_object_type_register (&omapi_type_message,
+ "message",
+ omapi_message_set_value,
+ omapi_message_get_value,
+ omapi_message_destroy,
+ omapi_message_signal_handler,
+ omapi_message_stuff_values,
+ 0, 0, 0, 0, 0, 0,
+ sizeof (omapi_message_object_t),
+ 0, RC_MISC);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_object_type_register (&omapi_type_waiter,
+ "waiter",
+ 0,
+ 0,
+ 0,
+ omapi_waiter_signal_handler, 0,
+ 0, 0, 0, 0, 0, 0,
+ sizeof (omapi_waiter_object_t),
+ 0, RC_MISC);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_object_type_register (&omapi_type_auth_key,
+ "authenticator",
+ 0,
+ omapi_auth_key_get_value,
+ omapi_auth_key_destroy,
+ 0,
+ omapi_auth_key_stuff_values,
+ omapi_auth_key_lookup,
+ 0, 0, 0, 0, 0,
+ sizeof (omapi_auth_key_t), 0,
+ RC_MISC);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+#if defined (TRACING)
+ omapi_listener_trace_setup ();
+ omapi_connection_trace_setup ();
+ omapi_buffer_trace_setup ();
+ trace_mr_init ();
+#endif
+
+ /* This seems silly, but leave it. */
+ return ISC_R_SUCCESS;
+}
+
+isc_result_t omapi_object_type_register (omapi_object_type_t **type,
+ const char *name,
+ isc_result_t (*set_value)
+ (omapi_object_t *,
+ omapi_object_t *,
+ omapi_data_string_t *,
+ omapi_typed_data_t *),
+ isc_result_t (*get_value)
+ (omapi_object_t *,
+ omapi_object_t *,
+ omapi_data_string_t *,
+ omapi_value_t **),
+ isc_result_t (*destroy)
+ (omapi_object_t *,
+ const char *, int),
+ isc_result_t (*signal_handler)
+ (omapi_object_t *,
+ const char *, va_list),
+ isc_result_t (*stuff_values)
+ (omapi_object_t *,
+ omapi_object_t *,
+ omapi_object_t *),
+ isc_result_t (*lookup)
+ (omapi_object_t **,
+ omapi_object_t *,
+ omapi_object_t *),
+ isc_result_t (*create)
+ (omapi_object_t **,
+ omapi_object_t *),
+ isc_result_t (*remove)
+ (omapi_object_t *,
+ omapi_object_t *),
+ isc_result_t (*freer)
+ (omapi_object_t *,
+ const char *, int),
+ isc_result_t (*allocator)
+ (omapi_object_t **,
+ const char *, int),
+ isc_result_t (*sizer) (size_t),
+ size_t size,
+ isc_result_t (*initialize)
+ (omapi_object_t *,
+ const char *, int),
+ int rc_flag)
+{
+ omapi_object_type_t *t;
+
+ t = dmalloc (sizeof *t, MDL);
+ if (!t)
+ return ISC_R_NOMEMORY;
+ memset (t, 0, sizeof *t);
+
+ t -> name = name;
+ t -> set_value = set_value;
+ t -> get_value = get_value;
+ t -> destroy = destroy;
+ t -> signal_handler = signal_handler;
+ t -> stuff_values = stuff_values;
+ t -> lookup = lookup;
+ t -> create = create;
+ t -> remove = remove;
+ t -> next = omapi_object_types;
+ t -> sizer = sizer;
+ t -> size = size;
+ t -> freer = freer;
+ t -> allocator = allocator;
+ t -> initialize = initialize;
+ t -> rc_flag = rc_flag;
+ omapi_object_types = t;
+ if (type)
+ *type = t;
+ return ISC_R_SUCCESS;
+}
+
+isc_result_t omapi_signal (omapi_object_t *handle, const char *name, ...)
+{
+ va_list ap;
+ omapi_object_t *outer;
+ isc_result_t status;
+
+ va_start (ap, name);
+ for (outer = handle; outer -> outer; outer = outer -> outer)
+ ;
+ if (outer -> type -> signal_handler)
+ status = (*(outer -> type -> signal_handler)) (outer,
+ name, ap);
+ else
+ status = ISC_R_NOTFOUND;
+ va_end (ap);
+ return status;
+}
+
+isc_result_t omapi_signal_in (omapi_object_t *handle, const char *name, ...)
+{
+ va_list ap;
+ omapi_object_t *outer;
+ isc_result_t status;
+
+ if (!handle)
+ return ISC_R_NOTFOUND;
+ va_start (ap, name);
+
+ if (handle -> type -> signal_handler)
+ status = (*(handle -> type -> signal_handler)) (handle,
+ name, ap);
+ else
+ status = ISC_R_NOTFOUND;
+ va_end (ap);
+ return status;
+}
+
+isc_result_t omapi_set_value (omapi_object_t *h,
+ omapi_object_t *id,
+ omapi_data_string_t *name,
+ omapi_typed_data_t *value)
+{
+ omapi_object_t *outer;
+ isc_result_t status;
+
+#if defined (DEBUG)
+ if (!value) {
+ log_info ("omapi_set_value (%.*s, NULL)",
+ (int)name -> len, name -> value);
+ } else if (value -> type == omapi_datatype_int) {
+ log_info ("omapi_set_value (%.*s, %ld)",
+ (int)name -> len, name -> value,
+ (long)value -> u.integer);
+ } else if (value -> type == omapi_datatype_string) {
+ log_info ("omapi_set_value (%.*s, %.*s)",
+ (int)name -> len, name -> value,
+ (int)value -> u.buffer.len, value -> u.buffer.value);
+ } else if (value -> type == omapi_datatype_data) {
+ log_info ("omapi_set_value (%.*s, %ld %lx)",
+ (int)name -> len, name -> value,
+ (long)value -> u.buffer.len,
+ (unsigned long)value -> u.buffer.value);
+ } else if (value -> type == omapi_datatype_object) {
+ log_info ("omapi_set_value (%.*s, %s)",
+ (int)name -> len, name -> value,
+ value -> u.object
+ ? (value -> u.object -> type
+ ? value -> u.object -> type -> name
+ : "(unknown object)")
+ : "(unknown object)");
+ }
+#endif
+
+ for (outer = h; outer -> outer; outer = outer -> outer)
+ ;
+ if (outer -> type -> set_value)
+ status = (*(outer -> type -> set_value)) (outer,
+ id, name, value);
+ else
+ status = ISC_R_NOTFOUND;
+#if defined (DEBUG)
+ log_info (" ==> %s", isc_result_totext (status));
+#endif
+ return status;
+}
+
+isc_result_t omapi_set_value_str (omapi_object_t *h,
+ omapi_object_t *id,
+ const char *name,
+ omapi_typed_data_t *value)
+{
+ omapi_object_t *outer;
+ omapi_data_string_t *nds;
+ isc_result_t status;
+
+ nds = (omapi_data_string_t *)0;
+ status = omapi_data_string_new (&nds, strlen (name), MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (nds -> value, name, strlen (name));
+
+ status = omapi_set_value (h, id, nds, value);
+ omapi_data_string_dereference (&nds, MDL);
+ return status;
+}
+
+isc_result_t omapi_set_boolean_value (omapi_object_t *h, omapi_object_t *id,
+ const char *name, int value)
+{
+ isc_result_t status;
+ omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
+ omapi_data_string_t *n = (omapi_data_string_t *)0;
+ int len;
+ int ip;
+
+ status = omapi_data_string_new (&n, strlen (name), MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (n -> value, name, strlen (name));
+
+ status = omapi_typed_data_new (MDL, &tv, omapi_datatype_int, value);
+ if (status != ISC_R_SUCCESS) {
+ omapi_data_string_dereference (&n, MDL);
+ return status;
+ }
+
+ status = omapi_set_value (h, id, n, tv);
+ omapi_data_string_dereference (&n, MDL);
+ omapi_typed_data_dereference (&tv, MDL);
+ return status;
+}
+
+isc_result_t omapi_set_int_value (omapi_object_t *h, omapi_object_t *id,
+ const char *name, int value)
+{
+ isc_result_t status;
+ omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
+ omapi_data_string_t *n = (omapi_data_string_t *)0;
+ int len;
+ int ip;
+
+ status = omapi_data_string_new (&n, strlen (name), MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (n -> value, name, strlen (name));
+
+ status = omapi_typed_data_new (MDL, &tv, omapi_datatype_int, value);
+ if (status != ISC_R_SUCCESS) {
+ omapi_data_string_dereference (&n, MDL);
+ return status;
+ }
+
+ status = omapi_set_value (h, id, n, tv);
+ omapi_data_string_dereference (&n, MDL);
+ omapi_typed_data_dereference (&tv, MDL);
+ return status;
+}
+
+isc_result_t omapi_set_object_value (omapi_object_t *h, omapi_object_t *id,
+ const char *name, omapi_object_t *value)
+{
+ isc_result_t status;
+ omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
+ omapi_data_string_t *n = (omapi_data_string_t *)0;
+ int len;
+ int ip;
+
+ status = omapi_data_string_new (&n, strlen (name), MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (n -> value, name, strlen (name));
+
+ status = omapi_typed_data_new (MDL, &tv, omapi_datatype_object, value);
+ if (status != ISC_R_SUCCESS) {
+ omapi_data_string_dereference (&n, MDL);
+ return status;
+ }
+
+ status = omapi_set_value (h, id, n, tv);
+ omapi_data_string_dereference (&n, MDL);
+ omapi_typed_data_dereference (&tv, MDL);
+ return status;
+}
+
+isc_result_t omapi_set_string_value (omapi_object_t *h, omapi_object_t *id,
+ const char *name, const char *value)
+{
+ isc_result_t status;
+ omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
+ omapi_data_string_t *n = (omapi_data_string_t *)0;
+ int len;
+ int ip;
+
+ status = omapi_data_string_new (&n, strlen (name), MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (n -> value, name, strlen (name));
+
+ status = omapi_typed_data_new (MDL, &tv, omapi_datatype_string, value);
+ if (status != ISC_R_SUCCESS) {
+ omapi_data_string_dereference (&n, MDL);
+ return status;
+ }
+
+ status = omapi_set_value (h, id, n, tv);
+ omapi_data_string_dereference (&n, MDL);
+ omapi_typed_data_dereference (&tv, MDL);
+ return status;
+}
+
+isc_result_t omapi_get_value (omapi_object_t *h,
+ omapi_object_t *id,
+ omapi_data_string_t *name,
+ omapi_value_t **value)
+{
+ omapi_object_t *outer;
+
+ for (outer = h; outer -> outer; outer = outer -> outer)
+ ;
+ if (outer -> type -> get_value)
+ return (*(outer -> type -> get_value)) (outer,
+ id, name, value);
+ return ISC_R_NOTFOUND;
+}
+
+isc_result_t omapi_get_value_str (omapi_object_t *h,
+ omapi_object_t *id,
+ const char *name,
+ omapi_value_t **value)
+{
+ omapi_object_t *outer;
+ omapi_data_string_t *nds;
+ isc_result_t status;
+
+ nds = (omapi_data_string_t *)0;
+ status = omapi_data_string_new (&nds, strlen (name), MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (nds -> value, name, strlen (name));
+
+ for (outer = h; outer -> outer; outer = outer -> outer)
+ ;
+ if (outer -> type -> get_value)
+ status = (*(outer -> type -> get_value)) (outer,
+ id, nds, value);
+ else
+ status = ISC_R_NOTFOUND;
+ omapi_data_string_dereference (&nds, MDL);
+ return status;
+}
+
+isc_result_t omapi_stuff_values (omapi_object_t *c,
+ omapi_object_t *id,
+ omapi_object_t *o)
+{
+ omapi_object_t *outer;
+
+ for (outer = o; outer -> outer; outer = outer -> outer)
+ ;
+ if (outer -> type -> stuff_values)
+ return (*(outer -> type -> stuff_values)) (c, id, outer);
+ return ISC_R_NOTFOUND;
+}
+
+isc_result_t omapi_object_create (omapi_object_t **obj, omapi_object_t *id,
+ omapi_object_type_t *type)
+{
+ if (!type -> create)
+ return ISC_R_NOTIMPLEMENTED;
+ return (*(type -> create)) (obj, id);
+}
+
+isc_result_t omapi_object_update (omapi_object_t *obj, omapi_object_t *id,
+ omapi_object_t *src, omapi_handle_t handle)
+{
+ omapi_generic_object_t *gsrc;
+ isc_result_t status;
+ int i;
+
+ if (!src)
+ return ISC_R_INVALIDARG;
+ if (src -> type != omapi_type_generic)
+ return ISC_R_NOTIMPLEMENTED;
+ gsrc = (omapi_generic_object_t *)src;
+ for (i = 0; i < gsrc -> nvalues; i++) {
+ status = omapi_set_value (obj, id,
+ gsrc -> values [i] -> name,
+ gsrc -> values [i] -> value);
+ if (status != ISC_R_SUCCESS && status != ISC_R_UNCHANGED)
+ return status;
+ }
+ if (handle)
+ omapi_set_int_value (obj, id, "remote-handle", (int)handle);
+ status = omapi_signal (obj, "updated");
+ if (status != ISC_R_NOTFOUND)
+ return status;
+ return ISC_R_SUCCESS;
+}
+
+int omapi_data_string_cmp (omapi_data_string_t *s1, omapi_data_string_t *s2)
+{
+ unsigned len;
+ int rv;
+
+ if (s1 -> len > s2 -> len)
+ len = s2 -> len;
+ else
+ len = s1 -> len;
+ rv = memcmp (s1 -> value, s2 -> value, len);
+ if (rv)
+ return rv;
+ if (s1 -> len > s2 -> len)
+ return 1;
+ else if (s1 -> len < s2 -> len)
+ return -1;
+ return 0;
+}
+
+int omapi_ds_strcmp (omapi_data_string_t *s1, const char *s2)
+{
+ unsigned len, slen;
+ int rv;
+
+ slen = strlen (s2);
+ if (slen > s1 -> len)
+ len = s1 -> len;
+ else
+ len = slen;
+ rv = memcmp (s1 -> value, s2, len);
+ if (rv)
+ return rv;
+ if (s1 -> len > slen)
+ return 1;
+ else if (s1 -> len < slen)
+ return -1;
+ return 0;
+}
+
+int omapi_td_strcmp (omapi_typed_data_t *s1, const char *s2)
+{
+ unsigned len, slen;
+ int rv;
+
+ /* If the data type is not compatible, never equal. */
+ if (s1 -> type != omapi_datatype_data &&
+ s1 -> type != omapi_datatype_string)
+ return -1;
+
+ slen = strlen (s2);
+ if (slen > s1 -> u.buffer.len)
+ len = s1 -> u.buffer.len;
+ else
+ len = slen;
+ rv = memcmp (s1 -> u.buffer.value, s2, len);
+ if (rv)
+ return rv;
+ if (s1 -> u.buffer.len > slen)
+ return 1;
+ else if (s1 -> u.buffer.len < slen)
+ return -1;
+ return 0;
+}
+
+int omapi_td_strcasecmp (omapi_typed_data_t *s1, const char *s2)
+{
+ unsigned len, slen;
+ int rv;
+
+ /* If the data type is not compatible, never equal. */
+ if (s1 -> type != omapi_datatype_data &&
+ s1 -> type != omapi_datatype_string)
+ return -1;
+
+ slen = strlen (s2);
+ if (slen > s1 -> u.buffer.len)
+ len = s1 -> u.buffer.len;
+ else
+ len = slen;
+ rv = casecmp (s1 -> u.buffer.value, s2, len);
+ if (rv)
+ return rv;
+ if (s1 -> u.buffer.len > slen)
+ return 1;
+ else if (s1 -> u.buffer.len < slen)
+ return -1;
+ return 0;
+}
+
+isc_result_t omapi_make_value (omapi_value_t **vp,
+ omapi_data_string_t *name,
+ omapi_typed_data_t *value,
+ const char *file, int line)
+{
+ isc_result_t status;
+
+ status = omapi_value_new (vp, file, line);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_data_string_reference (&(*vp) -> name,
+ name, file, line);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ if (value) {
+ status = omapi_typed_data_reference (&(*vp) -> value,
+ value, file, line);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ }
+ return ISC_R_SUCCESS;
+}
+
+isc_result_t omapi_make_const_value (omapi_value_t **vp,
+ omapi_data_string_t *name,
+ const unsigned char *value,
+ unsigned len,
+ const char *file, int line)
+{
+ isc_result_t status;
+
+ status = omapi_value_new (vp, file, line);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_data_string_reference (&(*vp) -> name,
+ name, file, line);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ if (value) {
+ status = omapi_typed_data_new (file, line, &(*vp) -> value,
+ omapi_datatype_data, len);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ memcpy ((*vp) -> value -> u.buffer.value, value, len);
+ }
+ return ISC_R_SUCCESS;
+}
+
+isc_result_t omapi_make_int_value (omapi_value_t **vp,
+ omapi_data_string_t *name,
+ int value, const char *file, int line)
+{
+ isc_result_t status;
+
+ status = omapi_value_new (vp, file, line);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_data_string_reference (&(*vp) -> name,
+ name, file, line);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ status = omapi_typed_data_new (file, line, &(*vp) -> value,
+ omapi_datatype_int, value);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ return ISC_R_SUCCESS;
+}
+
+isc_result_t omapi_make_uint_value (omapi_value_t **vp,
+ omapi_data_string_t *name,
+ unsigned int value,
+ const char *file, int line)
+{
+ return omapi_make_int_value (vp, name, (int)value, file, line);
+}
+
+isc_result_t omapi_make_object_value (omapi_value_t **vp,
+ omapi_data_string_t *name,
+ omapi_object_t *value,
+ const char *file, int line)
+{
+ isc_result_t status;
+
+ status = omapi_value_new (vp, file, line);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_data_string_reference (&(*vp) -> name,
+ name, file, line);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+
+ if (value) {
+ status = omapi_typed_data_new (file, line, &(*vp) -> value,
+ omapi_datatype_object, value);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ }
+
+ return ISC_R_SUCCESS;
+}
+
+isc_result_t omapi_make_handle_value (omapi_value_t **vp,
+ omapi_data_string_t *name,
+ omapi_object_t *value,
+ const char *file, int line)
+{
+ isc_result_t status;
+
+ status = omapi_value_new (vp, file, line);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_data_string_reference (&(*vp) -> name,
+ name, file, line);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ if (value) {
+ status = omapi_typed_data_new (file, line, &(*vp) -> value,
+ omapi_datatype_int);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ status = (omapi_object_handle
+ ((omapi_handle_t *)&(*vp) -> value -> u.integer,
+ value));
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ }
+ return ISC_R_SUCCESS;
+}
+
+isc_result_t omapi_make_string_value (omapi_value_t **vp,
+ omapi_data_string_t *name,
+ const char *value,
+ const char *file, int line)
+{
+ isc_result_t status;
+
+ status = omapi_value_new (vp, file, line);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_data_string_reference (&(*vp) -> name,
+ name, file, line);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ if (value) {
+ status = omapi_typed_data_new (file, line, &(*vp) -> value,
+ omapi_datatype_string, value);
+ if (status != ISC_R_SUCCESS) {
+ omapi_value_dereference (vp, file, line);
+ return status;
+ }
+ }
+ return ISC_R_SUCCESS;
+}
+
+isc_result_t omapi_get_int_value (unsigned long *v, omapi_typed_data_t *t)
+{
+ u_int32_t rv;
+
+ if (t -> type == omapi_datatype_int) {
+ *v = t -> u.integer;
+ return ISC_R_SUCCESS;
+ } else if (t -> type == omapi_datatype_string ||
+ t -> type == omapi_datatype_data) {
+ if (t -> u.buffer.len != sizeof (rv))
+ return ISC_R_INVALIDARG;
+ memcpy (&rv, t -> u.buffer.value, sizeof rv);
+ *v = ntohl (rv);
+ return ISC_R_SUCCESS;
+ }
+ return ISC_R_INVALIDARG;
+}