1 /*- 2 * Copyright (c) 2015-2016 Landon Fuller <landonf@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer, 10 * without modification. 11 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 12 * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any 13 * redistribution must be conditioned upon including a substantially 14 * similar Disclaimer requirement for further binary redistribution. 15 * 16 * NO WARRANTY 17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY 20 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 21 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, 22 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 27 * THE POSSIBILITY OF SUCH DAMAGES. 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 #include <sys/param.h> 34 #include <sys/sbuf.h> 35 36 #ifdef _KERNEL 37 38 #include <sys/ctype.h> 39 #include <sys/kernel.h> 40 #include <sys/malloc.h> 41 #include <sys/systm.h> 42 43 #include <machine/_inttypes.h> 44 45 #else /* !_KERNEL */ 46 47 #include <ctype.h> 48 #include <inttypes.h> 49 #include <errno.h> 50 #include <stdlib.h> 51 #include <string.h> 52 53 #endif /* _KERNEL */ 54 55 #include "bhnd_nvram_private.h" 56 #include "bhnd_nvram_valuevar.h" 57 58 #ifdef _KERNEL 59 #define bhnd_nv_hex2ascii(hex) hex2ascii(hex) 60 #else /* !_KERNEL */ 61 static char const bhnd_nv_hex2ascii[] = "0123456789abcdefghijklmnopqrstuvwxyz"; 62 #define bhnd_nv_hex2ascii(hex) (bhnd_nv_hex2ascii[hex]) 63 #endif /* _KERNEL */ 64 65 /** 66 * Maximum size, in bytes, of a string-encoded NVRAM integer value, not 67 * including any prefix (0x, 0, etc). 68 * 69 * We assume the largest possible encoding is the base-2 representation 70 * of a 64-bit integer. 71 */ 72 #define NV_NUMSTR_MAX ((sizeof(uint64_t) * CHAR_BIT) + 1) 73 74 /** 75 * Format a string representation of @p value using @p fmt, with, writing the 76 * result to @p outp. 77 * 78 * @param value The value to be formatted. 79 * @param fmt The format string. 80 * @param[out] outp On success, the string will be written to this 81 * buffer. This argment may be NULL if the value is 82 * not desired. 83 * @param[in,out] olen The capacity of @p outp. On success, will be set 84 * to the actual number of bytes required for the 85 * requested string encoding (including a trailing 86 * NUL). 87 * 88 * Refer to bhnd_nvram_val_vprintf() for full format string documentation. 89 * 90 * @retval 0 success 91 * @retval EINVAL If @p fmt contains unrecognized format string 92 * specifiers. 93 * @retval ENOMEM If the @p outp is non-NULL, and the provided @p olen 94 * is too small to hold the encoded value. 95 * @retval EFTYPE If value coercion from @p value to a single string 96 * value via @p fmt is unsupported. 97 * @retval ERANGE If value coercion of @p value would overflow (or 98 * underflow) the representation defined by @p fmt. 99 */ 100 int 101 bhnd_nvram_val_printf(bhnd_nvram_val *value, const char *fmt, char *outp, 102 size_t *olen, ...) 103 { 104 va_list ap; 105 int error; 106 107 va_start(ap, olen); 108 error = bhnd_nvram_val_vprintf(value, fmt, outp, olen, ap); 109 va_end(ap); 110 111 return (error); 112 } 113 114 115 /** 116 * Format a string representation of the elements of @p value using @p fmt, 117 * writing the result to @p outp. 118 * 119 * @param value The value to be formatted. 120 * @param fmt The format string. 121 * @param[out] outp On success, the string will be written to this 122 * buffer. This argment may be NULL if the value is 123 * not desired. 124 * @param[in,out] olen The capacity of @p outp. On success, will be set 125 * to the actual number of bytes required for the 126 * requested string encoding (including a trailing 127 * NUL). 128 * @param ap Argument list. 129 * 130 * @par Format Strings 131 * 132 * Value format strings are similar, but not identical to, those used 133 * by printf(3). 134 * 135 * Format specifier format: 136 * %[repeat][flags][width][.precision][length modifier][specifier] 137 * 138 * The format specifier is interpreted as an encoding directive for an 139 * individual value element; each format specifier will fetch the next element 140 * from the value, encode the element as the appropriate type based on the 141 * length modifiers and specifier, and then format the result as a string. 142 * 143 * For example, given a string value of '0x000F', and a format specifier of 144 * '%#hhx', the value will be asked to encode its first element as 145 * BHND_NVRAM_TYPE_UINT8. String formatting will then be applied to the 8-bit 146 * unsigned integer representation, producing a string value of "0xF". 147 * 148 * Repeat: 149 * - [digits] Repeatedly apply the format specifier to the input 150 * value's elements up to `digits` times. The delimiter 151 * must be passed as a string in the next variadic 152 * argument. 153 * - [] Repeatedly apply the format specifier to the input 154 * value's elements until all elements have been. The 155 * processed. The delimiter must be passed as a string in 156 * the next variadic argument. 157 * - [*] Repeatedly apply the format specifier to the input 158 * value's elements. The repeat count is read from the 159 * next variadic argument as a size_t value 160 * 161 * Flags: 162 * - '#' use alternative form (e.g. 0x/0X prefixing of hex 163 * strings). 164 * - '0' zero padding 165 * - '-' left adjust padding 166 * - '+' include a sign character 167 * - ' ' include a space in place of a sign character for 168 * positive numbers. 169 * 170 * Width/Precision: 171 * - digits minimum field width. 172 * - * read the minimum field width from the next variadic 173 * argument as a ssize_t value. A negative value enables 174 * left adjustment. 175 * - .digits field precision. 176 * - .* read the field precision from the next variadic argument 177 * as a ssize_t value. A negative value enables left 178 * adjustment. 179 * 180 * Length Modifiers: 181 * - 'hh', 'I8' Convert the value to an 8-bit signed or unsigned 182 * integer. 183 * - 'h', 'I16' Convert the value to an 16-bit signed or unsigned 184 * integer. 185 * - 'l', 'I32' Convert the value to an 32-bit signed or unsigned 186 * integer. 187 * - 'll', 'j', 'I64' Convert the value to an 64-bit signed or unsigned 188 * integer. 189 * 190 * Data Specifiers: 191 * - 'd', 'i' Convert and format as a signed decimal integer. 192 * - 'u' Convert and format as an unsigned decimal integer. 193 * - 'o' Convert and format as an unsigned octal integer. 194 * - 'x' Convert and format as an unsigned hexadecimal integer, 195 * using lowercase hex digits. 196 * - 'X' Convert and format as an unsigned hexadecimal integer, 197 * using uppercase hex digits. 198 * - 's' Convert and format as a string. 199 * - '%' Print a literal '%' character. 200 * 201 * @retval 0 success 202 * @retval EINVAL If @p fmt contains unrecognized format string 203 * specifiers. 204 * @retval ENOMEM If the @p outp is non-NULL, and the provided @p olen 205 * is too small to hold the encoded value. 206 * @retval EFTYPE If value coercion from @p value to a single string 207 * value via @p fmt is unsupported. 208 * @retval ERANGE If value coercion of @p value would overflow (or 209 * underflow) the representation defined by @p fmt. 210 */ 211 int 212 bhnd_nvram_val_vprintf(bhnd_nvram_val *value, const char *fmt, char *outp, 213 size_t *olen, va_list ap) 214 { 215 const void *elem; 216 size_t elen; 217 size_t limit, nbytes; 218 int error; 219 220 elem = NULL; 221 222 /* Determine output byte limit */ 223 nbytes = 0; 224 if (outp != NULL) 225 limit = *olen; 226 else 227 limit = 0; 228 229 #define WRITE_CHAR(_c) do { \ 230 if (limit > nbytes) \ 231 *(outp + nbytes) = _c; \ 232 \ 233 if (nbytes == SIZE_MAX) \ 234 return (EFTYPE); \ 235 nbytes++; \ 236 } while (0) 237 238 /* Encode string value as per the format string */ 239 for (const char *p = fmt; *p != '\0'; p++) { 240 const char *delim; 241 size_t precision, width, delim_len; 242 u_long repeat, bits; 243 bool alt_form, ladjust, have_precision; 244 char padc, signc, lenc; 245 246 padc = ' '; 247 signc = '\0'; 248 lenc = '\0'; 249 delim = ""; 250 delim_len = 0; 251 252 ladjust = false; 253 alt_form = false; 254 255 have_precision = false; 256 precision = 1; 257 bits = 32; 258 width = 0; 259 repeat = 1; 260 261 /* Copy all input to output until we hit a format specifier */ 262 if (*p != '%') { 263 WRITE_CHAR(*p); 264 continue; 265 } 266 267 /* Hit '%' -- is this followed by an escaped '%' literal? */ 268 p++; 269 if (*p == '%') { 270 WRITE_CHAR('%'); 271 p++; 272 continue; 273 } 274 275 /* Parse repeat specifier */ 276 if (*p == '[') { 277 p++; 278 279 /* Determine repeat count */ 280 if (*p == ']') { 281 /* Repeat consumes all input */ 282 repeat = bhnd_nvram_val_nelem(value); 283 } else if (*p == '*') { 284 /* Repeat is supplied as an argument */ 285 repeat = va_arg(ap, size_t); 286 p++; 287 } else { 288 char *endp; 289 290 /* Repeat specified as argument */ 291 repeat = strtoul(p, &endp, 10); 292 if (p == endp) { 293 BHND_NV_LOG("error parsing repeat " 294 "count at '%s'", p); 295 return (EINVAL); 296 } 297 298 /* Advance past repeat count */ 299 p = endp; 300 } 301 302 /* Advance past terminating ']' */ 303 if (*p != ']') { 304 BHND_NV_LOG("error parsing repeat count at " 305 "'%s'", p); 306 return (EINVAL); 307 } 308 p++; 309 310 delim = va_arg(ap, const char *); 311 delim_len = strlen(delim); 312 } 313 314 /* Parse flags */ 315 while (*p != '\0') { 316 const char *np; 317 bool stop; 318 319 stop = false; 320 np = p+1; 321 322 switch (*p) { 323 case '#': 324 alt_form = true; 325 break; 326 case '0': 327 padc = '0'; 328 break; 329 case '-': 330 ladjust = true; 331 break; 332 case ' ': 333 /* Must not override '+' */ 334 if (signc != '+') 335 signc = ' '; 336 break; 337 case '+': 338 signc = '+'; 339 break; 340 default: 341 /* Non-flag character */ 342 stop = true; 343 break; 344 } 345 346 if (stop) 347 break; 348 else 349 p = np; 350 } 351 352 /* Parse minimum width */ 353 if (*p == '*') { 354 ssize_t arg; 355 356 /* Width is supplied as an argument */ 357 arg = va_arg(ap, int); 358 359 /* Negative width argument is interpreted as 360 * '-' flag followed by positive width */ 361 if (arg < 0) { 362 ladjust = true; 363 arg = -arg; 364 } 365 366 width = arg; 367 p++; 368 } else if (bhnd_nv_isdigit(*p)) { 369 uint32_t v; 370 size_t len, parsed; 371 372 /* Parse width value */ 373 len = sizeof(v); 374 error = bhnd_nvram_parse_int(p, strlen(p), 10, &parsed, 375 &v, &len, BHND_NVRAM_TYPE_UINT32); 376 if (error) { 377 BHND_NV_LOG("error parsing width %s: %d\n", p, 378 error); 379 return (EINVAL); 380 } 381 382 /* Save width and advance input */ 383 width = v; 384 p += parsed; 385 } 386 387 /* Parse precision */ 388 if (*p == '.') { 389 uint32_t v; 390 size_t len, parsed; 391 392 p++; 393 have_precision = true; 394 395 if (*p == '*') { 396 ssize_t arg; 397 398 /* Precision is specified as an argument */ 399 arg = va_arg(ap, int); 400 401 /* Negative precision argument is interpreted 402 * as '-' flag followed by positive 403 * precision */ 404 if (arg < 0) { 405 ladjust = true; 406 arg = -arg; 407 } 408 409 precision = arg; 410 } else if (!bhnd_nv_isdigit(*p)) { 411 /* Implicit precision of 0 */ 412 precision = 0; 413 } else { 414 /* Parse precision value */ 415 len = sizeof(v); 416 error = bhnd_nvram_parse_int(p, strlen(p), 10, 417 &parsed, &v, &len, 418 BHND_NVRAM_TYPE_UINT32); 419 if (error) { 420 BHND_NV_LOG("error parsing width %s: " 421 "%d\n", p, error); 422 return (EINVAL); 423 } 424 425 /* Save precision and advance input */ 426 precision = v; 427 p += parsed; 428 } 429 } 430 431 /* Parse length modifiers */ 432 while (*p != '\0') { 433 const char *np; 434 bool stop; 435 436 stop = false; 437 np = p+1; 438 439 switch (*p) { 440 case 'h': 441 if (lenc == '\0') { 442 /* Set initial length value */ 443 lenc = *p; 444 bits = 16; 445 } else if (lenc == *p && bits == 16) { 446 /* Modify previous length value */ 447 bits = 8; 448 } else { 449 BHND_NV_LOG("invalid length modifier " 450 "%c\n", *p); 451 return (EINVAL); 452 } 453 break; 454 455 case 'l': 456 if (lenc == '\0') { 457 /* Set initial length value */ 458 lenc = *p; 459 bits = 32; 460 } else if (lenc == *p && bits == 32) { 461 /* Modify previous length value */ 462 bits = 64; 463 } else { 464 BHND_NV_LOG("invalid length modifier " 465 "%c\n", *p); 466 return (EINVAL); 467 } 468 break; 469 470 case 'j': 471 /* Conflicts with all other length 472 * specifications, and may only occur once */ 473 if (lenc != '\0') { 474 BHND_NV_LOG("invalid length modifier " 475 "%c\n", *p); 476 return (EINVAL); 477 } 478 479 lenc = *p; 480 bits = 64; 481 break; 482 483 case 'I': { 484 char *endp; 485 486 /* Conflicts with all other length 487 * specifications, and may only occur once */ 488 if (lenc != '\0') { 489 BHND_NV_LOG("invalid length modifier " 490 "%c\n", *p); 491 return (EINVAL); 492 } 493 494 lenc = *p; 495 496 /* Parse the length specifier value */ 497 p++; 498 bits = strtoul(p, &endp, 10); 499 if (p == endp) { 500 BHND_NV_LOG("invalid size specifier: " 501 "%s\n", p); 502 return (EINVAL); 503 } 504 505 /* Advance input past the parsed integer */ 506 np = endp; 507 break; 508 } 509 default: 510 /* Non-length modifier character */ 511 stop = true; 512 break; 513 } 514 515 if (stop) 516 break; 517 else 518 p = np; 519 } 520 521 /* Parse conversion specifier and format the value(s) */ 522 for (u_long n = 0; n < repeat; n++) { 523 bhnd_nvram_type arg_type; 524 size_t arg_size; 525 size_t i; 526 u_long base; 527 bool is_signed, is_upper; 528 529 is_signed = false; 530 is_upper = false; 531 base = 0; 532 533 /* Fetch next element */ 534 elem = bhnd_nvram_val_next(value, elem, &elen); 535 if (elem == NULL) { 536 BHND_NV_LOG("format string references more " 537 "than %zu available value elements\n", 538 bhnd_nvram_val_nelem(value)); 539 return (EINVAL); 540 } 541 542 /* 543 * If this is not the first value, append the delimiter. 544 */ 545 if (n > 0) { 546 size_t nremain = 0; 547 if (limit > nbytes) 548 nremain = limit - nbytes; 549 550 if (nremain >= delim_len) 551 memcpy(outp + nbytes, delim, delim_len); 552 553 /* Add delimiter length to the total byte count */ 554 if (SIZE_MAX - nbytes < delim_len) 555 return (EFTYPE); /* overflows size_t */ 556 557 nbytes += delim_len; 558 } 559 560 /* Parse integer conversion specifiers */ 561 switch (*p) { 562 case 'd': 563 case 'i': 564 base = 10; 565 is_signed = true; 566 break; 567 568 case 'u': 569 base = 10; 570 break; 571 572 case 'o': 573 base = 8; 574 break; 575 576 case 'x': 577 base = 16; 578 break; 579 580 case 'X': 581 base = 16; 582 is_upper = true; 583 break; 584 } 585 586 /* Format argument */ 587 switch (*p) { 588 #define NV_ENCODE_INT(_width) do { \ 589 arg_type = (is_signed) ? BHND_NVRAM_TYPE_INT ## _width : \ 590 BHND_NVRAM_TYPE_UINT ## _width; \ 591 arg_size = sizeof(v.u ## _width); \ 592 error = bhnd_nvram_val_encode_elem(value, elem, elen, \ 593 &v.u ## _width, &arg_size, arg_type); \ 594 if (error) { \ 595 BHND_NV_LOG("error encoding argument as %s: %d\n", \ 596 bhnd_nvram_type_name(arg_type), error); \ 597 return (error); \ 598 } \ 599 \ 600 if (is_signed) { \ 601 if (v.i ## _width < 0) { \ 602 add_neg = true; \ 603 numval = (int64_t)-(v.i ## _width); \ 604 } else { \ 605 numval = (int64_t) (v.i ## _width); \ 606 } \ 607 } else { \ 608 numval = v.u ## _width; \ 609 } \ 610 } while(0) 611 case 'd': 612 case 'i': 613 case 'u': 614 case 'o': 615 case 'x': 616 case 'X': { 617 char numbuf[NV_NUMSTR_MAX]; 618 char *sptr; 619 uint64_t numval; 620 size_t slen; 621 bool add_neg; 622 union { 623 uint8_t u8; 624 uint16_t u16; 625 uint32_t u32; 626 uint64_t u64; 627 int8_t i8; 628 int16_t i16; 629 int32_t i32; 630 int64_t i64; 631 } v; 632 633 add_neg = false; 634 635 /* If precision is specified, it overrides 636 * (and behaves identically) to a zero-prefixed 637 * minimum width */ 638 if (have_precision) { 639 padc = '0'; 640 width = precision; 641 ladjust = false; 642 } 643 644 /* If zero-padding is used, value must be right 645 * adjusted */ 646 if (padc == '0') 647 ladjust = false; 648 649 /* Request encode to the appropriate integer 650 * type, and then promote to common 64-bit 651 * representation */ 652 switch (bits) { 653 case 8: 654 NV_ENCODE_INT(8); 655 break; 656 case 16: 657 NV_ENCODE_INT(16); 658 break; 659 case 32: 660 NV_ENCODE_INT(32); 661 break; 662 case 64: 663 NV_ENCODE_INT(64); 664 break; 665 default: 666 BHND_NV_LOG("invalid length specifier: " 667 "%lu\n", bits); 668 return (EINVAL); 669 } 670 #undef NV_ENCODE_INT 671 672 /* If a precision of 0 is specified and the 673 * value is also zero, no characters should 674 * be produced */ 675 if (have_precision && precision == 0 && 676 numval == 0) 677 { 678 break; 679 } 680 681 /* Emit string representation to local buffer */ 682 BHND_NV_ASSERT(base <= 16, ("invalid base")); 683 sptr = numbuf + nitems(numbuf) - 1; 684 for (slen = 0; slen < sizeof(numbuf); slen++) { 685 char c; 686 uint64_t n; 687 688 n = numval % base; 689 c = bhnd_nv_hex2ascii(n); 690 if (is_upper) 691 c = bhnd_nv_toupper(c); 692 693 sptr--; 694 *sptr = c; 695 696 numval /= (uint64_t)base; 697 if (numval == 0) { 698 slen++; 699 break; 700 } 701 } 702 703 arg_size = slen; 704 705 /* Reserve space for 0/0x prefix? */ 706 if (alt_form) { 707 if (numval == 0) { 708 /* If 0, no prefix */ 709 alt_form = false; 710 } else if (base == 8) { 711 arg_size += 1; /* 0 */ 712 } else if (base == 16) { 713 arg_size += 2; /* 0x/0X */ 714 } 715 } 716 717 /* Reserve space for ' ', '+', or '-' prefix? */ 718 if (add_neg || signc != '\0') { 719 if (add_neg) 720 signc = '-'; 721 722 arg_size++; 723 } 724 725 /* Right adjust (if using spaces) */ 726 if (!ladjust && padc != '0') { 727 for (i = arg_size; i < width; i++) 728 WRITE_CHAR(padc); 729 } 730 731 if (signc != '\0') 732 WRITE_CHAR(signc); 733 734 if (alt_form) { 735 if (base == 8) { 736 WRITE_CHAR('0'); 737 } else if (base == 16) { 738 WRITE_CHAR('0'); 739 if (is_upper) 740 WRITE_CHAR('X'); 741 else 742 WRITE_CHAR('x'); 743 } 744 } 745 746 /* Right adjust (if using zeros) */ 747 if (!ladjust && padc == '0') { 748 for (i = slen; i < width; i++) 749 WRITE_CHAR(padc); 750 } 751 752 /* Write the string to our output buffer */ 753 if (limit > nbytes && limit - nbytes >= slen) 754 memcpy(outp + nbytes, sptr, slen); 755 756 /* Update the total byte count */ 757 if (SIZE_MAX - nbytes < arg_size) 758 return (EFTYPE); /* overflows size_t */ 759 760 nbytes += arg_size; 761 762 /* Left adjust */ 763 for (i = arg_size; ladjust && i < width; i++) 764 WRITE_CHAR(padc); 765 766 break; 767 } 768 769 case 's': { 770 char *s; 771 size_t slen; 772 773 /* Query the total length of the element when 774 * converted to a string */ 775 arg_type = BHND_NVRAM_TYPE_STRING; 776 error = bhnd_nvram_val_encode_elem(value, elem, 777 elen, NULL, &arg_size, arg_type); 778 if (error) { 779 BHND_NV_LOG("error encoding argument " 780 "as %s: %d\n", 781 bhnd_nvram_type_name(arg_type), 782 error); 783 return (error); 784 } 785 786 /* Do not include trailing NUL in the string 787 * length */ 788 if (arg_size > 0) 789 arg_size--; 790 791 /* Right adjust */ 792 for (i = arg_size; !ladjust && i < width; i++) 793 WRITE_CHAR(padc); 794 795 /* Determine output positition and remaining 796 * buffer space */ 797 if (limit > nbytes) { 798 s = outp + nbytes; 799 slen = limit - nbytes; 800 } else { 801 s = NULL; 802 slen = 0; 803 } 804 805 /* Encode the string to our output buffer */ 806 error = bhnd_nvram_val_encode_elem(value, elem, 807 elen, s, &slen, arg_type); 808 if (error && error != ENOMEM) { 809 BHND_NV_LOG("error encoding argument " 810 "as %s: %d\n", 811 bhnd_nvram_type_name(arg_type), 812 error); 813 return (error); 814 } 815 816 /* Update the total byte count */ 817 if (SIZE_MAX - nbytes < arg_size) 818 return (EFTYPE); /* overflows size_t */ 819 820 nbytes += arg_size; 821 822 /* Left adjust */ 823 for (i = arg_size; ladjust && i < width; i++) 824 WRITE_CHAR(padc); 825 826 break; 827 } 828 829 case 'c': { 830 char c; 831 832 arg_type = BHND_NVRAM_TYPE_CHAR; 833 arg_size = bhnd_nvram_type_width(arg_type); 834 835 /* Encode as single character */ 836 error = bhnd_nvram_val_encode_elem(value, elem, 837 elen, &c, &arg_size, arg_type); 838 if (error) { 839 BHND_NV_LOG("error encoding argument " 840 "as %s: %d\n", 841 bhnd_nvram_type_name(arg_type), 842 error); 843 return (error); 844 } 845 846 BHND_NV_ASSERT(arg_size == sizeof(c), 847 ("invalid encoded size")); 848 849 /* Right adjust */ 850 for (i = arg_size; !ladjust && i < width; i++) 851 WRITE_CHAR(padc); 852 853 WRITE_CHAR(padc); 854 855 /* Left adjust */ 856 for (i = arg_size; ladjust && i < width; i++) 857 WRITE_CHAR(padc); 858 859 break; 860 } 861 } 862 } 863 } 864 865 /* Append terminating NUL */ 866 if (limit > nbytes) 867 *(outp + nbytes) = '\0'; 868 869 if (nbytes < SIZE_MAX) 870 nbytes++; 871 else 872 return (EFTYPE); 873 874 /* Report required space */ 875 *olen = nbytes; 876 if (limit < nbytes) { 877 if (outp != NULL) 878 return (ENOMEM); 879 } 880 881 return (0); 882 } 883