| 1 | /* $NetBSD: prop_data.c,v 1.14 2009/01/25 06:59:35 cyber Exp $ */ |
| 2 | |
| 3 | /*- |
| 4 | * Copyright (c) 2006 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_data.h> |
| 33 | #include "prop_object_impl.h" |
| 34 | |
| 35 | #if defined(_KERNEL) |
| 36 | #include <sys/systm.h> |
| 37 | #include <sys/libkern.h> |
| 38 | #elif defined(_STANDALONE) |
| 39 | #include <sys/param.h> |
| 40 | #include <lib/libkern/libkern.h> |
| 41 | #else |
| 42 | #include <errno.h> |
| 43 | #include <limits.h> |
| 44 | #include <stdlib.h> |
| 45 | #endif |
| 46 | |
| 47 | struct _prop_data { |
| 48 | struct _prop_object pd_obj; |
| 49 | union { |
| 50 | void * pdu_mutable; |
| 51 | const void * pdu_immutable; |
| 52 | } pd_un; |
| 53 | #define pd_mutable pd_un.pdu_mutable |
| 54 | #define pd_immutable pd_un.pdu_immutable |
| 55 | size_t pd_size; |
| 56 | int pd_flags; |
| 57 | }; |
| 58 | |
| 59 | #define PD_F_NOCOPY 0x01 |
| 60 | |
| 61 | _PROP_POOL_INIT(_prop_data_pool, sizeof(struct _prop_data), "propdata") |
| 62 | |
| 63 | _PROP_MALLOC_DEFINE(M_PROP_DATA, "prop data", |
| 64 | "property data container object") |
| 65 | |
| 66 | static _prop_object_free_rv_t |
| 67 | _prop_data_free(prop_stack_t, prop_object_t *); |
| 68 | static bool _prop_data_externalize( |
| 69 | struct _prop_object_externalize_context *, |
| 70 | void *); |
| 71 | static _prop_object_equals_rv_t |
| 72 | _prop_data_equals(prop_object_t, prop_object_t, |
| 73 | void **, void **, |
| 74 | prop_object_t *, prop_object_t *); |
| 75 | |
| 76 | static const struct _prop_object_type _prop_object_type_data = { |
| 77 | .pot_type = PROP_TYPE_DATA, |
| 78 | .pot_free = _prop_data_free, |
| 79 | .pot_extern = _prop_data_externalize, |
| 80 | .pot_equals = _prop_data_equals, |
| 81 | }; |
| 82 | |
| 83 | #define prop_object_is_data(x) \ |
| 84 | ((x) != NULL && (x)->pd_obj.po_type == &_prop_object_type_data) |
| 85 | |
| 86 | /* ARGSUSED */ |
| 87 | static _prop_object_free_rv_t |
| 88 | _prop_data_free(prop_stack_t stack, prop_object_t *obj) |
| 89 | { |
| 90 | prop_data_t pd = *obj; |
| 91 | |
| 92 | if ((pd->pd_flags & PD_F_NOCOPY) == 0 && pd->pd_mutable != NULL) |
| 93 | _PROP_FREE(pd->pd_mutable, M_PROP_DATA); |
| 94 | _PROP_POOL_PUT(_prop_data_pool, pd); |
| 95 | |
| 96 | return (_PROP_OBJECT_FREE_DONE); |
| 97 | } |
| 98 | |
| 99 | static const char _prop_data_base64[] = |
| 100 | "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; |
| 101 | static const char _prop_data_pad64 = '='; |
| 102 | |
| 103 | static bool |
| 104 | _prop_data_externalize(struct _prop_object_externalize_context *ctx, void *v) |
| 105 | { |
| 106 | prop_data_t pd = v; |
| 107 | size_t i, srclen; |
| 108 | const uint8_t *src; |
| 109 | uint8_t output[4]; |
| 110 | uint8_t input[3]; |
| 111 | |
| 112 | if (pd->pd_size == 0) |
| 113 | return (_prop_object_externalize_empty_tag(ctx, "data")); |
| 114 | |
| 115 | if (_prop_object_externalize_start_tag(ctx, "data") == false) |
| 116 | return (false); |
| 117 | |
| 118 | for (src = pd->pd_immutable, srclen = pd->pd_size; |
| 119 | srclen > 2; srclen -= 3) { |
| 120 | input[0] = *src++; |
| 121 | input[1] = *src++; |
| 122 | input[2] = *src++; |
| 123 | |
| 124 | output[0] = (uint32_t)input[0] >> 2; |
| 125 | output[1] = ((uint32_t)(input[0] & 0x03) << 4) + |
| 126 | ((uint32_t)input[1] >> 4); |
| 127 | output[2] = ((uint32_t)(input[1] & 0x0f) << 2) + |
| 128 | ((uint32_t)input[2] >> 6); |
| 129 | output[3] = input[2] & 0x3f; |
| 130 | _PROP_ASSERT(output[0] < 64); |
| 131 | _PROP_ASSERT(output[1] < 64); |
| 132 | _PROP_ASSERT(output[2] < 64); |
| 133 | _PROP_ASSERT(output[3] < 64); |
| 134 | |
| 135 | if (_prop_object_externalize_append_char(ctx, |
| 136 | _prop_data_base64[output[0]]) == false || |
| 137 | _prop_object_externalize_append_char(ctx, |
| 138 | _prop_data_base64[output[1]]) == false || |
| 139 | _prop_object_externalize_append_char(ctx, |
| 140 | _prop_data_base64[output[2]]) == false || |
| 141 | _prop_object_externalize_append_char(ctx, |
| 142 | _prop_data_base64[output[3]]) == false) |
| 143 | return (false); |
| 144 | } |
| 145 | |
| 146 | if (srclen != 0) { |
| 147 | input[0] = input[1] = input[2] = '\0'; |
| 148 | for (i = 0; i < srclen; i++) |
| 149 | input[i] = *src++; |
| 150 | |
| 151 | output[0] = (uint32_t)input[0] >> 2; |
| 152 | output[1] = ((uint32_t)(input[0] & 0x03) << 4) + |
| 153 | ((uint32_t)input[1] >> 4); |
| 154 | output[2] = ((uint32_t)(input[1] & 0x0f) << 2) + |
| 155 | ((uint32_t)input[2] >> 6); |
| 156 | _PROP_ASSERT(output[0] < 64); |
| 157 | _PROP_ASSERT(output[1] < 64); |
| 158 | _PROP_ASSERT(output[2] < 64); |
| 159 | |
| 160 | if (_prop_object_externalize_append_char(ctx, |
| 161 | _prop_data_base64[output[0]]) == false || |
| 162 | _prop_object_externalize_append_char(ctx, |
| 163 | _prop_data_base64[output[1]]) == false || |
| 164 | _prop_object_externalize_append_char(ctx, |
| 165 | srclen == 1 ? _prop_data_pad64 |
| 166 | : _prop_data_base64[output[2]]) == false || |
| 167 | _prop_object_externalize_append_char(ctx, |
| 168 | _prop_data_pad64) == false) |
| 169 | return (false); |
| 170 | } |
| 171 | |
| 172 | if (_prop_object_externalize_end_tag(ctx, "data") == false) |
| 173 | return (false); |
| 174 | |
| 175 | return (true); |
| 176 | } |
| 177 | |
| 178 | /* ARGSUSED */ |
| 179 | static _prop_object_equals_rv_t |
| 180 | _prop_data_equals(prop_object_t v1, prop_object_t v2, |
| 181 | void **stored_pointer1, void **stored_pointer2, |
| 182 | prop_object_t *next_obj1, prop_object_t *next_obj2) |
| 183 | { |
| 184 | prop_data_t pd1 = v1; |
| 185 | prop_data_t pd2 = v2; |
| 186 | |
| 187 | if (pd1 == pd2) |
| 188 | return (_PROP_OBJECT_EQUALS_TRUE); |
| 189 | if (pd1->pd_size != pd2->pd_size) |
| 190 | return (_PROP_OBJECT_EQUALS_FALSE); |
| 191 | if (pd1->pd_size == 0) { |
| 192 | _PROP_ASSERT(pd1->pd_immutable == NULL); |
| 193 | _PROP_ASSERT(pd2->pd_immutable == NULL); |
| 194 | return (_PROP_OBJECT_EQUALS_TRUE); |
| 195 | } |
| 196 | if (memcmp(pd1->pd_immutable, pd2->pd_immutable, pd1->pd_size) == 0) |
| 197 | return _PROP_OBJECT_EQUALS_TRUE; |
| 198 | else |
| 199 | return _PROP_OBJECT_EQUALS_FALSE; |
| 200 | } |
| 201 | |
| 202 | static prop_data_t |
| 203 | _prop_data_alloc(void) |
| 204 | { |
| 205 | prop_data_t pd; |
| 206 | |
| 207 | pd = _PROP_POOL_GET(_prop_data_pool); |
| 208 | if (pd != NULL) { |
| 209 | _prop_object_init(&pd->pd_obj, &_prop_object_type_data); |
| 210 | |
| 211 | pd->pd_mutable = NULL; |
| 212 | pd->pd_size = 0; |
| 213 | pd->pd_flags = 0; |
| 214 | } |
| 215 | |
| 216 | return (pd); |
| 217 | } |
| 218 | |
| 219 | /* |
| 220 | * prop_data_create_data -- |
| 221 | * Create a data container that contains a copy of the data. |
| 222 | */ |
| 223 | prop_data_t |
| 224 | prop_data_create_data(const void *v, size_t size) |
| 225 | { |
| 226 | prop_data_t pd; |
| 227 | void *nv; |
| 228 | |
| 229 | pd = _prop_data_alloc(); |
| 230 | if (pd != NULL && size != 0) { |
| 231 | nv = _PROP_MALLOC(size, M_PROP_DATA); |
| 232 | if (nv == NULL) { |
| 233 | prop_object_release(pd); |
| 234 | return (NULL); |
| 235 | } |
| 236 | memcpy(nv, v, size); |
| 237 | pd->pd_mutable = nv; |
| 238 | pd->pd_size = size; |
| 239 | } |
| 240 | return (pd); |
| 241 | } |
| 242 | |
| 243 | /* |
| 244 | * prop_data_create_data_nocopy -- |
| 245 | * Create an immutable data container that contains a refrence to the |
| 246 | * provided external data. |
| 247 | */ |
| 248 | prop_data_t |
| 249 | prop_data_create_data_nocopy(const void *v, size_t size) |
| 250 | { |
| 251 | prop_data_t pd; |
| 252 | |
| 253 | pd = _prop_data_alloc(); |
| 254 | if (pd != NULL) { |
| 255 | pd->pd_immutable = v; |
| 256 | pd->pd_size = size; |
| 257 | pd->pd_flags |= PD_F_NOCOPY; |
| 258 | } |
| 259 | return (pd); |
| 260 | } |
| 261 | |
| 262 | /* |
| 263 | * prop_data_copy -- |
| 264 | * Copy a data container. If the original data is external, then |
| 265 | * the copy is also references the same external data. |
| 266 | */ |
| 267 | prop_data_t |
| 268 | prop_data_copy(prop_data_t opd) |
| 269 | { |
| 270 | prop_data_t pd; |
| 271 | |
| 272 | if (! prop_object_is_data(opd)) |
| 273 | return (NULL); |
| 274 | |
| 275 | pd = _prop_data_alloc(); |
| 276 | if (pd != NULL) { |
| 277 | pd->pd_size = opd->pd_size; |
| 278 | pd->pd_flags = opd->pd_flags; |
| 279 | if (opd->pd_flags & PD_F_NOCOPY) |
| 280 | pd->pd_immutable = opd->pd_immutable; |
| 281 | else if (opd->pd_size != 0) { |
| 282 | void *nv = _PROP_MALLOC(pd->pd_size, M_PROP_DATA); |
| 283 | if (nv == NULL) { |
| 284 | prop_object_release(pd); |
| 285 | return (NULL); |
| 286 | } |
| 287 | memcpy(nv, opd->pd_immutable, opd->pd_size); |
| 288 | pd->pd_mutable = nv; |
| 289 | } |
| 290 | } |
| 291 | return (pd); |
| 292 | } |
| 293 | |
| 294 | /* |
| 295 | * prop_data_size -- |
| 296 | * Return the size of the data. |
| 297 | */ |
| 298 | size_t |
| 299 | prop_data_size(prop_data_t pd) |
| 300 | { |
| 301 | |
| 302 | if (! prop_object_is_data(pd)) |
| 303 | return (0); |
| 304 | |
| 305 | return (pd->pd_size); |
| 306 | } |
| 307 | |
| 308 | /* |
| 309 | * prop_data_data -- |
| 310 | * Return a copy of the contents of the data container. |
| 311 | * The data is allocated with the M_TEMP malloc type. |
| 312 | * If the data container is empty, NULL is returned. |
| 313 | */ |
| 314 | void * |
| 315 | prop_data_data(prop_data_t pd) |
| 316 | { |
| 317 | void *v; |
| 318 | |
| 319 | if (! prop_object_is_data(pd)) |
| 320 | return (NULL); |
| 321 | |
| 322 | if (pd->pd_size == 0) { |
| 323 | _PROP_ASSERT(pd->pd_immutable == NULL); |
| 324 | return (NULL); |
| 325 | } |
| 326 | |
| 327 | _PROP_ASSERT(pd->pd_immutable != NULL); |
| 328 | |
| 329 | v = _PROP_MALLOC(pd->pd_size, M_TEMP); |
| 330 | if (v != NULL) |
| 331 | memcpy(v, pd->pd_immutable, pd->pd_size); |
| 332 | |
| 333 | return (v); |
| 334 | } |
| 335 | |
| 336 | /* |
| 337 | * prop_data_data_nocopy -- |
| 338 | * Return an immutable reference to the contents of the data |
| 339 | * container. |
| 340 | */ |
| 341 | const void * |
| 342 | prop_data_data_nocopy(prop_data_t pd) |
| 343 | { |
| 344 | |
| 345 | if (! prop_object_is_data(pd)) |
| 346 | return (NULL); |
| 347 | |
| 348 | _PROP_ASSERT((pd->pd_size == 0 && pd->pd_immutable == NULL) || |
| 349 | (pd->pd_size != 0 && pd->pd_immutable != NULL)); |
| 350 | |
| 351 | return (pd->pd_immutable); |
| 352 | } |
| 353 | |
| 354 | /* |
| 355 | * prop_data_equals -- |
| 356 | * Return true if two strings are equivalent. |
| 357 | */ |
| 358 | bool |
| 359 | prop_data_equals(prop_data_t pd1, prop_data_t pd2) |
| 360 | { |
| 361 | if (!prop_object_is_data(pd1) || !prop_object_is_data(pd2)) |
| 362 | return (false); |
| 363 | |
| 364 | return (prop_object_equals(pd1, pd2)); |
| 365 | } |
| 366 | |
| 367 | /* |
| 368 | * prop_data_equals_data -- |
| 369 | * Return true if the contained data is equivalent to the specified |
| 370 | * external data. |
| 371 | */ |
| 372 | bool |
| 373 | prop_data_equals_data(prop_data_t pd, const void *v, size_t size) |
| 374 | { |
| 375 | |
| 376 | if (! prop_object_is_data(pd)) |
| 377 | return (false); |
| 378 | |
| 379 | if (pd->pd_size != size) |
| 380 | return (false); |
| 381 | return (memcmp(pd->pd_immutable, v, size) == 0); |
| 382 | } |
| 383 | |
| 384 | static bool |
| 385 | _prop_data_internalize_decode(struct _prop_object_internalize_context *ctx, |
| 386 | uint8_t *target, size_t targsize, size_t *sizep, |
| 387 | const char **cpp) |
| 388 | { |
| 389 | const char *src; |
| 390 | size_t tarindex; |
| 391 | int state, ch; |
| 392 | const char *pos; |
| 393 | |
| 394 | state = 0; |
| 395 | tarindex = 0; |
| 396 | src = ctx->poic_cp; |
| 397 | |
| 398 | for (;;) { |
| 399 | ch = (unsigned char) *src++; |
| 400 | if (_PROP_EOF(ch)) |
| 401 | return (false); |
| 402 | if (_PROP_ISSPACE(ch)) |
| 403 | continue; |
| 404 | if (ch == '<') { |
| 405 | src--; |
| 406 | break; |
| 407 | } |
| 408 | if (ch == _prop_data_pad64) |
| 409 | break; |
| 410 | |
| 411 | pos = strchr(_prop_data_base64, ch); |
| 412 | if (pos == NULL) |
| 413 | return (false); |
| 414 | |
| 415 | switch (state) { |
| 416 | case 0: |
| 417 | if (target) { |
| 418 | if (tarindex >= targsize) |
| 419 | return (false); |
| 420 | target[tarindex] = |
| 421 | (uint8_t)((pos - _prop_data_base64) << 2); |
| 422 | } |
| 423 | state = 1; |
| 424 | break; |
| 425 | |
| 426 | case 1: |
| 427 | if (target) { |
| 428 | if (tarindex + 1 >= targsize) |
| 429 | return (false); |
| 430 | target[tarindex] |= |
| 431 | (uint32_t)(pos - _prop_data_base64) >> 4; |
| 432 | target[tarindex + 1] = |
| 433 | (uint8_t)(((pos - _prop_data_base64) & 0xf) |
| 434 | << 4); |
| 435 | } |
| 436 | tarindex++; |
| 437 | state = 2; |
| 438 | break; |
| 439 | |
| 440 | case 2: |
| 441 | if (target) { |
| 442 | if (tarindex + 1 >= targsize) |
| 443 | return (false); |
| 444 | target[tarindex] |= |
| 445 | (uint32_t)(pos - _prop_data_base64) >> 2; |
| 446 | target[tarindex + 1] = |
| 447 | (uint8_t)(((pos - _prop_data_base64) |
| 448 | & 0x3) << 6); |
| 449 | } |
| 450 | tarindex++; |
| 451 | state = 3; |
| 452 | break; |
| 453 | |
| 454 | case 3: |
| 455 | if (target) { |
| 456 | if (tarindex >= targsize) |
| 457 | return (false); |
| 458 | target[tarindex] |= (uint8_t) |
| 459 | (pos - _prop_data_base64); |
| 460 | } |
| 461 | tarindex++; |
| 462 | state = 0; |
| 463 | break; |
| 464 | |
| 465 | default: |
| 466 | _PROP_ASSERT(/*CONSTCOND*/0); |
| 467 | } |
| 468 | } |
| 469 | |
| 470 | /* |
| 471 | * We are done decoding the Base64 characters. Let's see if we |
| 472 | * ended up on a byte boundary and/or with unrecognized trailing |
| 473 | * characters. |
| 474 | */ |
| 475 | if (ch == _prop_data_pad64) { |
| 476 | ch = (unsigned char) *src; /* src already advanced */ |
| 477 | if (_PROP_EOF(ch)) |
| 478 | return (false); |
| 479 | switch (state) { |
| 480 | case 0: /* Invalid = in first position */ |
| 481 | case 1: /* Invalid = in second position */ |
| 482 | return (false); |
| 483 | |
| 484 | case 2: /* Valid, one byte of info */ |
| 485 | /* Skip whitespace */ |
| 486 | for (ch = (unsigned char) *src++; |
| 487 | ch != '<'; ch = (unsigned char) *src++) { |
| 488 | if (_PROP_EOF(ch)) |
| 489 | return (false); |
| 490 | if (!_PROP_ISSPACE(ch)) |
| 491 | break; |
| 492 | } |
| 493 | /* Make sure there is another trailing = */ |
| 494 | if (ch != _prop_data_pad64) |
| 495 | return (false); |
| 496 | ch = (unsigned char) *src; |
| 497 | /* FALLTHROUGH */ |
| 498 | |
| 499 | case 3: /* Valid, two bytes of info */ |
| 500 | /* |
| 501 | * We know this char is a =. Is there anything but |
| 502 | * whitespace after it? |
| 503 | */ |
| 504 | for (ch = (unsigned char) *src++; |
| 505 | ch != '<'; ch = (unsigned char) *src++) { |
| 506 | if (_PROP_EOF(ch)) |
| 507 | return (false); |
| 508 | if (!_PROP_ISSPACE(ch)) |
| 509 | return (false); |
| 510 | } |
| 511 | /* back up to '<' */ |
| 512 | src--; |
| 513 | } |
| 514 | } else { |
| 515 | /* |
| 516 | * We ended by seeing the end of the Base64 string. Make |
| 517 | * sure there are no partial bytes lying around. |
| 518 | */ |
| 519 | if (state != 0) |
| 520 | return (false); |
| 521 | } |
| 522 | |
| 523 | _PROP_ASSERT(*src == '<'); |
| 524 | if (sizep != NULL) |
| 525 | *sizep = tarindex; |
| 526 | if (cpp != NULL) |
| 527 | *cpp = src; |
| 528 | |
| 529 | return (true); |
| 530 | } |
| 531 | |
| 532 | /* |
| 533 | * _prop_data_internalize -- |
| 534 | * Parse a <data>...</data> and return the object created from the |
| 535 | * external representation. |
| 536 | */ |
| 537 | |
| 538 | /* strtoul is used for parsing, enforce. */ |
| 539 | typedef int PROP_DATA_ASSERT[/* CONSTCOND */sizeof(size_t) == sizeof(unsigned long) ? 1 : -1]; |
| 540 | |
| 541 | /* ARGSUSED */ |
| 542 | bool |
| 543 | _prop_data_internalize(prop_stack_t stack, prop_object_t *obj, |
| 544 | struct _prop_object_internalize_context *ctx) |
| 545 | { |
| 546 | prop_data_t data; |
| 547 | uint8_t *buf; |
| 548 | size_t len, alen; |
| 549 | |
| 550 | /* |
| 551 | * We don't accept empty elements. |
| 552 | * This actually only checks for the node to be <data/> |
| 553 | * (Which actually causes another error if found.) |
| 554 | */ |
| 555 | if (ctx->poic_is_empty_element) |
| 556 | return (true); |
| 557 | |
| 558 | /* |
| 559 | * If we got a "size" attribute, get the size of the data blob |
| 560 | * from that. Otherwise, we have to figure it out from the base64. |
| 561 | */ |
| 562 | if (ctx->poic_tagattr != NULL) { |
| 563 | char *cp; |
| 564 | |
| 565 | if (!_PROP_TAGATTR_MATCH(ctx, "size") || |
| 566 | ctx->poic_tagattrval_len == 0) |
| 567 | return (true); |
| 568 | |
| 569 | #ifndef _KERNEL |
| 570 | errno = 0; |
| 571 | #endif |
| 572 | len = strtoul(ctx->poic_tagattrval, &cp, 0); |
| 573 | #ifndef _KERNEL /* XXX can't check for ERANGE in the kernel */ |
| 574 | if (len == ULONG_MAX && errno == ERANGE) |
| 575 | return (true); |
| 576 | #endif |
| 577 | if (cp != ctx->poic_tagattrval + ctx->poic_tagattrval_len) |
| 578 | return (true); |
| 579 | _PROP_ASSERT(*cp == '\"'); |
| 580 | } else if (_prop_data_internalize_decode(ctx, NULL, 0, &len, |
| 581 | NULL) == false) |
| 582 | return (true); |
| 583 | |
| 584 | /* |
| 585 | * Always allocate one extra in case we don't land on an even byte |
| 586 | * boundary during the decode. |
| 587 | */ |
| 588 | buf = _PROP_MALLOC(len + 1, M_PROP_DATA); |
| 589 | if (buf == NULL) |
| 590 | return (true); |
| 591 | |
| 592 | if (_prop_data_internalize_decode(ctx, buf, len + 1, &alen, |
| 593 | &ctx->poic_cp) == false) { |
| 594 | _PROP_FREE(buf, M_PROP_DATA); |
| 595 | return (true); |
| 596 | } |
| 597 | if (alen != len) { |
| 598 | _PROP_FREE(buf, M_PROP_DATA); |
| 599 | return (true); |
| 600 | } |
| 601 | |
| 602 | if (_prop_object_internalize_find_tag(ctx, "data", |
| 603 | _PROP_TAG_TYPE_END) == false) { |
| 604 | _PROP_FREE(buf, M_PROP_DATA); |
| 605 | return (true); |
| 606 | } |
| 607 | |
| 608 | data = _prop_data_alloc(); |
| 609 | if (data == NULL) { |
| 610 | _PROP_FREE(buf, M_PROP_DATA); |
| 611 | return (true); |
| 612 | } |
| 613 | |
| 614 | /* |
| 615 | * Handle alternate type of empty node. |
| 616 | * XML document could contain open/close tags, yet still be empty. |
| 617 | */ |
| 618 | if (alen == 0) { |
| 619 | _PROP_FREE(buf, M_PROP_DATA); |
| 620 | data->pd_mutable = NULL; |
| 621 | } else { |
| 622 | data->pd_mutable = buf; |
| 623 | } |
| 624 | data->pd_size = len; |
| 625 | |
| 626 | *obj = data; |
| 627 | return (true); |
| 628 | } |