contrib/isc-dhcp/omapip/support.c

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