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