In several standard headers, harmonize checks for legacy defines etc.
[dragonfly.git] / sys / libprop / prop_dictionary.c
1 /*      $NetBSD: prop_dictionary.c,v 1.36 2010/09/24 22:51:52 rmind Exp $       */
2
3 /*-
4  * Copyright (c) 2006, 2007 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Jason R. Thorpe.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
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  *
19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include <libprop/prop_array.h>
33 #include <libprop/prop_dictionary.h>
34 #include <libprop/prop_string.h>
35 #include "prop_object_impl.h"
36 #include "prop_rb_impl.h"
37
38 #if !defined(_KERNEL) && !defined(_STANDALONE)
39 #include <errno.h>
40 #endif
41
42 /*
43  * We implement these like arrays, but we keep them sorted by key.
44  * This allows us to binary-search as well as keep externalized output
45  * sane-looking for human eyes.
46  */
47
48 #define EXPAND_STEP             16
49
50 /*
51  * prop_dictionary_keysym_t is allocated with space at the end to hold the
52  * key.  This must be a regular object so that we can maintain sane iterator
53  * semantics -- we don't want to require that the caller release the result
54  * of prop_object_iterator_next().
55  *
56  * We'd like to have some small'ish keysym objects for up-to-16 characters
57  * in a key, some for up-to-32 characters in a key, and then a final bucket
58  * for up-to-128 characters in a key (not including NUL).  Keys longer than
59  * 128 characters are not allowed.
60  */
61 struct _prop_dictionary_keysym {
62         struct _prop_object             pdk_obj;
63         size_t                          pdk_size;
64         struct rb_node                  pdk_link;
65         char                            pdk_key[1];
66         /* actually variable length */
67 };
68
69         /* pdk_key[1] takes care of the NUL */
70 #define PDK_SIZE_16             (sizeof(struct _prop_dictionary_keysym) + 16)
71 #define PDK_SIZE_32             (sizeof(struct _prop_dictionary_keysym) + 32)
72 #define PDK_SIZE_128            (sizeof(struct _prop_dictionary_keysym) + 128)
73
74 #define PDK_MAXKEY              128
75
76 _PROP_POOL_INIT(_prop_dictionary_keysym16_pool, PDK_SIZE_16, "pdict16");
77 _PROP_POOL_INIT(_prop_dictionary_keysym32_pool, PDK_SIZE_32, "pdict32");
78 _PROP_POOL_INIT(_prop_dictionary_keysym128_pool, PDK_SIZE_128, "pdict128");
79
80 struct _prop_dict_entry {
81         prop_dictionary_keysym_t        pde_key;
82         prop_object_t                   pde_objref;
83 };
84
85 struct _prop_dictionary {
86         struct _prop_object     pd_obj;
87         _PROP_RWLOCK_DECL(pd_rwlock)
88         struct _prop_dict_entry *pd_array;
89         unsigned int            pd_capacity;
90         unsigned int            pd_count;
91         int                     pd_flags;
92
93         uint32_t                pd_version;
94 };
95
96 #define PD_F_IMMUTABLE          0x01    /* dictionary is immutable */
97
98 _PROP_POOL_INIT(_prop_dictionary_pool, sizeof(struct _prop_dictionary),
99                 "propdict");
100 _PROP_MALLOC_DEFINE(M_PROP_DICT, "prop dictionary",
101                     "property dictionary container object")
102
103 static _prop_object_free_rv_t
104                 _prop_dictionary_free(prop_stack_t, prop_object_t *);
105 static void     _prop_dictionary_emergency_free(prop_object_t);
106 static bool     _prop_dictionary_externalize(
107                                 struct _prop_object_externalize_context *,
108                                 void *);
109 static _prop_object_equals_rv_t
110                 _prop_dictionary_equals(prop_object_t, prop_object_t,
111                                         void **, void **,
112                                         prop_object_t *, prop_object_t *);
113 static void     _prop_dictionary_equals_finish(prop_object_t, prop_object_t);
114 static prop_object_iterator_t
115                 _prop_dictionary_iterator_locked(prop_dictionary_t);
116 static prop_object_t
117                 _prop_dictionary_iterator_next_object_locked(void *);
118 static prop_object_t
119                 _prop_dictionary_get_keysym(prop_dictionary_t,
120                                             prop_dictionary_keysym_t, bool);
121 static prop_object_t
122                 _prop_dictionary_get(prop_dictionary_t, const char *, bool);
123
124 static void _prop_dictionary_lock(void);
125 static void _prop_dictionary_unlock(void);
126
127 static const struct _prop_object_type _prop_object_type_dictionary = {
128         .pot_type               =       PROP_TYPE_DICTIONARY,
129         .pot_free               =       _prop_dictionary_free,
130         .pot_emergency_free     =       _prop_dictionary_emergency_free,
131         .pot_extern             =       _prop_dictionary_externalize,
132         .pot_equals             =       _prop_dictionary_equals,
133         .pot_equals_finish      =       _prop_dictionary_equals_finish,
134         .pot_lock               =       _prop_dictionary_lock,
135         .pot_unlock             =       _prop_dictionary_unlock,                
136 };
137
138 static _prop_object_free_rv_t
139                 _prop_dict_keysym_free(prop_stack_t, prop_object_t *);
140 static bool     _prop_dict_keysym_externalize(
141                                 struct _prop_object_externalize_context *,
142                                 void *);
143 static _prop_object_equals_rv_t
144                 _prop_dict_keysym_equals(prop_object_t, prop_object_t,
145                                          void **, void **,
146                                          prop_object_t *, prop_object_t *);
147
148 static const struct _prop_object_type _prop_object_type_dict_keysym = {
149         .pot_type       =       PROP_TYPE_DICT_KEYSYM,
150         .pot_free       =       _prop_dict_keysym_free,
151         .pot_extern     =       _prop_dict_keysym_externalize,
152         .pot_equals     =       _prop_dict_keysym_equals,
153 };
154
155 #define prop_object_is_dictionary(x)            \
156         ((x) != NULL && (x)->pd_obj.po_type == &_prop_object_type_dictionary)
157 #define prop_object_is_dictionary_keysym(x)     \
158         ((x) != NULL && (x)->pdk_obj.po_type == &_prop_object_type_dict_keysym)
159
160 #define prop_dictionary_is_immutable(x)         \
161                                 (((x)->pd_flags & PD_F_IMMUTABLE) != 0)
162
163 struct _prop_dictionary_iterator {
164         struct _prop_object_iterator pdi_base;
165         unsigned int            pdi_index;
166 };
167
168 /*
169  * Dictionary key symbols are immutable, and we are likely to have many
170  * duplicated key symbols.  So, to save memory, we unique'ify key symbols
171  * so we only have to have one copy of each string.
172  */
173
174 static int
175 /*ARGSUSED*/
176 _prop_dict_keysym_rb_compare_nodes(void *ctx __unused,
177                                    const void *n1, const void *n2)
178 {
179         const struct _prop_dictionary_keysym *pdk1 = n1;
180         const struct _prop_dictionary_keysym *pdk2 = n2;
181
182         return strcmp(pdk1->pdk_key, pdk2->pdk_key);
183 }
184
185 static int
186 /*ARGSUSED*/
187 _prop_dict_keysym_rb_compare_key(void *ctx __unused,
188                                  const void *n, const void *v)
189 {
190         const struct _prop_dictionary_keysym *pdk = n;
191         const char *cp = v;
192
193         return strcmp(pdk->pdk_key, cp);
194 }
195
196 static const rb_tree_ops_t _prop_dict_keysym_rb_tree_ops = {
197         .rbto_compare_nodes = _prop_dict_keysym_rb_compare_nodes,
198         .rbto_compare_key = _prop_dict_keysym_rb_compare_key,
199         .rbto_node_offset = offsetof(struct _prop_dictionary_keysym, pdk_link),
200         .rbto_context = NULL
201 };
202
203 static struct rb_tree _prop_dict_keysym_tree;
204
205 _PROP_ONCE_DECL(_prop_dict_init_once)
206 _PROP_MUTEX_DECL_STATIC(_prop_dict_keysym_tree_mutex)
207
208 static int
209 _prop_dict_init(void)
210 {
211
212         _PROP_MUTEX_INIT(_prop_dict_keysym_tree_mutex);
213         _prop_rb_tree_init(&_prop_dict_keysym_tree,
214                            &_prop_dict_keysym_rb_tree_ops);
215         return 0;
216 }
217
218 static void
219 _prop_dict_keysym_put(prop_dictionary_keysym_t pdk)
220 {
221
222         if (pdk->pdk_size <= PDK_SIZE_16)
223                 _PROP_POOL_PUT(_prop_dictionary_keysym16_pool, pdk);
224         else if (pdk->pdk_size <= PDK_SIZE_32)
225                 _PROP_POOL_PUT(_prop_dictionary_keysym32_pool, pdk);
226         else {
227                 _PROP_ASSERT(pdk->pdk_size <= PDK_SIZE_128);
228                 _PROP_POOL_PUT(_prop_dictionary_keysym128_pool, pdk);
229         }
230 }
231
232 /* ARGSUSED */
233 static _prop_object_free_rv_t
234 _prop_dict_keysym_free(prop_stack_t stack, prop_object_t *obj)
235 {
236         prop_dictionary_keysym_t pdk = *obj;
237
238         _prop_rb_tree_remove_node(&_prop_dict_keysym_tree, pdk);
239         _prop_dict_keysym_put(pdk);
240
241         return _PROP_OBJECT_FREE_DONE;
242 }
243
244 static bool
245 _prop_dict_keysym_externalize(struct _prop_object_externalize_context *ctx,
246                              void *v)
247 {
248         prop_dictionary_keysym_t pdk = v;
249
250         /* We externalize these as strings, and they're never empty. */
251
252         _PROP_ASSERT(pdk->pdk_key[0] != '\0');
253
254         if (_prop_object_externalize_start_tag(ctx, "string") == false ||
255             _prop_object_externalize_append_encoded_cstring(ctx,
256                                                 pdk->pdk_key) == false ||
257             _prop_object_externalize_end_tag(ctx, "string") == false)
258                 return (false);
259         
260         return (true);
261 }
262
263 /* ARGSUSED */
264 static _prop_object_equals_rv_t
265 _prop_dict_keysym_equals(prop_object_t v1, prop_object_t v2,
266     void **stored_pointer1, void **stored_pointer2,
267     prop_object_t *next_obj1, prop_object_t *next_obj2)
268 {
269         prop_dictionary_keysym_t pdk1 = v1;
270         prop_dictionary_keysym_t pdk2 = v2;
271
272         /*
273          * There is only ever one copy of a keysym at any given time,
274          * so we can reduce this to a simple pointer equality check.
275          */
276         if (pdk1 == pdk2)
277                 return _PROP_OBJECT_EQUALS_TRUE;
278         else
279                 return _PROP_OBJECT_EQUALS_FALSE;
280 }
281
282 static prop_dictionary_keysym_t
283 _prop_dict_keysym_alloc(const char *key)
284 {
285         prop_dictionary_keysym_t opdk, pdk, rpdk;
286         size_t size;
287
288         _PROP_ONCE_RUN(_prop_dict_init_once, _prop_dict_init);
289
290         /*
291          * Check to see if this already exists in the tree.  If it does,
292          * we just retain it and return it.
293          */
294         _PROP_MUTEX_LOCK(_prop_dict_keysym_tree_mutex);
295         opdk = _prop_rb_tree_find(&_prop_dict_keysym_tree, key);
296         if (opdk != NULL) {
297                 prop_object_retain(opdk);
298                 _PROP_MUTEX_UNLOCK(_prop_dict_keysym_tree_mutex);
299                 return (opdk);
300         }
301         _PROP_MUTEX_UNLOCK(_prop_dict_keysym_tree_mutex);
302
303         /*
304          * Not in the tree.  Create it now.
305          */
306
307         size = sizeof(*pdk) + strlen(key) /* pdk_key[1] covers the NUL */;
308
309         if (size <= PDK_SIZE_16)
310                 pdk = _PROP_POOL_GET(_prop_dictionary_keysym16_pool);
311         else if (size <= PDK_SIZE_32)
312                 pdk = _PROP_POOL_GET(_prop_dictionary_keysym32_pool);
313         else if (size <= PDK_SIZE_128)
314                 pdk = _PROP_POOL_GET(_prop_dictionary_keysym128_pool);
315         else
316                 pdk = NULL;     /* key too long */
317
318         if (pdk == NULL)
319                 return (NULL);
320
321         _prop_object_init(&pdk->pdk_obj, &_prop_object_type_dict_keysym);
322
323         strcpy(pdk->pdk_key, key);
324         pdk->pdk_size = size;
325
326         /*
327          * We dropped the mutex when we allocated the new object, so
328          * we have to check again if it is in the tree.
329          */
330         _PROP_MUTEX_LOCK(_prop_dict_keysym_tree_mutex);
331         opdk = _prop_rb_tree_find(&_prop_dict_keysym_tree, key);
332         if (opdk != NULL) {
333                 prop_object_retain(opdk);
334                 _PROP_MUTEX_UNLOCK(_prop_dict_keysym_tree_mutex);
335                 _prop_dict_keysym_put(pdk);
336                 return (opdk);
337         }
338         rpdk = _prop_rb_tree_insert_node(&_prop_dict_keysym_tree, pdk);
339         _PROP_ASSERT(rpdk == pdk);
340         _PROP_MUTEX_UNLOCK(_prop_dict_keysym_tree_mutex);
341         return (pdk);
342 }
343
344 static _prop_object_free_rv_t
345 _prop_dictionary_free(prop_stack_t stack, prop_object_t *obj)
346 {
347         prop_dictionary_t pd = *obj;
348         prop_dictionary_keysym_t pdk;
349         prop_object_t po;
350
351         _PROP_ASSERT(pd->pd_count <= pd->pd_capacity);
352         _PROP_ASSERT((pd->pd_capacity == 0 && pd->pd_array == NULL) ||
353                      (pd->pd_capacity != 0 && pd->pd_array != NULL));
354
355         /* The empty dictorinary is easy, handle that first. */
356         if (pd->pd_count == 0) {
357                 if (pd->pd_array != NULL)
358                         _PROP_FREE(pd->pd_array, M_PROP_DICT);
359
360                 _PROP_RWLOCK_DESTROY(pd->pd_rwlock);
361
362                 _PROP_POOL_PUT(_prop_dictionary_pool, pd);
363
364                 return (_PROP_OBJECT_FREE_DONE);
365         }
366
367         po = pd->pd_array[pd->pd_count - 1].pde_objref;
368         _PROP_ASSERT(po != NULL);
369
370         if (stack == NULL) {
371                 /*
372                  * If we are in emergency release mode,
373                  * just let caller recurse down.
374                  */
375                 *obj = po;
376                 return (_PROP_OBJECT_FREE_FAILED);
377         }
378
379         /* Otherwise, try to push the current object on the stack. */
380         if (!_prop_stack_push(stack, pd, NULL, NULL, NULL)) {
381                 /* Push failed, entering emergency release mode. */
382                 return (_PROP_OBJECT_FREE_FAILED);
383         }
384         /* Object pushed on stack, caller will release it. */
385         --pd->pd_count;
386         pdk = pd->pd_array[pd->pd_count].pde_key;
387         _PROP_ASSERT(pdk != NULL);
388
389         prop_object_release(pdk);
390
391         *obj = po;
392         return (_PROP_OBJECT_FREE_RECURSE);
393 }
394
395
396 static void
397 _prop_dictionary_lock(void)
398 {
399
400         /* XXX: once necessary or paranoia? */
401         _PROP_ONCE_RUN(_prop_dict_init_once, _prop_dict_init);
402         _PROP_MUTEX_LOCK(_prop_dict_keysym_tree_mutex);
403 }
404
405 static void
406 _prop_dictionary_unlock(void)
407 {
408         _PROP_MUTEX_UNLOCK(_prop_dict_keysym_tree_mutex);
409 }
410
411 static void
412 _prop_dictionary_emergency_free(prop_object_t obj)
413 {
414         prop_dictionary_t pd = obj;
415         prop_dictionary_keysym_t pdk;
416
417         _PROP_ASSERT(pd->pd_count != 0);
418         --pd->pd_count;
419
420         pdk = pd->pd_array[pd->pd_count].pde_key;
421         _PROP_ASSERT(pdk != NULL);
422         prop_object_release(pdk);
423 }
424
425 static bool
426 _prop_dictionary_externalize(struct _prop_object_externalize_context *ctx,
427                              void *v)
428 {
429         prop_dictionary_t pd = v;
430         prop_dictionary_keysym_t pdk;
431         struct _prop_object *po;
432         prop_object_iterator_t pi;
433         unsigned int i;
434         bool rv = false;
435
436         _PROP_RWLOCK_RDLOCK(pd->pd_rwlock);
437
438         if (pd->pd_count == 0) {
439                 _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
440                 return (_prop_object_externalize_empty_tag(ctx, "dict"));
441         }
442
443         if (_prop_object_externalize_start_tag(ctx, "dict") == false ||
444             _prop_object_externalize_append_char(ctx, '\n') == false)
445                 goto out;
446
447         pi = _prop_dictionary_iterator_locked(pd);
448         if (pi == NULL)
449                 goto out;
450         
451         ctx->poec_depth++;
452         _PROP_ASSERT(ctx->poec_depth != 0);
453
454         while ((pdk = _prop_dictionary_iterator_next_object_locked(pi))
455             != NULL) {
456                 po = _prop_dictionary_get_keysym(pd, pdk, true);
457                 if (po == NULL ||
458                     _prop_object_externalize_start_tag(ctx, "key") == false ||
459                     _prop_object_externalize_append_encoded_cstring(ctx,
460                                                    pdk->pdk_key) == false ||
461                     _prop_object_externalize_end_tag(ctx, "key") == false ||
462                     (*po->po_type->pot_extern)(ctx, po) == false) {
463                         prop_object_iterator_release(pi);
464                         goto out;
465                 }
466         }
467
468         prop_object_iterator_release(pi);
469
470         ctx->poec_depth--;
471         for (i = 0; i < ctx->poec_depth; i++) {
472                 if (_prop_object_externalize_append_char(ctx, '\t') == false)
473                         goto out;
474         }
475         if (_prop_object_externalize_end_tag(ctx, "dict") == false)
476                 goto out;
477         
478         rv = true;
479
480  out:
481         _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
482         return (rv);
483 }
484
485 /* ARGSUSED */
486 static _prop_object_equals_rv_t
487 _prop_dictionary_equals(prop_object_t v1, prop_object_t v2,
488     void **stored_pointer1, void **stored_pointer2,
489     prop_object_t *next_obj1, prop_object_t *next_obj2)
490 {
491         prop_dictionary_t dict1 = v1;
492         prop_dictionary_t dict2 = v2;
493         uintptr_t idx;
494         _prop_object_equals_rv_t rv = _PROP_OBJECT_EQUALS_FALSE;
495
496         if (dict1 == dict2)
497                 return (_PROP_OBJECT_EQUALS_TRUE);
498
499         _PROP_ASSERT(*stored_pointer1 == *stored_pointer2);
500
501         idx = (uintptr_t)*stored_pointer1;
502
503         if (idx == 0) {
504                 if ((uintptr_t)dict1 < (uintptr_t)dict2) {
505                         _PROP_RWLOCK_RDLOCK(dict1->pd_rwlock);
506                         _PROP_RWLOCK_RDLOCK(dict2->pd_rwlock);
507                 } else {
508                         _PROP_RWLOCK_RDLOCK(dict2->pd_rwlock);
509                         _PROP_RWLOCK_RDLOCK(dict1->pd_rwlock);
510                 }
511         }
512
513         if (dict1->pd_count != dict2->pd_count)
514                 goto out;
515
516         if (idx == dict1->pd_count) {
517                 rv = _PROP_OBJECT_EQUALS_TRUE;
518                 goto out;
519         }
520
521         _PROP_ASSERT(idx < dict1->pd_count);
522
523         *stored_pointer1 = (void *)(idx + 1);
524         *stored_pointer2 = (void *)(idx + 1);
525
526         *next_obj1 = dict1->pd_array[idx].pde_objref;
527         *next_obj2 = dict2->pd_array[idx].pde_objref;
528
529         if (!prop_dictionary_keysym_equals(dict1->pd_array[idx].pde_key,
530                                            dict2->pd_array[idx].pde_key))
531                 goto out;
532
533         return (_PROP_OBJECT_EQUALS_RECURSE);
534
535  out:
536         _PROP_RWLOCK_UNLOCK(dict1->pd_rwlock);
537         _PROP_RWLOCK_UNLOCK(dict2->pd_rwlock);
538         return (rv);
539 }
540
541 static void
542 _prop_dictionary_equals_finish(prop_object_t v1, prop_object_t v2)
543 {
544         _PROP_RWLOCK_UNLOCK(((prop_dictionary_t)v1)->pd_rwlock);
545         _PROP_RWLOCK_UNLOCK(((prop_dictionary_t)v2)->pd_rwlock);
546 }
547
548 static prop_dictionary_t
549 _prop_dictionary_alloc(unsigned int capacity)
550 {
551         prop_dictionary_t pd;
552         struct _prop_dict_entry *array;
553
554         if (capacity != 0) {
555                 array = _PROP_CALLOC(capacity * sizeof(*array), M_PROP_DICT);
556                 if (array == NULL)
557                         return (NULL);
558         } else
559                 array = NULL;
560
561         pd = _PROP_POOL_GET(_prop_dictionary_pool);
562         if (pd != NULL) {
563                 _prop_object_init(&pd->pd_obj, &_prop_object_type_dictionary);
564
565                 _PROP_RWLOCK_INIT(pd->pd_rwlock);
566                 pd->pd_array = array;
567                 pd->pd_capacity = capacity;
568                 pd->pd_count = 0;
569                 pd->pd_flags = 0;
570
571                 pd->pd_version = 0;
572         } else if (array != NULL)
573                 _PROP_FREE(array, M_PROP_DICT);
574
575         return (pd);
576 }
577
578 static bool
579 _prop_dictionary_expand(prop_dictionary_t pd, unsigned int capacity)
580 {
581         struct _prop_dict_entry *array, *oarray;
582
583         /*
584          * Dictionary must be WRITE-LOCKED.
585          */
586
587         oarray = pd->pd_array;
588
589         array = _PROP_CALLOC(capacity * sizeof(*array), M_PROP_DICT);
590         if (array == NULL)
591                 return (false);
592         if (oarray != NULL)
593                 memcpy(array, oarray, pd->pd_capacity * sizeof(*array));
594         pd->pd_array = array;
595         pd->pd_capacity = capacity;
596
597         if (oarray != NULL)
598                 _PROP_FREE(oarray, M_PROP_DICT);
599         
600         return (true);
601 }
602
603 static prop_object_t
604 _prop_dictionary_iterator_next_object_locked(void *v)
605 {
606         struct _prop_dictionary_iterator *pdi = v;
607         prop_dictionary_t pd = pdi->pdi_base.pi_obj;
608         prop_dictionary_keysym_t pdk = NULL;
609
610         _PROP_ASSERT(prop_object_is_dictionary(pd));
611
612         if (pd->pd_version != pdi->pdi_base.pi_version)
613                 goto out;       /* dictionary changed during iteration */
614
615         _PROP_ASSERT(pdi->pdi_index <= pd->pd_count);
616
617         if (pdi->pdi_index == pd->pd_count)
618                 goto out;       /* we've iterated all objects */
619
620         pdk = pd->pd_array[pdi->pdi_index].pde_key;
621         pdi->pdi_index++;
622
623  out:
624         return (pdk);
625 }
626
627 static prop_object_t
628 _prop_dictionary_iterator_next_object(void *v)
629 {
630         struct _prop_dictionary_iterator *pdi = v;
631         prop_dictionary_t pd = pdi->pdi_base.pi_obj;
632         prop_dictionary_keysym_t pdk;
633
634         _PROP_ASSERT(prop_object_is_dictionary(pd));
635
636         _PROP_RWLOCK_RDLOCK(pd->pd_rwlock);
637         pdk = _prop_dictionary_iterator_next_object_locked(pdi);
638         _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
639         return (pdk);
640 }
641
642 static void
643 _prop_dictionary_iterator_reset_locked(void *v)
644 {
645         struct _prop_dictionary_iterator *pdi = v;
646         prop_dictionary_t pd = pdi->pdi_base.pi_obj;
647
648         _PROP_ASSERT(prop_object_is_dictionary(pd));
649
650         pdi->pdi_index = 0;
651         pdi->pdi_base.pi_version = pd->pd_version;
652 }
653
654 static void
655 _prop_dictionary_iterator_reset(void *v)
656 {
657         struct _prop_dictionary_iterator *pdi = v;
658         prop_dictionary_t pd = pdi->pdi_base.pi_obj;
659
660         _PROP_RWLOCK_RDLOCK(pd->pd_rwlock);
661         _prop_dictionary_iterator_reset_locked(pdi);
662         _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
663 }
664
665 /*
666  * prop_dictionary_create --
667  *      Create a dictionary.
668  */
669 prop_dictionary_t
670 prop_dictionary_create(void)
671 {
672
673         return (_prop_dictionary_alloc(0));
674 }
675
676 /*
677  * prop_dictionary_create_with_capacity --
678  *      Create a dictionary with the capacity to store N objects.
679  */
680 prop_dictionary_t
681 prop_dictionary_create_with_capacity(unsigned int capacity)
682 {
683
684         return (_prop_dictionary_alloc(capacity));
685 }
686
687 /*
688  * prop_dictionary_copy --
689  *      Copy a dictionary.  The new dictionary has an initial capacity equal
690  *      to the number of objects stored int the original dictionary.  The new
691  *      dictionary contains refrences to the original dictionary's objects,
692  *      not copies of those objects (i.e. a shallow copy).
693  */
694 prop_dictionary_t
695 prop_dictionary_copy(prop_dictionary_t opd)
696 {
697         prop_dictionary_t pd;
698         prop_dictionary_keysym_t pdk;
699         prop_object_t po;
700         unsigned int idx;
701
702         if (! prop_object_is_dictionary(opd))
703                 return (NULL);
704
705         _PROP_RWLOCK_RDLOCK(opd->pd_rwlock);
706
707         pd = _prop_dictionary_alloc(opd->pd_count);
708         if (pd != NULL) {
709                 for (idx = 0; idx < opd->pd_count; idx++) {
710                         pdk = opd->pd_array[idx].pde_key;
711                         po = opd->pd_array[idx].pde_objref;
712
713                         prop_object_retain(pdk);
714                         prop_object_retain(po);
715
716                         pd->pd_array[idx].pde_key = pdk;
717                         pd->pd_array[idx].pde_objref = po;
718                 }
719                 pd->pd_count = opd->pd_count;
720                 pd->pd_flags = opd->pd_flags;
721         }
722         _PROP_RWLOCK_UNLOCK(opd->pd_rwlock);
723         return (pd);
724 }
725
726 /*
727  * prop_dictionary_copy_mutable --
728  *      Like prop_dictionary_copy(), but the resulting dictionary is
729  *      mutable.
730  */
731 prop_dictionary_t
732 prop_dictionary_copy_mutable(prop_dictionary_t opd)
733 {
734         prop_dictionary_t pd;
735
736         if (! prop_object_is_dictionary(opd))
737                 return (NULL);
738
739         pd = prop_dictionary_copy(opd);
740         if (pd != NULL)
741                 pd->pd_flags &= ~PD_F_IMMUTABLE;
742
743         return (pd);
744 }
745
746 /*
747  * prop_dictionary_make_immutable --
748  *      Set the immutable flag on that dictionary.
749  */
750 void
751 prop_dictionary_make_immutable(prop_dictionary_t pd)
752 {
753
754         _PROP_RWLOCK_WRLOCK(pd->pd_rwlock);
755         if (prop_dictionary_is_immutable(pd) == false)
756                 pd->pd_flags |= PD_F_IMMUTABLE;
757         _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
758 }
759
760 /*
761  * prop_dictionary_count --
762  *      Return the number of objects stored in the dictionary.
763  */
764 unsigned int
765 prop_dictionary_count(prop_dictionary_t pd)
766 {
767         unsigned int rv;
768
769         if (! prop_object_is_dictionary(pd))
770                 return (0);
771
772         _PROP_RWLOCK_RDLOCK(pd->pd_rwlock);
773         rv = pd->pd_count;
774         _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
775
776         return (rv);
777 }
778
779 /*
780  * prop_dictionary_ensure_capacity --
781  *      Ensure that the dictionary has the capacity to store the specified
782  *      total number of objects (including the objects already stored in
783  *      the dictionary).
784  */
785 bool
786 prop_dictionary_ensure_capacity(prop_dictionary_t pd, unsigned int capacity)
787 {
788         bool rv;
789
790         if (! prop_object_is_dictionary(pd))
791                 return (false);
792
793         _PROP_RWLOCK_WRLOCK(pd->pd_rwlock);
794         if (capacity > pd->pd_capacity)
795                 rv = _prop_dictionary_expand(pd, capacity);
796         else
797                 rv = true;
798         _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
799         return (rv);
800 }
801
802 static prop_object_iterator_t
803 _prop_dictionary_iterator_locked(prop_dictionary_t pd)
804 {
805         struct _prop_dictionary_iterator *pdi;
806
807         if (! prop_object_is_dictionary(pd))
808                 return (NULL);
809
810         pdi = _PROP_CALLOC(sizeof(*pdi), M_TEMP);
811         if (pdi == NULL)
812                 return (NULL);
813         pdi->pdi_base.pi_next_object = _prop_dictionary_iterator_next_object;
814         pdi->pdi_base.pi_reset = _prop_dictionary_iterator_reset;
815         prop_object_retain(pd);
816         pdi->pdi_base.pi_obj = pd;
817         _prop_dictionary_iterator_reset_locked(pdi);
818
819         return (&pdi->pdi_base);
820 }
821
822 /*
823  * prop_dictionary_iterator --
824  *      Return an iterator for the dictionary.  The dictionary is retained by
825  *      the iterator.
826  */
827 prop_object_iterator_t
828 prop_dictionary_iterator(prop_dictionary_t pd)
829 {
830         prop_object_iterator_t pi;
831
832         _PROP_RWLOCK_RDLOCK(pd->pd_rwlock);
833         pi = _prop_dictionary_iterator_locked(pd);
834         _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
835         return (pi);
836 }
837
838 /*
839  * prop_dictionary_all_keys --
840  *      Return an array containing a snapshot of all of the keys
841  *      in the dictionary.
842  */
843 prop_array_t
844 prop_dictionary_all_keys(prop_dictionary_t pd)
845 {
846         prop_array_t array;
847         unsigned int idx;
848         bool rv = true;
849
850         if (! prop_object_is_dictionary(pd))
851                 return (NULL);
852
853         /* There is no pressing need to lock the dictionary for this. */
854         array = prop_array_create_with_capacity(pd->pd_count);
855
856         _PROP_RWLOCK_RDLOCK(pd->pd_rwlock);
857
858         for (idx = 0; idx < pd->pd_count; idx++) {
859                 rv = prop_array_add(array, pd->pd_array[idx].pde_key);
860                 if (rv == false)
861                         break;
862         }
863
864         _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
865
866         if (rv == false) {
867                 prop_object_release(array);
868                 array = NULL;
869         }
870         return (array);
871 }
872
873 static struct _prop_dict_entry *
874 _prop_dict_lookup(prop_dictionary_t pd, const char *key,
875                   unsigned int *idxp)
876 {
877         struct _prop_dict_entry *pde;
878         unsigned int base, idx, distance;
879         int res;
880
881         /*
882          * Dictionary must be READ-LOCKED or WRITE-LOCKED.
883          */
884
885         for (idx = 0, base = 0, distance = pd->pd_count; distance != 0;
886              distance >>= 1) {
887                 idx = base + (distance >> 1);
888                 pde = &pd->pd_array[idx];
889                 _PROP_ASSERT(pde->pde_key != NULL);
890                 res = strcmp(key, pde->pde_key->pdk_key);
891                 if (res == 0) {
892                         if (idxp != NULL)
893                                 *idxp = idx;
894                         return (pde);
895                 }
896                 if (res > 0) {  /* key > pdk_key: move right */
897                         base = idx + 1;
898                         distance--;
899                 }               /* else move left */
900         }
901
902         /* idx points to the slot we looked at last. */
903         if (idxp != NULL)
904                 *idxp = idx;
905         return (NULL);
906 }
907
908 static prop_object_t
909 _prop_dictionary_get(prop_dictionary_t pd, const char *key, bool locked)
910 {
911         const struct _prop_dict_entry *pde;
912         prop_object_t po = NULL;
913
914         if (! prop_object_is_dictionary(pd))
915                 return (NULL);
916
917         if (!locked)
918                 _PROP_RWLOCK_RDLOCK(pd->pd_rwlock);
919         pde = _prop_dict_lookup(pd, key, NULL);
920         if (pde != NULL) {
921                 _PROP_ASSERT(pde->pde_objref != NULL);
922                 po = pde->pde_objref;
923         }
924         if (!locked)
925                 _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
926         return (po);
927 }
928 /*
929  * prop_dictionary_get --
930  *      Return the object stored with specified key.
931  */
932 prop_object_t
933 prop_dictionary_get(prop_dictionary_t pd, const char *key)
934 {
935         prop_object_t po = NULL;
936
937         if (! prop_object_is_dictionary(pd))
938                 return (NULL);
939
940         _PROP_RWLOCK_RDLOCK(pd->pd_rwlock);
941         po = _prop_dictionary_get(pd, key, true);
942         _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
943         return (po);
944 }
945
946 static prop_object_t
947 _prop_dictionary_get_keysym(prop_dictionary_t pd, prop_dictionary_keysym_t pdk,
948     bool locked)
949 {
950
951         if (! (prop_object_is_dictionary(pd) &&
952                prop_object_is_dictionary_keysym(pdk)))
953                 return (NULL);
954
955         return (_prop_dictionary_get(pd, pdk->pdk_key, locked));
956 }
957
958 /*
959  * prop_dictionary_get_keysym --
960  *      Return the object stored at the location encoded by the keysym.
961  */
962 prop_object_t
963 prop_dictionary_get_keysym(prop_dictionary_t pd, prop_dictionary_keysym_t pdk)
964 {
965
966         return (_prop_dictionary_get_keysym(pd, pdk, false));
967 }
968
969 /*
970  * prop_dictionary_set --
971  *      Store a reference to an object at with the specified key.
972  *      If the key already exisit, the original object is released.
973  */
974 bool
975 prop_dictionary_set(prop_dictionary_t pd, const char *key, prop_object_t po)
976 {
977         struct _prop_dict_entry *pde;
978         prop_dictionary_keysym_t pdk;
979         unsigned int idx;
980         bool rv = false;
981
982         if (! prop_object_is_dictionary(pd))
983                 return (false);
984
985         _PROP_ASSERT(pd->pd_count <= pd->pd_capacity);
986
987         if (prop_dictionary_is_immutable(pd))
988                 return (false);
989
990         _PROP_RWLOCK_WRLOCK(pd->pd_rwlock);
991
992         pde = _prop_dict_lookup(pd, key, &idx);
993         if (pde != NULL) {
994                 prop_object_t opo = pde->pde_objref;
995                 prop_object_retain(po);
996                 pde->pde_objref = po;
997                 prop_object_release(opo);
998                 rv = true;
999                 goto out;
1000         }
1001
1002         pdk = _prop_dict_keysym_alloc(key);
1003         if (pdk == NULL)
1004                 goto out;
1005
1006         if (pd->pd_count == pd->pd_capacity &&
1007             _prop_dictionary_expand(pd,
1008                                     pd->pd_capacity + EXPAND_STEP) == false) {
1009                 prop_object_release(pdk);
1010                 goto out;
1011         }
1012
1013         /* At this point, the store will succeed. */
1014         prop_object_retain(po);
1015
1016         if (pd->pd_count == 0) {
1017                 pd->pd_array[0].pde_key = pdk;
1018                 pd->pd_array[0].pde_objref = po;
1019                 pd->pd_count++;
1020                 pd->pd_version++;
1021                 rv = true;
1022                 goto out;
1023         }
1024
1025         pde = &pd->pd_array[idx];
1026         _PROP_ASSERT(pde->pde_key != NULL);
1027
1028         if (strcmp(key, pde->pde_key->pdk_key) < 0) {
1029                 /*
1030                  * key < pdk_key: insert to the left.  This is the same as
1031                  * inserting to the right, except we decrement the current
1032                  * index first.
1033                  *
1034                  * Because we're unsigned, we have to special case 0
1035                  * (grumble).
1036                  */
1037                 if (idx == 0) {
1038                         memmove(&pd->pd_array[1], &pd->pd_array[0],
1039                                 pd->pd_count * sizeof(*pde));
1040                         pd->pd_array[0].pde_key = pdk;
1041                         pd->pd_array[0].pde_objref = po;
1042                         pd->pd_count++;
1043                         pd->pd_version++;
1044                         rv = true;
1045                         goto out;
1046                 }
1047                 idx--;
1048         }
1049
1050         memmove(&pd->pd_array[idx + 2], &pd->pd_array[idx + 1],
1051                 (pd->pd_count - (idx + 1)) * sizeof(*pde));
1052         pd->pd_array[idx + 1].pde_key = pdk;
1053         pd->pd_array[idx + 1].pde_objref = po;
1054         pd->pd_count++;
1055
1056         pd->pd_version++;
1057
1058         rv = true;
1059
1060  out:
1061         _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
1062         return (rv);
1063 }
1064
1065 /*
1066  * prop_dictionary_set_keysym --
1067  *      Replace the object in the dictionary at the location encoded by
1068  *      the keysym.
1069  */
1070 bool
1071 prop_dictionary_set_keysym(prop_dictionary_t pd, prop_dictionary_keysym_t pdk,
1072                            prop_object_t po)
1073 {
1074
1075         if (! (prop_object_is_dictionary(pd) &&
1076                prop_object_is_dictionary_keysym(pdk)))
1077                 return (false);
1078
1079         return (prop_dictionary_set(pd, pdk->pdk_key, po));
1080 }
1081
1082 static void
1083 _prop_dictionary_remove(prop_dictionary_t pd, struct _prop_dict_entry *pde,
1084     unsigned int idx)
1085 {
1086         prop_dictionary_keysym_t pdk = pde->pde_key;
1087         prop_object_t po = pde->pde_objref;
1088
1089         /*
1090          * Dictionary must be WRITE-LOCKED.
1091          */
1092
1093         _PROP_ASSERT(pd->pd_count != 0);
1094         _PROP_ASSERT(idx < pd->pd_count);
1095         _PROP_ASSERT(pde == &pd->pd_array[idx]);
1096
1097         idx++;
1098         memmove(&pd->pd_array[idx - 1], &pd->pd_array[idx],
1099                 (pd->pd_count - idx) * sizeof(*pde));
1100         pd->pd_count--;
1101         pd->pd_version++;
1102
1103
1104         prop_object_release(pdk);
1105
1106         prop_object_release(po);
1107 }
1108
1109 /*
1110  * prop_dictionary_remove --
1111  *      Remove the reference to an object with the specified key from
1112  *      the dictionary.
1113  */
1114 void
1115 prop_dictionary_remove(prop_dictionary_t pd, const char *key)
1116 {
1117         struct _prop_dict_entry *pde;
1118         unsigned int idx;
1119
1120         if (! prop_object_is_dictionary(pd))
1121                 return;
1122
1123         _PROP_RWLOCK_WRLOCK(pd->pd_rwlock);
1124
1125         /* XXX Should this be a _PROP_ASSERT()? */
1126         if (prop_dictionary_is_immutable(pd))
1127                 goto out;
1128
1129         pde = _prop_dict_lookup(pd, key, &idx);
1130         /* XXX Should this be a _PROP_ASSERT()? */
1131         if (pde == NULL)
1132                 goto out;
1133
1134         _prop_dictionary_remove(pd, pde, idx);
1135  out:
1136         _PROP_RWLOCK_UNLOCK(pd->pd_rwlock);
1137 }
1138
1139 /*
1140  * prop_dictionary_remove_keysym --
1141  *      Remove a reference to an object stored in the dictionary at the
1142  *      location encoded by the keysym.
1143  */
1144 void
1145 prop_dictionary_remove_keysym(prop_dictionary_t pd,
1146                               prop_dictionary_keysym_t pdk)
1147 {
1148
1149         if (! (prop_object_is_dictionary(pd) &&
1150                prop_object_is_dictionary_keysym(pdk)))
1151                 return;
1152
1153         prop_dictionary_remove(pd, pdk->pdk_key);
1154 }
1155
1156 /*
1157  * prop_dictionary_equals --
1158  *      Return true if the two dictionaries are equivalent.  Note we do a
1159  *      by-value comparison of the objects in the dictionary.
1160  */
1161 bool
1162 prop_dictionary_equals(prop_dictionary_t dict1, prop_dictionary_t dict2)
1163 {
1164         if (!prop_object_is_dictionary(dict1) ||
1165             !prop_object_is_dictionary(dict2))
1166                 return (false);
1167
1168         return (prop_object_equals(dict1, dict2));
1169 }
1170
1171 /*
1172  * prop_dictionary_keysym_cstring_nocopy --
1173  *      Return an immutable reference to the keysym's value.
1174  */
1175 const char *
1176 prop_dictionary_keysym_cstring_nocopy(prop_dictionary_keysym_t pdk)
1177 {
1178
1179         if (! prop_object_is_dictionary_keysym(pdk))
1180                 return (NULL);
1181
1182         return (pdk->pdk_key);
1183 }
1184
1185 /*
1186  * prop_dictionary_keysym_equals --
1187  *      Return true if the two dictionary key symbols are equivalent.
1188  *      Note: We do not compare the object references.
1189  */
1190 bool
1191 prop_dictionary_keysym_equals(prop_dictionary_keysym_t pdk1,
1192                               prop_dictionary_keysym_t pdk2)
1193 {
1194         if (!prop_object_is_dictionary_keysym(pdk1) ||
1195             !prop_object_is_dictionary_keysym(pdk2))
1196                 return (false);
1197
1198         return (prop_object_equals(pdk1, pdk2));
1199 }
1200
1201 /*
1202  * prop_dictionary_externalize --
1203  *      Externalize a dictionary, returning a NUL-terminated buffer
1204  *      containing the XML-style representation.  The buffer is allocated
1205  *      with the M_TEMP memory type.
1206  */
1207 char *
1208 prop_dictionary_externalize(prop_dictionary_t pd)
1209 {
1210         struct _prop_object_externalize_context *ctx;
1211         char *cp;
1212
1213         ctx = _prop_object_externalize_context_alloc();
1214         if (ctx == NULL)
1215                 return (NULL);
1216
1217         if (_prop_object_externalize_header(ctx) == false ||
1218             (*pd->pd_obj.po_type->pot_extern)(ctx, pd) == false ||
1219             _prop_object_externalize_footer(ctx) == false) {
1220                 /* We are responsible for releasing the buffer. */
1221                 _PROP_FREE(ctx->poec_buf, M_TEMP);
1222                 _prop_object_externalize_context_free(ctx);
1223                 return (NULL);
1224         }
1225
1226         cp = ctx->poec_buf;
1227         _prop_object_externalize_context_free(ctx);
1228
1229         return (cp);
1230 }
1231
1232 /*
1233  * _prop_dictionary_internalize --
1234  *      Parse a <dict>...</dict> and return the object created from the
1235  *      external representation.
1236  *
1237  * Internal state in via rec_data is the storage area for the last processed
1238  * key.
1239  * _prop_dictionary_internalize_body is the upper half of the parse loop.
1240  * It is responsible for parsing the key directly and storing it in the area
1241  * referenced by rec_data.
1242  * _prop_dictionary_internalize_cont is the lower half and called with the value
1243  * associated with the key.
1244  */
1245 static bool _prop_dictionary_internalize_body(prop_stack_t,
1246     prop_object_t *, struct _prop_object_internalize_context *, char *);
1247
1248 bool
1249 _prop_dictionary_internalize(prop_stack_t stack, prop_object_t *obj,
1250     struct _prop_object_internalize_context *ctx)
1251 {
1252         prop_dictionary_t dict;
1253         char *tmpkey;
1254
1255         /* We don't currently understand any attributes. */
1256         if (ctx->poic_tagattr != NULL)
1257                 return (true);
1258
1259         dict = prop_dictionary_create();
1260         if (dict == NULL)
1261                 return (true);
1262
1263         if (ctx->poic_is_empty_element) {
1264                 *obj = dict;
1265                 return (true);
1266         }
1267
1268         tmpkey = _PROP_MALLOC(PDK_MAXKEY + 1, M_TEMP);
1269         if (tmpkey == NULL) {
1270                 prop_object_release(dict);
1271                 return (true);
1272         }
1273
1274         *obj = dict;
1275         /*
1276          * Opening tag is found, storage for key allocated and
1277          * now continue to the first element.
1278          */
1279         return _prop_dictionary_internalize_body(stack, obj, ctx, tmpkey);
1280 }
1281
1282 static bool
1283 _prop_dictionary_internalize_continue(prop_stack_t stack, prop_object_t *obj,
1284     struct _prop_object_internalize_context *ctx, void *data, prop_object_t child)
1285 {
1286         prop_dictionary_t dict = *obj;
1287         char *tmpkey = data;
1288
1289         _PROP_ASSERT(tmpkey != NULL);
1290
1291         if (child == NULL ||
1292             prop_dictionary_set(dict, tmpkey, child) == false) {
1293                 _PROP_FREE(tmpkey, M_TEMP);
1294                 if (child != NULL)
1295                         prop_object_release(child);
1296                 prop_object_release(dict);
1297                 *obj = NULL;
1298                 return (true);
1299         }
1300
1301         prop_object_release(child);
1302
1303         /*
1304          * key, value was added, now continue looking for the next key
1305          * or the closing tag.
1306          */
1307         return _prop_dictionary_internalize_body(stack, obj, ctx, tmpkey);
1308 }
1309
1310 static bool
1311 _prop_dictionary_internalize_body(prop_stack_t stack, prop_object_t *obj,
1312     struct _prop_object_internalize_context *ctx, char *tmpkey)
1313 {
1314         prop_dictionary_t dict = *obj;
1315         size_t keylen;
1316
1317         /* Fetch the next tag. */
1318         if (_prop_object_internalize_find_tag(ctx, NULL, _PROP_TAG_TYPE_EITHER) == false)
1319                 goto bad;
1320
1321         /* Check to see if this is the end of the dictionary. */
1322         if (_PROP_TAG_MATCH(ctx, "dict") &&
1323             ctx->poic_tag_type == _PROP_TAG_TYPE_END) {
1324                 _PROP_FREE(tmpkey, M_TEMP);
1325                 return (true);
1326         }
1327
1328         /* Ok, it must be a non-empty key start tag. */
1329         if (!_PROP_TAG_MATCH(ctx, "key") ||
1330             ctx->poic_tag_type != _PROP_TAG_TYPE_START ||
1331             ctx->poic_is_empty_element)
1332                 goto bad;
1333
1334         if (_prop_object_internalize_decode_string(ctx,
1335                                         tmpkey, PDK_MAXKEY, &keylen,
1336                                         &ctx->poic_cp) == false)
1337                 goto bad;
1338
1339         _PROP_ASSERT(keylen <= PDK_MAXKEY);
1340         tmpkey[keylen] = '\0';
1341
1342         if (_prop_object_internalize_find_tag(ctx, "key",
1343                                 _PROP_TAG_TYPE_END) == false)
1344                 goto bad;
1345    
1346         /* ..and now the beginning of the value. */
1347         if (_prop_object_internalize_find_tag(ctx, NULL,
1348                                 _PROP_TAG_TYPE_START) == false)
1349                 goto bad;
1350
1351         /*
1352          * Key is found, now wait for value to be parsed.
1353          */
1354         if (_prop_stack_push(stack, *obj,
1355                              _prop_dictionary_internalize_continue,
1356                              tmpkey, NULL))
1357                 return (false);
1358
1359  bad:
1360         _PROP_FREE(tmpkey, M_TEMP);
1361         prop_object_release(dict);
1362         *obj = NULL;
1363         return (true);
1364 }
1365
1366 /*
1367  * prop_dictionary_internalize --
1368  *      Create a dictionary by parsing the NUL-terminated XML-style
1369  *      representation.
1370  */
1371 prop_dictionary_t
1372 prop_dictionary_internalize(const char *xml)
1373 {
1374         return _prop_generic_internalize(xml, "dict");
1375 }
1376
1377 #if !defined(_KERNEL) && !defined(_STANDALONE)
1378 /*
1379  * prop_dictionary_externalize_to_file --
1380  *      Externalize a dictionary to the specified file.
1381  */
1382 bool
1383 prop_dictionary_externalize_to_file(prop_dictionary_t dict, const char *fname)
1384 {
1385         char *xml;
1386         bool rv;
1387         int save_errno = 0;     /* XXXGCC -Wuninitialized [mips, ...] */
1388
1389         xml = prop_dictionary_externalize(dict);
1390         if (xml == NULL)
1391                 return (false);
1392         rv = _prop_object_externalize_write_file(fname, xml, strlen(xml));
1393         if (rv == false)
1394                 save_errno = errno;
1395         _PROP_FREE(xml, M_TEMP);
1396         if (rv == false)
1397                 errno = save_errno;
1398
1399         return (rv);
1400 }
1401
1402 /*
1403  * prop_dictionary_internalize_from_file --
1404  *      Internalize a dictionary from a file.
1405  */
1406 prop_dictionary_t
1407 prop_dictionary_internalize_from_file(const char *fname)
1408 {
1409         struct _prop_object_internalize_mapped_file *mf;
1410         prop_dictionary_t dict;
1411
1412         mf = _prop_object_internalize_map_file(fname);
1413         if (mf == NULL)
1414                 return (NULL);
1415         dict = prop_dictionary_internalize(mf->poimf_xml);
1416         _prop_object_internalize_unmap_file(mf);
1417
1418         return (dict);
1419 }
1420 #endif /* !_KERNEL && !_STANDALONE */