1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2009-2010 The FreeBSD Foundation 5 * All rights reserved. 6 * 7 * This software was developed by Pawel Jakub Dawidek under sponsorship from 8 * the FreeBSD Foundation. 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 AUTHORS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include <sys/param.h> 36 #include <sys/endian.h> 37 38 #include <bitstring.h> 39 #include <errno.h> 40 #include <stdarg.h> 41 #include <stdbool.h> 42 #include <stdint.h> 43 #include <stdlib.h> 44 #include <string.h> 45 #include <unistd.h> 46 47 #include <ebuf.h> 48 #include <pjdlog.h> 49 50 #include "nv.h" 51 52 #ifndef PJDLOG_ASSERT 53 #include <assert.h> 54 #define PJDLOG_ASSERT(...) assert(__VA_ARGS__) 55 #endif 56 #ifndef PJDLOG_ABORT 57 #define PJDLOG_ABORT(...) abort() 58 #endif 59 60 #define NV_TYPE_NONE 0 61 62 #define NV_TYPE_INT8 1 63 #define NV_TYPE_UINT8 2 64 #define NV_TYPE_INT16 3 65 #define NV_TYPE_UINT16 4 66 #define NV_TYPE_INT32 5 67 #define NV_TYPE_UINT32 6 68 #define NV_TYPE_INT64 7 69 #define NV_TYPE_UINT64 8 70 #define NV_TYPE_INT8_ARRAY 9 71 #define NV_TYPE_UINT8_ARRAY 10 72 #define NV_TYPE_INT16_ARRAY 11 73 #define NV_TYPE_UINT16_ARRAY 12 74 #define NV_TYPE_INT32_ARRAY 13 75 #define NV_TYPE_UINT32_ARRAY 14 76 #define NV_TYPE_INT64_ARRAY 15 77 #define NV_TYPE_UINT64_ARRAY 16 78 #define NV_TYPE_STRING 17 79 80 #define NV_TYPE_MASK 0x7f 81 #define NV_TYPE_FIRST NV_TYPE_INT8 82 #define NV_TYPE_LAST NV_TYPE_STRING 83 84 #define NV_ORDER_NETWORK 0x00 85 #define NV_ORDER_HOST 0x80 86 87 #define NV_ORDER_MASK 0x80 88 89 #define NV_MAGIC 0xaea1e 90 struct nv { 91 int nv_magic; 92 int nv_error; 93 struct ebuf *nv_ebuf; 94 }; 95 96 struct nvhdr { 97 uint8_t nvh_type; 98 uint8_t nvh_namesize; 99 uint32_t nvh_dsize; 100 char nvh_name[0]; 101 } __packed; 102 #define NVH_DATA(nvh) ((unsigned char *)nvh + NVH_HSIZE(nvh)) 103 #define NVH_HSIZE(nvh) \ 104 (sizeof(struct nvhdr) + roundup2((nvh)->nvh_namesize, 8)) 105 #define NVH_DSIZE(nvh) \ 106 (((nvh)->nvh_type & NV_ORDER_MASK) == NV_ORDER_HOST ? \ 107 (nvh)->nvh_dsize : \ 108 le32toh((nvh)->nvh_dsize)) 109 #define NVH_SIZE(nvh) (NVH_HSIZE(nvh) + roundup2(NVH_DSIZE(nvh), 8)) 110 111 #define NV_CHECK(nv) do { \ 112 PJDLOG_ASSERT((nv) != NULL); \ 113 PJDLOG_ASSERT((nv)->nv_magic == NV_MAGIC); \ 114 } while (0) 115 116 static void nv_add(struct nv *nv, const unsigned char *value, size_t vsize, 117 int type, const char *name); 118 static void nv_addv(struct nv *nv, const unsigned char *value, size_t vsize, 119 int type, const char *namefmt, va_list nameap); 120 static struct nvhdr *nv_find(struct nv *nv, int type, const char *namefmt, 121 va_list nameap); 122 static void nv_swap(struct nvhdr *nvh, bool tohost); 123 124 /* 125 * Allocate and initialize new nv structure. 126 * Return NULL in case of malloc(3) failure. 127 */ 128 struct nv * 129 nv_alloc(void) 130 { 131 struct nv *nv; 132 133 nv = malloc(sizeof(*nv)); 134 if (nv == NULL) 135 return (NULL); 136 nv->nv_ebuf = ebuf_alloc(0); 137 if (nv->nv_ebuf == NULL) { 138 free(nv); 139 return (NULL); 140 } 141 nv->nv_error = 0; 142 nv->nv_magic = NV_MAGIC; 143 return (nv); 144 } 145 146 /* 147 * Free the given nv structure. 148 */ 149 void 150 nv_free(struct nv *nv) 151 { 152 153 if (nv == NULL) 154 return; 155 156 NV_CHECK(nv); 157 158 nv->nv_magic = 0; 159 ebuf_free(nv->nv_ebuf); 160 free(nv); 161 } 162 163 /* 164 * Return error for the given nv structure. 165 */ 166 int 167 nv_error(const struct nv *nv) 168 { 169 170 if (nv == NULL) 171 return (ENOMEM); 172 173 NV_CHECK(nv); 174 175 return (nv->nv_error); 176 } 177 178 /* 179 * Set error for the given nv structure and return previous error. 180 */ 181 int 182 nv_set_error(struct nv *nv, int error) 183 { 184 int preverr; 185 186 if (nv == NULL) 187 return (ENOMEM); 188 189 NV_CHECK(nv); 190 191 preverr = nv->nv_error; 192 nv->nv_error = error; 193 return (preverr); 194 } 195 196 /* 197 * Validate correctness of the entire nv structure and all its elements. 198 * If extrap is not NULL, store number of extra bytes at the end of the buffer. 199 */ 200 int 201 nv_validate(struct nv *nv, size_t *extrap) 202 { 203 struct nvhdr *nvh; 204 unsigned char *data, *ptr; 205 size_t dsize, size, vsize; 206 int error; 207 208 if (nv == NULL) { 209 errno = ENOMEM; 210 return (-1); 211 } 212 213 NV_CHECK(nv); 214 PJDLOG_ASSERT(nv->nv_error == 0); 215 216 /* TODO: Check that names are unique? */ 217 218 error = 0; 219 ptr = ebuf_data(nv->nv_ebuf, &size); 220 while (size > 0) { 221 /* 222 * Zeros at the end of the buffer are acceptable. 223 */ 224 if (ptr[0] == '\0') 225 break; 226 /* 227 * Minimum size at this point is size of nvhdr structure, one 228 * character long name plus terminating '\0'. 229 */ 230 if (size < sizeof(*nvh) + 2) { 231 error = EINVAL; 232 break; 233 } 234 nvh = (struct nvhdr *)ptr; 235 if (size < NVH_HSIZE(nvh)) { 236 error = EINVAL; 237 break; 238 } 239 if (nvh->nvh_name[nvh->nvh_namesize - 1] != '\0') { 240 error = EINVAL; 241 break; 242 } 243 if (strlen(nvh->nvh_name) != 244 (size_t)(nvh->nvh_namesize - 1)) { 245 error = EINVAL; 246 break; 247 } 248 if ((nvh->nvh_type & NV_TYPE_MASK) < NV_TYPE_FIRST || 249 (nvh->nvh_type & NV_TYPE_MASK) > NV_TYPE_LAST) { 250 error = EINVAL; 251 break; 252 } 253 dsize = NVH_DSIZE(nvh); 254 if (dsize == 0) { 255 error = EINVAL; 256 break; 257 } 258 if (size < NVH_SIZE(nvh)) { 259 error = EINVAL; 260 break; 261 } 262 vsize = 0; 263 switch (nvh->nvh_type & NV_TYPE_MASK) { 264 case NV_TYPE_INT8: 265 case NV_TYPE_UINT8: 266 if (vsize == 0) 267 vsize = 1; 268 /* FALLTHROUGH */ 269 case NV_TYPE_INT16: 270 case NV_TYPE_UINT16: 271 if (vsize == 0) 272 vsize = 2; 273 /* FALLTHROUGH */ 274 case NV_TYPE_INT32: 275 case NV_TYPE_UINT32: 276 if (vsize == 0) 277 vsize = 4; 278 /* FALLTHROUGH */ 279 case NV_TYPE_INT64: 280 case NV_TYPE_UINT64: 281 if (vsize == 0) 282 vsize = 8; 283 if (dsize != vsize) { 284 error = EINVAL; 285 break; 286 } 287 break; 288 case NV_TYPE_INT8_ARRAY: 289 case NV_TYPE_UINT8_ARRAY: 290 break; 291 case NV_TYPE_INT16_ARRAY: 292 case NV_TYPE_UINT16_ARRAY: 293 if (vsize == 0) 294 vsize = 2; 295 /* FALLTHROUGH */ 296 case NV_TYPE_INT32_ARRAY: 297 case NV_TYPE_UINT32_ARRAY: 298 if (vsize == 0) 299 vsize = 4; 300 /* FALLTHROUGH */ 301 case NV_TYPE_INT64_ARRAY: 302 case NV_TYPE_UINT64_ARRAY: 303 if (vsize == 0) 304 vsize = 8; 305 if ((dsize % vsize) != 0) { 306 error = EINVAL; 307 break; 308 } 309 break; 310 case NV_TYPE_STRING: 311 data = NVH_DATA(nvh); 312 if (data[dsize - 1] != '\0') { 313 error = EINVAL; 314 break; 315 } 316 if (strlen((char *)data) != dsize - 1) { 317 error = EINVAL; 318 break; 319 } 320 break; 321 default: 322 PJDLOG_ABORT("invalid condition"); 323 } 324 if (error != 0) 325 break; 326 ptr += NVH_SIZE(nvh); 327 size -= NVH_SIZE(nvh); 328 } 329 if (error != 0) { 330 errno = error; 331 if (nv->nv_error == 0) 332 nv->nv_error = error; 333 return (-1); 334 } 335 if (extrap != NULL) 336 *extrap = size; 337 return (0); 338 } 339 340 /* 341 * Convert the given nv structure to network byte order and return ebuf 342 * structure. 343 */ 344 struct ebuf * 345 nv_hton(struct nv *nv) 346 { 347 struct nvhdr *nvh; 348 unsigned char *ptr; 349 size_t size; 350 351 NV_CHECK(nv); 352 PJDLOG_ASSERT(nv->nv_error == 0); 353 354 ptr = ebuf_data(nv->nv_ebuf, &size); 355 while (size > 0) { 356 /* 357 * Minimum size at this point is size of nvhdr structure, 358 * one character long name plus terminating '\0'. 359 */ 360 PJDLOG_ASSERT(size >= sizeof(*nvh) + 2); 361 nvh = (struct nvhdr *)ptr; 362 PJDLOG_ASSERT(NVH_SIZE(nvh) <= size); 363 nv_swap(nvh, false); 364 ptr += NVH_SIZE(nvh); 365 size -= NVH_SIZE(nvh); 366 } 367 368 return (nv->nv_ebuf); 369 } 370 371 /* 372 * Create nv structure based on ebuf received from the network. 373 */ 374 struct nv * 375 nv_ntoh(struct ebuf *eb) 376 { 377 struct nv *nv; 378 size_t extra; 379 int rerrno; 380 381 PJDLOG_ASSERT(eb != NULL); 382 383 nv = malloc(sizeof(*nv)); 384 if (nv == NULL) 385 return (NULL); 386 nv->nv_error = 0; 387 nv->nv_ebuf = eb; 388 nv->nv_magic = NV_MAGIC; 389 390 if (nv_validate(nv, &extra) == -1) { 391 rerrno = errno; 392 nv->nv_magic = 0; 393 free(nv); 394 errno = rerrno; 395 return (NULL); 396 } 397 /* 398 * Remove extra zeros at the end of the buffer. 399 */ 400 ebuf_del_tail(eb, extra); 401 402 return (nv); 403 } 404 405 #define NV_DEFINE_ADD(type, TYPE) \ 406 void \ 407 nv_add_##type(struct nv *nv, type##_t value, const char *namefmt, ...) \ 408 { \ 409 va_list nameap; \ 410 \ 411 va_start(nameap, namefmt); \ 412 nv_addv(nv, (unsigned char *)&value, sizeof(value), \ 413 NV_TYPE_##TYPE, namefmt, nameap); \ 414 va_end(nameap); \ 415 } 416 417 NV_DEFINE_ADD(int8, INT8) 418 NV_DEFINE_ADD(uint8, UINT8) 419 NV_DEFINE_ADD(int16, INT16) 420 NV_DEFINE_ADD(uint16, UINT16) 421 NV_DEFINE_ADD(int32, INT32) 422 NV_DEFINE_ADD(uint32, UINT32) 423 NV_DEFINE_ADD(int64, INT64) 424 NV_DEFINE_ADD(uint64, UINT64) 425 426 #undef NV_DEFINE_ADD 427 428 #define NV_DEFINE_ADD_ARRAY(type, TYPE) \ 429 void \ 430 nv_add_##type##_array(struct nv *nv, const type##_t *value, \ 431 size_t nsize, const char *namefmt, ...) \ 432 { \ 433 va_list nameap; \ 434 \ 435 va_start(nameap, namefmt); \ 436 nv_addv(nv, (const unsigned char *)value, \ 437 sizeof(value[0]) * nsize, NV_TYPE_##TYPE##_ARRAY, namefmt, \ 438 nameap); \ 439 va_end(nameap); \ 440 } 441 442 NV_DEFINE_ADD_ARRAY(int8, INT8) 443 NV_DEFINE_ADD_ARRAY(uint8, UINT8) 444 NV_DEFINE_ADD_ARRAY(int16, INT16) 445 NV_DEFINE_ADD_ARRAY(uint16, UINT16) 446 NV_DEFINE_ADD_ARRAY(int32, INT32) 447 NV_DEFINE_ADD_ARRAY(uint32, UINT32) 448 NV_DEFINE_ADD_ARRAY(int64, INT64) 449 NV_DEFINE_ADD_ARRAY(uint64, UINT64) 450 451 #undef NV_DEFINE_ADD_ARRAY 452 453 void 454 nv_add_string(struct nv *nv, const char *value, const char *namefmt, ...) 455 { 456 va_list nameap; 457 size_t size; 458 459 size = strlen(value) + 1; 460 461 va_start(nameap, namefmt); 462 nv_addv(nv, (const unsigned char *)value, size, NV_TYPE_STRING, 463 namefmt, nameap); 464 va_end(nameap); 465 } 466 467 void 468 nv_add_stringf(struct nv *nv, const char *name, const char *valuefmt, ...) 469 { 470 va_list valueap; 471 472 va_start(valueap, valuefmt); 473 nv_add_stringv(nv, name, valuefmt, valueap); 474 va_end(valueap); 475 } 476 477 void 478 nv_add_stringv(struct nv *nv, const char *name, const char *valuefmt, 479 va_list valueap) 480 { 481 char *value; 482 ssize_t size; 483 484 size = vasprintf(&value, valuefmt, valueap); 485 if (size == -1) { 486 if (nv->nv_error == 0) 487 nv->nv_error = ENOMEM; 488 return; 489 } 490 size++; 491 nv_add(nv, (const unsigned char *)value, size, NV_TYPE_STRING, name); 492 free(value); 493 } 494 495 #define NV_DEFINE_GET(type, TYPE) \ 496 type##_t \ 497 nv_get_##type(struct nv *nv, const char *namefmt, ...) \ 498 { \ 499 struct nvhdr *nvh; \ 500 va_list nameap; \ 501 type##_t value; \ 502 \ 503 va_start(nameap, namefmt); \ 504 nvh = nv_find(nv, NV_TYPE_##TYPE, namefmt, nameap); \ 505 va_end(nameap); \ 506 if (nvh == NULL) \ 507 return (0); \ 508 PJDLOG_ASSERT((nvh->nvh_type & NV_ORDER_MASK) == NV_ORDER_HOST);\ 509 PJDLOG_ASSERT(sizeof(value) == nvh->nvh_dsize); \ 510 bcopy(NVH_DATA(nvh), &value, sizeof(value)); \ 511 \ 512 return (value); \ 513 } 514 515 NV_DEFINE_GET(int8, INT8) 516 NV_DEFINE_GET(uint8, UINT8) 517 NV_DEFINE_GET(int16, INT16) 518 NV_DEFINE_GET(uint16, UINT16) 519 NV_DEFINE_GET(int32, INT32) 520 NV_DEFINE_GET(uint32, UINT32) 521 NV_DEFINE_GET(int64, INT64) 522 NV_DEFINE_GET(uint64, UINT64) 523 524 #undef NV_DEFINE_GET 525 526 #define NV_DEFINE_GET_ARRAY(type, TYPE) \ 527 const type##_t * \ 528 nv_get_##type##_array(struct nv *nv, size_t *sizep, \ 529 const char *namefmt, ...) \ 530 { \ 531 struct nvhdr *nvh; \ 532 va_list nameap; \ 533 \ 534 va_start(nameap, namefmt); \ 535 nvh = nv_find(nv, NV_TYPE_##TYPE##_ARRAY, namefmt, nameap); \ 536 va_end(nameap); \ 537 if (nvh == NULL) \ 538 return (NULL); \ 539 PJDLOG_ASSERT((nvh->nvh_type & NV_ORDER_MASK) == NV_ORDER_HOST);\ 540 PJDLOG_ASSERT((nvh->nvh_dsize % sizeof(type##_t)) == 0); \ 541 if (sizep != NULL) \ 542 *sizep = nvh->nvh_dsize / sizeof(type##_t); \ 543 return ((type##_t *)(void *)NVH_DATA(nvh)); \ 544 } 545 546 NV_DEFINE_GET_ARRAY(int8, INT8) 547 NV_DEFINE_GET_ARRAY(uint8, UINT8) 548 NV_DEFINE_GET_ARRAY(int16, INT16) 549 NV_DEFINE_GET_ARRAY(uint16, UINT16) 550 NV_DEFINE_GET_ARRAY(int32, INT32) 551 NV_DEFINE_GET_ARRAY(uint32, UINT32) 552 NV_DEFINE_GET_ARRAY(int64, INT64) 553 NV_DEFINE_GET_ARRAY(uint64, UINT64) 554 555 #undef NV_DEFINE_GET_ARRAY 556 557 const char * 558 nv_get_string(struct nv *nv, const char *namefmt, ...) 559 { 560 struct nvhdr *nvh; 561 va_list nameap; 562 char *str; 563 564 va_start(nameap, namefmt); 565 nvh = nv_find(nv, NV_TYPE_STRING, namefmt, nameap); 566 va_end(nameap); 567 if (nvh == NULL) 568 return (NULL); 569 PJDLOG_ASSERT((nvh->nvh_type & NV_ORDER_MASK) == NV_ORDER_HOST); 570 PJDLOG_ASSERT(nvh->nvh_dsize >= 1); 571 str = (char *)NVH_DATA(nvh); 572 PJDLOG_ASSERT(str[nvh->nvh_dsize - 1] == '\0'); 573 PJDLOG_ASSERT(strlen(str) == nvh->nvh_dsize - 1); 574 return (str); 575 } 576 577 static bool 578 nv_vexists(struct nv *nv, const char *namefmt, va_list nameap) 579 { 580 struct nvhdr *nvh; 581 int snverror, serrno; 582 583 if (nv == NULL) 584 return (false); 585 586 serrno = errno; 587 snverror = nv->nv_error; 588 589 nvh = nv_find(nv, NV_TYPE_NONE, namefmt, nameap); 590 591 errno = serrno; 592 nv->nv_error = snverror; 593 594 return (nvh != NULL); 595 } 596 597 bool 598 nv_exists(struct nv *nv, const char *namefmt, ...) 599 { 600 va_list nameap; 601 bool ret; 602 603 va_start(nameap, namefmt); 604 ret = nv_vexists(nv, namefmt, nameap); 605 va_end(nameap); 606 607 return (ret); 608 } 609 610 void 611 nv_assert(struct nv *nv, const char *namefmt, ...) 612 { 613 va_list nameap; 614 615 va_start(nameap, namefmt); 616 PJDLOG_ASSERT(nv_vexists(nv, namefmt, nameap)); 617 va_end(nameap); 618 } 619 620 /* 621 * Dump content of the nv structure. 622 */ 623 void 624 nv_dump(struct nv *nv) 625 { 626 struct nvhdr *nvh; 627 unsigned char *data, *ptr; 628 size_t dsize, size; 629 unsigned int ii; 630 bool swap; 631 632 if (nv_validate(nv, NULL) == -1) { 633 printf("error: %d\n", errno); 634 return; 635 } 636 637 NV_CHECK(nv); 638 PJDLOG_ASSERT(nv->nv_error == 0); 639 640 ptr = ebuf_data(nv->nv_ebuf, &size); 641 while (size > 0) { 642 PJDLOG_ASSERT(size >= sizeof(*nvh) + 2); 643 nvh = (struct nvhdr *)ptr; 644 PJDLOG_ASSERT(size >= NVH_SIZE(nvh)); 645 swap = ((nvh->nvh_type & NV_ORDER_MASK) == NV_ORDER_NETWORK); 646 dsize = NVH_DSIZE(nvh); 647 data = NVH_DATA(nvh); 648 printf(" %s", nvh->nvh_name); 649 switch (nvh->nvh_type & NV_TYPE_MASK) { 650 case NV_TYPE_INT8: 651 printf("(int8): %jd", (intmax_t)(*(int8_t *)data)); 652 break; 653 case NV_TYPE_UINT8: 654 printf("(uint8): %ju", (uintmax_t)(*(uint8_t *)data)); 655 break; 656 case NV_TYPE_INT16: 657 printf("(int16): %jd", swap ? 658 (intmax_t)le16toh(*(int16_t *)(void *)data) : 659 (intmax_t)*(int16_t *)(void *)data); 660 break; 661 case NV_TYPE_UINT16: 662 printf("(uint16): %ju", swap ? 663 (uintmax_t)le16toh(*(uint16_t *)(void *)data) : 664 (uintmax_t)*(uint16_t *)(void *)data); 665 break; 666 case NV_TYPE_INT32: 667 printf("(int32): %jd", swap ? 668 (intmax_t)le32toh(*(int32_t *)(void *)data) : 669 (intmax_t)*(int32_t *)(void *)data); 670 break; 671 case NV_TYPE_UINT32: 672 printf("(uint32): %ju", swap ? 673 (uintmax_t)le32toh(*(uint32_t *)(void *)data) : 674 (uintmax_t)*(uint32_t *)(void *)data); 675 break; 676 case NV_TYPE_INT64: 677 printf("(int64): %jd", swap ? 678 (intmax_t)le64toh(*(int64_t *)(void *)data) : 679 (intmax_t)*(int64_t *)(void *)data); 680 break; 681 case NV_TYPE_UINT64: 682 printf("(uint64): %ju", swap ? 683 (uintmax_t)le64toh(*(uint64_t *)(void *)data) : 684 (uintmax_t)*(uint64_t *)(void *)data); 685 break; 686 case NV_TYPE_INT8_ARRAY: 687 printf("(int8 array):"); 688 for (ii = 0; ii < dsize; ii++) 689 printf(" %jd", (intmax_t)((int8_t *)data)[ii]); 690 break; 691 case NV_TYPE_UINT8_ARRAY: 692 printf("(uint8 array):"); 693 for (ii = 0; ii < dsize; ii++) 694 printf(" %ju", (uintmax_t)((uint8_t *)data)[ii]); 695 break; 696 case NV_TYPE_INT16_ARRAY: 697 printf("(int16 array):"); 698 for (ii = 0; ii < dsize / 2; ii++) { 699 printf(" %jd", swap ? 700 (intmax_t)le16toh(((int16_t *)(void *)data)[ii]) : 701 (intmax_t)((int16_t *)(void *)data)[ii]); 702 } 703 break; 704 case NV_TYPE_UINT16_ARRAY: 705 printf("(uint16 array):"); 706 for (ii = 0; ii < dsize / 2; ii++) { 707 printf(" %ju", swap ? 708 (uintmax_t)le16toh(((uint16_t *)(void *)data)[ii]) : 709 (uintmax_t)((uint16_t *)(void *)data)[ii]); 710 } 711 break; 712 case NV_TYPE_INT32_ARRAY: 713 printf("(int32 array):"); 714 for (ii = 0; ii < dsize / 4; ii++) { 715 printf(" %jd", swap ? 716 (intmax_t)le32toh(((int32_t *)(void *)data)[ii]) : 717 (intmax_t)((int32_t *)(void *)data)[ii]); 718 } 719 break; 720 case NV_TYPE_UINT32_ARRAY: 721 printf("(uint32 array):"); 722 for (ii = 0; ii < dsize / 4; ii++) { 723 printf(" %ju", swap ? 724 (uintmax_t)le32toh(((uint32_t *)(void *)data)[ii]) : 725 (uintmax_t)((uint32_t *)(void *)data)[ii]); 726 } 727 break; 728 case NV_TYPE_INT64_ARRAY: 729 printf("(int64 array):"); 730 for (ii = 0; ii < dsize / 8; ii++) { 731 printf(" %ju", swap ? 732 (uintmax_t)le64toh(((uint64_t *)(void *)data)[ii]) : 733 (uintmax_t)((uint64_t *)(void *)data)[ii]); 734 } 735 break; 736 case NV_TYPE_UINT64_ARRAY: 737 printf("(uint64 array):"); 738 for (ii = 0; ii < dsize / 8; ii++) { 739 printf(" %ju", swap ? 740 (uintmax_t)le64toh(((uint64_t *)(void *)data)[ii]) : 741 (uintmax_t)((uint64_t *)(void *)data)[ii]); 742 } 743 break; 744 case NV_TYPE_STRING: 745 printf("(string): %s", (char *)data); 746 break; 747 default: 748 PJDLOG_ABORT("invalid condition"); 749 } 750 printf("\n"); 751 ptr += NVH_SIZE(nvh); 752 size -= NVH_SIZE(nvh); 753 } 754 } 755 756 /* 757 * Local routines below. 758 */ 759 760 static void 761 nv_add(struct nv *nv, const unsigned char *value, size_t vsize, int type, 762 const char *name) 763 { 764 static unsigned char align[7]; 765 struct nvhdr *nvh; 766 size_t namesize; 767 768 if (nv == NULL) { 769 errno = ENOMEM; 770 return; 771 } 772 773 NV_CHECK(nv); 774 775 namesize = strlen(name) + 1; 776 777 nvh = malloc(sizeof(*nvh) + roundup2(namesize, 8)); 778 if (nvh == NULL) { 779 if (nv->nv_error == 0) 780 nv->nv_error = ENOMEM; 781 return; 782 } 783 nvh->nvh_type = NV_ORDER_HOST | type; 784 nvh->nvh_namesize = (uint8_t)namesize; 785 nvh->nvh_dsize = (uint32_t)vsize; 786 bcopy(name, nvh->nvh_name, namesize); 787 788 /* Add header first. */ 789 if (ebuf_add_tail(nv->nv_ebuf, nvh, NVH_HSIZE(nvh)) == -1) { 790 PJDLOG_ASSERT(errno != 0); 791 if (nv->nv_error == 0) 792 nv->nv_error = errno; 793 free(nvh); 794 return; 795 } 796 free(nvh); 797 /* Add the actual data. */ 798 if (ebuf_add_tail(nv->nv_ebuf, value, vsize) == -1) { 799 PJDLOG_ASSERT(errno != 0); 800 if (nv->nv_error == 0) 801 nv->nv_error = errno; 802 return; 803 } 804 /* Align the data (if needed). */ 805 vsize = roundup2(vsize, 8) - vsize; 806 if (vsize == 0) 807 return; 808 PJDLOG_ASSERT(vsize > 0 && vsize <= sizeof(align)); 809 if (ebuf_add_tail(nv->nv_ebuf, align, vsize) == -1) { 810 PJDLOG_ASSERT(errno != 0); 811 if (nv->nv_error == 0) 812 nv->nv_error = errno; 813 return; 814 } 815 } 816 817 static void 818 nv_addv(struct nv *nv, const unsigned char *value, size_t vsize, int type, 819 const char *namefmt, va_list nameap) 820 { 821 char name[255]; 822 size_t namesize; 823 824 namesize = vsnprintf(name, sizeof(name), namefmt, nameap); 825 PJDLOG_ASSERT(namesize > 0 && namesize < sizeof(name)); 826 827 nv_add(nv, value, vsize, type, name); 828 } 829 830 static struct nvhdr * 831 nv_find(struct nv *nv, int type, const char *namefmt, va_list nameap) 832 { 833 char name[255]; 834 struct nvhdr *nvh; 835 unsigned char *ptr; 836 size_t size, namesize; 837 838 if (nv == NULL) { 839 errno = ENOMEM; 840 return (NULL); 841 } 842 843 NV_CHECK(nv); 844 845 namesize = vsnprintf(name, sizeof(name), namefmt, nameap); 846 PJDLOG_ASSERT(namesize > 0 && namesize < sizeof(name)); 847 namesize++; 848 849 ptr = ebuf_data(nv->nv_ebuf, &size); 850 while (size > 0) { 851 PJDLOG_ASSERT(size >= sizeof(*nvh) + 2); 852 nvh = (struct nvhdr *)ptr; 853 PJDLOG_ASSERT(size >= NVH_SIZE(nvh)); 854 nv_swap(nvh, true); 855 if (strcmp(nvh->nvh_name, name) == 0) { 856 if (type != NV_TYPE_NONE && 857 (nvh->nvh_type & NV_TYPE_MASK) != type) { 858 errno = EINVAL; 859 if (nv->nv_error == 0) 860 nv->nv_error = EINVAL; 861 return (NULL); 862 } 863 return (nvh); 864 } 865 ptr += NVH_SIZE(nvh); 866 size -= NVH_SIZE(nvh); 867 } 868 errno = ENOENT; 869 if (nv->nv_error == 0) 870 nv->nv_error = ENOENT; 871 return (NULL); 872 } 873 874 static void 875 nv_swap(struct nvhdr *nvh, bool tohost) 876 { 877 unsigned char *data, *end, *p; 878 size_t vsize; 879 880 data = NVH_DATA(nvh); 881 if (tohost) { 882 if ((nvh->nvh_type & NV_ORDER_MASK) == NV_ORDER_HOST) 883 return; 884 nvh->nvh_dsize = le32toh(nvh->nvh_dsize); 885 end = data + nvh->nvh_dsize; 886 nvh->nvh_type &= ~NV_ORDER_MASK; 887 nvh->nvh_type |= NV_ORDER_HOST; 888 } else { 889 if ((nvh->nvh_type & NV_ORDER_MASK) == NV_ORDER_NETWORK) 890 return; 891 end = data + nvh->nvh_dsize; 892 nvh->nvh_dsize = htole32(nvh->nvh_dsize); 893 nvh->nvh_type &= ~NV_ORDER_MASK; 894 nvh->nvh_type |= NV_ORDER_NETWORK; 895 } 896 897 vsize = 0; 898 899 switch (nvh->nvh_type & NV_TYPE_MASK) { 900 case NV_TYPE_INT8: 901 case NV_TYPE_UINT8: 902 case NV_TYPE_INT8_ARRAY: 903 case NV_TYPE_UINT8_ARRAY: 904 break; 905 case NV_TYPE_INT16: 906 case NV_TYPE_UINT16: 907 case NV_TYPE_INT16_ARRAY: 908 case NV_TYPE_UINT16_ARRAY: 909 if (vsize == 0) 910 vsize = 2; 911 /* FALLTHROUGH */ 912 case NV_TYPE_INT32: 913 case NV_TYPE_UINT32: 914 case NV_TYPE_INT32_ARRAY: 915 case NV_TYPE_UINT32_ARRAY: 916 if (vsize == 0) 917 vsize = 4; 918 /* FALLTHROUGH */ 919 case NV_TYPE_INT64: 920 case NV_TYPE_UINT64: 921 case NV_TYPE_INT64_ARRAY: 922 case NV_TYPE_UINT64_ARRAY: 923 if (vsize == 0) 924 vsize = 8; 925 for (p = data; p < end; p += vsize) { 926 if (tohost) { 927 switch (vsize) { 928 case 2: 929 *(uint16_t *)(void *)p = 930 le16toh(*(uint16_t *)(void *)p); 931 break; 932 case 4: 933 *(uint32_t *)(void *)p = 934 le32toh(*(uint32_t *)(void *)p); 935 break; 936 case 8: 937 *(uint64_t *)(void *)p = 938 le64toh(*(uint64_t *)(void *)p); 939 break; 940 default: 941 PJDLOG_ABORT("invalid condition"); 942 } 943 } else { 944 switch (vsize) { 945 case 2: 946 *(uint16_t *)(void *)p = 947 htole16(*(uint16_t *)(void *)p); 948 break; 949 case 4: 950 *(uint32_t *)(void *)p = 951 htole32(*(uint32_t *)(void *)p); 952 break; 953 case 8: 954 *(uint64_t *)(void *)p = 955 htole64(*(uint64_t *)(void *)p); 956 break; 957 default: 958 PJDLOG_ABORT("invalid condition"); 959 } 960 } 961 } 962 break; 963 case NV_TYPE_STRING: 964 break; 965 default: 966 PJDLOG_ABORT("unrecognized type"); 967 } 968 } 969