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 } 629