| 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 | |
| 32 | #include <libprop/prop_array.h> |
| 33 | #include "prop_object_impl.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 _prop_object_free_rv_t |
| 57 | _prop_array_free(prop_stack_t, prop_object_t *); |
| 58 | static void _prop_array_emergency_free(prop_object_t); |
| 59 | static bool _prop_array_externalize( |
| 60 | struct _prop_object_externalize_context *, |
| 61 | void *); |
| 62 | static _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 *); |
| 66 | static void _prop_array_equals_finish(prop_object_t, prop_object_t); |
| 67 | static prop_object_iterator_t |
| 68 | _prop_array_iterator_locked(prop_array_t); |
| 69 | static prop_object_t |
| 70 | _prop_array_iterator_next_object_locked(void *); |
| 71 | static void _prop_array_iterator_reset_locked(void *); |
| 72 | |
| 73 | static 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 | |
| 87 | struct _prop_array_iterator { |
| 88 | struct _prop_object_iterator pai_base; |
| 89 | unsigned int pai_index; |
| 90 | }; |
| 91 | |
| 92 | #define EXPAND_STEP 16 |
| 93 | |
| 94 | static _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 | |
| 139 | static 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 | |
| 148 | static 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 */ |
| 202 | static _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 | |
| 251 | static 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 | |
| 258 | static 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 | |
| 290 | static 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 | |
| 315 | static 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 | |
| 339 | static prop_object_t |
| 340 | _prop_array_iterator_next_object(void *v) |
| 341 | { |
| 342 | struct _prop_array_iterator *pai = v; |
| 343 | prop_array_t pa = pai->pai_base.pi_obj; |
| 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 | |
| 354 | static 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 | |
| 366 | static void |
| 367 | _prop_array_iterator_reset(void *v) |
| 368 | { |
| 369 | struct _prop_array_iterator *pai = v; |
| 370 | prop_array_t pa = pai->pai_base.pi_obj; |
| 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 | */ |
| 383 | prop_array_t |
| 384 | prop_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 | */ |
| 394 | prop_array_t |
| 395 | prop_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 | */ |
| 408 | prop_array_t |
| 409 | prop_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 | */ |
| 438 | prop_array_t |
| 439 | prop_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 | */ |
| 454 | unsigned int |
| 455 | prop_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 | */ |
| 473 | unsigned int |
| 474 | prop_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 | */ |
| 494 | bool |
| 495 | prop_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 | |
| 512 | static 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 | */ |
| 537 | prop_object_iterator_t |
| 538 | prop_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 | */ |
| 552 | void |
| 553 | prop_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 | */ |
| 566 | bool |
| 567 | prop_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 | */ |
| 582 | prop_object_t |
| 583 | prop_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 | |
| 600 | static 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 | */ |
| 629 | bool |
| 630 | prop_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 | */ |
| 671 | bool |
| 672 | prop_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 | */ |
| 691 | void |
| 692 | prop_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 | */ |
| 727 | bool |
| 728 | prop_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 | */ |
| 742 | char * |
| 743 | prop_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 | */ |
| 772 | static bool _prop_array_internalize_body(prop_stack_t, prop_object_t *, |
| 773 | struct _prop_object_internalize_context *); |
| 774 | |
| 775 | bool |
| 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 | |
| 796 | static 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 | |
| 828 | static 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 | */ |
| 862 | prop_array_t |
| 863 | prop_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 | */ |
| 873 | bool |
| 874 | prop_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 | */ |
| 897 | prop_array_t |
| 898 | prop_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 */ |