aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--contrib/isc-dhcp/dhcpctl/Makefile.dist106
-rw-r--r--contrib/isc-dhcp/dhcpctl/callback.c179
-rw-r--r--contrib/isc-dhcp/dhcpctl/cltest.c188
-rw-r--r--contrib/isc-dhcp/dhcpctl/dhcpctl.3470
-rw-r--r--contrib/isc-dhcp/dhcpctl/dhcpctl.c599
-rw-r--r--contrib/isc-dhcp/dhcpctl/dhcpctl.h134
-rw-r--r--contrib/isc-dhcp/dhcpctl/omshell.1341
-rw-r--r--contrib/isc-dhcp/dhcpctl/omshell.c728
-rw-r--r--contrib/isc-dhcp/dhcpctl/remote.c371
9 files changed, 3116 insertions, 0 deletions
diff --git a/contrib/isc-dhcp/dhcpctl/Makefile.dist b/contrib/isc-dhcp/dhcpctl/Makefile.dist
new file mode 100644
index 000000000000..093dcbb38b17
--- /dev/null
+++ b/contrib/isc-dhcp/dhcpctl/Makefile.dist
@@ -0,0 +1,106 @@
+# Makefile.dist
+#
+# Copyright (c) 1996-2002 Internet Software Consortium.
+# Use is subject to license terms which appear in the file named
+# ISC-LICENSE that should have accompanied this file when you
+# received it. If a file named ISC-LICENSE did not accompany this
+# file, or you are not sure the one you have is correct, you may
+# obtain an applicable copy of the license at:
+#
+# http://www.isc.org/isc-license-1.0.html.
+#
+# This file is part of the ISC DHCP distribution. The documentation
+# associated with this file is listed in the file DOCUMENTATION,
+# included in the top-level directory of this release.
+#
+# Support and other services are available for ISC products - see
+# http://www.isc.org for more information.
+#
+
+CATMANPAGES = dhcpctl.cat3 omshell.cat1
+SEDMANPAGES = dhcpctl.man3 omshell.man1
+SRC = dhcpctl.c callback.c remote.c
+OBJ = dhcpctl.o callback.o remote.o
+MAN = dhcpctl.3 omshell.1
+HDRS = dhcpctl.h
+
+INCLUDES = $(BINDINC) -I$(TOP)/includes
+CFLAGS = $(DEBUG) $(PREDEFINES) $(INCLUDES) $(COPTS)
+DHCPCTLLIBS = libdhcpctl.a ../common/libdhcp.a $(BINDLIB) \
+ ../omapip/libomapi.a ../dst/libdst.a
+
+all: libdhcpctl.a omshell cltest $(CATMANPAGES)
+
+omshell: omshell.o $(DHCPCTLLIBS)
+ $(CC) $(DEBUG) $(LFLAGS) -o omshell omshell.o $(DHCPCTLLIBS) $(LIBS)
+
+cltest: cltest.o $(DHCPCTLLIBS)
+ $(CC) $(DEBUG) $(LFLAGS) -o cltest cltest.o $(DHCPCTLLIBS) $(LIBS)
+
+libdhcpctl.a: $(OBJ)
+ rm -f libdhcpctl.a
+ ar cruv libdhcpctl.a $(OBJ)
+ $(RANLIB) libdhcpctl.a
+
+install: all $(CATMANPAGES)
+ for dir in $(LIBDIR) $(LIBMANDIR) $(INCDIR) $(USRMANDIR) \
+ $(USERBINDIR); do \
+ foo=""; \
+ for bar in `echo $(DESTDIR)$${dir} |tr / ' '`; do \
+ foo=$${foo}/$$bar; \
+ if [ ! -d $$foo ]; then \
+ mkdir $$foo; \
+ chmod 755 $$foo; \
+ fi; \
+ done; \
+ done
+ $(INSTALL) libdhcpctl.a $(DESTDIR)$(LIBDIR)
+ $(CHMOD) 644 $(DESTDIR)$(LIBDIR)/libdhcpctl.a
+ $(INSTALL) dhcpctl.h $(DESTDIR)$(INCDIR)
+ $(CHMOD) 644 $(DESTDIR)$(INCDIR)/dhcpctl.h
+ for man in $(MAN); do \
+ prefix=`echo $$man |sed -e 's/\.[0-9]$$//'`; \
+ suffix=`echo $$man |sed -e 's/.*\.\([0-9]\)$$/\1/'`; \
+ $(MANINSTALL) $(MANFROM) $${prefix}.$(MANCAT)$${suffix} $(MANTO) \
+ $(DESTDIR)$(LIBMANDIR)/$${prefix}$(LIBMANEXT); \
+ done
+ $(INSTALL) omshell $(DESTDIR)$(USERBINDIR)
+ $(CHMOD) 755 $(DESTDIR)$(USERBINDIR)/omshell
+ $(MANINSTALL) $(MANFROM) omshell.$(MANCAT)1 $(MANTO) \
+ $(DESTDIR)$(USRMANDIR)/omshell$(USRMANEXT)
+
+depend:
+ $(MKDEP) $(INCLUDES) $(PREDEFINES) $(SRC)
+
+clean:
+ -rm -f $(OBJ) test.o svtest cltest.o cltest
+
+realclean: clean
+ -rm -f libdhcpctl.a *~ $(CATMANPAGES) $(SEDMANPAGES)
+
+distclean: realclean
+ -rm -f Makefile
+
+links:
+ @for foo in $(SRC) $(MAN) omshell.c cltest.c $(HDRS); do \
+ if [ ! -b $$foo ]; then \
+ rm -f $$foo; \
+ fi; \
+ ln -s $(TOP)/dhcpctl/$$foo $$foo; \
+ done
+
+dhcpctl.cat3: dhcpctl.man3
+ nroff -man dhcpctl.man3 >dhcpctl.cat3
+
+dhcpctl.man3: dhcpctl.3
+ sed -e "s#ETCDIR#$(ETC)#g" -e "s#DBDIR#$(VARDB)#g" \
+ -e "s#RUNDIR#$(VARRUN)#g" < dhcpctl.3 >dhcpctl.man3
+
+omshell.cat1: omshell.man1
+ nroff -man omshell.man1 >omshell.cat1
+
+omshell.man1: omshell.1
+ sed -e "s#ETCDIR#$(ETC)#g" -e "s#DBDIR#$(VARDB)#g" \
+ -e "s#RUNDIR#$(VARRUN)#g" < omshell.1 >omshell.man1
+
+# Dependencies (semi-automatically-generated)
diff --git a/contrib/isc-dhcp/dhcpctl/callback.c b/contrib/isc-dhcp/dhcpctl/callback.c
new file mode 100644
index 000000000000..af1364c19171
--- /dev/null
+++ b/contrib/isc-dhcp/dhcpctl/callback.c
@@ -0,0 +1,179 @@
+/* callback.c
+
+ The dhcpctl callback object. */
+
+/*
+ * Copyright (c) 1999-2002 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>
+#include "dhcpctl.h"
+
+/* dhcpctl_set_callback
+
+ synchronous, with asynchronous aftereffect
+ handle is some object upon which some kind of process has been
+ started - e.g., an open, an update or a refresh.
+ data is an anonymous pointer containing some information that
+ the callback will use to figure out what event completed.
+ return value of 0 means callback was successfully set, a nonzero
+ status code is returned otherwise.
+ Upon completion of whatever task is in process, the callback
+ will be passed the handle to the object, a status code
+ indicating what happened, and the anonymous pointer passed to */
+
+dhcpctl_status dhcpctl_set_callback (dhcpctl_handle h, void *data,
+ void (*func) (dhcpctl_handle,
+ dhcpctl_status, void *))
+{
+ dhcpctl_callback_object_t *callback;
+ omapi_object_t *inner;
+ isc_result_t status;
+
+ callback = dmalloc (sizeof *callback, MDL);
+ if (!callback)
+ return ISC_R_NOMEMORY;
+
+ /* Tie the callback object to the innermost object in the chain. */
+ for (inner = h; inner -> inner; inner = inner -> inner)
+ ;
+ omapi_object_reference (&inner -> inner,
+ (omapi_object_t *)callback, MDL);
+ omapi_object_reference ((omapi_object_t **)&callback -> outer,
+ inner, MDL);
+
+ /* Save the actual handle pointer we were passed for the callback. */
+ omapi_object_reference (&callback -> object, h, MDL);
+ callback -> data = data;
+ callback -> callback = func;
+
+ return ISC_R_SUCCESS;
+}
+
+/* Callback methods (not meant to be called directly) */
+
+isc_result_t dhcpctl_callback_set_value (omapi_object_t *h,
+ omapi_object_t *id,
+ omapi_data_string_t *name,
+ omapi_typed_data_t *value)
+{
+ if (h -> type != dhcpctl_callback_type)
+ return ISC_R_INVALIDARG;
+
+ if (h -> inner && h -> inner -> type -> set_value)
+ return (*(h -> inner -> type -> set_value))
+ (h -> inner, id, name, value);
+ return ISC_R_NOTFOUND;
+}
+
+isc_result_t dhcpctl_callback_get_value (omapi_object_t *h,
+ omapi_object_t *id,
+ omapi_data_string_t *name,
+ omapi_value_t **value)
+{
+ if (h -> type != dhcpctl_callback_type)
+ return ISC_R_INVALIDARG;
+
+ if (h -> inner && h -> inner -> type -> get_value)
+ return (*(h -> inner -> type -> get_value))
+ (h -> inner, id, name, value);
+ return ISC_R_NOTFOUND;
+}
+
+isc_result_t dhcpctl_callback_signal_handler (omapi_object_t *o,
+ const char *name, va_list ap)
+{
+ dhcpctl_callback_object_t *p;
+ isc_result_t waitstatus;
+
+ if (o -> type != dhcpctl_callback_type)
+ return ISC_R_INVALIDARG;
+ p = (dhcpctl_callback_object_t *)o;
+
+ /* Not a signal we recognize? */
+ if (strcmp (name, "ready")) {
+ if (p -> inner && p -> inner -> type -> signal_handler)
+ return (*(p -> inner -> type -> signal_handler))
+ (p -> inner, name, ap);
+ return ISC_R_NOTFOUND;
+ }
+
+ if (p -> object -> type == dhcpctl_remote_type) {
+ waitstatus = (((dhcpctl_remote_object_t *)
+ (p -> object)) -> waitstatus);
+ } else
+ waitstatus = ISC_R_SUCCESS;
+
+ /* Do the callback. */
+ if (p -> callback)
+ (*(p -> callback)) (p -> object, waitstatus, p -> data);
+
+ return ISC_R_SUCCESS;
+}
+
+isc_result_t dhcpctl_callback_destroy (omapi_object_t *h,
+ const char *file, int line)
+{
+ dhcpctl_callback_object_t *p;
+ if (h -> type != dhcpctl_callback_type)
+ return ISC_R_INVALIDARG;
+ p = (dhcpctl_callback_object_t *)h;
+ if (p -> handle)
+ omapi_object_dereference ((omapi_object_t **)&p -> handle,
+ file, line);
+ return ISC_R_SUCCESS;
+}
+
+/* Write all the published values associated with the object through the
+ specified connection. */
+
+isc_result_t dhcpctl_callback_stuff_values (omapi_object_t *c,
+ omapi_object_t *id,
+ omapi_object_t *p)
+{
+ int i;
+
+ if (p -> type != dhcpctl_callback_type)
+ return ISC_R_INVALIDARG;
+
+ if (p -> inner && p -> inner -> type -> stuff_values)
+ return (*(p -> inner -> type -> stuff_values)) (c, id,
+ p -> inner);
+ return ISC_R_SUCCESS;
+}
+
diff --git a/contrib/isc-dhcp/dhcpctl/cltest.c b/contrib/isc-dhcp/dhcpctl/cltest.c
new file mode 100644
index 000000000000..e38574f1b8a8
--- /dev/null
+++ b/contrib/isc-dhcp/dhcpctl/cltest.c
@@ -0,0 +1,188 @@
+/* cltest.c
+
+ Example program that uses the dhcpctl library. */
+
+/* Copyright (C) 2000-2002 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 was contributed to the Internet Software Consortium
+ * by Brian Murrell.
+ */
+
+#include <time.h>
+#include <sys/time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <isc-dhcp/result.h>
+#include "dhcpctl.h"
+
+int main (int, char **);
+
+enum modes { up, down, undefined };
+
+static void usage (char *s) {
+ fprintf (stderr,
+ "Usage: %s [-n <username>] [-p <password>] [-a <algorithm>]"
+ "(-u | -d) <if>\n", s);
+ exit (1);
+}
+
+int main (argc, argv)
+ int argc;
+ char **argv;
+{
+ isc_result_t status, waitstatus;
+ dhcpctl_handle authenticator;
+ dhcpctl_handle connection;
+ dhcpctl_handle host_handle, group_handle, interface_handle;
+ dhcpctl_data_string cid;
+ dhcpctl_data_string result, groupname, identifier;
+ int i;
+ int mode = undefined;
+ const char *interface = 0;
+ const char *action;
+
+ for (i = 1; i < argc; i++) {
+ if (!strcmp (argv[i], "-u")) {
+ mode = up;
+ } else if (!strcmp (argv [i], "-d")) {
+ mode = down;
+ } else if (argv[i][0] == '-') {
+ usage(argv[0]);
+ } else {
+ interface = argv[i];
+ }
+ }
+
+ if (!interface)
+ usage(argv[0]);
+ if (mode == undefined)
+ usage(argv[0]);
+
+ status = dhcpctl_initialize ();
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_initialize: %s\n",
+ isc_result_totext (status));
+ exit (1);
+ }
+
+ authenticator = dhcpctl_null_handle;
+ connection = dhcpctl_null_handle;
+
+ status = dhcpctl_connect (&connection, "127.0.0.1", 7911,
+ authenticator);
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_connect: %s\n",
+ isc_result_totext (status));
+ exit (1);
+ }
+
+ interface_handle = dhcpctl_null_handle;
+ status = dhcpctl_new_object (&interface_handle,
+ connection, "interface");
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_new_object: %s\n",
+ isc_result_totext (status));
+ exit (1);
+ }
+
+ status = dhcpctl_set_string_value (interface_handle,
+ interface, "name");
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_set_value: %s\n",
+ isc_result_totext (status));
+ exit (1);
+ }
+
+ if (mode == up) {
+ /* "up" the interface */
+ printf ("upping interface %s\n", interface);
+ action = "create";
+ status = dhcpctl_open_object (interface_handle, connection,
+ DHCPCTL_CREATE | DHCPCTL_EXCL);
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_open_object: %s\n",
+ isc_result_totext (status));
+ exit (1);
+ }
+ } else {
+ /* down the interface */
+ printf ("downing interface %s\n", interface);
+ action = "remove";
+ status = dhcpctl_open_object (interface_handle, connection, 0);
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_open_object: %s\n",
+ isc_result_totext (status));
+ exit (1);
+ }
+ status = dhcpctl_wait_for_completion (interface_handle,
+ &waitstatus);
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_wait_for_completion: %s\n",
+ isc_result_totext (status));
+ exit (1);
+ }
+ if (waitstatus != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_wait_for_completion: %s\n",
+ isc_result_totext (waitstatus));
+ exit (1);
+ }
+ status = dhcpctl_object_remove (connection, interface_handle);
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_open_object: %s\n",
+ isc_result_totext (status));
+ exit (1);
+ }
+ }
+
+ status = dhcpctl_wait_for_completion (interface_handle, &waitstatus);
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_wait_for_completion: %s\n",
+ isc_result_totext (status));
+ exit (1);
+ }
+ if (waitstatus != ISC_R_SUCCESS) {
+ fprintf (stderr, "interface object %s: %s\n", action,
+ isc_result_totext (waitstatus));
+ exit (1);
+ }
+
+ memset (&result, 0, sizeof result);
+ status = dhcpctl_get_value (&result, interface_handle, "state");
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_get_value: %s\n",
+ isc_result_totext (status));
+ exit (1);
+ }
+
+ exit (0);
+}
diff --git a/contrib/isc-dhcp/dhcpctl/dhcpctl.3 b/contrib/isc-dhcp/dhcpctl/dhcpctl.3
new file mode 100644
index 000000000000..8ab7918f8c34
--- /dev/null
+++ b/contrib/isc-dhcp/dhcpctl/dhcpctl.3
@@ -0,0 +1,470 @@
+.\" -*- nroff -*-
+.\"
+.\" Project: DHCP
+.\" File: dhcpctl.3
+.\" RCSId: $Id: dhcpctl.3,v 1.3.2.1 2001/06/26 18:35:35 mellon Exp $
+.\"
+.\" Copyright (C) 2000 Nominum, Inc.
+.\"
+.\" Description: dhcpctl man page.
+.\"
+.\"
+.Dd Nov 15, 2000
+.Dt DHCPCTL 3
+.Os DHCP 3
+.ds vT DHCP Programmer's Manual
+.\"
+.\"
+.\"
+.Sh NAME
+.Nm dhcpctl_initialize
+.Nd dhcpctl library initialization.
+.\"
+.\"
+.\"
+.Sh SYNOPSIS
+.Fd #include <dhcpctl/dhcpctl.h>
+.Fd
+.Ft dhcpctl_status
+.Fo dhcpctl_initialize
+.Fa void
+.Fc
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_connect
+.Fa "dhcpctl_handle *cxn"
+.Fa "const char *host"
+.Fa "int port"
+.Fa "dhcpctl_handle auth"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_wait_for_completion
+.Fa "dhcpctl_handle object"
+.Fa "dhcpctl_status *status"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_get_value
+.Fa "dhcpctl_data_string *value"
+.Fa "dhcpctl_handle object"
+.Fa "const char *name"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_get_boolean
+.Fa "int *value"
+.Fa "dhcpctl_handle object"
+.Fa "const char *name"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_set_value
+.Fa "dhcpctl_handle object"
+.Fa "dhcpctl_data_string value"
+.Fa "const char *name"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_set_string_value
+.Fa "dhcpctl_handle object"
+.Fa "const char *value"
+.Fa "const char *name"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_set_boolean_value
+.Fa "dhcpctl_handle object"
+.Fa "int value"
+.Fa "const char *name"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_set_int_value
+.Fa "dhcpctl_handle object"
+.Fa "int value"
+.Fa "const char *name"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_object_update
+.Fa "dhcpctl_handle connection"
+.Fa "dhcpctl_handle object"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_object_refresh
+.Fa "dhcpctl_handle connection"
+.Fa "dhcpctl_handle object"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_object_remove
+.Fa "dhcpctl_handle connection"
+.Fa "dhcpctl_handle object"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_set_callback
+.Fa "dhcpctl_handle object"
+.Fa "void *data"
+.Fa "void (*function) (dhcpctl_handle, dhcpctl_status, void *)"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_new_authenticator
+.Fa "dhcpctl_handle *object"
+.Fa "const char *name"
+.Fa "const char *algorithm"
+.Fa "const char *secret"
+.Fa "unsigned secret_len"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_new_object
+.Fa "dhcpctl_handle *object"
+.Fa "dhcpctl_handle connection"
+.Fa "const char *object_type"
+.Fc
+.\"
+.\"
+.\"
+.Ft dhcpctl_status
+.Fo dhcpctl_open_object
+.Fa "dhcpctl_handle object"
+.Fa "dhcpctl_handle connection"
+.Fa "int flags"
+.Fc
+.\"
+.\"
+.\"
+.Ft isc_result_t
+.Fo omapi_data_string_new
+.Fa dhcpctl_data_string *data
+.Fa unsigned int length
+.Fa const char *filename,
+.Fa int lineno
+.Fc
+.\"
+.\"
+.\"
+.Ft isc_result_t
+.Fo dhcpctl_data_string_dereference
+.Fa "dhcpctl_data_string *"
+.Fa "const char *"
+.Fa "int"
+.Fc
+.Sh DESCRIPTION
+The dhcpctl set of functions provide an API that can be used to communicate
+with and manipulate a running ISC DHCP server. All functions return a value of
+.Dv isc_result_t .
+The return values reflects the result of operations to local data
+structures. If an operation fails on the server for any reason, then the error
+result will be returned through the
+second parameter of the
+.Fn dhcpctl_wait_for_completion
+call.
+.\"
+.\"
+.\"
+.Pp
+.Fn dhcpctl_initialize
+sets up the data structures the library needs to do its work. This function
+must be called once before any other.
+.Pp
+.Fn dhcpctl_connect
+opens a connection to the DHCP server at the given host and port. If an
+authenticator has been created for the connection, then it is given as the 4th
+argument. On a successful return the address pointed at by the first
+argument will have a new connection object assigned to it.
+.Pp
+For example:
+.Bd -literal -offset indent
+s = dhcpctl_connect(&cxn, "127.0.0.1", 7911, NULL);
+.Ed
+.Pp
+connects to the DHCP server on the localhost via port 7911 (the standard
+OMAPI port). No authentication is used for the connection.
+.\"
+.\"
+.\"
+.Pp
+.Fn dhcpctl_wait_for_completion
+flushes a pending message to the server and waits for the response. The result
+of the request as processed on the server is returned via the second
+parameter.
+.Bd -literal -offset indent
+s = dhcpctl_wait_for_completion(cxn, &wv);
+if (s != ISC_R_SUCCESS)
+ local_failure(s);
+else if (wv != ISC_R_SUCCESS)
+ server_failure(wc);
+.Ed
+.Pp
+The call to
+.Fn dhcpctl_wait_for_completion
+won't return until the remote message processing completes or the connection
+to the server is lost.
+.\"
+.\"
+.\"
+.Pp
+.Fn dhcpctl_get_value
+extracts a value of an attribute from the handle. The value can be of any
+length and is treated as a sequence of bytes. The handle must have been
+created first with
+.Fn dhcpctl_new_object
+and opened with
+.Fn dhcpctl_open_object .
+The value is returned via the parameter named
+.Dq value .
+The last parameter is the name of attribute to retrieve.
+.Bd -literal -offset indent
+dhcpctl_data_string value = NULL;
+dhcpctl_handle lease;
+time_t thetime;
+
+s = dhcpctl_get_value (&value, lease, "ends");
+assert(s == ISC_R_SUCCESS && value->len == sizeof(thetime));
+memcpy(&thetime, value->value, value->len);
+.Ed
+.\"
+.\"
+.\"
+.Pp
+.Fn dhcpctl_get_boolean
+extracts a boolean valued attribute from the object handle.
+.\"
+.\"
+.\"
+.Pp
+The
+.Fn dhcpctl_set_value ,
+.Fn dhcpctl_set_string_value ,
+.Fn dhcpctl_set_boolean_value ,
+and
+.Fn dhcpctl_set_int_value
+functions all set a value on the object handle.
+.\"
+.\"
+.\"
+.Pp
+.Fn dhcpctl_object_update
+function queues a request for
+all the changes made to the object handle be be sent to the remote
+for processing. The changes made to the atributes on the handle will be
+applied to remote object if permitted.
+.\"
+.\"
+.\"
+.Pp
+.Fn dhcpctl_object_refresh
+queues up a request for a fresh copy of all the attribute values to be sent
+from the remote to
+refresh the values in the local object handle.
+.\"
+.\"
+.\"
+.Pp
+.Fn dhcpctl_object_remove
+queues a request for the removal on the server of the object referenced by the
+handle.
+.\"
+.\"
+.\"
+.Pp
+The
+.Fn dhcpctl_set_callback
+function sets up a user-defined function to be called when an event completes
+on the given object handle. This is needed for asynchronous handling of
+events, versus the synchronous handling given by
+.Fn dhcpctl_wait_for_completion .
+When the function is called the first parameter is the object the event
+arrived for, the second is the status of the message that was processed, the
+third is the same value as the second parameter given to
+.Fn dhcpctl_set_callback .
+.\"
+.\"
+.\"
+.Pp
+The
+.Fn dhcpctl_new_authenticator
+creates a new authenticator object to be used for signing the messages
+that cross over the network. The
+.Dq name ,
+.Dq algorithm ,
+and
+.Dq secret
+values must all match what the server uses and are defined in its
+configuration file. The created object is returned through the first parameter
+and must be used as the 4th parameter to
+.Fn dhcpctl_connect .
+.\"
+.\"
+.\"
+.Pp
+.Fn dhcpctl_new_object
+creates a local handle for an object on the the server. The
+.Dq object_type
+parameter is the ascii name of the type of object being accessed. e.g.
+.Qq lease .
+This function only sets up local data structures, it does not queue any
+messages
+to be sent to the remote side,
+.Fn dhcpctl_open_object
+does that.
+.\"
+.\"
+.\"
+.Pp
+.Fn dhcpctl_open_object
+builds and queues the request to the remote side. This function is used with
+handle created via
+.Fn dhcpctl_new_object .
+The flags argument is a bit mask with the following values available for
+setting:
+.Bl -tag -offset indent -width 20
+.It DHCPCTL_CREATE
+if the object does not exist then the remote will create it
+.It DHCPCTL_UPDATE
+update the object on the remote side using the
+attributes already set in the handle.
+.It DHCPCTL_EXCL
+return and error if the object exists and DHCPCTL_CREATE
+was also specified
+.El
+.\"
+.\"
+.\"
+.Pp
+The
+.Fn omapi_data_string_new
+function allocates a new
+.Ft dhcpctl_data_string
+object. The data string will be large enough to hold
+.Dq length
+bytes of data. The
+.Dq file
+and
+.Dq lineno
+arguments are the source file location the call is made from, typically by
+using the
+.Dv __FILE__
+and
+.Dv __LINE__
+macros or the
+.Dv MDL
+macro defined in
+.
+.\"
+.\"
+.\"
+.Pp
+.Fn dhcpctl_data_string_dereference
+deallocates a data string created by
+.Fn omapi_data_string_new .
+The memory for the object won't be freed until the last reference is
+released.
+.Sh EXAMPLES
+.Pp
+The following program will connect to the DHCP server running on the local
+host and will get the details of the existing lease for IP address
+10.0.0.101. It will then print out the time the lease is due to expire. Note
+that most error checking has been ommitted for brevity.
+.Bd -literal -offset indent
+#include <stdarg.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <stdio.h>
+#include <netinet/in.h>
+
+#include <isc/result.h>
+#include <dhcpctl/dhcpctl.h>
+
+int main (int argc, char **argv) {
+ dhcpctl_data_string ipaddrstring = NULL;
+ dhcpctl_data_string value = NULL;
+ dhcpctl_handle connection = NULL;
+ dhcpctl_handle lease = NULL;
+ isc_result_t waitstatus;
+ struct in_addr convaddr;
+ time_t thetime;
+
+ dhcpctl_initialize ();
+
+ dhcpctl_connect (&connection, "127.0.0.1",
+ 7911, 0);
+
+ dhcpctl_new_object (&lease, connection,
+ "lease");
+
+ memset (&ipaddrstring, 0, sizeof
+ ipaddrstring);
+
+ inet_pton(AF_INET, "10.0.0.101",
+ &convaddr);
+
+ omapi_data_string_new (&ipaddrstring,
+ 4, MDL);
+ memcpy(ipaddrstring->value, &convaddr.s_addr, 4);
+
+ dhcpctl_set_value (lease, ipaddrstring,
+ "ip-address");
+
+ dhcpctl_open_object (lease, connection, 0);
+
+ dhcpctl_wait_for_completion (lease,
+ &waitstatus);
+ if (waitstatus != ISC_R_SUCCESS) {
+ /* server not authoritative */
+ exit (0);
+ }
+
+ dhcpctl_data_string_dereference(&ipaddrstring,
+ MDL);
+
+ dhcpctl_get_value (&value, lease, "ends");
+
+ memcpy(&thetime, value->value, value->len);
+
+ dhcpctl_data_string_dereference(&value, MDL);
+
+ fprintf (stdout, "ending time is %s",
+ ctime(&thetime));
+}
+.Ed
+.Sh SEE ALSO
+.SH SEE ALSO
+omapi(3), omshell(3), dhcpd(8), dhclient(8), dhcpd.conf(5), dhclient.conf(5).
+.SH AUTHOR
+.B dhcpctl
+was written by Ted Lemon of Nominum, Inc. Information about Nominum
+and support contracts for DHCP and BIND can be found at
+.B http://www.nominum.com. This preliminary documentation was
+written by James Brister of Nominum, Inc.
diff --git a/contrib/isc-dhcp/dhcpctl/dhcpctl.c b/contrib/isc-dhcp/dhcpctl/dhcpctl.c
new file mode 100644
index 000000000000..2cb43034b043
--- /dev/null
+++ b/contrib/isc-dhcp/dhcpctl/dhcpctl.c
@@ -0,0 +1,599 @@
+/* dhcpctl.c
+
+ Subroutines providing general support for objects. */
+
+/*
+ * Copyright (c) 1999-2002 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>
+#include "dhcpctl.h"
+
+omapi_object_type_t *dhcpctl_callback_type;
+omapi_object_type_t *dhcpctl_remote_type;
+
+/* dhcpctl_initialize ()
+
+ Must be called before any other dhcpctl function. */
+
+dhcpctl_status dhcpctl_initialize ()
+{
+ isc_result_t status;
+
+ status = omapi_init();
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_object_type_register (&dhcpctl_callback_type,
+ "dhcpctl-callback",
+ dhcpctl_callback_set_value,
+ dhcpctl_callback_get_value,
+ dhcpctl_callback_destroy,
+ dhcpctl_callback_signal_handler,
+ dhcpctl_callback_stuff_values,
+ 0, 0, 0, 0, 0, 0,
+ sizeof
+ (dhcpctl_callback_object_t), 0,
+ RC_MISC);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ status = omapi_object_type_register (&dhcpctl_remote_type,
+ "dhcpctl-remote",
+ dhcpctl_remote_set_value,
+ dhcpctl_remote_get_value,
+ dhcpctl_remote_destroy,
+ dhcpctl_remote_signal_handler,
+ dhcpctl_remote_stuff_values,
+ 0, 0, 0, 0, 0, 0,
+ sizeof (dhcpctl_remote_object_t),
+ 0, RC_MISC);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ return ISC_R_SUCCESS;
+}
+
+/* dhcpctl_connect
+
+ synchronous
+ returns nonzero status code if it didn't connect, zero otherwise
+ stores connection handle through connection, which can be used
+ for subsequent access to the specified server.
+ server_name is the name of the server, and port is the TCP
+ port on which it is listening.
+ authinfo is the handle to an object containing authentication
+ information. */
+
+dhcpctl_status dhcpctl_connect (dhcpctl_handle *connection,
+ const char *server_name, int port,
+ dhcpctl_handle authinfo)
+{
+ isc_result_t status;
+ dhcpctl_status waitstatus;
+
+ status = omapi_generic_new (connection, MDL);
+ if (status != ISC_R_SUCCESS) {
+ return status;
+ }
+
+ status = omapi_protocol_connect (*connection, server_name,
+ (unsigned)port, authinfo);
+ if (status == ISC_R_SUCCESS)
+ return status;
+ if (status != ISC_R_INCOMPLETE) {
+ omapi_object_dereference (connection, MDL);
+ return status;
+ }
+
+ status = omapi_wait_for_completion (*connection, 0);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (connection, MDL);
+ return status;
+ }
+
+ return status;
+}
+
+/* dhcpctl_wait_for_completion
+
+ synchronous
+ returns zero if the callback completes, a nonzero status if
+ there was some problem relating to the wait operation. The
+ status of the queued request will be stored through s, and
+ will also be either zero for success or nonzero for some kind
+ of failure. Never returns until completion or until the
+ connection to the server is lost. This performs the same
+ function as dhcpctl_set_callback and the subsequent callback,
+ for programs that want to do inline execution instead of using
+ callbacks. */
+
+dhcpctl_status dhcpctl_wait_for_completion (dhcpctl_handle h,
+ dhcpctl_status *s)
+{
+ isc_result_t status;
+ status = omapi_wait_for_completion (h, 0);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ if (h -> type == dhcpctl_remote_type)
+ *s = ((dhcpctl_remote_object_t *)h) -> waitstatus;
+ return ISC_R_SUCCESS;
+}
+
+/* dhcpctl_get_value
+
+ synchronous
+ returns zero if the call succeeded, a nonzero status code if
+ it didn't.
+ result is the address of an empty data string (initialized
+ with bzero or cleared with data_string_forget). On
+ successful completion, the addressed data string will contain
+ the value that was fetched.
+ dhcpctl_handle refers to some dhcpctl item
+ value_name refers to some value related to that item - e.g.,
+ for a handle associated with a completed host lookup, value
+ could be one of "hardware-address", "dhcp-client-identifier",
+ "known" or "client-hostname". */
+
+dhcpctl_status dhcpctl_get_value (dhcpctl_data_string *result,
+ dhcpctl_handle h, const char *value_name)
+{
+ isc_result_t status;
+ omapi_value_t *tv = (omapi_value_t *)0;
+ omapi_data_string_t *value = (omapi_data_string_t *)0;
+ unsigned len;
+ int ip;
+
+ status = omapi_get_value_str (h, (omapi_object_t *)0, value_name, &tv);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ switch (tv -> value -> type) {
+ case omapi_datatype_int:
+ len = sizeof (int);
+ break;
+
+ case omapi_datatype_string:
+ case omapi_datatype_data:
+ len = tv -> value -> u.buffer.len;
+ break;
+
+ case omapi_datatype_object:
+ len = sizeof (omapi_handle_t);
+ break;
+
+ default:
+ omapi_typed_data_dereference (&tv -> value, MDL);
+ return ISC_R_UNEXPECTED;
+ }
+
+ status = omapi_data_string_new (result, len, MDL);
+ if (status != ISC_R_SUCCESS) {
+ omapi_typed_data_dereference (&tv -> value, MDL);
+ return status;
+ }
+
+ switch (tv -> value -> type) {
+ case omapi_datatype_int:
+ ip = htonl (tv -> value -> u.integer);
+ memcpy ((*result) -> value, &ip, sizeof ip);
+ break;
+
+ case omapi_datatype_string:
+ case omapi_datatype_data:
+ memcpy ((*result) -> value,
+ tv -> value -> u.buffer.value,
+ tv -> value -> u.buffer.len);
+ break;
+
+ case omapi_datatype_object:
+ ip = htonl (tv -> value -> u.object -> handle);
+ memcpy ((*result) -> value, &ip, sizeof ip);
+ break;
+ }
+
+ omapi_value_dereference (&tv, MDL);
+ return ISC_R_SUCCESS;
+}
+
+/* dhcpctl_get_boolean
+
+ like dhcpctl_get_value, but more convenient for boolean
+ values, since no data_string needs to be dealt with. */
+
+dhcpctl_status dhcpctl_get_boolean (int *result,
+ dhcpctl_handle h, const char *value_name)
+{
+ isc_result_t status;
+ dhcpctl_data_string data = (dhcpctl_data_string)0;
+ int rv;
+
+ status = dhcpctl_get_value (&data, h, value_name);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ if (data -> len != sizeof rv) {
+ omapi_data_string_dereference (&data, MDL);
+ return ISC_R_UNEXPECTED;
+ }
+ memcpy (&rv, data -> value, sizeof rv);
+ *result = ntohl (rv);
+ return ISC_R_SUCCESS;
+}
+
+/* dhcpctl_set_value
+
+ Sets a value on an object referred to by a dhcpctl_handle.
+ The opposite of dhcpctl_get_value. Does not update the
+ server - just sets the value on the handle. */
+
+dhcpctl_status dhcpctl_set_value (dhcpctl_handle h, dhcpctl_data_string value,
+ const char *value_name)
+{
+ isc_result_t status;
+ omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
+ omapi_data_string_t *name = (omapi_data_string_t *)0;
+ int len;
+
+ status = omapi_data_string_new (&name, strlen (value_name), MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (name -> value, value_name, strlen (value_name));
+
+ status = omapi_typed_data_new (MDL, &tv, omapi_datatype_data,
+ value -> len);
+ if (status != ISC_R_SUCCESS) {
+ omapi_data_string_dereference (&name, MDL);
+ return status;
+ }
+ memcpy (tv -> u.buffer.value, value -> value, value -> len);
+
+ status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
+ omapi_data_string_dereference (&name, MDL);
+ omapi_typed_data_dereference (&tv, MDL);
+ return status;
+}
+
+/* dhcpctl_set_string_value
+
+ Sets a NUL-terminated ASCII value on an object referred to by
+ a dhcpctl_handle. like dhcpctl_set_value, but saves the
+ trouble of creating a data_string for a NUL-terminated string.
+ Does not update the server - just sets the value on the handle. */
+
+dhcpctl_status dhcpctl_set_string_value (dhcpctl_handle h, const char *value,
+ const char *value_name)
+{
+ isc_result_t status;
+ omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
+ omapi_data_string_t *name = (omapi_data_string_t *)0;
+ int len;
+
+ status = omapi_data_string_new (&name, strlen (value_name), MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (name -> value, value_name, strlen (value_name));
+
+ status = omapi_typed_data_new (MDL, &tv, omapi_datatype_string, value);
+ if (status != ISC_R_SUCCESS) {
+ omapi_data_string_dereference (&name, MDL);
+ return status;
+ }
+
+ status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
+ omapi_data_string_dereference (&name, MDL);
+ omapi_typed_data_dereference (&tv, MDL);
+ return status;
+}
+
+/* dhcpctl_set_buffer_value
+
+ Sets a value on an object referred to by a dhcpctl_handle. like
+ dhcpctl_set_value, but saves the trouble of creating a data_string
+ for string for which we have a buffer and length. Does not update
+ the server - just sets the value on the handle. */
+
+dhcpctl_status dhcpctl_set_data_value (dhcpctl_handle h,
+ const char *value, unsigned len,
+ const char *value_name)
+{
+ isc_result_t status;
+ omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
+ omapi_data_string_t *name = (omapi_data_string_t *)0;
+ unsigned ll;
+
+ ll = strlen (value_name);
+ status = omapi_data_string_new (&name, ll, MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (name -> value, value_name, ll);
+
+ status = omapi_typed_data_new (MDL, &tv,
+ omapi_datatype_data, len, value);
+ if (status != ISC_R_SUCCESS) {
+ omapi_data_string_dereference (&name, MDL);
+ return status;
+ }
+ memcpy (tv -> u.buffer.value, value, len);
+
+ status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
+ omapi_data_string_dereference (&name, MDL);
+ omapi_typed_data_dereference (&tv, MDL);
+ return status;
+}
+
+/* dhcpctl_set_null_value
+
+ Sets a null value on an object referred to by a dhcpctl_handle. */
+
+dhcpctl_status dhcpctl_set_null_value (dhcpctl_handle h,
+ const char *value_name)
+{
+ isc_result_t status;
+ omapi_data_string_t *name = (omapi_data_string_t *)0;
+ unsigned ll;
+
+ ll = strlen (value_name);
+ status = omapi_data_string_new (&name, ll, MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (name -> value, value_name, ll);
+
+ status = omapi_set_value (h, (omapi_object_t *)0, name,
+ (omapi_typed_data_t *)0);
+ omapi_data_string_dereference (&name, MDL);
+ return status;
+}
+
+/* dhcpctl_set_boolean_value
+
+ Sets a boolean value on an object - like dhcpctl_set_value,
+ only more convenient for booleans. */
+
+dhcpctl_status dhcpctl_set_boolean_value (dhcpctl_handle h, int value,
+ const char *value_name)
+{
+ isc_result_t status;
+ omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
+ omapi_data_string_t *name = (omapi_data_string_t *)0;
+ int len;
+
+ status = omapi_data_string_new (&name, strlen (value_name), MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (name -> value, value_name, strlen (value_name));
+
+ status = omapi_typed_data_new (MDL, &tv, omapi_datatype_int, value);
+ if (status != ISC_R_SUCCESS) {
+ omapi_data_string_dereference (&name, MDL);
+ return status;
+ }
+
+ status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
+ omapi_data_string_dereference (&name, MDL);
+ omapi_typed_data_dereference (&tv, MDL);
+ return status;
+}
+
+/* dhcpctl_set_int_value
+
+ Sets a boolean value on an object - like dhcpctl_set_value,
+ only more convenient for booleans. */
+
+dhcpctl_status dhcpctl_set_int_value (dhcpctl_handle h, int value,
+ const char *value_name)
+{
+ isc_result_t status;
+ omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
+ omapi_data_string_t *name = (omapi_data_string_t *)0;
+ int len;
+
+ status = omapi_data_string_new (&name, strlen (value_name), MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ memcpy (name -> value, value_name, strlen (value_name));
+
+ status = omapi_typed_data_new (MDL, &tv, omapi_datatype_int, value);
+ if (status != ISC_R_SUCCESS) {
+ omapi_data_string_dereference (&name, MDL);
+ return status;
+ }
+
+ status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
+ omapi_data_string_dereference (&name, MDL);
+ omapi_typed_data_dereference (&tv, MDL);
+ return status;
+}
+
+/* dhcpctl_object_update
+
+ Queues an update on the object referenced by the handle (there
+ can't be any other work in progress on the handle). An
+ update means local parameters will be sent to the server. */
+
+dhcpctl_status dhcpctl_object_update (dhcpctl_handle connection,
+ dhcpctl_handle h)
+{
+ isc_result_t status;
+ omapi_object_t *message = (omapi_object_t *)0;
+ dhcpctl_remote_object_t *ro;
+
+ if (h -> type != dhcpctl_remote_type)
+ return ISC_R_INVALIDARG;
+ ro = (dhcpctl_remote_object_t *)h;
+
+ status = omapi_message_new (&message, MDL);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+ status = omapi_set_int_value (message, (omapi_object_t *)0,
+ "op", OMAPI_OP_UPDATE);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+
+ status = omapi_set_object_value (message, (omapi_object_t *)0,
+ "object", h);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+
+ status = omapi_set_int_value (message, (omapi_object_t *)0, "handle",
+ (int)(ro -> remote_handle));
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+
+ omapi_message_register (message);
+ status = omapi_protocol_send_message (connection -> outer,
+ (omapi_object_t *)0,
+ message, (omapi_object_t *)0);
+ omapi_object_dereference (&message, MDL);
+ return status;
+}
+
+/* Requests a refresh on the object referenced by the handle (there
+ can't be any other work in progress on the handle). A
+ refresh means local parameters are updated from the server. */
+
+dhcpctl_status dhcpctl_object_refresh (dhcpctl_handle connection,
+ dhcpctl_handle h)
+{
+ isc_result_t status;
+ omapi_object_t *message = (omapi_object_t *)0;
+ dhcpctl_remote_object_t *ro;
+
+ if (h -> type != dhcpctl_remote_type)
+ return ISC_R_INVALIDARG;
+ ro = (dhcpctl_remote_object_t *)h;
+
+ status = omapi_message_new (&message, MDL);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+ status = omapi_set_int_value (message, (omapi_object_t *)0,
+ "op", OMAPI_OP_REFRESH);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+ status = omapi_set_int_value (message, (omapi_object_t *)0,
+ "handle", (int)(ro -> remote_handle));
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+
+ omapi_message_register (message);
+ status = omapi_protocol_send_message (connection -> outer,
+ (omapi_object_t *)0,
+ message, (omapi_object_t *)0);
+
+ /* We don't want to send the contents of the object down the
+ wire, but we do need to reference it so that we know what
+ to do with the update. */
+ status = omapi_set_object_value (message, (omapi_object_t *)0,
+ "object", h);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+
+ omapi_object_dereference (&message, MDL);
+ return status;
+}
+
+/* Requests the removal of the object referenced by the handle (there
+ can't be any other work in progress on the handle). A
+ removal means that all searchable references to the object on the
+ server are deleted. */
+
+dhcpctl_status dhcpctl_object_remove (dhcpctl_handle connection,
+ dhcpctl_handle h)
+{
+ isc_result_t status;
+ omapi_object_t *message = (omapi_object_t *)0;
+ dhcpctl_remote_object_t *ro;
+
+ if (h -> type != dhcpctl_remote_type)
+ return ISC_R_INVALIDARG;
+ ro = (dhcpctl_remote_object_t *)h;
+
+ status = omapi_message_new (&message, MDL);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+ status = omapi_set_int_value (message, (omapi_object_t *)0,
+ "op", OMAPI_OP_DELETE);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+
+ status = omapi_set_int_value (message, (omapi_object_t *)0, "handle",
+ (int)(ro -> remote_handle));
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+
+ status = omapi_set_object_value (message, (omapi_object_t *)0,
+ "notify-object", h);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+
+ omapi_message_register (message);
+ status = omapi_protocol_send_message (connection -> outer,
+ (omapi_object_t *)0,
+ message, (omapi_object_t *)0);
+ omapi_object_dereference (&message, MDL);
+ return status;
+}
+
+isc_result_t dhcpctl_data_string_dereference (dhcpctl_data_string *vp,
+ const char *file, int line)
+{
+ return omapi_data_string_dereference (vp, file, line);
+}
diff --git a/contrib/isc-dhcp/dhcpctl/dhcpctl.h b/contrib/isc-dhcp/dhcpctl/dhcpctl.h
new file mode 100644
index 000000000000..0956f6542b3d
--- /dev/null
+++ b/contrib/isc-dhcp/dhcpctl/dhcpctl.h
@@ -0,0 +1,134 @@
+/* dhcpctl.h
+
+ Subroutines providing general support for objects. */
+
+/*
+ * Copyright (c) 1999-2002 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''.
+ */
+
+#ifndef _DHCPCTL_H_
+#define _DHCPCTL_H_
+
+#include <omapip/omapip.h>
+
+typedef isc_result_t dhcpctl_status;
+typedef omapi_object_t *dhcpctl_handle;
+typedef omapi_data_string_t *dhcpctl_data_string;
+
+#define dhcpctl_null_handle ((dhcpctl_handle) 0)
+
+#define DHCPCTL_CREATE OMAPI_CREATE
+#define DHCPCTL_UPDATE OMAPI_UPDATE
+#define DHCPCTL_EXCL OMAPI_EXCL
+
+typedef struct {
+ OMAPI_OBJECT_PREAMBLE;
+ omapi_object_t *object;
+ void *data;
+ void (*callback) (dhcpctl_handle, dhcpctl_status, void *);
+} dhcpctl_callback_object_t;
+
+typedef struct {
+ OMAPI_OBJECT_PREAMBLE;
+ omapi_typed_data_t *rtype;
+ isc_result_t waitstatus;
+ omapi_typed_data_t *message;
+ omapi_handle_t remote_handle;
+} dhcpctl_remote_object_t;
+
+extern omapi_object_type_t *dhcpctl_callback_type;
+extern omapi_object_type_t *dhcpctl_remote_type;
+
+dhcpctl_status dhcpctl_initialize (void);
+dhcpctl_status dhcpctl_connect (dhcpctl_handle *,
+ const char *, int, dhcpctl_handle);
+dhcpctl_status dhcpctl_wait_for_completion (dhcpctl_handle, dhcpctl_status *);
+dhcpctl_status dhcpctl_get_value (dhcpctl_data_string *,
+ dhcpctl_handle, const char *);
+dhcpctl_status dhcpctl_get_boolean (int *, dhcpctl_handle, const char *);
+dhcpctl_status dhcpctl_set_value (dhcpctl_handle,
+ dhcpctl_data_string, const char *);
+dhcpctl_status dhcpctl_set_string_value (dhcpctl_handle, const char *,
+ const char *);
+dhcpctl_status dhcpctl_set_data_value (dhcpctl_handle,
+ const char *, unsigned, const char *);
+dhcpctl_status dhcpctl_set_null_value (dhcpctl_handle, const char *);
+dhcpctl_status dhcpctl_set_boolean_value (dhcpctl_handle, int, const char *);
+dhcpctl_status dhcpctl_set_int_value (dhcpctl_handle, int, const char *);
+dhcpctl_status dhcpctl_object_update (dhcpctl_handle, dhcpctl_handle);
+dhcpctl_status dhcpctl_object_refresh (dhcpctl_handle, dhcpctl_handle);
+dhcpctl_status dhcpctl_object_remove (dhcpctl_handle, dhcpctl_handle);
+
+dhcpctl_status dhcpctl_set_callback (dhcpctl_handle, void *,
+ void (*) (dhcpctl_handle,
+ dhcpctl_status, void *));
+isc_result_t dhcpctl_callback_set_value (omapi_object_t *, omapi_object_t *,
+ omapi_data_string_t *,
+ omapi_typed_data_t *);
+isc_result_t dhcpctl_callback_get_value (omapi_object_t *, omapi_object_t *,
+ omapi_data_string_t *,
+ omapi_value_t **);
+isc_result_t dhcpctl_callback_destroy (omapi_object_t *, const char *, int);
+isc_result_t dhcpctl_callback_signal_handler (omapi_object_t *,
+ const char *, va_list);
+isc_result_t dhcpctl_callback_stuff_values (omapi_object_t *,
+ omapi_object_t *,
+ omapi_object_t *);
+
+dhcpctl_status dhcpctl_new_authenticator (dhcpctl_handle *,
+ const char *, const char *,
+ const unsigned char *, unsigned);
+
+dhcpctl_status dhcpctl_open_object (dhcpctl_handle, dhcpctl_handle, int);
+dhcpctl_status dhcpctl_new_object (dhcpctl_handle *,
+ dhcpctl_handle, const char *);
+isc_result_t dhcpctl_remote_set_value (omapi_object_t *, omapi_object_t *,
+ omapi_data_string_t *,
+ omapi_typed_data_t *);
+isc_result_t dhcpctl_remote_get_value (omapi_object_t *, omapi_object_t *,
+ omapi_data_string_t *,
+ omapi_value_t **);
+isc_result_t dhcpctl_remote_destroy (omapi_object_t *, const char *, int);
+isc_result_t dhcpctl_remote_signal_handler (omapi_object_t *,
+ const char *, va_list);
+isc_result_t dhcpctl_remote_stuff_values (omapi_object_t *,
+ omapi_object_t *,
+ omapi_object_t *);
+isc_result_t dhcpctl_data_string_dereference (dhcpctl_data_string *,
+ const char *, int);
+#endif /* _DHCPCTL_H_ */
diff --git a/contrib/isc-dhcp/dhcpctl/omshell.1 b/contrib/isc-dhcp/dhcpctl/omshell.1
new file mode 100644
index 000000000000..6ac23f3c5e61
--- /dev/null
+++ b/contrib/isc-dhcp/dhcpctl/omshell.1
@@ -0,0 +1,341 @@
+.\" omshell.1
+.\"
+.\" Copyright (c) 2001-2002 Internet Software Consortium.
+.\" 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''.
+.TH omshell 1
+.SH NAME
+omshell - OMAPI Command Shell
+.SH SYNOPSIS
+.B omshell
+.SH DESCRIPTION
+The OMAPI Command Shell, omshell, provides an interactive way to connect to,
+query, and possibly change, the ISC DHCP Server's state via OMAPI, the Object
+Management API. By using OMAPI and omshell, you do not have to stop, make
+changes, and then restart the DHCP server, but can make the changes
+while the server is running. Omshell provides a way of accessing
+OMAPI.
+.PP
+OMAPI is simply a communications mechanism that allows you to
+manipulate objects. In order to actually \fIuse\fR omshell, you
+.I must
+understand what objects are available and how to use them.
+Documentation for OMAPI objects can be found in the documentation for
+the server that provides them - for example, in the \fBdhcpd(1)\fR
+manual page and the \fBdhclient(1)\fR manual page.
+.SH CONTRIBUTIONS
+.PP
+This software is free software. At various times its development has
+been underwritten by various organizations, including the ISC and
+Vixie Enterprises. The development of 3.0 has been funded almost
+entirely by Nominum, Inc.
+.PP
+At this point development is being shepherded by Ted Lemon, and hosted
+by the ISC, but the future of this project depends on you. If you
+have features you want, please consider implementing them.
+.SH LOCAL AND REMOTE OBJECTS
+.PP
+Throughout this document, there are references to local and remote objects.
+Local objects are ones created in omshell with the \fBnew\fR command. Remote
+objects are ones on the server: leases, hosts, and groups that the DHCP
+server knows about. Local and remote objects are associated together to
+enable viewing and modification of object attributes. Also, new remote
+objects can be created to match local objects.
+.SH OPENING A CONNECTION
+.PP
+omshell is started from the command line. Once omshell is started, there are
+several commands that can be issued:
+.PP
+.B server \fIaddress\fR
+.RS 0.5i
+where address is the IP address of the DHCP server to connect to. If this is
+not specified, the default server is 127.0.0.1 (localhost).
+.RE
+.PP
+.B port \fInumber\fR
+.RS 0.5i
+where number is the port that OMAPI listens on. By default, this is 7911.
+.RE
+.PP
+.B key \fIname secret\fR
+.RS 0.5i
+This specifies the TSIG key to use to authenticate the OMAPI transactions.
+\fIname\fR is the name of a key defined in \fIdhcpd.conf\fR with the
+\fBomapi-key\fR statement. The \fIsecret\fR is the secret generated from
+\fBdnssec-keygen\fR or another key generation program.
+.RE
+.PP
+.B connect
+.RS 0.5i
+This starts the OMAPI connection to the server as specified by the \fIserver\fR
+statement.
+.SH CREATING LOCAL OBJECTS
+.PP
+Any object defined in OMAPI can be created, queried, and/or modified. The
+object types available to OMAPI are defined in \fBdhcpd(8)\fR and
+\fBdhclient\fR. When using omshell, objects are first defined locally,
+manipulated as desired, and then associated with an object on the server.
+Only one object can be manipulated at a time. To create a local object, use
+.PP
+.B new \fIobject-type\fR
+.RS 0.5i
+\fIobject-type\fR is one of group, host, or lease.
+.RE
+.PP
+At this point, you now have an object that you can set properties on. For
+example, if a new lease object was created with \fInew lease\fR, any of a
+lease's attributes can be set as follows:
+.PP
+.B set \fIattribute-name = value\fR
+.RS 0.5i
+\fBAttribute names are defined in \fBdhcpd(8)\fR and \fBdhclient(8)\fR.
+Values should be quoted if they are strings. So, to set a lease's IP address,
+you would do the following:
+\fB set ip-address = 192.168.4.50\fR
+.SH ASSOCIATING LOCAL AND REMOTE OBJECTS
+.PP
+At this point, you can query the server for information about this lease, by
+.PP
+.B open
+.PP
+Now, the local lease object you created and set the IP address for is associated
+with the corresponding lease object on the DHCP server. All of the lease
+attributes from the DHCP server are now also the attributes on the local
+object, and will be shown in omshell.
+.SH VIEWING A REMOTE OBJECT
+.PP
+To query a lease of address 192.168.4.50, and find out its attributes, after
+connecting to the server, take the following steps:
+.PP
+.B new "lease"
+.PP
+This creates a new local lease object.
+.PP
+.B set ip-address = 192.168.4.50
+.PP
+This sets the \fIlocal\fR object's IP address to be 192.168.4.50
+.PP
+.B open
+.PP
+Now, if a lease with that IP address exists, you will see all the information
+the DHCP server has about that particular lease. Any data that isn't readily
+printable text will show up in colon-separated hexadecimal values. In this
+example, output back from the server for the entire transaction might look
+like this:
+.nf
+.sp 1
+> new "lease"
+obj: lease
+> set ip-address = 192.168.4.50
+obj: lease
+ip-address = c0:a8:04:32
+> open
+obj: lease
+ip-address = c0:a8:04:32
+state = 00:00:00:02
+dhcp-client-identifier = 01:00:10:a4:b2:36:2c
+client-hostname = "wendelina"
+subnet = 00:00:00:06
+pool = 00:00:00:07
+hardware-address = 00:10:a4:b2:36:2c
+hardware-type = 00:00:00:01
+ends = dc:d9:0d:3b
+starts = 5c:9f:04:3b
+tstp = 00:00:00:00
+tsfp = 00:00:00:00
+cltt = 00:00:00:00
+.fi
+.PP
+As you can see here, the IP address is represented in hexadecimal, as are the
+starting and ending times of the lease.
+.SH MODIFYING A REMOTE OBJECT
+.PP
+Attributes of remote objects are updated by using the \fBset\fR command as
+before, and then issuing an \fBupdate\fR command. The \fBset\fR command sets
+the attributes on the current local object, and the \fBupdate\fR command
+pushes those changes out to the server.
+.PP
+Continuing with the previous example, if a \fBset client-hostname =
+"something-else"\fR was issued, followed by an \fBupdate\fR command, the
+output would look about like this:
+.nf
+.sp 1
+> set client-hostname = "something-else"
+obj: lease
+ip-address = c0:a8:04:32
+state = 00:00:00:02
+dhcp-client-identifier = 01:00:10:a4:b2:36:2c
+client-hostname = "something-else"
+subnet = 00:00:00:06
+pool = 00:00:00:07
+hardware-address = 00:10:a4:b2:36:2c
+hardware-type = 00:00:00:01
+ends = dc:d9:0d:3b
+starts = 5c:9f:04:3b
+tstp = 00:00:00:00
+tsfp = 00:00:00:00
+cltt = 00:00:00:00
+> update
+obj: lease
+ip-address = c0:a8:04:32
+state = 00:00:00:02
+dhcp-client-identifier = 01:00:10:a4:b2:36:2c
+client-hostname = "something-else"
+subnet = 00:00:00:06
+pool = 00:00:00:07
+hardware-address = 00:10:a4:b2:36:2c
+hardware-type = 00:00:00:01
+ends = dc:d9:0d:3b
+starts = 5c:9f:04:3b
+tstp = 00:00:00:00
+tsfp = 00:00:00:00
+cltt = 00:00:00:00
+.fi
+.SH NEW REMOTE OBJECTS
+.PP
+New remote objects are created much in the same way that existing server
+objects are modified. Create a local object using \fBnew\fR, set the
+attributes as you'd wish them to be, and then create the remote object with
+the same properties by using
+.PP
+.B create
+.PP
+Now a new object exists on the DHCP server which matches the properties that
+you gave your local object. Objects created via OMAPI are saved into the
+dhcpd.leases file.
+.PP
+For example, if a new host with the IP address of 192.168.4.40 needs to be
+created it would be done as follows:
+.nf
+.sp 1
+> new host
+obj: host
+> set name = "some-host"
+obj: host
+name = "some-host"
+> set hardware-address = 00:80:c7:84:b1:94
+obj: host
+name = "some-host"
+hardware-address = 00:80:c7:84:b1:94
+> set hardware-type = 1
+obj: host
+name = "some-host"
+hardware-address = 00:80:c7:84:b1:94
+hardware-type = 1
+> set ip-address = 192.168.4.40
+obj: host
+name = "some-host"
+hardware-address = 00:80:c7:84:b1:94
+hardware-type = 1
+ip-address = c0:a8:04:28
+> create
+obj: host
+name = "some-host"
+hardware-address = 00:80:c7:84:b1:94
+hardware-type = 00:00:00:01
+ip-address = c0:a8:04:28
+>
+.fi
+.PP
+Your dhcpd.leases file would then have an entry like this in it:
+.nf
+.sp 1
+host some-host {
+ dynamic;
+ hardware ethernet 00:80:c7:84:b1:94;
+ fixed-address 192.168.4.40;
+}
+.fi
+.PP
+The \fIdynamic;\fR line is to denote that this host entry did not come from
+dhcpd.conf, but was created dynamically via OMAPI.
+.SH RESETTING ATTRIBUTES
+.PP
+If you want to remove an attribute from an object, you can do this with the
+\fBunset\fR command. Once you have unset an attribute, you must use the
+\fBupdate\fR command to update the remote object. So, if the host "some-host"
+from the previous example will not have a static IP address anymore, the
+commands in omshell would look like this:
+.nf
+.sp 1
+obj: host
+name = "some-host"
+hardware-address = 00:80:c7:84:b1:94
+hardware-type = 00:00:00:01
+ip-address = c0:a8:04:28
+> unset ip-address
+obj: host
+name = "some-host"
+hardware-address = 00:80:c7:84:b1:94
+hardware-type = 00:00:00:01
+ip-address = <null>
+>
+.fi
+.SH REFRESHING OBJECTS
+.PP
+A local object may be refreshed with the current remote object properties
+using the \fBrefresh\fR command. This is useful for object that change
+periodically, like leases, to see if they have been updated. This isn't
+particularly useful for hosts.
+.SH DELETING OBJECTS
+.PP
+Any remote object that can be created can also be destroyed. This is done by
+creating a new local object, setting attributes, associating the local and
+remote object using \fBopen\fI, and then using the \fBremove\fR command.
+If the host "some-host" from before was created in error, this could be
+corrected as follows:
+.nf
+.sp 1
+obj: host
+name = "some-host"
+hardware-address = 00:80:c7:84:b1:94
+hardware-type = 00:00:00:01
+ip-address = c0:a8:04:28
+> remove
+obj: <null>
+>
+.fi
+.SH HELP
+.PP
+The \fBhelp\fR command will print out all of the commands available in
+omshell, with some syntax pointers.
+.SH SEE ALSO
+dhcpctl(3), omapi(3), dhcpd(8), dhclient(8), dhcpd.conf(5), dhclient.conf(5).
+.SH AUTHOR
+.B omshell
+was written by Ted Lemon of Nominum, Inc. Information about Nominum
+and support contracts for DHCP and BIND can be found at
+.B http://www.nominum.com. This preliminary documentation was
+written by Wendy Verschoor of Nominum, Inc., while she was testing
+omshell.
diff --git a/contrib/isc-dhcp/dhcpctl/omshell.c b/contrib/isc-dhcp/dhcpctl/omshell.c
new file mode 100644
index 000000000000..345faaf3d5b5
--- /dev/null
+++ b/contrib/isc-dhcp/dhcpctl/omshell.c
@@ -0,0 +1,728 @@
+/* omshell.c
+
+ Examine and modify omapi objects. */
+
+/*
+ * Copyright (c) 2001-2002 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 <time.h>
+#include <sys/time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <isc-dhcp/result.h>
+#include "dhcpctl.h"
+#include "dhcpd.h"
+
+/* Fixups */
+isc_result_t find_class (struct class **c, const char *n, const char *f, int l)
+{
+ return 0;
+}
+int parse_allow_deny (struct option_cache **oc, struct parse *cfile, int flag)
+{
+ return 0;
+}
+void dhcp (struct packet *packet) { }
+void bootp (struct packet *packet) { }
+int check_collection (struct packet *p, struct lease *l, struct collection *c)
+{
+ return 0;
+}
+void classify (struct packet *packet, struct class *class) { }
+
+static void usage (char *s) {
+ fprintf (stderr, "Usage: %s\n", s);
+ exit (1);
+}
+
+static void check (isc_result_t status, const char *func) {
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "%s: %s\n", func, isc_result_totext (status));
+ exit (1);
+ }
+}
+
+int main (int argc, char **argv, char **envp)
+{
+ isc_result_t status, waitstatus;
+ dhcpctl_handle connection;
+ dhcpctl_handle authenticator;
+ dhcpctl_handle oh;
+ dhcpctl_data_string cid, ip_addr;
+ dhcpctl_data_string result, groupname, identifier;
+ struct data_string secret;
+ const char *name = 0, *algorithm = "hmac-md5";
+ int i, j;
+ int port = 7911;
+ const char *server = "127.0.0.1";
+ struct parse *cfile;
+ enum dhcp_token token;
+ const char *val;
+ char *s;
+ char buf[1024];
+ char s1[1024];
+ int connected = 0;
+
+ for (i = 1; i < argc; i++) {
+ usage(argv[0]);
+ }
+
+ /* Initially, log errors to stderr as well as to syslogd. */
+#ifdef SYSLOG_4_2
+ openlog ("omshell", LOG_NDELAY);
+ log_priority = DHCPD_LOG_FACILITY;
+#else
+ openlog ("omshell", LOG_NDELAY, DHCPD_LOG_FACILITY);
+#endif
+ status = dhcpctl_initialize ();
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_initialize: %s\n",
+ isc_result_totext (status));
+ exit (1);
+ }
+
+ memset (&oh, 0, sizeof oh);
+
+ do {
+ if (!connected) {
+ } else if (oh == NULL) {
+ printf ("obj: <null>\n");
+ } else {
+ dhcpctl_remote_object_t *r = (dhcpctl_remote_object_t *)oh;
+ omapi_generic_object_t *g =
+ (omapi_generic_object_t *)(r -> inner);
+
+ printf ("obj: ");
+
+ if (r -> rtype -> type != omapi_datatype_string) {
+ printf ("?\n");
+ } else {
+ printf ("%.*s\n",
+ (int)(r -> rtype -> u . buffer . len),
+ r -> rtype -> u . buffer . value);
+ }
+
+ for (i = 0; i < g -> nvalues; i++) {
+ omapi_value_t *v = g -> values [i];
+
+ if (!g -> values [i])
+ continue;
+
+ printf ("%.*s = ", (int)v -> name -> len,
+ v -> name -> value);
+
+ if (!v -> value) {
+ printf ("<null>\n");
+ continue;
+ }
+ switch (v -> value -> type) {
+ case omapi_datatype_int:
+ printf ("%d\n",
+ v -> value -> u . integer);
+ break;
+
+ case omapi_datatype_string:
+ printf ("\"%.*s\"\n",
+ (int) v -> value -> u.buffer.len,
+ v -> value -> u.buffer.value);
+ break;
+
+ case omapi_datatype_data:
+ printf ("%s\n",
+ print_hex_1 (v -> value -> u.buffer.len,
+ v -> value -> u.buffer.value,
+ 60));
+ break;
+
+ case omapi_datatype_object:
+ printf ("<obj>\n");
+ break;
+ }
+ }
+ }
+
+ fputs ("> ", stdout);
+ fflush (stdout);
+ if (fgets (buf, sizeof(buf), stdin) == NULL)
+ break;
+
+ status = new_parse (&cfile, 0, buf, strlen(buf), "<STDIN>", 1);
+ check(status, "new_parse()");
+
+ token = next_token (&val, (unsigned *)0, cfile);
+ switch (token) {
+ default:
+ parse_warn (cfile, "unknown token: %s", val);
+ skip_to_semi (cfile);
+ break;
+
+ case END_OF_FILE:
+ case EOL:
+ break;
+
+ case TOKEN_HELP:
+ case '?':
+ printf ("Commands:\n");
+ printf (" port <server omapi port>\n");
+ printf (" server <server address>\n");
+ printf (" key <key name> <key value>\n");
+ printf (" connect\n");
+ printf (" new <object-type>\n");
+ printf (" set <name> = <value>\n");
+ printf (" create\n");
+ printf (" open\n");
+ printf (" update\n");
+ printf (" unset <name>\n");
+ printf (" refresh\n");
+ printf (" remove\n");
+ skip_to_semi (cfile);
+ break;
+
+ case PORT:
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (is_identifier (token)) {
+ struct servent *se;
+ se = getservbyname (val, "tcp");
+ if (se)
+ port = ntohs (se -> s_port);
+ else {
+ printf ("unknown service name: %s\n", val);
+ break;
+ }
+ } else if (token == NUMBER) {
+ port = atoi (val);
+ } else {
+ skip_to_semi (cfile);
+ printf ("usage: port <port>\n");
+ break;
+ }
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != END_OF_FILE && token != EOL) {
+ printf ("usage: port <server>\n");
+ skip_to_semi (cfile);
+ break;
+ }
+ break;
+
+ case SERVER:
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token == NUMBER) {
+ int alen = (sizeof buf) - 1;
+ int len;
+
+ s = &buf [0];
+ len = strlen (val);
+ if (len + 1 > alen) {
+ baddq:
+ printf ("usage: server <server>\n");
+ skip_to_semi (cfile);
+ break;
+ } strcpy (buf, val);
+ s += len;
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != DOT)
+ goto baddq;
+ *s++ = '.';
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != NUMBER)
+ goto baddq;
+ len = strlen (val);
+ if (len + 1 > alen)
+ goto baddq;
+ strcpy (s, val);
+ s += len;
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != DOT)
+ goto baddq;
+ *s++ = '.';
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != NUMBER)
+ goto baddq;
+ len = strlen (val);
+ if (len + 1 > alen)
+ goto baddq;
+ strcpy (s, val);
+ s += len;
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != DOT)
+ goto baddq;
+ *s++ = '.';
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != NUMBER)
+ goto baddq;
+ len = strlen (val);
+ if (len + 1 > alen)
+ goto baddq;
+ strcpy (s, val);
+ val = &buf [0];
+ } else if (is_identifier (token)) {
+ /* Use val directly. */
+ } else {
+ printf ("usage: server <server>\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ s = dmalloc (strlen (val) + 1, MDL);
+ if (!server) {
+ printf ("no memory to store server name.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+ strcpy (s, val);
+ server = s;
+
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != END_OF_FILE && token != EOL) {
+ printf ("usage: server <server>\n");
+ skip_to_semi (cfile);
+ break;
+ }
+ break;
+
+ case KEY:
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (!is_identifier (token)) {
+ printf ("usage: key <name> <value>\n");
+ skip_to_semi (cfile);
+ break;
+ }
+ s = dmalloc (strlen (val) + 1, MDL);
+ if (!s) {
+ printf ("no memory for key name.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+ strcpy (s, val);
+ name = s;
+ memset (&secret, 0, sizeof secret);
+ if (!parse_base64 (&secret, cfile)) {
+ skip_to_semi (cfile);
+ break;
+ }
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != END_OF_FILE && token != EOL) {
+ printf ("usage: key <name> <secret>\n");
+ skip_to_semi (cfile);
+ break;
+ }
+ break;
+
+ case CONNECT:
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != END_OF_FILE && token != EOL) {
+ printf ("usage: connect\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ authenticator = dhcpctl_null_handle;
+
+ if (name) {
+ status = dhcpctl_new_authenticator (&authenticator,
+ name, algorithm,
+ secret.data,
+ secret.len);
+
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr,
+ "Cannot create authenticator: %s\n",
+ isc_result_totext (status));
+ break;
+ }
+ }
+
+ memset (&connection, 0, sizeof connection);
+ status = dhcpctl_connect (&connection,
+ server, port, authenticator);
+ if (status != ISC_R_SUCCESS) {
+ fprintf (stderr, "dhcpctl_connect: %s\n",
+ isc_result_totext (status));
+ break;
+ }
+ connected = 1;
+ break;
+
+ case TOKEN_NEW:
+ token = next_token (&val, (unsigned *)0, cfile);
+ if ((!is_identifier (token) && token != STRING)) {
+ printf ("usage: new <object-type>\n");
+ break;
+ }
+
+ if (oh) {
+ printf ("an object is already open.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!connected) {
+ printf ("not connected.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ status = dhcpctl_new_object (&oh, connection, val);
+ if (status != ISC_R_SUCCESS) {
+ printf ("can't create object: %s\n",
+ isc_result_totext (status));
+ break;
+ }
+
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != END_OF_FILE && token != EOL) {
+ printf ("usage: new <object-type>\n");
+ skip_to_semi (cfile);
+ break;
+ }
+ break;
+
+ case TOKEN_CLOSE:
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != END_OF_FILE && token != EOL) {
+ printf ("usage: close\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!connected) {
+ printf ("not connected.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!oh) {
+ printf ("not open.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+ omapi_object_dereference (&oh, MDL);
+
+ break;
+
+ case TOKEN_SET:
+ token = next_token (&val, (unsigned *)0, cfile);
+
+ if ((!is_identifier (token) && token != STRING)) {
+ set_usage:
+ printf ("usage: set <name> = <value>\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (oh == NULL) {
+ printf ("no open object.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!connected) {
+ printf ("not connected.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ s1[0] = '\0';
+ strncat (s1, val, sizeof(s1)-1);
+
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != EQUAL)
+ goto set_usage;
+
+ token = next_token (&val, (unsigned *)0, cfile);
+ switch (token) {
+ case STRING:
+ dhcpctl_set_string_value (oh, val, s1);
+ token = next_token (&val, (unsigned *)0, cfile);
+ break;
+
+ case NUMBER:
+ strcpy (buf, val);
+ token = peek_token (&val, (unsigned *)0, cfile);
+ /* Colon-seperated hex list? */
+ if (token == COLON)
+ goto cshl;
+ else if (token == DOT) {
+ s = buf;
+ val = buf;
+ do {
+ int intval = atoi (val);
+ dotiszero:
+ if (intval > 255) {
+ parse_warn (cfile,
+ "dotted octet > 255: %s",
+ val);
+ skip_to_semi (cfile);
+ goto badnum;
+ }
+ *s++ = intval;
+ token = next_token (&val,
+ (unsigned *)0, cfile);
+ if (token != DOT)
+ break;
+ /* DOT is zero. */
+ while ((token = next_token (&val,
+ (unsigned *)0, cfile)) == DOT)
+ *s++ = 0;
+ } while (token == NUMBER);
+ dhcpctl_set_data_value (oh, buf,
+ (unsigned)(s - buf),
+ s1);
+ break;
+ }
+ dhcpctl_set_int_value (oh, atoi (buf), s1);
+ token = next_token (&val, (unsigned *)0, cfile);
+ badnum:
+ break;
+
+ case NUMBER_OR_NAME:
+ strcpy (buf, val);
+ cshl:
+ s = buf;
+ val = buf;
+ do {
+ convert_num (cfile, (unsigned char *)s,
+ val, 16, 8);
+ ++s;
+ token = next_token (&val,
+ (unsigned *)0, cfile);
+ if (token != COLON)
+ break;
+ token = next_token (&val,
+ (unsigned *)0, cfile);
+ } while (token == NUMBER ||
+ token == NUMBER_OR_NAME);
+ dhcpctl_set_data_value (oh, buf,
+ (unsigned)(s - buf), s1);
+ break;
+
+ default:
+ printf ("invalid value.\n");
+ skip_to_semi (cfile);
+ }
+
+ if (token != END_OF_FILE && token != EOL)
+ goto set_usage;
+ break;
+
+ case UNSET:
+ token = next_token (&val, (unsigned *)0, cfile);
+
+ if ((!is_identifier (token) && token != STRING)) {
+ unset_usage:
+ printf ("usage: unset <name>\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!oh) {
+ printf ("no open object.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!connected) {
+ printf ("not connected.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ s1[0] = '\0';
+ strncat (s1, val, sizeof(s1)-1);
+
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != END_OF_FILE && token != EOL)
+ goto unset_usage;
+
+ dhcpctl_set_null_value (oh, s1);
+ break;
+
+
+ case TOKEN_CREATE:
+ case TOKEN_OPEN:
+ i = token;
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != END_OF_FILE && token != EOL) {
+ printf ("usage: %s\n", val);
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!connected) {
+ printf ("not connected.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!oh) {
+ printf ("you must make a new object first!\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (i == TOKEN_CREATE)
+ i = DHCPCTL_CREATE | DHCPCTL_EXCL;
+ else
+ i = 0;
+
+ status = dhcpctl_open_object (oh, connection, i);
+ if (status == ISC_R_SUCCESS)
+ status = dhcpctl_wait_for_completion
+ (oh, &waitstatus);
+ if (status == ISC_R_SUCCESS)
+ status = waitstatus;
+ if (status != ISC_R_SUCCESS) {
+ printf ("can't open object: %s\n",
+ isc_result_totext (status));
+ break;
+ }
+
+ break;
+
+ case UPDATE:
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != END_OF_FILE && token != EOL) {
+ printf ("usage: %s\n", val);
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!connected) {
+ printf ("not connected.\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!oh) {
+ printf ("you haven't opened an object yet!\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ status = dhcpctl_object_update(connection, oh);
+ if (status == ISC_R_SUCCESS)
+ status = dhcpctl_wait_for_completion
+ (oh, &waitstatus);
+ if (status == ISC_R_SUCCESS)
+ status = waitstatus;
+ if (status != ISC_R_SUCCESS) {
+ printf ("can't update object: %s\n",
+ isc_result_totext (status));
+ break;
+ }
+
+ break;
+
+ case REMOVE:
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != END_OF_FILE && token != EOL) {
+ printf ("usage: remove\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!connected) {
+ printf ("not connected.\n");
+ break;
+ }
+
+ if (!oh) {
+ printf ("no object.\n");
+ break;
+ }
+
+ status = dhcpctl_object_remove(connection, oh);
+ if (status == ISC_R_SUCCESS)
+ status = dhcpctl_wait_for_completion
+ (oh, &waitstatus);
+ if (status == ISC_R_SUCCESS)
+ status = waitstatus;
+ if (status != ISC_R_SUCCESS) {
+ printf ("can't destroy object: %s\n",
+ isc_result_totext (status));
+ break;
+ }
+ omapi_object_dereference (&oh, MDL);
+ break;
+
+ case REFRESH:
+ token = next_token (&val, (unsigned *)0, cfile);
+ if (token != END_OF_FILE && token != EOL) {
+ printf ("usage: refresh\n");
+ skip_to_semi (cfile);
+ break;
+ }
+
+ if (!connected) {
+ printf ("not connected.\n");
+ break;
+ }
+
+ if (!oh) {
+ printf ("no object.\n");
+ break;
+ }
+
+ status = dhcpctl_object_refresh(connection, oh);
+ if (status == ISC_R_SUCCESS)
+ status = dhcpctl_wait_for_completion
+ (oh, &waitstatus);
+ if (status == ISC_R_SUCCESS)
+ status = waitstatus;
+ if (status != ISC_R_SUCCESS) {
+ printf ("can't refresh object: %s\n",
+ isc_result_totext (status));
+ break;
+ }
+
+ break;
+ }
+ } while (1);
+
+ exit (0);
+}
+
+/* Sigh */
+isc_result_t dhcp_set_control_state (control_object_state_t oldstate,
+ control_object_state_t newstate)
+{
+ return ISC_R_SUCCESS;
+}
diff --git a/contrib/isc-dhcp/dhcpctl/remote.c b/contrib/isc-dhcp/dhcpctl/remote.c
new file mode 100644
index 000000000000..f888ac24f9fd
--- /dev/null
+++ b/contrib/isc-dhcp/dhcpctl/remote.c
@@ -0,0 +1,371 @@
+/* remote.c
+
+ The dhcpctl remote object. */
+
+/*
+ * Copyright (c) 1999-2003 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>
+#include "dhcpctl.h"
+
+/* dhcpctl_new_authenticator
+
+ synchronous - creates an authenticator object.
+ returns nonzero status code if the object couldn't be created
+ stores handle to authenticator through h if successful, and returns zero.
+ name is the authenticator name (NUL-terminated string).
+ algorithm is the NUL-terminated string name of the algorithm to use
+ (currently, only "hmac-md5" is supported).
+ secret and secret_len is the key secret. */
+
+dhcpctl_status dhcpctl_new_authenticator (dhcpctl_handle *h,
+ const char *name,
+ const char *algorithm,
+ const unsigned char *secret,
+ unsigned secret_len)
+{
+ struct auth_key *key = (struct auth_key *)0;
+ isc_result_t status;
+
+ status = omapi_auth_key_new (&key, MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ key -> name = dmalloc (strlen (name) + 1, MDL);
+ if (!key -> name) {
+ omapi_auth_key_dereference (&key, MDL);
+ return ISC_R_NOMEMORY;
+ }
+ strcpy (key -> name, name);
+
+ /* If the algorithm name isn't an FQDN, tack on the
+ .SIG-ALG.REG.NET. domain. */
+ if (strchr (algorithm, '.') == 0) {
+ static char add[] = ".SIG-ALG.REG.INT.";
+ key -> algorithm = dmalloc (strlen (algorithm) +
+ sizeof (add), MDL);
+ if (!key -> algorithm) {
+ omapi_auth_key_dereference (&key, MDL);
+ return ISC_R_NOMEMORY;
+ }
+ strcpy (key -> algorithm, algorithm);
+ strcat (key -> algorithm, add);
+ } else {
+ key -> algorithm = dmalloc (strlen (algorithm) + 1, MDL);
+ if (!key -> algorithm) {
+ omapi_auth_key_dereference (&key, MDL);
+ return ISC_R_NOMEMORY;
+ }
+ strcpy (key -> algorithm, algorithm);
+ }
+
+ status = omapi_data_string_new (&key -> key, secret_len, MDL);
+ if (status != ISC_R_SUCCESS) {
+ omapi_auth_key_dereference (&key, MDL);
+ return status;
+ }
+ memcpy (key -> key -> value, secret, secret_len);
+ key -> key -> len = secret_len;
+
+ *h = (dhcpctl_handle) key;
+ return ISC_R_SUCCESS;
+}
+
+
+/* dhcpctl_new_object
+
+ synchronous - creates a local handle for a host entry.
+ returns nonzero status code if the local host entry couldn't
+ be created
+ stores handle to host through h if successful, and returns zero.
+ object_type is a pointer to a NUL-terminated string containing
+ the ascii name of the type of object being accessed - e.g., "host" */
+
+dhcpctl_status dhcpctl_new_object (dhcpctl_handle *h,
+ dhcpctl_handle connection,
+ const char *object_type)
+{
+ dhcpctl_remote_object_t *m;
+ omapi_object_t *g;
+ isc_result_t status;
+
+ m = (dhcpctl_remote_object_t *)0;
+ status = omapi_object_allocate ((omapi_object_t **)&m,
+ dhcpctl_remote_type, 0, MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ g = (omapi_object_t *)0;
+ status = omapi_generic_new (&g, MDL);
+ if (status != ISC_R_SUCCESS) {
+ dfree (m, MDL);
+ return status;
+ }
+ status = omapi_object_reference (&m -> inner, g, MDL);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference ((omapi_object_t **)&m, MDL);
+ omapi_object_dereference (&g, MDL);
+ return status;
+ }
+ status = omapi_object_reference (&g -> outer,
+ (omapi_object_t *)m, MDL);
+
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference ((omapi_object_t **)&m, MDL);
+ omapi_object_dereference (&g, MDL);
+ return status;
+ }
+
+ status = omapi_typed_data_new (MDL, &m -> rtype,
+ omapi_datatype_string,
+ object_type);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference ((omapi_object_t **)&m, MDL);
+ omapi_object_dereference (&g, MDL);
+ return status;
+ }
+
+ status = omapi_object_reference (h, (omapi_object_t *)m, MDL);
+ omapi_object_dereference ((omapi_object_t **)&m, MDL);
+ omapi_object_dereference (&g, MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+
+ return status;
+}
+
+/* asynchronous - just queues the request
+ returns nonzero status code if open couldn't be queued
+ returns zero if open was queued
+ h is a handle to an object created by dhcpctl_new_object
+ connection is a connection to a DHCP server
+ flags include:
+ DHCPCTL_CREATE - if the object doesn't exist, create it
+ DHCPCTL_UPDATE - update the object on the server using the
+ attached parameters
+ DHCPCTL_EXCL - error if the object exists and DHCPCTL_CREATE
+ was also specified */
+
+dhcpctl_status dhcpctl_open_object (dhcpctl_handle h,
+ dhcpctl_handle connection,
+ int flags)
+{
+ isc_result_t status;
+ omapi_object_t *message = (omapi_object_t *)0;
+ dhcpctl_remote_object_t *remote;
+
+ if (h -> type != dhcpctl_remote_type)
+ return ISC_R_INVALIDARG;
+ remote = (dhcpctl_remote_object_t *)h;
+
+ status = omapi_message_new (&message, MDL);
+ if (status != ISC_R_SUCCESS)
+ return status;
+ status = omapi_set_int_value (message, (omapi_object_t *)0,
+ "op", OMAPI_OP_OPEN);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+ status = omapi_set_object_value (message, (omapi_object_t *)0,
+ "object", h);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+ if (flags & DHCPCTL_CREATE) {
+ status = omapi_set_boolean_value (message, (omapi_object_t *)0,
+ "create", 1);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+ }
+ if (flags & DHCPCTL_UPDATE) {
+ status = omapi_set_boolean_value (message, (omapi_object_t *)0,
+ "update", 1);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+ }
+ if (flags & DHCPCTL_EXCL) {
+ status = omapi_set_boolean_value (message, (omapi_object_t *)0,
+ "exclusive", 1);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+ }
+
+ if (remote -> rtype) {
+ status = omapi_set_value_str (message, (omapi_object_t *)0,
+ "type", remote -> rtype);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+ }
+
+ status = omapi_message_register (message);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, MDL);
+ return status;
+ }
+
+ status = omapi_protocol_send_message (connection -> outer,
+ (omapi_object_t *)0,
+ message, (omapi_object_t *)0);
+
+ if (status != ISC_R_SUCCESS)
+ omapi_message_unregister (message);
+
+ omapi_object_dereference (&message, MDL);
+ return status;
+}
+
+/* Callback methods (not meant to be called directly) */
+
+isc_result_t dhcpctl_remote_set_value (omapi_object_t *h,
+ omapi_object_t *id,
+ omapi_data_string_t *name,
+ omapi_typed_data_t *value)
+{
+ dhcpctl_remote_object_t *ro;
+ unsigned long rh;
+ isc_result_t status;
+
+ if (h -> type != dhcpctl_remote_type)
+ return ISC_R_INVALIDARG;
+ ro = (dhcpctl_remote_object_t *)h;
+
+ if (!omapi_ds_strcmp (name, "remote-handle")) {
+ status = omapi_get_int_value (&rh, value);
+ if (status == ISC_R_SUCCESS)
+ ro -> remote_handle = rh;
+ return status;
+ }
+
+ if (h -> inner && h -> inner -> type -> set_value)
+ return (*(h -> inner -> type -> set_value))
+ (h -> inner, id, name, value);
+ return ISC_R_NOTFOUND;
+}
+
+isc_result_t dhcpctl_remote_get_value (omapi_object_t *h,
+ omapi_object_t *id,
+ omapi_data_string_t *name,
+ omapi_value_t **value)
+{
+ if (h -> type != dhcpctl_remote_type)
+ return ISC_R_INVALIDARG;
+
+ if (h -> inner && h -> inner -> type -> get_value)
+ return (*(h -> inner -> type -> get_value))
+ (h -> inner, id, name, value);
+ return ISC_R_NOTFOUND;
+}
+
+isc_result_t dhcpctl_remote_signal_handler (omapi_object_t *o,
+ const char *name, va_list ap)
+{
+ dhcpctl_remote_object_t *p;
+ omapi_typed_data_t *tv;
+
+ if (o -> type != dhcpctl_remote_type)
+ return ISC_R_INVALIDARG;
+ p = (dhcpctl_remote_object_t *)o;
+
+ if (!strcmp (name, "updated")) {
+ p -> waitstatus = ISC_R_SUCCESS;
+ if (o -> inner -> type == omapi_type_generic)
+ omapi_generic_clear_flags (o -> inner);
+ return omapi_signal_in (o -> inner, "ready");
+ }
+ if (!strcmp (name, "status")) {
+ p -> waitstatus = va_arg (ap, isc_result_t);
+ if (p -> message)
+ omapi_typed_data_dereference (&p -> message, MDL);
+ tv = va_arg (ap, omapi_typed_data_t *);
+ if (tv)
+ omapi_typed_data_reference (&p -> message, tv, MDL);
+ return omapi_signal_in (o -> inner, "ready");
+ }
+
+ if (p -> inner && p -> inner -> type -> signal_handler)
+ return (*(p -> inner -> type -> signal_handler))
+ (p -> inner, name, ap);
+
+ return ISC_R_SUCCESS;
+}
+
+isc_result_t dhcpctl_remote_destroy (omapi_object_t *h,
+ const char *file, int line)
+{
+ dhcpctl_remote_object_t *p;
+ if (h -> type != dhcpctl_remote_type)
+ return ISC_R_INVALIDARG;
+ p = (dhcpctl_remote_object_t *)h;
+ if (p -> handle)
+ omapi_object_dereference ((omapi_object_t **)&p -> handle,
+ file, line);
+ if (p -> rtype)
+ omapi_typed_data_dereference ((omapi_typed_data_t **)&p->rtype,
+ file, line);
+ return ISC_R_SUCCESS;
+}
+
+/* Write all the published values associated with the object through the
+ specified connection. */
+
+isc_result_t dhcpctl_remote_stuff_values (omapi_object_t *c,
+ omapi_object_t *id,
+ omapi_object_t *p)
+{
+ int i;
+
+ if (p -> type != dhcpctl_remote_type)
+ return ISC_R_INVALIDARG;
+
+ if (p -> inner && p -> inner -> type -> stuff_values)
+ return (*(p -> inner -> type -> stuff_values)) (c, id,
+ p -> inner);
+ return ISC_R_SUCCESS;
+}
+