--- /dev/null
+/* 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;
+ }
+ status = omapi_set_object_value (message, "object", h);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, "dhcpctl_open_object");
+ 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, "dhcpctl_object_update");
+ 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;
+
+ 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_REFRESH);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, "dhcpctl_open_object");
+ return status;
+ }
+ status = omapi_set_int_value (message, "handle", h -> handle);
+ if (status != ISC_R_SUCCESS) {
+ omapi_object_dereference (&message, "dhcpctl_open_object");
+ 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, "dhcpctl_object_update");
+ return status;
+}
+
projects / thirdparty / dhcp.git / commitdiff
