Break dhcpctl objects out into seperate files.

diff --git a/dhcpctl/callback.c b/dhcpctl/callback.c
new file mode 100644 (file)
index 0000000..d6da79d
--- /dev/null
+++ b/dhcpctl/callback.c
@@ -0,0 +1,157 @@
+/* callback.c
+
+   The dhcpctl callback object. */
+
+/*
+ * 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"
+
+/* 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;
+}
+
+/* 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,
+                                             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, 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;
+}
+

diff --git a/dhcpctl/remote.c b/dhcpctl/remote.c
new file mode 100644 (file)
index 0000000..b5e0a29
--- /dev/null
+++ b/dhcpctl/remote.c
@@ -0,0 +1,274 @@
+/* remote.c
+
+   The dhcpctl remote object. */
+
+/*
+ * 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"
+
+/* 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)
+{
+       dhcpctl_remote_object_t *m;
+       omapi_object_t *g;
+       isc_result_t status;
+
+       m = malloc (sizeof *m);
+       if (!m)
+               return ISC_R_NOMEMORY;
+       memset (m, 0, sizeof *m);
+       m -> type = dhcpctl_remote_type;
+       m -> refcnt = 1;
+
+       g = (omapi_object_t *)0;
+       status = omapi_generic_new (&g, "dhcpctl_new_object");
+       if (status != ISC_R_SUCCESS) {
+               free (m);
+               return status;
+       }
+       status = omapi_object_reference (&m -> inner, g, "dhcpctl_new_object");
+       if (status != ISC_R_SUCCESS) {
+               omapi_object_dereference ((omapi_object_t **)&m,
+                                         "dhcpctl_new_object");
+               omapi_object_dereference (&g, "dhcpctl_new_object");
+               return status;
+       }
+       status = omapi_object_reference (&g -> outer,
+                                        (omapi_object_t *)m,
+                                        "dhcpctl_new_object");
+
+       if (status != ISC_R_SUCCESS) {
+               omapi_object_dereference ((omapi_object_t **)&m,
+                                         "dhcpctl_new_object");
+               omapi_object_dereference (&g, "dhcpctl_new_object");
+               return status;
+       }
+
+       status = omapi_typed_data_new (&m -> rtype,
+                                      omapi_datatype_string,
+                                      object_type, "dhcpctl_new_object");
+       if (status != ISC_R_SUCCESS) {
+               omapi_object_dereference ((omapi_object_t **)&m,
+                                         "dhcpctl_new_object");
+               omapi_object_dereference (&g, "dhcpctl_new_object");
+               return status;
+       }
+
+       status = omapi_object_reference (h, (omapi_object_t *)m,
+                                        "dhcpctl_new_object");
+       omapi_object_dereference ((omapi_object_t **)&m, "dhcpctl_new_object");
+       omapi_object_dereference (&g, "dhcpctl_new_object");
+       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, "dhcpctl_open_object");
+       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, "dhcpctl_open_object");
+               return status;
+       }
+       status = omapi_set_object_value (message, (omapi_object_t *)0,
+                                        "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, (omapi_object_t *)0,
+                                                 "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, (omapi_object_t *)0,
+                                                 "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, (omapi_object_t *)0,
+                                                 "exclusive", 1);
+               if (status != ISC_R_SUCCESS) {
+                       omapi_object_dereference (&message,
+                                                 "dhcpctl_open_object");
+                       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,
+                                                 "dhcpctl_open_object");
+                       return status;
+               }
+       }
+
+       status = omapi_message_register (message);
+       if (status != ISC_R_SUCCESS) {
+               omapi_object_dereference (&message, "dhcpctl_open_object");
+               return status;
+       }
+       return omapi_protocol_send_message (connection -> outer,
+                                           (omapi_object_t *)0,
+                                           message, (omapi_object_t *)0);
+}
+
+/* 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)
+{
+       if (h -> type != dhcpctl_remote_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_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,
+                                           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;
+               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,
+                                "dhcpctl_remote_signal_handler");
+               tv = va_arg (ap, omapi_typed_data_t *);
+               if (tv)
+                       omapi_typed_data_reference
+                               (&p -> message, tv,
+                                "dhcpctl_remote_signal_handler");
+               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, char *name)
+{
+       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,
+                                         name);
+       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;
+}
+