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 } 465