omapip/support.c

Go to the documentation of this file.
00001 /* support.c
00002 
00003    Subroutines providing general support for objects. */
00004 
00005 /*
00006  * Copyright (c) 2009,2012,2014 by Internet Systems Consortium, Inc. ("ISC")
00007  * Copyright (c) 2004-2007 by Internet Systems Consortium, Inc. ("ISC")
00008  * Copyright (c) 1999-2003 by Internet Software Consortium
00009  *
00010  * Permission to use, copy, modify, and distribute this software for any
00011  * purpose with or without fee is hereby granted, provided that the above
00012  * copyright notice and this permission notice appear in all copies.
00013  *
00014  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
00015  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
00016  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
00017  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
00018  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
00019  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
00020  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
00021  *
00022  *   Internet Systems Consortium, Inc.
00023  *   950 Charter Street
00024  *   Redwood City, CA 94063
00025  *   <info@isc.org>
00026  *   https://www.isc.org/
00027  *
00028  */
00029 
00030 #include "dhcpd.h"
00031 
00032 #include <omapip/omapip_p.h>
00033 
00034 omapi_object_type_t *omapi_type_connection;
00035 omapi_object_type_t *omapi_type_listener;
00036 omapi_object_type_t *omapi_type_io_object;
00037 omapi_object_type_t *omapi_type_datagram;
00038 omapi_object_type_t *omapi_type_generic;
00039 omapi_object_type_t *omapi_type_protocol;
00040 omapi_object_type_t *omapi_type_protocol_listener;
00041 omapi_object_type_t *omapi_type_waiter;
00042 omapi_object_type_t *omapi_type_remote;
00043 omapi_object_type_t *omapi_type_message;
00044 omapi_object_type_t *omapi_type_auth_key;
00045 
00046 omapi_object_type_t *omapi_object_types;
00047 int omapi_object_type_count;
00048 
00049 #if defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
00050 void omapi_type_relinquish ()
00051 {
00052         omapi_object_type_t *t, *n;
00053 
00054         for (t = omapi_object_types; t; t = n) {
00055                 n = t -> next;
00056                 dfree (t, MDL);
00057         }
00058         omapi_object_types = (omapi_object_type_t *)0;
00059 }
00060 #endif
00061 
00062 isc_result_t omapi_init (void)
00063 {
00064         isc_result_t status;
00065 
00066         /* Register all the standard object types... */
00067         status = omapi_object_type_register (&omapi_type_connection,
00068                                              "connection",
00069                                              omapi_connection_set_value,
00070                                              omapi_connection_get_value,
00071                                              omapi_connection_destroy,
00072                                              omapi_connection_signal_handler,
00073                                              omapi_connection_stuff_values,
00074                                              0, 0, 0, 0, 0, 0,
00075                                              sizeof
00076                                              (omapi_connection_object_t), 0,
00077                                              RC_MISC);
00078         if (status != ISC_R_SUCCESS)
00079                 return status;
00080 
00081         status = omapi_object_type_register (&omapi_type_listener,
00082                                              "listener",
00083                                              omapi_listener_set_value,
00084                                              omapi_listener_get_value,
00085                                              omapi_listener_destroy,
00086                                              omapi_listener_signal_handler,
00087                                              omapi_listener_stuff_values,
00088                                              0, 0, 0, 0, 0, 0,
00089                                              sizeof (omapi_listener_object_t),
00090                                              0, RC_MISC);
00091         if (status != ISC_R_SUCCESS)
00092                 return status;
00093 
00094         status = omapi_object_type_register (&omapi_type_io_object,
00095                                              "io",
00096                                              omapi_io_set_value,
00097                                              omapi_io_get_value,
00098                                              omapi_io_destroy,
00099                                              omapi_io_signal_handler,
00100                                              omapi_io_stuff_values,
00101                                              0, 0, 0, 0, 0, 0,
00102                                              sizeof (omapi_io_object_t),
00103                                              0, RC_MISC);
00104         if (status != ISC_R_SUCCESS)
00105                 return status;
00106 
00107         status = omapi_object_type_register (&omapi_type_generic,
00108                                              "generic",
00109                                              omapi_generic_set_value,
00110                                              omapi_generic_get_value,
00111                                              omapi_generic_destroy,
00112                                              omapi_generic_signal_handler,
00113                                              omapi_generic_stuff_values,
00114                                              0, 0, 0, 0, 0, 0,
00115                                              sizeof (omapi_generic_object_t),
00116                                              0, RC_MISC);
00117         if (status != ISC_R_SUCCESS)
00118                 return status;
00119 
00120         status = omapi_object_type_register (&omapi_type_protocol,
00121                                              "protocol",
00122                                              omapi_protocol_set_value,
00123                                              omapi_protocol_get_value,
00124                                              omapi_protocol_destroy,
00125                                              omapi_protocol_signal_handler,
00126                                              omapi_protocol_stuff_values,
00127                                              0, 0, 0, 0, 0, 0,
00128                                              sizeof (omapi_protocol_object_t),
00129                                              0, RC_MISC);
00130         if (status != ISC_R_SUCCESS)
00131                 return status;
00132 
00133         status = (omapi_object_type_register
00134                   (&omapi_type_protocol_listener, "protocol-listener",
00135                    omapi_protocol_listener_set_value,
00136                    omapi_protocol_listener_get_value,
00137                    omapi_protocol_listener_destroy,
00138                    omapi_protocol_listener_signal,
00139                    omapi_protocol_listener_stuff,
00140                    0, 0, 0, 0, 0, 0,
00141                    sizeof (omapi_protocol_listener_object_t), 0, RC_MISC));
00142         if (status != ISC_R_SUCCESS)
00143                 return status;
00144 
00145         status = omapi_object_type_register (&omapi_type_message,
00146                                              "message",
00147                                              omapi_message_set_value,
00148                                              omapi_message_get_value,
00149                                              omapi_message_destroy,
00150                                              omapi_message_signal_handler,
00151                                              omapi_message_stuff_values,
00152                                              0, 0, 0, 0, 0, 0,
00153                                              sizeof (omapi_message_object_t),
00154                                              0, RC_MISC);
00155         if (status != ISC_R_SUCCESS)
00156                 return status;
00157 
00158         status = omapi_object_type_register (&omapi_type_waiter,
00159                                              "waiter",
00160                                              0,
00161                                              0,
00162                                              0,
00163                                              omapi_waiter_signal_handler, 0,
00164                                              0, 0, 0, 0, 0, 0,
00165                                              sizeof (omapi_waiter_object_t),
00166                                              0, RC_MISC);
00167         if (status != ISC_R_SUCCESS)
00168                 return status;
00169 
00170         status = omapi_object_type_register (&omapi_type_auth_key,
00171                                              "authenticator",
00172                                              0,
00173                                              omapi_auth_key_get_value,
00174                                              omapi_auth_key_destroy,
00175                                              0,
00176                                              omapi_auth_key_stuff_values,
00177                                              omapi_auth_key_lookup,
00178                                              0, 0, 0, 0, 0,
00179                                              sizeof (omapi_auth_key_t), 0,
00180                                              RC_MISC);
00181         if (status != ISC_R_SUCCESS)
00182                 return status;
00183 
00184 #if defined (TRACING)
00185         omapi_listener_trace_setup ();
00186         omapi_connection_trace_setup ();
00187         omapi_buffer_trace_setup ();
00188 #endif
00189 
00190         /* This seems silly, but leave it. */
00191         return ISC_R_SUCCESS;
00192 }
00193 
00194 isc_result_t omapi_object_type_register (omapi_object_type_t **type,
00195                                          const char *name,
00196                                          isc_result_t (*set_value)
00197                                                  (omapi_object_t *,
00198                                                   omapi_object_t *,
00199                                                   omapi_data_string_t *,
00200                                                   omapi_typed_data_t *),
00201                                          isc_result_t (*get_value)
00202                                                 (omapi_object_t *,
00203                                                  omapi_object_t *,
00204                                                  omapi_data_string_t *,
00205                                                  omapi_value_t **),
00206                                          isc_result_t (*destroy)
00207                                                 (omapi_object_t *,
00208                                                  const char *, int),
00209                                          isc_result_t (*signal_handler)
00210                                                  (omapi_object_t *,
00211                                                   const char *, va_list),
00212                                          isc_result_t (*stuff_values)
00213                                                 (omapi_object_t *,
00214                                                  omapi_object_t *,
00215                                                  omapi_object_t *),
00216                                          isc_result_t (*lookup)
00217                                                 (omapi_object_t **,
00218                                                  omapi_object_t *,
00219                                                  omapi_object_t *),
00220                                          isc_result_t (*create)
00221                                                 (omapi_object_t **,
00222                                                  omapi_object_t *),
00223                                          isc_result_t (*remove)
00224                                                 (omapi_object_t *,
00225                                                  omapi_object_t *),
00226                                          isc_result_t (*freer)
00227                                                 (omapi_object_t *,
00228                                                  const char *, int),
00229                                          isc_result_t (*allocator)
00230                                                 (omapi_object_t **,
00231                                                  const char *, int),
00232                                          isc_result_t (*sizer) (size_t),
00233                                          size_t size,
00234                                          isc_result_t (*initialize)
00235                                                 (omapi_object_t *,
00236                                                  const char *, int),
00237                                          int rc_flag)
00238 {
00239         omapi_object_type_t *t;
00240 
00241         t = dmalloc (sizeof *t, MDL);
00242         if (!t)
00243                 return ISC_R_NOMEMORY;
00244         memset (t, 0, sizeof *t);
00245 
00246         t -> name = name;
00247         t -> set_value = set_value;
00248         t -> get_value = get_value;
00249         t -> destroy = destroy;
00250         t -> signal_handler = signal_handler;
00251         t -> stuff_values = stuff_values;
00252         t -> lookup = lookup;
00253         t -> create = create;
00254         t -> remove = remove;
00255         t -> next = omapi_object_types;
00256         t -> sizer = sizer;
00257         t -> size = size;
00258         t -> freer = freer;
00259         t -> allocator = allocator;
00260         t -> initialize = initialize;
00261         t -> rc_flag = rc_flag;
00262         omapi_object_types = t;
00263         if (type)
00264                 *type = t;
00265         return ISC_R_SUCCESS;
00266 }
00267 
00268 isc_result_t omapi_signal (omapi_object_t *handle, const char *name, ...)
00269 {
00270         va_list ap;
00271         omapi_object_t *outer;
00272         isc_result_t status;
00273 
00274         va_start (ap, name);
00275         for (outer = handle; outer -> outer; outer = outer -> outer)
00276                 ;
00277         if (outer -> type -> signal_handler)
00278                 status = (*(outer -> type -> signal_handler)) (outer,
00279                                                                name, ap);
00280         else
00281                 status = ISC_R_NOTFOUND;
00282         va_end (ap);
00283         return status;
00284 }
00285 
00286 isc_result_t omapi_signal_in (omapi_object_t *handle, const char *name, ...)
00287 {
00288         va_list ap;
00289         isc_result_t status;
00290 
00291         if (!handle)
00292                 return ISC_R_NOTFOUND;
00293         va_start (ap, name);
00294 
00295         if (handle -> type -> signal_handler)
00296                 status = (*(handle -> type -> signal_handler)) (handle,
00297                                                                 name, ap);
00298         else
00299                 status = ISC_R_NOTFOUND;
00300         va_end (ap);
00301         return status;
00302 }
00303 
00304 isc_result_t omapi_set_value (omapi_object_t *h,
00305                               omapi_object_t *id,
00306                               omapi_data_string_t *name,
00307                               omapi_typed_data_t *value)
00308 {
00309         omapi_object_t *outer;
00310         isc_result_t status;
00311 
00312 #if defined (DEBUG)
00313         if (!value) {
00314                 log_info ("omapi_set_value (%.*s, NULL)",
00315                           (int)name -> len, name -> value);
00316         } else if (value -> type == omapi_datatype_int) {
00317                 log_info ("omapi_set_value (%.*s, %ld)",
00318                           (int)name -> len, name -> value,
00319                           (long)value -> u.integer);
00320         } else if (value -> type == omapi_datatype_string) {
00321                 log_info ("omapi_set_value (%.*s, %.*s)",
00322                           (int)name -> len, name -> value,
00323                           (int)value -> u.buffer.len, value -> u.buffer.value);
00324         } else if (value -> type == omapi_datatype_data) {
00325                 log_info ("omapi_set_value (%.*s, %ld %lx)",
00326                           (int)name -> len, name -> value,
00327                           (long)value -> u.buffer.len,
00328                           (unsigned long)value -> u.buffer.value);
00329         } else if (value -> type == omapi_datatype_object) {
00330                 log_info ("omapi_set_value (%.*s, %s)",
00331                           (int)name -> len, name -> value,
00332                           value -> u.object
00333                           ? (value -> u.object -> type
00334                              ? value -> u.object -> type -> name
00335                              : "(unknown object)")
00336                           : "(unknown object)");
00337         }
00338 #endif
00339 
00340         for (outer = h; outer -> outer; outer = outer -> outer)
00341                 ;
00342         if (outer -> type -> set_value)
00343                 status = (*(outer -> type -> set_value)) (outer,
00344                                                           id, name, value);
00345         else
00346                 status = ISC_R_NOTFOUND;
00347 #if defined (DEBUG)
00348         log_info (" ==> %s", isc_result_totext (status));
00349 #endif
00350         return status;
00351 }
00352 
00353 isc_result_t omapi_set_value_str (omapi_object_t *h,
00354                                   omapi_object_t *id,
00355                                   const char *name,
00356                                   omapi_typed_data_t *value)
00357 {
00358         omapi_data_string_t *nds;
00359         isc_result_t status;
00360 
00361         nds = (omapi_data_string_t *)0;
00362         status = omapi_data_string_new (&nds, strlen (name), MDL);
00363         if (status != ISC_R_SUCCESS)
00364                 return status;
00365         memcpy (nds -> value, name, strlen (name));
00366 
00367         status = omapi_set_value (h, id, nds, value);
00368         omapi_data_string_dereference (&nds, MDL);
00369         return status;
00370 }
00371 
00372 isc_result_t omapi_set_boolean_value (omapi_object_t *h, omapi_object_t *id,
00373                                       const char *name, int value)
00374 {
00375         isc_result_t status;
00376         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
00377         omapi_data_string_t *n = (omapi_data_string_t *)0;
00378 
00379         status = omapi_data_string_new (&n, strlen (name), MDL);
00380         if (status != ISC_R_SUCCESS)
00381                 return status;
00382         memcpy (n -> value, name, strlen (name));
00383 
00384         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_int, value);
00385         if (status != ISC_R_SUCCESS) {
00386                 omapi_data_string_dereference (&n, MDL);
00387                 return status;
00388         }
00389 
00390         status = omapi_set_value (h, id, n, tv);
00391         omapi_data_string_dereference (&n, MDL);
00392         omapi_typed_data_dereference (&tv, MDL);
00393         return status;
00394 }
00395 
00396 isc_result_t omapi_set_int_value (omapi_object_t *h, omapi_object_t *id,
00397                                   const char *name, int value)
00398 {
00399         isc_result_t status;
00400         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
00401         omapi_data_string_t *n = (omapi_data_string_t *)0;
00402 
00403         status = omapi_data_string_new (&n, strlen (name), MDL);
00404         if (status != ISC_R_SUCCESS)
00405                 return status;
00406         memcpy (n -> value, name, strlen (name));
00407 
00408         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_int, value);
00409         if (status != ISC_R_SUCCESS) {
00410                 omapi_data_string_dereference (&n, MDL);
00411                 return status;
00412         }
00413 
00414         status = omapi_set_value (h, id, n, tv);
00415         omapi_data_string_dereference (&n, MDL);
00416         omapi_typed_data_dereference (&tv, MDL);
00417         return status;
00418 }
00419 
00420 isc_result_t omapi_set_object_value (omapi_object_t *h, omapi_object_t *id,
00421                                      const char *name, omapi_object_t *value)
00422 {
00423         isc_result_t status;
00424         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
00425         omapi_data_string_t *n = (omapi_data_string_t *)0;
00426 
00427         status = omapi_data_string_new (&n, strlen (name), MDL);
00428         if (status != ISC_R_SUCCESS)
00429                 return status;
00430         memcpy (n -> value, name, strlen (name));
00431 
00432         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_object, value);
00433         if (status != ISC_R_SUCCESS) {
00434                 omapi_data_string_dereference (&n, MDL);
00435                 return status;
00436         }
00437 
00438         status = omapi_set_value (h, id, n, tv);
00439         omapi_data_string_dereference (&n, MDL);
00440         omapi_typed_data_dereference (&tv, MDL);
00441         return status;
00442 }
00443 
00444 isc_result_t omapi_set_string_value (omapi_object_t *h, omapi_object_t *id,
00445                                      const char *name, const char *value)
00446 {
00447         isc_result_t status;
00448         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
00449         omapi_data_string_t *n = (omapi_data_string_t *)0;
00450 
00451         status = omapi_data_string_new (&n, strlen (name), MDL);
00452         if (status != ISC_R_SUCCESS)
00453                 return status;
00454         memcpy (n -> value, name, strlen (name));
00455 
00456         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_string, value);
00457         if (status != ISC_R_SUCCESS) {
00458                 omapi_data_string_dereference (&n, MDL);
00459                 return status;
00460         }
00461 
00462         status = omapi_set_value (h, id, n, tv);
00463         omapi_data_string_dereference (&n, MDL);
00464         omapi_typed_data_dereference (&tv, MDL);
00465         return status;
00466 }
00467 
00468 isc_result_t omapi_get_value (omapi_object_t *h,
00469                               omapi_object_t *id,
00470                               omapi_data_string_t *name,
00471                               omapi_value_t **value)
00472 {
00473         omapi_object_t *outer;
00474 
00475         for (outer = h; outer -> outer; outer = outer -> outer)
00476                 ;
00477         if (outer -> type -> get_value)
00478                 return (*(outer -> type -> get_value)) (outer,
00479                                                         id, name, value);
00480         return ISC_R_NOTFOUND;
00481 }
00482 
00483 isc_result_t omapi_get_value_str (omapi_object_t *h,
00484                                   omapi_object_t *id,
00485                                   const char *name,
00486                                   omapi_value_t **value)
00487 {
00488         omapi_object_t *outer;
00489         omapi_data_string_t *nds;
00490         isc_result_t status;
00491 
00492         nds = (omapi_data_string_t *)0;
00493         status = omapi_data_string_new (&nds, strlen (name), MDL);
00494         if (status != ISC_R_SUCCESS)
00495                 return status;
00496         memcpy (nds -> value, name, strlen (name));
00497 
00498         for (outer = h; outer -> outer; outer = outer -> outer)
00499                 ;
00500         if (outer -> type -> get_value)
00501                 status = (*(outer -> type -> get_value)) (outer,
00502                                                           id, nds, value);
00503         else
00504                 status = ISC_R_NOTFOUND;
00505         omapi_data_string_dereference (&nds, MDL);
00506         return status;
00507 }
00508 
00509 isc_result_t omapi_stuff_values (omapi_object_t *c,
00510                                  omapi_object_t *id,
00511                                  omapi_object_t *o)
00512 {
00513         omapi_object_t *outer;
00514 
00515         for (outer = o; outer -> outer; outer = outer -> outer)
00516                 ;
00517         if (outer -> type -> stuff_values)
00518                 return (*(outer -> type -> stuff_values)) (c, id, outer);
00519         return ISC_R_NOTFOUND;
00520 }
00521 
00522 isc_result_t omapi_object_create (omapi_object_t **obj, omapi_object_t *id,
00523                                   omapi_object_type_t *type)
00524 {
00525         if (!type -> create)
00526                 return ISC_R_NOTIMPLEMENTED;
00527         return (*(type -> create)) (obj, id);
00528 }
00529 
00530 isc_result_t omapi_object_update (omapi_object_t *obj, omapi_object_t *id,
00531                                   omapi_object_t *src, omapi_handle_t handle)
00532 {
00533         omapi_generic_object_t *gsrc;
00534         isc_result_t status;
00535         int i;
00536 
00537         if (!src)
00538                 return DHCP_R_INVALIDARG;
00539         if (src -> type != omapi_type_generic)
00540                 return ISC_R_NOTIMPLEMENTED;
00541         gsrc = (omapi_generic_object_t *)src;
00542         for (i = 0; i < gsrc -> nvalues; i++) {
00543                 status = omapi_set_value (obj, id,
00544                                           gsrc -> values [i] -> name,
00545                                           gsrc -> values [i] -> value);
00546                 if (status != ISC_R_SUCCESS && status != DHCP_R_UNCHANGED)
00547                         return status;
00548         }
00549 
00550         /*
00551          * For now ignore the return value.  I'm not sure if we want to
00552          * generate an error if we can't set the handle value.  If we
00553          * do add a check we probably should allow unchanged and notfound
00554          */
00555         if (handle)
00556                 (void) omapi_set_int_value (obj, id, "remote-handle", (int)handle);
00557         status = omapi_signal (obj, "updated");
00558         if (status != ISC_R_NOTFOUND)
00559                 return status;
00560         return ISC_R_SUCCESS;
00561 }
00562 
00563 int omapi_data_string_cmp (omapi_data_string_t *s1, omapi_data_string_t *s2)
00564 {
00565         unsigned len;
00566         int rv;
00567 
00568         if (s1 -> len > s2 -> len)
00569                 len = s2 -> len;
00570         else
00571                 len = s1 -> len;
00572         rv = memcmp (s1 -> value, s2 -> value, len);
00573         if (rv)
00574                 return rv;
00575         if (s1 -> len > s2 -> len)
00576                 return 1;
00577         else if (s1 -> len < s2 -> len)
00578                 return -1;
00579         return 0;
00580 }
00581 
00582 int omapi_ds_strcmp (omapi_data_string_t *s1, const char *s2)
00583 {
00584         unsigned len, slen;
00585         int rv;
00586 
00587         slen = strlen (s2);
00588         if (slen > s1 -> len)
00589                 len = s1 -> len;
00590         else
00591                 len = slen;
00592         rv = memcmp (s1 -> value, s2, len);
00593         if (rv)
00594                 return rv;
00595         if (s1 -> len > slen)
00596                 return 1;
00597         else if (s1 -> len < slen)
00598                 return -1;
00599         return 0;
00600 }
00601 
00602 int omapi_td_strcmp (omapi_typed_data_t *s1, const char *s2)
00603 {
00604         unsigned len, slen;
00605         int rv;
00606 
00607         /* If the data type is not compatible, never equal. */
00608         if (s1 -> type != omapi_datatype_data &&
00609             s1 -> type != omapi_datatype_string)
00610                 return -1;
00611 
00612         slen = strlen (s2);
00613         if (slen > s1 -> u.buffer.len)
00614                 len = s1 -> u.buffer.len;
00615         else
00616                 len = slen;
00617         rv = memcmp (s1 -> u.buffer.value, s2, len);
00618         if (rv)
00619                 return rv;
00620         if (s1 -> u.buffer.len > slen)
00621                 return 1;
00622         else if (s1 -> u.buffer.len < slen)
00623                 return -1;
00624         return 0;
00625 }
00626 
00627 int omapi_td_strcasecmp (omapi_typed_data_t *s1, const char *s2)
00628 {
00629         unsigned len, slen;
00630         int rv;
00631 
00632         /* If the data type is not compatible, never equal. */
00633         if (s1 -> type != omapi_datatype_data &&
00634             s1 -> type != omapi_datatype_string)
00635                 return -1;
00636 
00637         slen = strlen (s2);
00638         if (slen > s1 -> u.buffer.len)
00639                 len = s1 -> u.buffer.len;
00640         else
00641                 len = slen;
00642         rv = casecmp (s1 -> u.buffer.value, s2, len);
00643         if (rv)
00644                 return rv;
00645         if (s1 -> u.buffer.len > slen)
00646                 return 1;
00647         else if (s1 -> u.buffer.len < slen)
00648                 return -1;
00649         return 0;
00650 }
00651 
00652 isc_result_t omapi_make_value (omapi_value_t **vp,
00653                                omapi_data_string_t *name,
00654                                omapi_typed_data_t *value,
00655                                const char *file, int line)
00656 {
00657         isc_result_t status;
00658 
00659         status = omapi_value_new (vp, file, line);
00660         if (status != ISC_R_SUCCESS)
00661                 return status;
00662 
00663         status = omapi_data_string_reference (&(*vp) -> name,
00664                                               name, file, line);
00665         if (status != ISC_R_SUCCESS) {
00666                 omapi_value_dereference (vp, file, line);
00667                 return status;
00668         }
00669         if (value) {
00670                 status = omapi_typed_data_reference (&(*vp) -> value,
00671                                                      value, file, line);
00672                 if (status != ISC_R_SUCCESS) {
00673                         omapi_value_dereference (vp, file, line);
00674                         return status;
00675                 }
00676         }
00677         return ISC_R_SUCCESS;
00678 }
00679 
00680 isc_result_t omapi_make_const_value (omapi_value_t **vp,
00681                                      omapi_data_string_t *name,
00682                                      const unsigned char *value,
00683                                      unsigned len,
00684                                      const char *file, int line)
00685 {
00686         isc_result_t status;
00687 
00688         status = omapi_value_new (vp, file, line);
00689         if (status != ISC_R_SUCCESS)
00690                 return status;
00691 
00692         status = omapi_data_string_reference (&(*vp) -> name,
00693                                               name, file, line);
00694         if (status != ISC_R_SUCCESS) {
00695                 omapi_value_dereference (vp, file, line);
00696                 return status;
00697         }
00698         if (value) {
00699                 status = omapi_typed_data_new (file, line, &(*vp) -> value,
00700                                                omapi_datatype_data, len);
00701                 if (status != ISC_R_SUCCESS) {
00702                         omapi_value_dereference (vp, file, line);
00703                         return status;
00704                 }
00705                 memcpy ((*vp) -> value -> u.buffer.value, value, len);
00706         }
00707         return ISC_R_SUCCESS;
00708 }
00709 
00710 isc_result_t omapi_make_int_value (omapi_value_t **vp,
00711                                    omapi_data_string_t *name,
00712                                    int value, const char *file, int line)
00713 {
00714         isc_result_t status;
00715 
00716         status = omapi_value_new (vp, file, line);
00717         if (status != ISC_R_SUCCESS)
00718                 return status;
00719 
00720         status = omapi_data_string_reference (&(*vp) -> name,
00721                                               name, file, line);
00722         if (status != ISC_R_SUCCESS) {
00723                 omapi_value_dereference (vp, file, line);
00724                 return status;
00725         }
00726         status = omapi_typed_data_new (file, line, &(*vp) -> value,
00727                                        omapi_datatype_int, value);
00728         if (status != ISC_R_SUCCESS) {
00729                 omapi_value_dereference (vp, file, line);
00730                 return status;
00731         }
00732         return ISC_R_SUCCESS;
00733 }
00734 
00735 isc_result_t omapi_make_uint_value (omapi_value_t **vp,
00736                                     omapi_data_string_t *name,
00737                                     unsigned int value,
00738                                     const char *file, int line)
00739 {
00740         return omapi_make_int_value (vp, name, (int)value, file, line);
00741 }
00742 
00743 isc_result_t omapi_make_object_value (omapi_value_t **vp,
00744                                       omapi_data_string_t *name,
00745                                       omapi_object_t *value,
00746                                       const char *file, int line)
00747 {
00748         isc_result_t status;
00749         
00750         status = omapi_value_new (vp, file, line);
00751         if (status != ISC_R_SUCCESS)
00752                 return status;
00753         
00754         status = omapi_data_string_reference (&(*vp) -> name,
00755                                               name, file, line);
00756         if (status != ISC_R_SUCCESS) {
00757                 omapi_value_dereference (vp, file, line);
00758                 return status;
00759         }
00760         
00761         if (value) {
00762                 status = omapi_typed_data_new (file, line, &(*vp) -> value,
00763                                                omapi_datatype_object, value);
00764                 if (status != ISC_R_SUCCESS) {
00765                         omapi_value_dereference (vp, file, line);
00766                         return status;
00767                 }
00768         }
00769         
00770         return ISC_R_SUCCESS;
00771 }
00772 
00773 isc_result_t omapi_make_handle_value (omapi_value_t **vp,
00774                                       omapi_data_string_t *name,
00775                                       omapi_object_t *value,
00776                                       const char *file, int line)
00777 {
00778         isc_result_t status;
00779 
00780         status = omapi_value_new (vp, file, line);
00781         if (status != ISC_R_SUCCESS)
00782                 return status;
00783 
00784         status = omapi_data_string_reference (&(*vp) -> name,
00785                                               name, file, line);
00786         if (status != ISC_R_SUCCESS) {
00787                 omapi_value_dereference (vp, file, line);
00788                 return status;
00789         }
00790         if (value) {
00791                 status = omapi_typed_data_new (file, line, &(*vp) -> value,
00792                                                omapi_datatype_int);
00793                 if (status != ISC_R_SUCCESS) {
00794                         omapi_value_dereference (vp, file, line);
00795                         return status;
00796                 }
00797                 status = (omapi_object_handle
00798                           ((omapi_handle_t *)&(*vp) -> value -> u.integer,
00799                            value));
00800                 if (status != ISC_R_SUCCESS) {
00801                         omapi_value_dereference (vp, file, line);
00802                         return status;
00803                 }
00804         }
00805         return ISC_R_SUCCESS;
00806 }
00807 
00808 isc_result_t omapi_make_string_value (omapi_value_t **vp,
00809                                       omapi_data_string_t *name,
00810                                       const char *value,
00811                                       const char *file, int line)
00812 {
00813         isc_result_t status;
00814 
00815         status = omapi_value_new (vp, file, line);
00816         if (status != ISC_R_SUCCESS)
00817                 return status;
00818 
00819         status = omapi_data_string_reference (&(*vp) -> name,
00820                                               name, file, line);
00821         if (status != ISC_R_SUCCESS) {
00822                 omapi_value_dereference (vp, file, line);
00823                 return status;
00824         }
00825         if (value) {
00826                 status = omapi_typed_data_new (file, line, &(*vp) -> value,
00827                                                omapi_datatype_string, value);
00828                 if (status != ISC_R_SUCCESS) {
00829                         omapi_value_dereference (vp, file, line);
00830                         return status;
00831                 }
00832         }
00833         return ISC_R_SUCCESS;
00834 }
00835 
00836 isc_result_t omapi_get_int_value (unsigned long *v, omapi_typed_data_t *t)
00837 {
00838         u_int32_t rv;
00839 
00840         if (t -> type == omapi_datatype_int) {
00841                 *v = t -> u.integer;
00842                 return ISC_R_SUCCESS;
00843         } else if (t -> type == omapi_datatype_string ||
00844                    t -> type == omapi_datatype_data) {
00845                 if (t -> u.buffer.len != sizeof (rv))
00846                         return DHCP_R_INVALIDARG;
00847                 memcpy (&rv, t -> u.buffer.value, sizeof rv);
00848                 *v = ntohl (rv);
00849                 return ISC_R_SUCCESS;
00850         }
00851         return DHCP_R_INVALIDARG;
00852 }

Generated on 5 Apr 2014 for ISC DHCP by  doxygen 1.6.1