Commit 1d6fed18 authored by Ted Lemon's avatar Ted Lemon

Dhcpctl control library

parent 61b844bf
# Makefile.dist
#
# Copyright (c) 1996-1999 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
SEDMANPAGES = dhcpctl.man3
SRC = dhcpctl.c
OBJ = dhcpctl.o
MAN = dhcpctl.3
DEBUG = -g
INCLUDES = $(BINDINC) -I../includes
CFLAGS = $(DEBUG) $(PREDEFINES) $(INCLUDES) $(COPTS)
all: libdhcpctl.a $(CATMANPAGES)
test: test.o libdhcpctl.a
$(CC) $(DEBUG) -o test test.o libdhcpctl.a
libdhcpctl.a: $(OBJ)
rm -f libdhcpctl.a
ar cruv libdhcpctl.a $(OBJ)
$(RANLIB) libdhcpctl.a
install: all
for dir in $(LIBMANDIR); 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
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
depend:
makedepend $(INCLUDES) $(PREDEFINES) $(SRCS)
clean:
-rm -f $(OBJ)
realclean: clean
-rm -f libdhcp.a *~ $(CATMANPAGES) $(SEDMANPAGES)
distclean: realclean
-rm -f Makefile
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
# Dependencies (semi-automatically-generated)
/* dhcpctl.c
Subroutines providing general support for objects. */
/*
* Copyright (c) 1996-1999 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.
*/
#include "dhcpctl.h"
omapi_object_type_t *dhcpctl_callback_type;
/* dhcpctl_initialize ()
Must be called before any other dhcpctl function. */
dhcpctl_status dhcpctl_initialize ()
{
omapi_init();
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);
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 omapi_callback_signal_handler (omapi_object_t *o,
char *name, va_list ap)
{
dhcpctl_callback_object_t *p;
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;
}
/* Do the callback. */
if (p -> callback)
(*(p -> callback)) (p -> object, 0, p -> data);
return ISC_R_SUCCESS;
}
isc_result_t dhcpctl_callback_destroy (omapi_object_t *h, char *name)
{
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,
name);
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;
}
/* 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,
char *server_name, int port,
dhcpctl_handle authinfo)
{
isc_result_t status;
status = omapi_generic_new (connection, "dhcpctl_connect");
if (status != ISC_R_SUCCESS) {
return status;
}
status = omapi_protocol_connect (*connection, server_name,
port, authinfo);
if (status != ISC_R_SUCCESS) {
omapi_handle_dereference (connection, "dhcpctl_connect");
return status;
}
status = omapi_wait_for_completion (*connection, 0);
if (status != ISC_R_SUCCESS) {
omapi_handle_dereference (connection, "dhcpctl_connect");
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;
status = omapi_message_new (&message, "dhcpctl_open_object");
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, "dhcpctl_open_object");
return status;
}
status = omapi_set_int_value (message, "op", OMAPI_OP_OPEN);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, "dhcpctl_open_object");
return status;
}
status = omapi_set_object_value (message, "object", h);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, "dhcpctl_open_object");
return status;
}
if (flags & DHCPCTL_CREATE) {
status = omapi_set_boolean_value (message, "create", 1);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message,
"dhcpctl_open_object");
return status;
}
}
if (flags & DHCPCTL_UPDATE) {
status = omapi_set_boolean_value (message, "update", 1);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message,
"dhcpctl_open_object");
return status;
}
}
if (flags & DHCPCTL_EXCL) {
status = omapi_set_boolean_value (message, "exclusive", 1);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message,
"dhcpctl_open_object");
return status;
}
}
omapi_message_register (message);
return omapi_protocol_send_message (connection -> outer,
(omapi_object_t *)0,
message, (omapi_object_t *)0);
}
/* 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,
char *object_type)
{
isc_result_t status;
status = omapi_generic_object_new (h, "dhcpctl_new_object");
if (status != ISC_R_SUCCESS)
return status;
status = omapi_set_string_value (h, object_type);
if (status != ISC_R_SUCCESS)
omapi_object_dereference (h, "dhcpctl_new_object");
return status;
}
/* 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 = malloc (sizeof *callback);
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,
"dhcpctl_set_callback");
omapi_object_reference ((omapi_object_t **)&callback -> outer, inner,
"dhcpctl_set_callback");
/* Save the actual handle pointer we were passed for the callback. */
omapi_object_reference (&callback -> object, h,
"dhcpctl_set_callback");
callback -> data = data;
callback -> callback = func;
return ISC_R_SUCCESS;
}
/* 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)
{
*s = 0;
return omapi_wait_for_completion (h, 0);
}
/* 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, char *value_name)
{
isc_result_t status;
omapi_value_t *tv = (omapi_value_t *)0;
omapi_data_string_t *name = (omapi_data_string_t *)0;
omapi_data_string_t *value = (omapi_data_string_t *)0;
int len;
int ip;
status = omapi_data_string_new (&name, strlen (value_name) + 1,
"dhcpctl_get_value");
if (status != ISC_R_SUCCESS)
return status;
strcpy (name -> value, value_name);
status = omapi_get_value (h, (omapi_object_t *)0, name, &tv);
if (status != ISC_R_SUCCESS) {
omapi_data_string_dereference (&name, "dhcpctl_get_value");
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_data_string_dereference (&name, "dhcpctl_get_value");
omapi_typed_data_dereference (&tv -> value,
"dhcpctl_get_value");
return ISC_R_UNEXPECTED;
}
status = omapi_data_string_new (result, len, "dhcpctl_get_value");
if (status != ISC_R_SUCCESS) {
omapi_data_string_dereference (&name, "dhcpctl_get_value");
omapi_typed_data_dereference (&tv -> value,
"dhcpctl_get_value");
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_data_string_dereference (&name, "dhcpctl_get_value");
omapi_value_dereference (&tv, "dhcpctl_get_value");
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, 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, "dhcpctl_get_boolean");
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,
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;
int ip;
status = omapi_data_string_new (&name, strlen (value_name) + 1,
"dhcpctl_set_value");
if (status != ISC_R_SUCCESS)
return status;
strcpy (name -> value, value_name);
status = omapi_typed_data_new (&tv, omapi_datatype_data,
value -> len);
if (status != ISC_R_SUCCESS) {
omapi_data_string_dereference (&name, "dhcpctl_set_value");
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, "dhcpctl_set_value");
omapi_typed_data_dereference (&tv, "dhcpctl_set_value");
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, char *value,
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;
int ip;
status = omapi_data_string_new (&name, strlen (value_name) + 1,
"dhcpctl_set_string_value");
if (status != ISC_R_SUCCESS)
return status;
strcpy (name -> value, value_name);
status = omapi_typed_data_new (&tv, omapi_datatype_string, value);
if (status != ISC_R_SUCCESS) {
omapi_data_string_dereference (&name,
"dhcpctl_set_string_value");
return status;
}
status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
omapi_data_string_dereference (&name, "dhcpctl_set_string_value");
omapi_typed_data_dereference (&tv, "dhcpctl_set_string_value");
return status;
}
/* dhcpctl_set_boolean
Sets a boolean value on an object - like dhcpctl_set_value,
only more convenient for booleans. */
dhcpctl_status dhcpctl_set_boolean (dhcpctl_handle h, int value,
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;
int ip;
status = omapi_data_string_new (&name, strlen (value_name) + 1,
"dhcpctl_set_boolean_value");
if (status != ISC_R_SUCCESS)
return status;
strcpy (name -> value, value_name);
status = omapi_typed_data_new (&tv, omapi_datatype_int, value);
if (status != ISC_R_SUCCESS) {
omapi_data_string_dereference (&name,
"dhcpctl_set_boolean_value");
return status;
}
status = omapi_set_value (h, (omapi_object_t *)0, name, tv);
omapi_data_string_dereference (&name, "dhcpctl_set_boolean_value");
omapi_typed_data_dereference (&tv, "dhcpctl_set_boolean_value");
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;
status = omapi_message_new (&message, "dhcpctl_open_object");
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, "dhcpctl_open_object");
return status;
}
status = omapi_set_int_value (message, "op", OMAPI_OP_UPDATE);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, "dhcpctl_open_object");
return status;
}