bge: Avoid accessing invalid internal memory region on BCM5906
[dragonfly.git] / sys / libprop / prop_array.c
CommitLineData
349fb218
AH
1/* $NetBSD: prop_array.c,v 1.20 2008/08/11 05:54:21 christos 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
9f95f3e0 32#include <libprop/prop_array.h>
349fb218
AH
33#include "prop_object_impl.h"
34
35#if !defined(_KERNEL) && !defined(_STANDALONE)
36#include <errno.h>
37#endif
38
39struct _prop_array {
40 struct _prop_object pa_obj;
41 _PROP_RWLOCK_DECL(pa_rwlock)
42 prop_object_t * pa_array;
43 unsigned int pa_capacity;
44 unsigned int pa_count;
45 int pa_flags;
46
47 uint32_t pa_version;
48};
49
50#define PA_F_IMMUTABLE 0x01 /* array is immutable */
51
52_PROP_POOL_INIT(_prop_array_pool, sizeof(struct _prop_array), "proparay")
53_PROP_MALLOC_DEFINE(M_PROP_ARRAY, "prop array",
54 "property array container object")
55
56static _prop_object_free_rv_t
57 _prop_array_free(prop_stack_t, prop_object_t *);
58static void _prop_array_emergency_free(prop_object_t);
59static bool _prop_array_externalize(
60 struct _prop_object_externalize_context *,
61 void *);
62static _prop_object_equals_rv_t
63 _prop_array_equals(prop_object_t, prop_object_t,
64 void **, void **,
65 prop_object_t *, prop_object_t *);
66static void _prop_array_equals_finish(prop_object_t, prop_object_t);
67static prop_object_iterator_t
68 _prop_array_iterator_locked(prop_array_t);
69static prop_object_t
70 _prop_array_iterator_next_object_locked(void *);
71static void _prop_array_iterator_reset_locked(void *);
72
73static const struct _prop_object_type _prop_object_type_array = {
74 .pot_type = PROP_TYPE_ARRAY,
75 .pot_free = _prop_array_free,
76 .pot_emergency_free = _prop_array_emergency_free,
77 .pot_extern = _prop_array_externalize,
78 .pot_equals = _prop_array_equals,
79 .pot_equals_finish = _prop_array_equals_finish,
80};
81
82#define prop_object_is_array(x) \
83 ((x) != NULL && (x)->pa_obj.po_type == &_prop_object_type_array)
84
85#define prop_array_is_immutable(x) (((x)->pa_flags & PA_F_IMMUTABLE) != 0)
86
87struct _prop_array_iterator {
88 struct _prop_object_iterator pai_base;
89 unsigned int pai_index;
90};
91
92#define EXPAND_STEP 16
93
94static _prop_object_free_rv_t
95_prop_array_free(prop_stack_t stack, prop_object_t *obj)
96{
97 prop_array_t pa = *obj;
98 prop_object_t po;
99
100 _PROP_ASSERT(pa->pa_count <= pa->pa_capacity);
101 _PROP_ASSERT((pa->pa_capacity == 0 && pa->pa_array == NULL) ||
102 (pa->pa_capacity != 0 && pa->pa_array != NULL));
103
104 /* The easy case is an empty array, just free and return. */
105 if (pa->pa_count == 0) {
106 if (pa->pa_array != NULL)
107 _PROP_FREE(pa->pa_array, M_PROP_ARRAY);
108
109 _PROP_RWLOCK_DESTROY(pa->pa_rwlock);
110
111 _PROP_POOL_PUT(_prop_array_pool, pa);
112
113 return (_PROP_OBJECT_FREE_DONE);
114 }
115
116 po = pa->pa_array[pa->pa_count - 1];
117 _PROP_ASSERT(po != NULL);
118
119 if (stack == NULL) {
120 /*
121 * If we are in emergency release mode,
122 * just let caller recurse down.
123 */
124 *obj = po;
125 return (_PROP_OBJECT_FREE_FAILED);
126 }
127
128 /* Otherwise, try to push the current object on the stack. */
129 if (!_prop_stack_push(stack, pa, NULL, NULL, NULL)) {
130 /* Push failed, entering emergency release mode. */
131 return (_PROP_OBJECT_FREE_FAILED);
132 }
133 /* Object pushed on stack, caller will release it. */
134 --pa->pa_count;
135 *obj = po;
136 return (_PROP_OBJECT_FREE_RECURSE);
137}
138
139static void
140_prop_array_emergency_free(prop_object_t obj)
141{
142 prop_array_t pa = obj;
143
144 _PROP_ASSERT(pa->pa_count != 0);
145 --pa->pa_count;
146}
147
148static bool
149_prop_array_externalize(struct _prop_object_externalize_context *ctx,
150 void *v)
151{
152 prop_array_t pa = v;
153 struct _prop_object *po;
154 prop_object_iterator_t pi;
155 unsigned int i;
156 bool rv = false;
157
158 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
159
160 if (pa->pa_count == 0) {
161 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
162 return (_prop_object_externalize_empty_tag(ctx, "array"));
163 }
164
165 /* XXXJRT Hint "count" for the internalize step? */
166 if (_prop_object_externalize_start_tag(ctx, "array") == false ||
167 _prop_object_externalize_append_char(ctx, '\n') == false)
168 goto out;
169
170 pi = _prop_array_iterator_locked(pa);
171 if (pi == NULL)
172 goto out;
173
174 ctx->poec_depth++;
175 _PROP_ASSERT(ctx->poec_depth != 0);
176
177 while ((po = _prop_array_iterator_next_object_locked(pi)) != NULL) {
178 if ((*po->po_type->pot_extern)(ctx, po) == false) {
179 prop_object_iterator_release(pi);
180 goto out;
181 }
182 }
183
184 prop_object_iterator_release(pi);
185
186 ctx->poec_depth--;
187 for (i = 0; i < ctx->poec_depth; i++) {
188 if (_prop_object_externalize_append_char(ctx, '\t') == false)
189 goto out;
190 }
191 if (_prop_object_externalize_end_tag(ctx, "array") == false)
192 goto out;
193
194 rv = true;
195
196 out:
197 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
198 return (rv);
199}
200
201/* ARGSUSED */
202static _prop_object_equals_rv_t
203_prop_array_equals(prop_object_t v1, prop_object_t v2,
204 void **stored_pointer1, void **stored_pointer2,
205 prop_object_t *next_obj1, prop_object_t *next_obj2)
206{
207 prop_array_t array1 = v1;
208 prop_array_t array2 = v2;
209 uintptr_t idx;
210 _prop_object_equals_rv_t rv = _PROP_OBJECT_EQUALS_FALSE;
211
212 if (array1 == array2)
213 return (_PROP_OBJECT_EQUALS_TRUE);
214
215 _PROP_ASSERT(*stored_pointer1 == *stored_pointer2);
216 idx = (uintptr_t)*stored_pointer1;
217
218 /* For the first iteration, lock the objects. */
219 if (idx == 0) {
220 if ((uintptr_t)array1 < (uintptr_t)array2) {
221 _PROP_RWLOCK_RDLOCK(array1->pa_rwlock);
222 _PROP_RWLOCK_RDLOCK(array2->pa_rwlock);
223 } else {
224 _PROP_RWLOCK_RDLOCK(array2->pa_rwlock);
225 _PROP_RWLOCK_RDLOCK(array1->pa_rwlock);
226 }
227 }
228
229 if (array1->pa_count != array2->pa_count)
230 goto out;
231 if (idx == array1->pa_count) {
232 rv = _PROP_OBJECT_EQUALS_TRUE;
233 goto out;
234 }
235 _PROP_ASSERT(idx < array1->pa_count);
236
237 *stored_pointer1 = (void *)(idx + 1);
238 *stored_pointer2 = (void *)(idx + 1);
239
240 *next_obj1 = array1->pa_array[idx];
241 *next_obj2 = array2->pa_array[idx];
242
243 return (_PROP_OBJECT_EQUALS_RECURSE);
244
245 out:
246 _PROP_RWLOCK_UNLOCK(array1->pa_rwlock);
247 _PROP_RWLOCK_UNLOCK(array2->pa_rwlock);
248 return (rv);
249}
250
251static void
252_prop_array_equals_finish(prop_object_t v1, prop_object_t v2)
253{
254 _PROP_RWLOCK_UNLOCK(((prop_array_t)v1)->pa_rwlock);
255 _PROP_RWLOCK_UNLOCK(((prop_array_t)v2)->pa_rwlock);
256}
257
258static prop_array_t
259_prop_array_alloc(unsigned int capacity)
260{
261 prop_array_t pa;
262 prop_object_t *array;
263
264 if (capacity != 0) {
265 array = _PROP_CALLOC(capacity * sizeof(prop_object_t),
266 M_PROP_ARRAY);
267 if (array == NULL)
268 return (NULL);
269 } else
270 array = NULL;
271
272 pa = _PROP_POOL_GET(_prop_array_pool);
273 if (pa != NULL) {
274 _prop_object_init(&pa->pa_obj, &_prop_object_type_array);
275 pa->pa_obj.po_type = &_prop_object_type_array;
276
277 _PROP_RWLOCK_INIT(pa->pa_rwlock);
278 pa->pa_array = array;
279 pa->pa_capacity = capacity;
280 pa->pa_count = 0;
281 pa->pa_flags = 0;
282
283 pa->pa_version = 0;
284 } else if (array != NULL)
285 _PROP_FREE(array, M_PROP_ARRAY);
286
287 return (pa);
288}
289
290static bool
291_prop_array_expand(prop_array_t pa, unsigned int capacity)
292{
293 prop_object_t *array, *oarray;
294
295 /*
296 * Array must be WRITE-LOCKED.
297 */
298
299 oarray = pa->pa_array;
300
301 array = _PROP_CALLOC(capacity * sizeof(*array), M_PROP_ARRAY);
302 if (array == NULL)
303 return (false);
304 if (oarray != NULL)
305 memcpy(array, oarray, pa->pa_capacity * sizeof(*array));
306 pa->pa_array = array;
307 pa->pa_capacity = capacity;
308
309 if (oarray != NULL)
310 _PROP_FREE(oarray, M_PROP_ARRAY);
311
312 return (true);
313}
314
315static prop_object_t
316_prop_array_iterator_next_object_locked(void *v)
317{
318 struct _prop_array_iterator *pai = v;
319 prop_array_t pa = pai->pai_base.pi_obj;
320 prop_object_t po = NULL;
321
322 _PROP_ASSERT(prop_object_is_array(pa));
323
324 if (pa->pa_version != pai->pai_base.pi_version)
325 goto out; /* array changed during iteration */
326
327 _PROP_ASSERT(pai->pai_index <= pa->pa_count);
328
329 if (pai->pai_index == pa->pa_count)
330 goto out; /* we've iterated all objects */
331
332 po = pa->pa_array[pai->pai_index];
333 pai->pai_index++;
334
335 out:
336 return (po);
337}
338
339static prop_object_t
340_prop_array_iterator_next_object(void *v)
341{
342 struct _prop_array_iterator *pai = v;
b0dfaa52 343 prop_array_t pa = pai->pai_base.pi_obj;
349fb218
AH
344 prop_object_t po;
345
346 _PROP_ASSERT(prop_object_is_array(pa));
347
348 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
349 po = _prop_array_iterator_next_object_locked(pai);
350 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
351 return (po);
352}
353
354static void
355_prop_array_iterator_reset_locked(void *v)
356{
357 struct _prop_array_iterator *pai = v;
358 prop_array_t pa = pai->pai_base.pi_obj;
359
360 _PROP_ASSERT(prop_object_is_array(pa));
361
362 pai->pai_index = 0;
363 pai->pai_base.pi_version = pa->pa_version;
364}
365
366static void
367_prop_array_iterator_reset(void *v)
368{
369 struct _prop_array_iterator *pai = v;
b0dfaa52 370 prop_array_t pa = pai->pai_base.pi_obj;
349fb218
AH
371
372 _PROP_ASSERT(prop_object_is_array(pa));
373
374 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
375 _prop_array_iterator_reset_locked(pai);
376 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
377}
378
379/*
380 * prop_array_create --
381 * Create an empty array.
382 */
383prop_array_t
384prop_array_create(void)
385{
386
387 return (_prop_array_alloc(0));
388}
389
390/*
391 * prop_array_create_with_capacity --
392 * Create an array with the capacity to store N objects.
393 */
394prop_array_t
395prop_array_create_with_capacity(unsigned int capacity)
396{
397
398 return (_prop_array_alloc(capacity));
399}
400
401/*
402 * prop_array_copy --
403 * Copy an array. The new array has an initial capacity equal to
404 * the number of objects stored in the original array. The new
405 * array contains references to the original array's objects, not
406 * copies of those objects (i.e. a shallow copy).
407 */
408prop_array_t
409prop_array_copy(prop_array_t opa)
410{
411 prop_array_t pa;
412 prop_object_t po;
413 unsigned int idx;
414
415 if (! prop_object_is_array(opa))
416 return (NULL);
417
418 _PROP_RWLOCK_RDLOCK(opa->pa_rwlock);
419
420 pa = _prop_array_alloc(opa->pa_count);
421 if (pa != NULL) {
422 for (idx = 0; idx < opa->pa_count; idx++) {
423 po = opa->pa_array[idx];
424 prop_object_retain(po);
425 pa->pa_array[idx] = po;
426 }
427 pa->pa_count = opa->pa_count;
428 pa->pa_flags = opa->pa_flags;
429 }
430 _PROP_RWLOCK_UNLOCK(opa->pa_rwlock);
431 return (pa);
432}
433
434/*
435 * prop_array_copy_mutable --
436 * Like prop_array_copy(), but the resulting array is mutable.
437 */
438prop_array_t
439prop_array_copy_mutable(prop_array_t opa)
440{
441 prop_array_t pa;
442
443 pa = prop_array_copy(opa);
444 if (pa != NULL)
445 pa->pa_flags &= ~PA_F_IMMUTABLE;
446
447 return (pa);
448}
449
450/*
451 * prop_array_capacity --
452 * Return the capacity of the array.
453 */
454unsigned int
455prop_array_capacity(prop_array_t pa)
456{
457 unsigned int rv;
458
459 if (! prop_object_is_array(pa))
460 return (0);
461
462 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
463 rv = pa->pa_capacity;
464 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
465
466 return (rv);
467}
468
469/*
470 * prop_array_count --
471 * Return the number of objects stored in the array.
472 */
473unsigned int
474prop_array_count(prop_array_t pa)
475{
476 unsigned int rv;
477
478 if (! prop_object_is_array(pa))
479 return (0);
480
481 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
482 rv = pa->pa_count;
483 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
484
485 return (rv);
486}
487
488/*
489 * prop_array_ensure_capacity --
490 * Ensure that the array has the capacity to store the specified
491 * total number of objects (inluding the objects already stored
492 * in the array).
493 */
494bool
495prop_array_ensure_capacity(prop_array_t pa, unsigned int capacity)
496{
497 bool rv;
498
499 if (! prop_object_is_array(pa))
500 return (false);
501
502 _PROP_RWLOCK_WRLOCK(pa->pa_rwlock);
503 if (capacity > pa->pa_capacity)
504 rv = _prop_array_expand(pa, capacity);
505 else
506 rv = true;
507 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
508
509 return (rv);
510}
511
512static prop_object_iterator_t
513_prop_array_iterator_locked(prop_array_t pa)
514{
515 struct _prop_array_iterator *pai;
516
517 if (! prop_object_is_array(pa))
518 return (NULL);
519
520 pai = _PROP_CALLOC(sizeof(*pai), M_TEMP);
521 if (pai == NULL)
522 return (NULL);
523 pai->pai_base.pi_next_object = _prop_array_iterator_next_object;
524 pai->pai_base.pi_reset = _prop_array_iterator_reset;
525 prop_object_retain(pa);
526 pai->pai_base.pi_obj = pa;
527 _prop_array_iterator_reset_locked(pai);
528
529 return (&pai->pai_base);
530}
531
532/*
533 * prop_array_iterator --
534 * Return an iterator for the array. The array is retained by
535 * the iterator.
536 */
537prop_object_iterator_t
538prop_array_iterator(prop_array_t pa)
539{
540 prop_object_iterator_t pi;
541
542 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
543 pi = _prop_array_iterator_locked(pa);
544 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
545 return (pi);
546}
547
548/*
549 * prop_array_make_immutable --
550 * Make the array immutable.
551 */
552void
553prop_array_make_immutable(prop_array_t pa)
554{
555
556 _PROP_RWLOCK_WRLOCK(pa->pa_rwlock);
557 if (prop_array_is_immutable(pa) == false)
558 pa->pa_flags |= PA_F_IMMUTABLE;
559 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
560}
561
562/*
563 * prop_array_mutable --
564 * Returns true if the array is mutable.
565 */
566bool
567prop_array_mutable(prop_array_t pa)
568{
569 bool rv;
570
571 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
572 rv = prop_array_is_immutable(pa) == false;
573 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
574
575 return (rv);
576}
577
578/*
579 * prop_array_get --
580 * Return the object stored at the specified array index.
581 */
582prop_object_t
583prop_array_get(prop_array_t pa, unsigned int idx)
584{
585 prop_object_t po = NULL;
586
587 if (! prop_object_is_array(pa))
588 return (NULL);
589
590 _PROP_RWLOCK_RDLOCK(pa->pa_rwlock);
591 if (idx >= pa->pa_count)
592 goto out;
593 po = pa->pa_array[idx];
594 _PROP_ASSERT(po != NULL);
595 out:
596 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
597 return (po);
598}
599
600static bool
601_prop_array_add(prop_array_t pa, prop_object_t po)
602{
603
604 /*
605 * Array must be WRITE-LOCKED.
606 */
607
608 _PROP_ASSERT(pa->pa_count <= pa->pa_capacity);
609
610 if (prop_array_is_immutable(pa) ||
611 (pa->pa_count == pa->pa_capacity &&
612 _prop_array_expand(pa, pa->pa_capacity + EXPAND_STEP) == false))
613 return (false);
614
615 prop_object_retain(po);
616 pa->pa_array[pa->pa_count++] = po;
617 pa->pa_version++;
618
619 return (true);
620}
621
622/*
623 * prop_array_set --
624 * Store a reference to an object at the specified array index.
625 * This method is not allowed to create holes in the array; the
626 * caller must either be setting the object just beyond the existing
627 * count or replacing an already existing object reference.
628 */
629bool
630prop_array_set(prop_array_t pa, unsigned int idx, prop_object_t po)
631{
632 prop_object_t opo;
633 bool rv = false;
634
635 if (! prop_object_is_array(pa))
636 return (false);
637
638 _PROP_RWLOCK_WRLOCK(pa->pa_rwlock);
639
640 if (prop_array_is_immutable(pa))
641 goto out;
642
643 if (idx == pa->pa_count) {
644 rv = _prop_array_add(pa, po);
645 goto out;
646 }
647
648 _PROP_ASSERT(idx < pa->pa_count);
649
650 opo = pa->pa_array[idx];
651 _PROP_ASSERT(opo != NULL);
652
653 prop_object_retain(po);
654 pa->pa_array[idx] = po;
655 pa->pa_version++;
656
657 prop_object_release(opo);
658
659 rv = true;
660
661 out:
662 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
663 return (rv);
664}
665
666/*
667 * prop_array_add --
668 * Add a reference to an object to the specified array, appending
669 * to the end and growing the array's capacity, if necessary.
670 */
671bool
672prop_array_add(prop_array_t pa, prop_object_t po)
673{
674 bool rv;
675
676 if (! prop_object_is_array(pa))
677 return (false);
678
679 _PROP_RWLOCK_WRLOCK(pa->pa_rwlock);
680 rv = _prop_array_add(pa, po);
681 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
682
683 return (rv);
684}
685
686/*
687 * prop_array_remove --
688 * Remove the reference to an object from an array at the specified
689 * index. The array will be compacted following the removal.
690 */
691void
692prop_array_remove(prop_array_t pa, unsigned int idx)
693{
694 prop_object_t po;
695
696 if (! prop_object_is_array(pa))
697 return;
698
699 _PROP_RWLOCK_WRLOCK(pa->pa_rwlock);
700
701 _PROP_ASSERT(idx < pa->pa_count);
702
703 /* XXX Should this be a _PROP_ASSERT()? */
704 if (prop_array_is_immutable(pa)) {
705 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
706 return;
707 }
708
709 po = pa->pa_array[idx];
710 _PROP_ASSERT(po != NULL);
711
712 for (++idx; idx < pa->pa_count; idx++)
713 pa->pa_array[idx - 1] = pa->pa_array[idx];
714 pa->pa_count--;
715 pa->pa_version++;
716
717 _PROP_RWLOCK_UNLOCK(pa->pa_rwlock);
718
719 prop_object_release(po);
720}
721
722/*
723 * prop_array_equals --
724 * Return true if the two arrays are equivalent. Note we do a
725 * by-value comparison of the objects in the array.
726 */
727bool
728prop_array_equals(prop_array_t array1, prop_array_t array2)
729{
730 if (!prop_object_is_array(array1) || !prop_object_is_array(array2))
731 return (false);
732
733 return (prop_object_equals(array1, array2));
734}
735
736/*
737 * prop_array_externalize --
738 * Externalize an array, return a NUL-terminated buffer
739 * containing the XML-style representation. The buffer is allocated
740 * with the M_TEMP memory type.
741 */
742char *
743prop_array_externalize(prop_array_t pa)
744{
745 struct _prop_object_externalize_context *ctx;
746 char *cp;
747
748 ctx = _prop_object_externalize_context_alloc();
749 if (ctx == NULL)
750 return (NULL);
751
752 if (_prop_object_externalize_header(ctx) == false ||
753 (*pa->pa_obj.po_type->pot_extern)(ctx, pa) == false ||
754 _prop_object_externalize_footer(ctx) == false) {
755 /* We are responsible for releasing the buffer. */
756 _PROP_FREE(ctx->poec_buf, M_TEMP);
757 _prop_object_externalize_context_free(ctx);
758 return (NULL);
759 }
760
761 cp = ctx->poec_buf;
762 _prop_object_externalize_context_free(ctx);
763
764 return (cp);
765}
766
767/*
768 * _prop_array_internalize --
769 * Parse an <array>...</array> and return the object created from the
770 * external representation.
771 */
772static bool _prop_array_internalize_body(prop_stack_t, prop_object_t *,
773 struct _prop_object_internalize_context *);
774
775bool
776_prop_array_internalize(prop_stack_t stack, prop_object_t *obj,
777 struct _prop_object_internalize_context *ctx)
778{
779 /* We don't currently understand any attributes. */
780 if (ctx->poic_tagattr != NULL)
781 return (true);
782
783 *obj = prop_array_create();
784 /*
785 * We are done if the create failed or no child elements exist.
786 */
787 if (*obj == NULL || ctx->poic_is_empty_element)
788 return (true);
789
790 /*
791 * Opening tag is found, now continue to the first element.
792 */
793 return (_prop_array_internalize_body(stack, obj, ctx));
794}
795
796static bool
797_prop_array_internalize_continue(prop_stack_t stack,
798 prop_object_t *obj,
799 struct _prop_object_internalize_context *ctx,
800 void *data, prop_object_t child)
801{
802 prop_array_t array;
803
804 _PROP_ASSERT(data == NULL);
805
806 if (child == NULL)
807 goto bad; /* Element could not be parsed. */
808
809 array = *obj;
810
811 if (prop_array_add(array, child) == false) {
812 prop_object_release(child);
813 goto bad;
814 }
815 prop_object_release(child);
816
817 /*
818 * Current element is processed and added, look for next.
819 */
820 return (_prop_array_internalize_body(stack, obj, ctx));
821
822 bad:
823 prop_object_release(*obj);
824 *obj = NULL;
825 return (true);
826}
827
828static bool
829_prop_array_internalize_body(prop_stack_t stack, prop_object_t *obj,
830 struct _prop_object_internalize_context *ctx)
831{
832 prop_array_t array = *obj;
833
834 _PROP_ASSERT(array != NULL);
835
836 /* Fetch the next tag. */
837 if (_prop_object_internalize_find_tag(ctx, NULL,
838 _PROP_TAG_TYPE_EITHER) == false)
839 goto bad;
840
841 /* Check to see if this is the end of the array. */
842 if (_PROP_TAG_MATCH(ctx, "array") &&
843 ctx->poic_tag_type == _PROP_TAG_TYPE_END) {
844 /* It is, so don't iterate any further. */
845 return (true);
846 }
847
848 if (_prop_stack_push(stack, array,
849 _prop_array_internalize_continue, NULL, NULL))
850 return (false);
851
852 bad:
853 prop_object_release(array);
854 *obj = NULL;
855 return (true);
856}
857
858/*
859 * prop_array_internalize --
860 * Create an array by parsing the XML-style representation.
861 */
862prop_array_t
863prop_array_internalize(const char *xml)
864{
865 return _prop_generic_internalize(xml, "array");
866}
867
868#if !defined(_KERNEL) && !defined(_STANDALONE)
869/*
870 * prop_array_externalize_to_file --
871 * Externalize an array to the specified file.
872 */
873bool
874prop_array_externalize_to_file(prop_array_t array, const char *fname)
875{
876 char *xml;
877 bool rv;
878 int save_errno = 0; /* XXXGCC -Wuninitialized [mips, ...] */
879
880 xml = prop_array_externalize(array);
881 if (xml == NULL)
882 return (false);
883 rv = _prop_object_externalize_write_file(fname, xml, strlen(xml));
884 if (rv == false)
885 save_errno = errno;
886 _PROP_FREE(xml, M_TEMP);
887 if (rv == false)
888 errno = save_errno;
889
890 return (rv);
891}
892
893/*
894 * prop_array_internalize_from_file --
895 * Internalize an array from a file.
896 */
897prop_array_t
898prop_array_internalize_from_file(const char *fname)
899{
900 struct _prop_object_internalize_mapped_file *mf;
901 prop_array_t array;
902
903 mf = _prop_object_internalize_map_file(fname);
904 if (mf == NULL)
905 return (NULL);
906 array = prop_array_internalize(mf->poimf_xml);
907 _prop_object_internalize_unmap_file(mf);
908
909 return (array);
910}
911#endif /* _KERNEL && !_STANDALONE */