usr/src/lib/udapl/libdat/common/dat_dictionary.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2002-2003, Network Appliance, Inc. All rights reserved.
  24  */
  25
  26 /*
  27  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30
  31 #pragma ident   "%Z%%M% %I%     %E% SMI"
  32
  33 /*
  34  *
  35  * MODULE: dat_dictionary.c
  36  *
  37  * PURPOSE: dictionary data structure
  38  *
  39  * $Id: dat_dictionary.c,v 1.11 2003/08/05 19:01:48 jlentini Exp $
  40  */
  41
  42
  43 #include "dat_dictionary.h"
  44
  45
  46 /*
  47  *
  48  * Structures
  49  *
  50  */
  51
  52 typedef struct DAT_DICTIONARY_NODE
  53 {
  54     DAT_PROVIDER_INFO           key;
  55     DAT_DICTIONARY_DATA         data;
  56     struct DAT_DICTIONARY_NODE  *prev;
  57     struct DAT_DICTIONARY_NODE  *next;
  58 } DAT_DICTIONARY_NODE;
  59
  60
  61 struct DAT_DICTIONARY
  62 {
  63     DAT_DICTIONARY_NODE         *head;
  64     DAT_DICTIONARY_NODE         *tail;
  65     DAT_COUNT                   size;
  66 };
  67
  68 /*
  69  *
  70  * Function Declarations
  71  *
  72  */
  73
  74 static DAT_RETURN
  75 dat_dictionary_key_dup(
  76     const DAT_PROVIDER_INFO     *old_key,
  77     DAT_PROVIDER_INFO           *new_key);
  78
  79 static DAT_BOOLEAN
  80 dat_dictionary_key_is_equal(
  81     const DAT_PROVIDER_INFO     *key_a,
  82     const DAT_PROVIDER_INFO     *key_b);
  83
  84
  85 /*
  86  *
  87  * External Functions
  88  *
  89  */
  90
  91
  92 /*
  93  * Function: dat_dictionary_create
  94  */
  95
  96 DAT_RETURN
  97 dat_dictionary_create(
  98     OUT DAT_DICTIONARY **pp_dictionary)
  99 {
 100         DAT_DICTIONARY  *p_dictionary;
 101         DAT_RETURN status;
 102
 103         dat_os_assert(NULL != pp_dictionary);
 104
 105         status = DAT_SUCCESS;
 106
 107         /* create the dictionary */
 108         p_dictionary = dat_os_alloc(sizeof (DAT_DICTIONARY));
 109         if (NULL == p_dictionary) {
 110                 status = DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
 111                     DAT_RESOURCE_MEMORY);
 112                 goto bail;
 113         }
 114
 115         (void) dat_os_memset(p_dictionary, '\0', sizeof (DAT_DICTIONARY));
 116
 117         /* create the head node */
 118         p_dictionary->head = dat_os_alloc(sizeof (DAT_DICTIONARY_NODE));
 119         if (NULL == p_dictionary->head) {
 120                 status = DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
 121                     DAT_RESOURCE_MEMORY);
 122                 goto bail;
 123         }
 124
 125         (void) dat_os_memset(p_dictionary->head, '\0',
 126             sizeof (DAT_DICTIONARY_NODE));
 127
 128         /* create the tail node */
 129         p_dictionary->tail = dat_os_alloc(sizeof (DAT_DICTIONARY_NODE));
 130         if (NULL == p_dictionary->tail) {
 131                 status = DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
 132                     DAT_RESOURCE_MEMORY);
 133                 goto bail;
 134         }
 135
 136         (void) dat_os_memset(p_dictionary->tail, '\0',
 137             sizeof (DAT_DICTIONARY_NODE));
 138
 139         p_dictionary->head->next = p_dictionary->tail;
 140         p_dictionary->tail->prev = p_dictionary->head;
 141
 142         *pp_dictionary = p_dictionary;
 143
 144 bail:
 145         if (DAT_SUCCESS != status) {
 146                 if (NULL != p_dictionary) {
 147                         dat_os_free(p_dictionary, sizeof (DAT_DICTIONARY));
 148
 149                         if (NULL != p_dictionary->head) {
 150                                 dat_os_free(p_dictionary->head,
 151                                     sizeof (DAT_DICTIONARY_NODE));
 152                         }
 153
 154                         if (NULL != p_dictionary->tail) {
 155                                 dat_os_free(p_dictionary->tail,
 156                                     sizeof (DAT_DICTIONARY_NODE));
 157                         }
 158                 }
 159         }
 160
 161         return (status);
 162 }
 163
 164
 165 /*
 166  * Function: dat_dictionary_destroy
 167  */
 168
 169 DAT_RETURN
 170 dat_dictionary_destroy(
 171     IN  DAT_DICTIONARY *p_dictionary)
 172 {
 173         DAT_DICTIONARY_NODE *cur_node;
 174
 175         dat_os_assert(NULL != p_dictionary);
 176
 177         while (NULL != p_dictionary->head) {
 178                 cur_node = p_dictionary->head;
 179                 p_dictionary->head = cur_node->next;
 180
 181                 dat_os_free(cur_node, sizeof (DAT_DICTIONARY_NODE));
 182         }
 183
 184         dat_os_free(p_dictionary, sizeof (DAT_DICTIONARY));
 185
 186         return (DAT_SUCCESS);
 187 }
 188
 189
 190 /*
 191  * Function: dat_dictionary_size
 192  */
 193
 194 DAT_RETURN
 195 dat_dictionary_size(
 196     IN  DAT_DICTIONARY *p_dictionary,
 197     OUT DAT_COUNT *p_size)
 198 {
 199         dat_os_assert(NULL != p_dictionary);
 200         dat_os_assert(NULL != p_size);
 201
 202         *p_size = p_dictionary->size;
 203
 204         return (DAT_SUCCESS);
 205 }
 206
 207
 208 /*
 209  * Function: dat_dictionary_entry_create
 210  */
 211
 212 DAT_RETURN
 213 dat_dictionary_entry_create(
 214     OUT DAT_DICTIONARY_ENTRY *p_entry)
 215 {
 216         DAT_DICTIONARY_NODE     *node;
 217         DAT_RETURN              dat_status;
 218
 219         dat_os_assert(NULL != p_entry);
 220
 221         dat_status = DAT_SUCCESS;
 222
 223         node = dat_os_alloc(sizeof (DAT_DICTIONARY_NODE));
 224         if (NULL == node) {
 225                 dat_status = DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
 226                     DAT_RESOURCE_MEMORY);
 227                 goto bail;
 228         }
 229
 230         *p_entry = node;
 231
 232 bail:
 233         return (dat_status);
 234 }
 235
 236
 237 /*
 238  * Function: dat_dictionary_entry_destroy
 239  */
 240
 241 DAT_RETURN
 242 dat_dictionary_entry_destroy(
 243     OUT DAT_DICTIONARY_ENTRY entry)
 244 {
 245         dat_os_free(entry, sizeof (DAT_DICTIONARY_NODE));
 246         return (DAT_SUCCESS);
 247 }
 248
 249
 250 /*
 251  * Function: dat_dictionary_insert
 252  */
 253
 254 DAT_RETURN
 255 dat_dictionary_insert(
 256     IN  DAT_DICTIONARY *p_dictionary,
 257     IN  DAT_DICTIONARY_ENTRY entry,
 258     IN  const DAT_PROVIDER_INFO *key,
 259     IN  DAT_DICTIONARY_DATA data)
 260 {
 261         DAT_RETURN              dat_status;
 262         DAT_DICTIONARY_NODE *cur_node, *prev_node, *next_node;
 263
 264         dat_os_assert(NULL != p_dictionary);
 265         dat_os_assert(NULL != entry);
 266
 267         cur_node = entry;
 268
 269         if (DAT_SUCCESS == dat_dictionary_search(p_dictionary, key, NULL)) {
 270                 dat_status = DAT_ERROR(DAT_PROVIDER_ALREADY_REGISTERED, 0);
 271                 goto bail;
 272         }
 273
 274         dat_status = dat_dictionary_key_dup(key, &cur_node->key);
 275         if (DAT_SUCCESS != dat_status) {
 276                 goto bail;
 277         }
 278
 279         /* insert node at end of list to preserve registration order */
 280         prev_node = p_dictionary->tail->prev;
 281         next_node = p_dictionary->tail;
 282
 283         cur_node->data = data;
 284         cur_node->next = next_node;
 285         cur_node->prev = prev_node;
 286
 287         prev_node->next = cur_node;
 288         next_node->prev = cur_node;
 289
 290         p_dictionary->size++;
 291
 292 bail:
 293         return (dat_status);
 294 }
 295
 296
 297 /*
 298  * Function: dat_dictionary_search
 299  */
 300
 301 DAT_RETURN
 302 dat_dictionary_search(
 303     IN  DAT_DICTIONARY *p_dictionary,
 304     IN  const DAT_PROVIDER_INFO *key,
 305     OUT DAT_DICTIONARY_DATA *p_data)
 306 {
 307         DAT_DICTIONARY_NODE *cur_node;
 308         DAT_RETURN status;
 309
 310         dat_os_assert(NULL != p_dictionary);
 311
 312         status = DAT_ERROR(DAT_NAME_NOT_FOUND, 0);
 313
 314         for (cur_node = p_dictionary->head->next;
 315                 p_dictionary->tail != cur_node;
 316                 cur_node = cur_node->next) {
 317                 if (DAT_TRUE == dat_dictionary_key_is_equal(&cur_node->key,
 318                     key)) {
 319                         if (NULL != p_data) {
 320                                 *p_data = cur_node->data;
 321                         }
 322
 323                         status = DAT_SUCCESS;
 324                         goto bail;
 325                 }
 326         }
 327
 328 bail:
 329         return (status);
 330 }
 331
 332
 333 /*
 334  * Function: dat_dictionary_enumerate
 335  */
 336
 337 DAT_RETURN
 338 dat_dictionary_enumerate(
 339     IN  DAT_DICTIONARY *p_dictionary,
 340     IN  DAT_DICTIONARY_DATA array[],
 341     IN  DAT_COUNT array_size)
 342 {
 343         DAT_DICTIONARY_NODE *cur_node;
 344         DAT_COUNT i;
 345         DAT_RETURN status;
 346
 347         dat_os_assert(NULL != p_dictionary);
 348         dat_os_assert(NULL != array);
 349
 350         status = DAT_SUCCESS;
 351
 352         if (array_size < p_dictionary->size) {
 353                 status = DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, 0);
 354                 goto bail;
 355         }
 356
 357         for (cur_node = p_dictionary->head->next, i = 0;
 358                 p_dictionary->tail != cur_node;
 359                 cur_node = cur_node->next, i++) {
 360                 array[i] = cur_node->data;
 361         }
 362
 363 bail:
 364         return (status);
 365 }
 366
 367
 368 /*
 369  * Function: dat_dictionary_remove
 370  */
 371
 372 DAT_RETURN
 373 dat_dictionary_remove(
 374     IN  DAT_DICTIONARY *p_dictionary,
 375     IN  DAT_DICTIONARY_ENTRY *p_entry,
 376     IN  const DAT_PROVIDER_INFO *key,
 377     OUT DAT_DICTIONARY_DATA *p_data)
 378 {
 379         DAT_DICTIONARY_NODE *cur_node, *prev_node, *next_node;
 380         DAT_RETURN status;
 381
 382         dat_os_assert(NULL != p_dictionary);
 383         dat_os_assert(NULL != p_entry);
 384
 385         status = DAT_ERROR(DAT_NAME_NOT_FOUND, 0);
 386
 387         for (cur_node = p_dictionary->head->next;
 388                 p_dictionary->tail != cur_node;
 389                 cur_node = cur_node->next) {
 390                 if (DAT_TRUE == dat_dictionary_key_is_equal(&cur_node->key,
 391                     key)) {
 392                         if (NULL != p_data) {
 393                                 *p_data = cur_node->data;
 394                         }
 395
 396                         prev_node = cur_node->prev;
 397                         next_node = cur_node->next;
 398
 399                         prev_node->next = next_node;
 400                         next_node->prev = prev_node;
 401
 402                         *p_entry = cur_node;
 403
 404                         p_dictionary->size--;
 405
 406                         status = DAT_SUCCESS;
 407                         goto bail;
 408                 }
 409         }
 410
 411 bail:
 412         return (status);
 413 }
 414
 415
 416 /*
 417  *
 418  * Internal Function Definitions
 419  *
 420  */
 421
 422
 423 /*
 424  * Function: dat_dictionary_key_create
 425  */
 426
 427 DAT_RETURN
 428 dat_dictionary_key_dup(
 429     const DAT_PROVIDER_INFO     *old_key,
 430     DAT_PROVIDER_INFO           *new_key)
 431 {
 432         dat_os_assert(NULL != old_key);
 433         dat_os_assert(NULL != new_key);
 434
 435         (void) dat_os_strncpy(new_key->ia_name, old_key->ia_name,
 436             DAT_NAME_MAX_LENGTH);
 437         new_key->dapl_version_major = old_key->dapl_version_major;
 438         new_key->dapl_version_minor = old_key->dapl_version_minor;
 439         new_key->is_thread_safe = old_key->is_thread_safe;
 440
 441         return (DAT_SUCCESS);
 442 }
 443
 444
 445 /*
 446  * Function: dat_dictionary_key_is_equal
 447  */
 448
 449 DAT_BOOLEAN
 450 dat_dictionary_key_is_equal(
 451     const DAT_PROVIDER_INFO     *key_a,
 452     const DAT_PROVIDER_INFO     *key_b)
 453 {
 454         if ((dat_os_strlen(key_a->ia_name) == dat_os_strlen(key_b->ia_name)) &&
 455             (!dat_os_strncmp(key_a->ia_name, key_b->ia_name,
 456                 dat_os_strlen(key_a->ia_name))) &&
 457             (key_a->dapl_version_major == key_b->dapl_version_major) &&
 458             (key_a->dapl_version_minor == key_b->dapl_version_minor) &&
 459             (key_a->is_thread_safe == key_b->is_thread_safe)) {
 460                 return (DAT_TRUE);
 461         } else {
 462                 return (DAT_FALSE);
 463         }
 464 }