omapip/support.c

   1 /* support.c
   2
   3    Subroutines providing general support for objects. */
   4
   5 /*
   6  * Copyright (c) 2004-2020 by Internet Systems Consortium, Inc. ("ISC")
   7  * Copyright (c) 1999-2003 by Internet Software Consortium
   8  *
   9  * This Source Code Form is subject to the terms of the Mozilla Public
  10  * License, v. 2.0. If a copy of the MPL was not distributed with this
  11  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
  14  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  15  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  16  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  17  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  18  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  19  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  20  *
  21  *   Internet Systems Consortium, Inc.
  22  *   PO Box 360
  23  *   Newmarket, NH 03857 USA
  24  *   <info@isc.org>
  25  *   https://www.isc.org/
  26  *
  27  */
  28
  29 #include "dhcpd.h"
  30
  31 #include <omapip/omapip_p.h>
  32
  33 omapi_object_type_t *omapi_type_connection;
  34 omapi_object_type_t *omapi_type_listener;
  35 omapi_object_type_t *omapi_type_io_object;
  36 omapi_object_type_t *omapi_type_datagram;
  37 omapi_object_type_t *omapi_type_generic;
  38 omapi_object_type_t *omapi_type_protocol;
  39 omapi_object_type_t *omapi_type_protocol_listener;
  40 omapi_object_type_t *omapi_type_waiter;
  41 omapi_object_type_t *omapi_type_remote;
  42 omapi_object_type_t *omapi_type_message;
  43 omapi_object_type_t *omapi_type_auth_key;
  44
  45 omapi_object_type_t *omapi_object_types;
  46 int omapi_object_type_count;
  47
  48 #if defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
  49 void omapi_type_relinquish ()
  50 {
  51         omapi_object_type_t *t, *n;
  52
  53         for (t = omapi_object_types; t; t = n) {
  54                 n = t -> next;
  55                 dfree (t, MDL);
  56         }
  57         omapi_object_types = (omapi_object_type_t *)0;
  58 }
  59 #endif
  60
  61 isc_result_t omapi_init (void)
  62 {
  63         isc_result_t status;
  64
  65         /* Register all the standard object types... */
  66         status = omapi_object_type_register (&omapi_type_connection,
  67                                              "connection",
  68                                              omapi_connection_set_value,
  69                                              omapi_connection_get_value,
  70                                              omapi_connection_destroy,
  71                                              omapi_connection_signal_handler,
  72                                              omapi_connection_stuff_values,
  73                                              0, 0, 0, 0, 0, 0,
  74                                              sizeof
  75                                              (omapi_connection_object_t), 0,
  76                                              RC_MISC);
  77         if (status != ISC_R_SUCCESS)
  78                 return status;
  79
  80         status = omapi_object_type_register (&omapi_type_listener,
  81                                              "listener",
  82                                              omapi_listener_set_value,
  83                                              omapi_listener_get_value,
  84                                              omapi_listener_destroy,
  85                                              omapi_listener_signal_handler,
  86                                              omapi_listener_stuff_values,
  87                                              0, 0, 0, 0, 0, 0,
  88                                              sizeof (omapi_listener_object_t),
  89                                              0, RC_MISC);
  90         if (status != ISC_R_SUCCESS)
  91                 return status;
  92
  93         status = omapi_object_type_register (&omapi_type_io_object,
  94                                              "io",
  95                                              omapi_io_set_value,
  96                                              omapi_io_get_value,
  97                                              omapi_io_destroy,
  98                                              omapi_io_signal_handler,
  99                                              omapi_io_stuff_values,
 100                                              0, 0, 0, 0, 0, 0,
 101                                              sizeof (omapi_io_object_t),
 102                                              0, RC_MISC);
 103         if (status != ISC_R_SUCCESS)
 104                 return status;
 105
 106         status = omapi_object_type_register (&omapi_type_generic,
 107                                              "generic",
 108                                              omapi_generic_set_value,
 109                                              omapi_generic_get_value,
 110                                              omapi_generic_destroy,
 111                                              omapi_generic_signal_handler,
 112                                              omapi_generic_stuff_values,
 113                                              0, 0, 0, 0, 0, 0,
 114                                              sizeof (omapi_generic_object_t),
 115                                              0, RC_MISC);
 116         if (status != ISC_R_SUCCESS)
 117                 return status;
 118
 119         status = omapi_object_type_register (&omapi_type_protocol,
 120                                              "protocol",
 121                                              omapi_protocol_set_value,
 122                                              omapi_protocol_get_value,
 123                                              omapi_protocol_destroy,
 124                                              omapi_protocol_signal_handler,
 125                                              omapi_protocol_stuff_values,
 126                                              0, 0, 0, 0, 0, 0,
 127                                              sizeof (omapi_protocol_object_t),
 128                                              0, RC_MISC);
 129         if (status != ISC_R_SUCCESS)
 130                 return status;
 131
 132         status = (omapi_object_type_register
 133                   (&omapi_type_protocol_listener, "protocol-listener",
 134                    omapi_protocol_listener_set_value,
 135                    omapi_protocol_listener_get_value,
 136                    omapi_protocol_listener_destroy,
 137                    omapi_protocol_listener_signal,
 138                    omapi_protocol_listener_stuff,
 139                    0, 0, 0, 0, 0, 0,
 140                    sizeof (omapi_protocol_listener_object_t), 0, RC_MISC));
 141         if (status != ISC_R_SUCCESS)
 142                 return status;
 143
 144         status = omapi_object_type_register (&omapi_type_message,
 145                                              "message",
 146                                              omapi_message_set_value,
 147                                              omapi_message_get_value,
 148                                              omapi_message_destroy,
 149                                              omapi_message_signal_handler,
 150                                              omapi_message_stuff_values,
 151                                              0, 0, 0, 0, 0, 0,
 152                                              sizeof (omapi_message_object_t),
 153                                              0, RC_MISC);
 154         if (status != ISC_R_SUCCESS)
 155                 return status;
 156
 157         status = omapi_object_type_register (&omapi_type_waiter,
 158                                              "waiter",
 159                                              0,
 160                                              0,
 161                                              0,
 162                                              omapi_waiter_signal_handler, 0,
 163                                              0, 0, 0, 0, 0, 0,
 164                                              sizeof (omapi_waiter_object_t),
 165                                              0, RC_MISC);
 166         if (status != ISC_R_SUCCESS)
 167                 return status;
 168
 169         status = omapi_object_type_register (&omapi_type_auth_key,
 170                                              "authenticator",
 171                                              0,
 172                                              omapi_auth_key_get_value,
 173                                              omapi_auth_key_destroy,
 174                                              0,
 175                                              omapi_auth_key_stuff_values,
 176                                              omapi_auth_key_lookup,
 177                                              0, 0, 0, 0, 0,
 178                                              sizeof (omapi_auth_key_t), 0,
 179                                              RC_MISC);
 180         if (status != ISC_R_SUCCESS)
 181                 return status;
 182
 183 #if defined (TRACING)
 184         omapi_listener_trace_setup ();
 185         omapi_connection_trace_setup ();
 186         omapi_buffer_trace_setup ();
 187 #endif
 188
 189         /* This seems silly, but leave it. */
 190         return ISC_R_SUCCESS;
 191 }
 192
 193 isc_result_t omapi_object_type_register (omapi_object_type_t **type,
 194                                          const char *name,
 195                                          isc_result_t (*set_value)
 196                                                  (omapi_object_t *,
 197                                                   omapi_object_t *,
 198                                                   omapi_data_string_t *,
 199                                                   omapi_typed_data_t *),
 200                                          isc_result_t (*get_value)
 201                                                 (omapi_object_t *,
 202                                                  omapi_object_t *,
 203                                                  omapi_data_string_t *,
 204                                                  omapi_value_t **),
 205                                          isc_result_t (*destroy)
 206                                                 (omapi_object_t *,
 207                                                  const char *, int),
 208                                          isc_result_t (*signal_handler)
 209                                                  (omapi_object_t *,
 210                                                   const char *, va_list),
 211                                          isc_result_t (*stuff_values)
 212                                                 (omapi_object_t *,
 213                                                  omapi_object_t *,
 214                                                  omapi_object_t *),
 215                                          isc_result_t (*lookup)
 216                                                 (omapi_object_t **,
 217                                                  omapi_object_t *,
 218                                                  omapi_object_t *),
 219                                          isc_result_t (*create)
 220                                                 (omapi_object_t **,
 221                                                  omapi_object_t *),
 222                                          isc_result_t (*remove)
 223                                                 (omapi_object_t *,
 224                                                  omapi_object_t *),
 225                                          isc_result_t (*freer)
 226                                                 (omapi_object_t *,
 227                                                  const char *, int),
 228                                          isc_result_t (*allocator)
 229                                                 (omapi_object_t **,
 230                                                  const char *, int),
 231                                          isc_result_t (*sizer) (size_t),
 232                                          size_t size,
 233                                          isc_result_t (*initialize)
 234                                                 (omapi_object_t *,
 235                                                  const char *, int),
 236                                          int rc_flag)
 237 {
 238         omapi_object_type_t *t;
 239
 240         t = dmalloc (sizeof *t, MDL);
 241         if (!t)
 242                 return ISC_R_NOMEMORY;
 243         memset (t, 0, sizeof *t);
 244
 245         t -> name = name;
 246         t -> set_value = set_value;
 247         t -> get_value = get_value;
 248         t -> destroy = destroy;
 249         t -> signal_handler = signal_handler;
 250         t -> stuff_values = stuff_values;
 251         t -> lookup = lookup;
 252         t -> create = create;
 253         t -> remove = remove;
 254         t -> next = omapi_object_types;
 255         t -> sizer = sizer;
 256         t -> size = size;
 257         t -> freer = freer;
 258         t -> allocator = allocator;
 259         t -> initialize = initialize;
 260         t -> rc_flag = rc_flag;
 261         omapi_object_types = t;
 262         if (type)
 263                 *type = t;
 264         return ISC_R_SUCCESS;
 265 }
 266
 267 isc_result_t omapi_signal (omapi_object_t *handle, const char *name, ...)
 268 {
 269         va_list ap;
 270         omapi_object_t *outer;
 271         isc_result_t status;
 272
 273         va_start (ap, name);
 274         for (outer = handle; outer -> outer; outer = outer -> outer)
 275                 ;
 276         if (outer -> type -> signal_handler)
 277                 status = (*(outer -> type -> signal_handler)) (outer,
 278                                                                name, ap);
 279         else
 280                 status = ISC_R_NOTFOUND;
 281         va_end (ap);
 282         return status;
 283 }
 284
 285 isc_result_t omapi_signal_in (omapi_object_t *handle, const char *name, ...)
 286 {
 287         va_list ap;
 288         isc_result_t status;
 289
 290         if (!handle)
 291                 return ISC_R_NOTFOUND;
 292         va_start (ap, name);
 293
 294         if (handle -> type -> signal_handler)
 295                 status = (*(handle -> type -> signal_handler)) (handle,
 296                                                                 name, ap);
 297         else
 298                 status = ISC_R_NOTFOUND;
 299         va_end (ap);
 300         return status;
 301 }
 302
 303 isc_result_t omapi_set_value (omapi_object_t *h,
 304                               omapi_object_t *id,
 305                               omapi_data_string_t *name,
 306                               omapi_typed_data_t *value)
 307 {
 308         omapi_object_t *outer;
 309         isc_result_t status;
 310
 311 #if defined (DEBUG_PROTOCOL)
 312         if (!value) {
 313                 log_info ("omapi_set_value (%.*s, NULL)",
 314                           (int)name -> len, name -> value);
 315         } else if (value -> type == omapi_datatype_int) {
 316                 log_info ("omapi_set_value (%.*s, %ld)",
 317                           (int)name -> len, name -> value,
 318                           (long)value -> u.integer);
 319         } else if (value -> type == omapi_datatype_string) {
 320                 log_info ("omapi_set_value (%.*s, %.*s)",
 321                           (int)name -> len, name -> value,
 322                           (int)value -> u.buffer.len, value -> u.buffer.value);
 323         } else if (value -> type == omapi_datatype_data) {
 324                 log_info ("omapi_set_value (%.*s, %ld %lx)",
 325                           (int)name -> len, name -> value,
 326                           (long)value -> u.buffer.len,
 327                           (unsigned long)value -> u.buffer.value);
 328         } else if (value -> type == omapi_datatype_object) {
 329                 log_info ("omapi_set_value (%.*s, %s)",
 330                           (int)name -> len, name -> value,
 331                           value -> u.object
 332                           ? (value -> u.object -> type
 333                              ? value -> u.object -> type -> name
 334                              : "(unknown object)")
 335                           : "(unknown object)");
 336         }
 337 #endif
 338
 339         for (outer = h; outer -> outer; outer = outer -> outer)
 340                 ;
 341         if (outer -> type -> set_value)
 342                 status = (*(outer -> type -> set_value)) (outer,
 343                                                           id, name, value);
 344         else
 345                 status = ISC_R_NOTFOUND;
 346 #if defined (DEBUG_PROTOCOL)
 347         log_info (" ==> %s", isc_result_totext (status));
 348 #endif
 349         return status;
 350 }
 351
 352 isc_result_t omapi_set_value_str (omapi_object_t *h,
 353                                   omapi_object_t *id,
 354                                   const char *name,
 355                                   omapi_typed_data_t *value)
 356 {
 357         omapi_data_string_t *nds;
 358         isc_result_t status;
 359
 360         nds = (omapi_data_string_t *)0;
 361         status = omapi_data_string_new (&nds, strlen (name), MDL);
 362         if (status != ISC_R_SUCCESS)
 363                 return status;
 364         memcpy (nds -> value, name, strlen (name));
 365
 366         status = omapi_set_value (h, id, nds, value);
 367         omapi_data_string_dereference (&nds, MDL);
 368         return status;
 369 }
 370
 371 isc_result_t omapi_set_boolean_value (omapi_object_t *h, omapi_object_t *id,
 372                                       const char *name, int value)
 373 {
 374         isc_result_t status;
 375         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
 376         omapi_data_string_t *n = (omapi_data_string_t *)0;
 377
 378         status = omapi_data_string_new (&n, strlen (name), MDL);
 379         if (status != ISC_R_SUCCESS)
 380                 return status;
 381         memcpy (n -> value, name, strlen (name));
 382
 383         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_int, value);
 384         if (status != ISC_R_SUCCESS) {
 385                 omapi_data_string_dereference (&n, MDL);
 386                 return status;
 387         }
 388
 389         status = omapi_set_value (h, id, n, tv);
 390         omapi_data_string_dereference (&n, MDL);
 391         omapi_typed_data_dereference (&tv, MDL);
 392         return status;
 393 }
 394
 395 isc_result_t omapi_set_int_value (omapi_object_t *h, omapi_object_t *id,
 396                                   const char *name, int value)
 397 {
 398         isc_result_t status;
 399         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
 400         omapi_data_string_t *n = (omapi_data_string_t *)0;
 401
 402         status = omapi_data_string_new (&n, strlen (name), MDL);
 403         if (status != ISC_R_SUCCESS)
 404                 return status;
 405         memcpy (n -> value, name, strlen (name));
 406
 407         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_int, value);
 408         if (status != ISC_R_SUCCESS) {
 409                 omapi_data_string_dereference (&n, MDL);
 410                 return status;
 411         }
 412
 413         status = omapi_set_value (h, id, n, tv);
 414         omapi_data_string_dereference (&n, MDL);
 415         omapi_typed_data_dereference (&tv, MDL);
 416         return status;
 417 }
 418
 419 isc_result_t omapi_set_object_value (omapi_object_t *h, omapi_object_t *id,
 420                                      const char *name, omapi_object_t *value)
 421 {
 422         isc_result_t status;
 423         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
 424         omapi_data_string_t *n = (omapi_data_string_t *)0;
 425
 426         status = omapi_data_string_new (&n, strlen (name), MDL);
 427         if (status != ISC_R_SUCCESS)
 428                 return status;
 429         memcpy (n -> value, name, strlen (name));
 430
 431         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_object, value);
 432         if (status != ISC_R_SUCCESS) {
 433                 omapi_data_string_dereference (&n, MDL);
 434                 return status;
 435         }
 436
 437         status = omapi_set_value (h, id, n, tv);
 438         omapi_data_string_dereference (&n, MDL);
 439         omapi_typed_data_dereference (&tv, MDL);
 440         return status;
 441 }
 442
 443 isc_result_t omapi_set_string_value (omapi_object_t *h, omapi_object_t *id,
 444                                      const char *name, const char *value)
 445 {
 446         isc_result_t status;
 447         omapi_typed_data_t *tv = (omapi_typed_data_t *)0;
 448         omapi_data_string_t *n = (omapi_data_string_t *)0;
 449
 450         status = omapi_data_string_new (&n, strlen (name), MDL);
 451         if (status != ISC_R_SUCCESS)
 452                 return status;
 453         memcpy (n -> value, name, strlen (name));
 454
 455         status = omapi_typed_data_new (MDL, &tv, omapi_datatype_string, value);
 456         if (status != ISC_R_SUCCESS) {
 457                 omapi_data_string_dereference (&n, MDL);
 458                 return status;
 459         }
 460
 461         status = omapi_set_value (h, id, n, tv);
 462         omapi_data_string_dereference (&n, MDL);
 463         omapi_typed_data_dereference (&tv, MDL);
 464         return status;
 465 }
 466
 467 isc_result_t omapi_get_value (omapi_object_t *h,
 468                               omapi_object_t *id,
 469                               omapi_data_string_t *name,
 470                               omapi_value_t **value)
 471 {
 472         omapi_object_t *outer;
 473
 474         for (outer = h; outer -> outer; outer = outer -> outer)
 475                 ;
 476         if (outer -> type -> get_value)
 477                 return (*(outer -> type -> get_value)) (outer,
 478                                                         id, name, value);
 479         return ISC_R_NOTFOUND;
 480 }
 481
 482 isc_result_t omapi_get_value_str (omapi_object_t *h,
 483                                   omapi_object_t *id,
 484                                   const char *name,
 485                                   omapi_value_t **value)
 486 {
 487         omapi_object_t *outer;
 488         omapi_data_string_t *nds;
 489         isc_result_t status;
 490
 491         nds = (omapi_data_string_t *)0;
 492         status = omapi_data_string_new (&nds, strlen (name), MDL);
 493         if (status != ISC_R_SUCCESS)
 494                 return status;
 495         memcpy (nds -> value, name, strlen (name));
 496
 497         for (outer = h; outer -> outer; outer = outer -> outer)
 498                 ;
 499         if (outer -> type -> get_value)
 500                 status = (*(outer -> type -> get_value)) (outer,
 501                                                           id, nds, value);
 502         else
 503                 status = ISC_R_NOTFOUND;
 504         omapi_data_string_dereference (&nds, MDL);
 505         return status;
 506 }
 507
 508 isc_result_t omapi_stuff_values (omapi_object_t *c,
 509                                  omapi_object_t *id,
 510                                  omapi_object_t *o)
 511 {
 512         omapi_object_t *outer;
 513
 514         for (outer = o; outer -> outer; outer = outer -> outer)
 515                 ;
 516         if (outer -> type -> stuff_values)
 517                 return (*(outer -> type -> stuff_values)) (c, id, outer);
 518         return ISC_R_NOTFOUND;
 519 }
 520
 521 isc_result_t omapi_object_create (omapi_object_t **obj, omapi_object_t *id,
 522                                   omapi_object_type_t *type)
 523 {
 524         if (!type -> create)
 525                 return ISC_R_NOTIMPLEMENTED;
 526         return (*(type -> create)) (obj, id);
 527 }
 528
 529 isc_result_t omapi_object_update (omapi_object_t *obj, omapi_object_t *id,
 530                                   omapi_object_t *src, omapi_handle_t handle)
 531 {
 532         omapi_generic_object_t *gsrc;
 533         isc_result_t status;
 534         int i;
 535
 536         if (!src)
 537                 return DHCP_R_INVALIDARG;
 538         if (src -> type != omapi_type_generic)
 539                 return ISC_R_NOTIMPLEMENTED;
 540         gsrc = (omapi_generic_object_t *)src;
 541         for (i = 0; i < gsrc -> nvalues; i++) {
 542                 status = omapi_set_value (obj, id,
 543                                           gsrc -> values [i] -> name,
 544                                           gsrc -> values [i] -> value);
 545                 if (status != ISC_R_SUCCESS && status != DHCP_R_UNCHANGED)
 546                         return status;
 547         }
 548
 549         /*
 550          * For now ignore the return value.  I'm not sure if we want to
 551          * generate an error if we can't set the handle value.  If we
 552          * do add a check we probably should allow unchanged and notfound
 553          */
 554         if (handle)
 555                 (void) omapi_set_int_value (obj, id, "remote-handle", (int)handle);
 556         status = omapi_signal (obj, "updated");
 557         if (status != ISC_R_NOTFOUND)
 558                 return status;
 559         return ISC_R_SUCCESS;
 560 }
 561
 562 int omapi_data_string_cmp (omapi_data_string_t *s1, omapi_data_string_t *s2)
 563 {
 564         unsigned len;
 565         int rv;
 566
 567         if (s1 -> len > s2 -> len)
 568                 len = s2 -> len;
 569         else
 570                 len = s1 -> len;
 571         rv = memcmp (s1 -> value, s2 -> value, len);
 572         if (rv)
 573                 return rv;
 574         if (s1 -> len > s2 -> len)
 575                 return 1;
 576         else if (s1 -> len < s2 -> len)
 577                 return -1;
 578         return 0;
 579 }
 580
 581 int omapi_ds_strcmp (omapi_data_string_t *s1, const char *s2)
 582 {
 583         unsigned len, slen;
 584         int rv;
 585
 586         slen = strlen (s2);
 587         if (slen > s1 -> len)
 588                 len = s1 -> len;
 589         else
 590                 len = slen;
 591         rv = memcmp (s1 -> value, s2, len);
 592         if (rv)
 593                 return rv;
 594         if (s1 -> len > slen)
 595                 return 1;
 596         else if (s1 -> len < slen)
 597                 return -1;
 598         return 0;
 599 }
 600
 601 int omapi_td_strcmp (omapi_typed_data_t *s1, const char *s2)
 602 {
 603         unsigned len, slen;
 604         int rv;
 605
 606         /* If the data type is not compatible, never equal. */
 607         if (s1 -> type != omapi_datatype_data &&
 608             s1 -> type != omapi_datatype_string)
 609                 return -1;
 610
 611         slen = strlen (s2);
 612         if (slen > s1 -> u.buffer.len)
 613                 len = s1 -> u.buffer.len;
 614         else
 615                 len = slen;
 616         rv = memcmp (s1 -> u.buffer.value, s2, len);
 617         if (rv)
 618                 return rv;
 619         if (s1 -> u.buffer.len > slen)
 620                 return 1;
 621         else if (s1 -> u.buffer.len < slen)
 622                 return -1;
 623         return 0;
 624 }
 625
 626 int omapi_td_strcasecmp (omapi_typed_data_t *s1, const char *s2)
 627 {
 628         unsigned len, slen;
 629         int rv;
 630
 631         /* If the data type is not compatible, never equal. */
 632         if (s1 -> type != omapi_datatype_data &&
 633             s1 -> type != omapi_datatype_string)
 634                 return -1;
 635
 636         slen = strlen (s2);
 637         if (slen > s1 -> u.buffer.len)
 638                 len = s1 -> u.buffer.len;
 639         else
 640                 len = slen;
 641         rv = casecmp (s1 -> u.buffer.value, s2, len);
 642         if (rv)
 643                 return rv;
 644         if (s1 -> u.buffer.len > slen)
 645                 return 1;
 646         else if (s1 -> u.buffer.len < slen)
 647                 return -1;
 648         return 0;
 649 }
 650
 651 isc_result_t omapi_make_value (omapi_value_t **vp,
 652                                omapi_data_string_t *name,
 653                                omapi_typed_data_t *value,
 654                                const char *file, int line)
 655 {
 656         isc_result_t status;
 657
 658         status = omapi_value_new (vp, file, line);
 659         if (status != ISC_R_SUCCESS)
 660                 return status;
 661
 662         status = omapi_data_string_reference (&(*vp) -> name,
 663                                               name, file, line);
 664         if (status != ISC_R_SUCCESS) {
 665                 omapi_value_dereference (vp, file, line);
 666                 return status;
 667         }
 668         if (value) {
 669                 status = omapi_typed_data_reference (&(*vp) -> value,
 670                                                      value, file, line);
 671                 if (status != ISC_R_SUCCESS) {
 672                         omapi_value_dereference (vp, file, line);
 673                         return status;
 674                 }
 675         }
 676         return ISC_R_SUCCESS;
 677 }
 678
 679 isc_result_t omapi_make_const_value (omapi_value_t **vp,
 680                                      omapi_data_string_t *name,
 681                                      const unsigned char *value,
 682                                      unsigned len,
 683                                      const char *file, int line)
 684 {
 685         isc_result_t status;
 686
 687         status = omapi_value_new (vp, file, line);
 688         if (status != ISC_R_SUCCESS)
 689                 return status;
 690
 691         status = omapi_data_string_reference (&(*vp) -> name,
 692                                               name, file, line);
 693         if (status != ISC_R_SUCCESS) {
 694                 omapi_value_dereference (vp, file, line);
 695                 return status;
 696         }
 697         if (value) {
 698                 status = omapi_typed_data_new (file, line, &(*vp) -> value,
 699                                                omapi_datatype_data, len);
 700                 if (status != ISC_R_SUCCESS) {
 701                         omapi_value_dereference (vp, file, line);
 702                         return status;
 703                 }
 704                 memcpy ((*vp) -> value -> u.buffer.value, value, len);
 705         }
 706         return ISC_R_SUCCESS;
 707 }
 708
 709 isc_result_t omapi_make_int_value (omapi_value_t **vp,
 710                                    omapi_data_string_t *name,
 711                                    int value, const char *file, int line)
 712 {
 713         isc_result_t status;
 714
 715         status = omapi_value_new (vp, file, line);
 716         if (status != ISC_R_SUCCESS)
 717                 return status;
 718
 719         status = omapi_data_string_reference (&(*vp) -> name,
 720                                               name, file, line);
 721         if (status != ISC_R_SUCCESS) {
 722                 omapi_value_dereference (vp, file, line);
 723                 return status;
 724         }
 725         status = omapi_typed_data_new (file, line, &(*vp) -> value,
 726                                        omapi_datatype_int, value);
 727         if (status != ISC_R_SUCCESS) {
 728                 omapi_value_dereference (vp, file, line);
 729                 return status;
 730         }
 731         return ISC_R_SUCCESS;
 732 }
 733
 734 isc_result_t omapi_make_uint_value (omapi_value_t **vp,
 735                                     omapi_data_string_t *name,
 736                                     unsigned int value,
 737                                     const char *file, int line)
 738 {
 739         return omapi_make_int_value (vp, name, (int)value, file, line);
 740 }
 741
 742 isc_result_t omapi_make_object_value (omapi_value_t **vp,
 743                                       omapi_data_string_t *name,
 744                                       omapi_object_t *value,
 745                                       const char *file, int line)
 746 {
 747         isc_result_t status;
 748
 749         status = omapi_value_new (vp, file, line);
 750         if (status != ISC_R_SUCCESS)
 751                 return status;
 752
 753         status = omapi_data_string_reference (&(*vp) -> name,
 754                                               name, file, line);
 755         if (status != ISC_R_SUCCESS) {
 756                 omapi_value_dereference (vp, file, line);
 757                 return status;
 758         }
 759
 760         if (value) {
 761                 status = omapi_typed_data_new (file, line, &(*vp) -> value,
 762                                                omapi_datatype_object, value);
 763                 if (status != ISC_R_SUCCESS) {
 764                         omapi_value_dereference (vp, file, line);
 765                         return status;
 766                 }
 767         }
 768
 769         return ISC_R_SUCCESS;
 770 }
 771
 772 isc_result_t omapi_make_handle_value (omapi_value_t **vp,
 773                                       omapi_data_string_t *name,
 774                                       omapi_object_t *value,
 775                                       const char *file, int line)
 776 {
 777         isc_result_t status;
 778
 779         status = omapi_value_new (vp, file, line);
 780         if (status != ISC_R_SUCCESS)
 781                 return status;
 782
 783         status = omapi_data_string_reference (&(*vp) -> name,
 784                                               name, file, line);
 785         if (status != ISC_R_SUCCESS) {
 786                 omapi_value_dereference (vp, file, line);
 787                 return status;
 788         }
 789         if (value) {
 790                 status = omapi_typed_data_new (file, line, &(*vp) -> value,
 791                                                omapi_datatype_int);
 792                 if (status != ISC_R_SUCCESS) {
 793                         omapi_value_dereference (vp, file, line);
 794                         return status;
 795                 }
 796                 status = (omapi_object_handle
 797                           ((omapi_handle_t *)&(*vp) -> value -> u.integer,
 798                            value));
 799                 if (status != ISC_R_SUCCESS) {
 800                         omapi_value_dereference (vp, file, line);
 801                         return status;
 802                 }
 803         }
 804         return ISC_R_SUCCESS;
 805 }
 806
 807 isc_result_t omapi_make_string_value (omapi_value_t **vp,
 808                                       omapi_data_string_t *name,
 809                                       const char *value,
 810                                       const char *file, int line)
 811 {
 812         isc_result_t status;
 813
 814         status = omapi_value_new (vp, file, line);
 815         if (status != ISC_R_SUCCESS)
 816                 return status;
 817
 818         status = omapi_data_string_reference (&(*vp) -> name,
 819                                               name, file, line);
 820         if (status != ISC_R_SUCCESS) {
 821                 omapi_value_dereference (vp, file, line);
 822                 return status;
 823         }
 824         if (value) {
 825                 status = omapi_typed_data_new (file, line, &(*vp) -> value,
 826                                                omapi_datatype_string, value);
 827                 if (status != ISC_R_SUCCESS) {
 828                         omapi_value_dereference (vp, file, line);
 829                         return status;
 830                 }
 831         }
 832         return ISC_R_SUCCESS;
 833 }
 834
 835 isc_result_t omapi_get_int_value (unsigned long *v, omapi_typed_data_t *t)
 836 {
 837         u_int32_t rv;
 838
 839         if (t -> type == omapi_datatype_int) {
 840                 *v = t -> u.integer;
 841                 return ISC_R_SUCCESS;
 842         } else if (t -> type == omapi_datatype_string ||
 843                    t -> type == omapi_datatype_data) {
 844                 if (t -> u.buffer.len != sizeof (rv))
 845                         return DHCP_R_INVALIDARG;
 846                 memcpy (&rv, t -> u.buffer.value, sizeof rv);
 847                 *v = ntohl (rv);
 848                 return ISC_R_SUCCESS;
 849         }
 850         return DHCP_R_INVALIDARG;
 851 }