omapip/support.c

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