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