1 /* 2 * linux/lib/vsprintf.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7 /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */ 8 /* 9 * Wirzenius wrote this portably, Torvalds fucked it up :-) 10 */ 11 12 /* 13 * Fri Jul 13 2001 Crutcher Dunnavant <crutcher+kernel@datastacks.com> 14 * - changed to provide snprintf and vsnprintf functions 15 * So Feb 1 16:51:32 CET 2004 Juergen Quade <quade@hsnr.de> 16 * - scnprintf and vscnprintf 17 */ 18 19 #include <stdarg.h> 20 #include <linux/module.h> 21 #include <linux/types.h> 22 #include <linux/string.h> 23 #include <linux/ctype.h> 24 #include <linux/kernel.h> 25 26 #include <asm/div64.h> 27 28 /** 29 * simple_strtoul - convert a string to an unsigned long 30 * @cp: The start of the string 31 * @endp: A pointer to the end of the parsed string will be placed here 32 * @base: The number base to use 33 */ 34 unsigned long simple_strtoul(const char *cp,char **endp,unsigned int base) 35 { 36 unsigned long result = 0,value; 37 38 if (!base) { 39 base = 10; 40 if (*cp == '0') { 41 base = 8; 42 cp++; 43 if ((toupper(*cp) == 'X') && isxdigit(cp[1])) { 44 cp++; 45 base = 16; 46 } 47 } 48 } else if (base == 16) { 49 if (cp[0] == '0' && toupper(cp[1]) == 'X') 50 cp += 2; 51 } 52 while (isxdigit(*cp) && 53 (value = isdigit(*cp) ? *cp-'0' : toupper(*cp)-'A'+10) < base) { 54 result = result*base + value; 55 cp++; 56 } 57 if (endp) 58 *endp = (char *)cp; 59 return result; 60 } 61 62 EXPORT_SYMBOL(simple_strtoul); 63 64 /** 65 * simple_strtol - convert a string to a signed long 66 * @cp: The start of the string 67 * @endp: A pointer to the end of the parsed string will be placed here 68 * @base: The number base to use 69 */ 70 long simple_strtol(const char *cp,char **endp,unsigned int base) 71 { 72 if(*cp=='-') 73 return -simple_strtoul(cp+1,endp,base); 74 return simple_strtoul(cp,endp,base); 75 } 76 77 EXPORT_SYMBOL(simple_strtol); 78 79 /** 80 * simple_strtoull - convert a string to an unsigned long long 81 * @cp: The start of the string 82 * @endp: A pointer to the end of the parsed string will be placed here 83 * @base: The number base to use 84 */ 85 unsigned long long simple_strtoull(const char *cp,char **endp,unsigned int base) 86 { 87 unsigned long long result = 0,value; 88 89 if (!base) { 90 base = 10; 91 if (*cp == '0') { 92 base = 8; 93 cp++; 94 if ((toupper(*cp) == 'X') && isxdigit(cp[1])) { 95 cp++; 96 base = 16; 97 } 98 } 99 } else if (base == 16) { 100 if (cp[0] == '0' && toupper(cp[1]) == 'X') 101 cp += 2; 102 } 103 while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp) 104 ? toupper(*cp) : *cp)-'A'+10) < base) { 105 result = result*base + value; 106 cp++; 107 } 108 if (endp) 109 *endp = (char *)cp; 110 return result; 111 } 112 113 EXPORT_SYMBOL(simple_strtoull); 114 115 /** 116 * simple_strtoll - convert a string to a signed long long 117 * @cp: The start of the string 118 * @endp: A pointer to the end of the parsed string will be placed here 119 * @base: The number base to use 120 */ 121 long long simple_strtoll(const char *cp,char **endp,unsigned int base) 122 { 123 if(*cp=='-') 124 return -simple_strtoull(cp+1,endp,base); 125 return simple_strtoull(cp,endp,base); 126 } 127 128 static int skip_atoi(const char **s) 129 { 130 int i=0; 131 132 while (isdigit(**s)) 133 i = i*10 + *((*s)++) - '0'; 134 return i; 135 } 136 137 #define ZEROPAD 1 /* pad with zero */ 138 #define SIGN 2 /* unsigned/signed long */ 139 #define PLUS 4 /* show plus */ 140 #define SPACE 8 /* space if plus */ 141 #define LEFT 16 /* left justified */ 142 #define SPECIAL 32 /* 0x */ 143 #define LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */ 144 145 static char * number(char * buf, char * end, unsigned long long num, int base, int size, int precision, int type) 146 { 147 char c,sign,tmp[66]; 148 const char *digits; 149 static const char small_digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; 150 static const char large_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 151 int i; 152 153 digits = (type & LARGE) ? large_digits : small_digits; 154 if (type & LEFT) 155 type &= ~ZEROPAD; 156 if (base < 2 || base > 36) 157 return NULL; 158 c = (type & ZEROPAD) ? '0' : ' '; 159 sign = 0; 160 if (type & SIGN) { 161 if ((signed long long) num < 0) { 162 sign = '-'; 163 num = - (signed long long) num; 164 size--; 165 } else if (type & PLUS) { 166 sign = '+'; 167 size--; 168 } else if (type & SPACE) { 169 sign = ' '; 170 size--; 171 } 172 } 173 if (type & SPECIAL) { 174 if (base == 16) 175 size -= 2; 176 else if (base == 8) 177 size--; 178 } 179 i = 0; 180 if (num == 0) 181 tmp[i++]='0'; 182 else while (num != 0) 183 tmp[i++] = digits[do_div(num,base)]; 184 if (i > precision) 185 precision = i; 186 size -= precision; 187 if (!(type&(ZEROPAD+LEFT))) { 188 while(size-->0) { 189 if (buf <= end) 190 *buf = ' '; 191 ++buf; 192 } 193 } 194 if (sign) { 195 if (buf <= end) 196 *buf = sign; 197 ++buf; 198 } 199 if (type & SPECIAL) { 200 if (base==8) { 201 if (buf <= end) 202 *buf = '0'; 203 ++buf; 204 } else if (base==16) { 205 if (buf <= end) 206 *buf = '0'; 207 ++buf; 208 if (buf <= end) 209 *buf = digits[33]; 210 ++buf; 211 } 212 } 213 if (!(type & LEFT)) { 214 while (size-- > 0) { 215 if (buf <= end) 216 *buf = c; 217 ++buf; 218 } 219 } 220 while (i < precision--) { 221 if (buf <= end) 222 *buf = '0'; 223 ++buf; 224 } 225 while (i-- > 0) { 226 if (buf <= end) 227 *buf = tmp[i]; 228 ++buf; 229 } 230 while (size-- > 0) { 231 if (buf <= end) 232 *buf = ' '; 233 ++buf; 234 } 235 return buf; 236 } 237 238 /** 239 * vsnprintf - Format a string and place it in a buffer 240 * @buf: The buffer to place the result into 241 * @size: The size of the buffer, including the trailing null space 242 * @fmt: The format string to use 243 * @args: Arguments for the format string 244 * 245 * The return value is the number of characters which would 246 * be generated for the given input, excluding the trailing 247 * '\0', as per ISO C99. If you want to have the exact 248 * number of characters written into @buf as return value 249 * (not including the trailing '\0'), use vscnprintf. If the 250 * return is greater than or equal to @size, the resulting 251 * string is truncated. 252 * 253 * Call this function if you are already dealing with a va_list. 254 * You probably want snprintf instead. 255 */ 256 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) 257 { 258 int len; 259 unsigned long long num; 260 int i, base; 261 char *str, *end, c; 262 const char *s; 263 264 int flags; /* flags to number() */ 265 266 int field_width; /* width of output field */ 267 int precision; /* min. # of digits for integers; max 268 number of chars for from string */ 269 int qualifier; /* 'h', 'l', or 'L' for integer fields */ 270 /* 'z' support added 23/7/1999 S.H. */ 271 /* 'z' changed to 'Z' --davidm 1/25/99 */ 272 273 /* Reject out-of-range values early */ 274 if (unlikely((int) size < 0)) { 275 /* There can be only one.. */ 276 static int warn = 1; 277 WARN_ON(warn); 278 warn = 0; 279 return 0; 280 } 281 282 str = buf; 283 end = buf + size - 1; 284 285 if (end < buf - 1) { 286 end = ((void *) -1); 287 size = end - buf + 1; 288 } 289 290 for (; *fmt ; ++fmt) { 291 if (*fmt != '%') { 292 if (str <= end) 293 *str = *fmt; 294 ++str; 295 continue; 296 } 297 298 /* process flags */ 299 flags = 0; 300 repeat: 301 ++fmt; /* this also skips first '%' */ 302 switch (*fmt) { 303 case '-': flags |= LEFT; goto repeat; 304 case '+': flags |= PLUS; goto repeat; 305 case ' ': flags |= SPACE; goto repeat; 306 case '#': flags |= SPECIAL; goto repeat; 307 case '0': flags |= ZEROPAD; goto repeat; 308 } 309 310 /* get field width */ 311 field_width = -1; 312 if (isdigit(*fmt)) 313 field_width = skip_atoi(&fmt); 314 else if (*fmt == '*') { 315 ++fmt; 316 /* it's the next argument */ 317 field_width = va_arg(args, int); 318 if (field_width < 0) { 319 field_width = -field_width; 320 flags |= LEFT; 321 } 322 } 323 324 /* get the precision */ 325 precision = -1; 326 if (*fmt == '.') { 327 ++fmt; 328 if (isdigit(*fmt)) 329 precision = skip_atoi(&fmt); 330 else if (*fmt == '*') { 331 ++fmt; 332 /* it's the next argument */ 333 precision = va_arg(args, int); 334 } 335 if (precision < 0) 336 precision = 0; 337 } 338 339 /* get the conversion qualifier */ 340 qualifier = -1; 341 if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || 342 *fmt =='Z' || *fmt == 'z') { 343 qualifier = *fmt; 344 ++fmt; 345 if (qualifier == 'l' && *fmt == 'l') { 346 qualifier = 'L'; 347 ++fmt; 348 } 349 } 350 351 /* default base */ 352 base = 10; 353 354 switch (*fmt) { 355 case 'c': 356 if (!(flags & LEFT)) { 357 while (--field_width > 0) { 358 if (str <= end) 359 *str = ' '; 360 ++str; 361 } 362 } 363 c = (unsigned char) va_arg(args, int); 364 if (str <= end) 365 *str = c; 366 ++str; 367 while (--field_width > 0) { 368 if (str <= end) 369 *str = ' '; 370 ++str; 371 } 372 continue; 373 374 case 's': 375 s = va_arg(args, char *); 376 if ((unsigned long)s < PAGE_SIZE) 377 s = "<NULL>"; 378 379 len = strnlen(s, precision); 380 381 if (!(flags & LEFT)) { 382 while (len < field_width--) { 383 if (str <= end) 384 *str = ' '; 385 ++str; 386 } 387 } 388 for (i = 0; i < len; ++i) { 389 if (str <= end) 390 *str = *s; 391 ++str; ++s; 392 } 393 while (len < field_width--) { 394 if (str <= end) 395 *str = ' '; 396 ++str; 397 } 398 continue; 399 400 case 'p': 401 if (field_width == -1) { 402 field_width = 2*sizeof(void *); 403 flags |= ZEROPAD; 404 } 405 str = number(str, end, 406 (unsigned long) va_arg(args, void *), 407 16, field_width, precision, flags); 408 continue; 409 410 411 case 'n': 412 /* FIXME: 413 * What does C99 say about the overflow case here? */ 414 if (qualifier == 'l') { 415 long * ip = va_arg(args, long *); 416 *ip = (str - buf); 417 } else if (qualifier == 'Z' || qualifier == 'z') { 418 size_t * ip = va_arg(args, size_t *); 419 *ip = (str - buf); 420 } else { 421 int * ip = va_arg(args, int *); 422 *ip = (str - buf); 423 } 424 continue; 425 426 case '%': 427 if (str <= end) 428 *str = '%'; 429 ++str; 430 continue; 431 432 /* integer number formats - set up the flags and "break" */ 433 case 'o': 434 base = 8; 435 break; 436 437 case 'X': 438 flags |= LARGE; 439 case 'x': 440 base = 16; 441 break; 442 443 case 'd': 444 case 'i': 445 flags |= SIGN; 446 case 'u': 447 break; 448 449 default: 450 if (str <= end) 451 *str = '%'; 452 ++str; 453 if (*fmt) { 454 if (str <= end) 455 *str = *fmt; 456 ++str; 457 } else { 458 --fmt; 459 } 460 continue; 461 } 462 if (qualifier == 'L') 463 num = va_arg(args, long long); 464 else if (qualifier == 'l') { 465 num = va_arg(args, unsigned long); 466 if (flags & SIGN) 467 num = (signed long) num; 468 } else if (qualifier == 'Z' || qualifier == 'z') { 469 num = va_arg(args, size_t); 470 } else if (qualifier == 'h') { 471 num = (unsigned short) va_arg(args, int); 472 if (flags & SIGN) 473 num = (signed short) num; 474 } else { 475 num = va_arg(args, unsigned int); 476 if (flags & SIGN) 477 num = (signed int) num; 478 } 479 str = number(str, end, num, base, 480 field_width, precision, flags); 481 } 482 if (str <= end) 483 *str = '\0'; 484 else if (size > 0) 485 /* don't write out a null byte if the buf size is zero */ 486 *end = '\0'; 487 /* the trailing null byte doesn't count towards the total 488 * ++str; 489 */ 490 return str-buf; 491 } 492 493 EXPORT_SYMBOL(vsnprintf); 494 495 /** 496 * vscnprintf - Format a string and place it in a buffer 497 * @buf: The buffer to place the result into 498 * @size: The size of the buffer, including the trailing null space 499 * @fmt: The format string to use 500 * @args: Arguments for the format string 501 * 502 * The return value is the number of characters which have been written into 503 * the @buf not including the trailing '\0'. If @size is <= 0 the function 504 * returns 0. 505 * 506 * Call this function if you are already dealing with a va_list. 507 * You probably want scnprintf instead. 508 */ 509 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 510 { 511 int i; 512 513 i=vsnprintf(buf,size,fmt,args); 514 return (i >= size) ? (size - 1) : i; 515 } 516 517 EXPORT_SYMBOL(vscnprintf); 518 519 /** 520 * snprintf - Format a string and place it in a buffer 521 * @buf: The buffer to place the result into 522 * @size: The size of the buffer, including the trailing null space 523 * @fmt: The format string to use 524 * @...: Arguments for the format string 525 * 526 * The return value is the number of characters which would be 527 * generated for the given input, excluding the trailing null, 528 * as per ISO C99. If the return is greater than or equal to 529 * @size, the resulting string is truncated. 530 */ 531 int snprintf(char * buf, size_t size, const char *fmt, ...) 532 { 533 va_list args; 534 int i; 535 536 va_start(args, fmt); 537 i=vsnprintf(buf,size,fmt,args); 538 va_end(args); 539 return i; 540 } 541 542 EXPORT_SYMBOL(snprintf); 543 544 /** 545 * scnprintf - Format a string and place it in a buffer 546 * @buf: The buffer to place the result into 547 * @size: The size of the buffer, including the trailing null space 548 * @fmt: The format string to use 549 * @...: Arguments for the format string 550 * 551 * The return value is the number of characters written into @buf not including 552 * the trailing '\0'. If @size is <= 0 the function returns 0. If the return is 553 * greater than or equal to @size, the resulting string is truncated. 554 */ 555 556 int scnprintf(char * buf, size_t size, const char *fmt, ...) 557 { 558 va_list args; 559 int i; 560 561 va_start(args, fmt); 562 i = vsnprintf(buf, size, fmt, args); 563 va_end(args); 564 return (i >= size) ? (size - 1) : i; 565 } 566 EXPORT_SYMBOL(scnprintf); 567 568 /** 569 * vsprintf - Format a string and place it in a buffer 570 * @buf: The buffer to place the result into 571 * @fmt: The format string to use 572 * @args: Arguments for the format string 573 * 574 * The function returns the number of characters written 575 * into @buf. Use vsnprintf or vscnprintf in order to avoid 576 * buffer overflows. 577 * 578 * Call this function if you are already dealing with a va_list. 579 * You probably want sprintf instead. 580 */ 581 int vsprintf(char *buf, const char *fmt, va_list args) 582 { 583 return vsnprintf(buf, INT_MAX, fmt, args); 584 } 585 586 EXPORT_SYMBOL(vsprintf); 587 588 /** 589 * sprintf - Format a string and place it in a buffer 590 * @buf: The buffer to place the result into 591 * @fmt: The format string to use 592 * @...: Arguments for the format string 593 * 594 * The function returns the number of characters written 595 * into @buf. Use snprintf or scnprintf in order to avoid 596 * buffer overflows. 597 */ 598 int sprintf(char * buf, const char *fmt, ...) 599 { 600 va_list args; 601 int i; 602 603 va_start(args, fmt); 604 i=vsnprintf(buf, INT_MAX, fmt, args); 605 va_end(args); 606 return i; 607 } 608 609 EXPORT_SYMBOL(sprintf); 610 611 /** 612 * vsscanf - Unformat a buffer into a list of arguments 613 * @buf: input buffer 614 * @fmt: format of buffer 615 * @args: arguments 616 */ 617 int vsscanf(const char * buf, const char * fmt, va_list args) 618 { 619 const char *str = buf; 620 char *next; 621 char digit; 622 int num = 0; 623 int qualifier; 624 int base; 625 int field_width; 626 int is_sign = 0; 627 628 while(*fmt && *str) { 629 /* skip any white space in format */ 630 /* white space in format matchs any amount of 631 * white space, including none, in the input. 632 */ 633 if (isspace(*fmt)) { 634 while (isspace(*fmt)) 635 ++fmt; 636 while (isspace(*str)) 637 ++str; 638 } 639 640 /* anything that is not a conversion must match exactly */ 641 if (*fmt != '%' && *fmt) { 642 if (*fmt++ != *str++) 643 break; 644 continue; 645 } 646 647 if (!*fmt) 648 break; 649 ++fmt; 650 651 /* skip this conversion. 652 * advance both strings to next white space 653 */ 654 if (*fmt == '*') { 655 while (!isspace(*fmt) && *fmt) 656 fmt++; 657 while (!isspace(*str) && *str) 658 str++; 659 continue; 660 } 661 662 /* get field width */ 663 field_width = -1; 664 if (isdigit(*fmt)) 665 field_width = skip_atoi(&fmt); 666 667 /* get conversion qualifier */ 668 qualifier = -1; 669 if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || 670 *fmt == 'Z' || *fmt == 'z') { 671 qualifier = *fmt++; 672 if (unlikely(qualifier == *fmt)) { 673 if (qualifier == 'h') { 674 qualifier = 'H'; 675 fmt++; 676 } else if (qualifier == 'l') { 677 qualifier = 'L'; 678 fmt++; 679 } 680 } 681 } 682 base = 10; 683 is_sign = 0; 684 685 if (!*fmt || !*str) 686 break; 687 688 switch(*fmt++) { 689 case 'c': 690 { 691 char *s = (char *) va_arg(args,char*); 692 if (field_width == -1) 693 field_width = 1; 694 do { 695 *s++ = *str++; 696 } while (--field_width > 0 && *str); 697 num++; 698 } 699 continue; 700 case 's': 701 { 702 char *s = (char *) va_arg(args, char *); 703 if(field_width == -1) 704 field_width = INT_MAX; 705 /* first, skip leading white space in buffer */ 706 while (isspace(*str)) 707 str++; 708 709 /* now copy until next white space */ 710 while (*str && !isspace(*str) && field_width--) { 711 *s++ = *str++; 712 } 713 *s = '\0'; 714 num++; 715 } 716 continue; 717 case 'n': 718 /* return number of characters read so far */ 719 { 720 int *i = (int *)va_arg(args,int*); 721 *i = str - buf; 722 } 723 continue; 724 case 'o': 725 base = 8; 726 break; 727 case 'x': 728 case 'X': 729 base = 16; 730 break; 731 case 'i': 732 base = 0; 733 case 'd': 734 is_sign = 1; 735 case 'u': 736 break; 737 case '%': 738 /* looking for '%' in str */ 739 if (*str++ != '%') 740 return num; 741 continue; 742 default: 743 /* invalid format; stop here */ 744 return num; 745 } 746 747 /* have some sort of integer conversion. 748 * first, skip white space in buffer. 749 */ 750 while (isspace(*str)) 751 str++; 752 753 digit = *str; 754 if (is_sign && digit == '-') 755 digit = *(str + 1); 756 757 if (!digit 758 || (base == 16 && !isxdigit(digit)) 759 || (base == 10 && !isdigit(digit)) 760 || (base == 8 && (!isdigit(digit) || digit > '7')) 761 || (base == 0 && !isdigit(digit))) 762 break; 763 764 switch(qualifier) { 765 case 'H': /* that's 'hh' in format */ 766 if (is_sign) { 767 signed char *s = (signed char *) va_arg(args,signed char *); 768 *s = (signed char) simple_strtol(str,&next,base); 769 } else { 770 unsigned char *s = (unsigned char *) va_arg(args, unsigned char *); 771 *s = (unsigned char) simple_strtoul(str, &next, base); 772 } 773 break; 774 case 'h': 775 if (is_sign) { 776 short *s = (short *) va_arg(args,short *); 777 *s = (short) simple_strtol(str,&next,base); 778 } else { 779 unsigned short *s = (unsigned short *) va_arg(args, unsigned short *); 780 *s = (unsigned short) simple_strtoul(str, &next, base); 781 } 782 break; 783 case 'l': 784 if (is_sign) { 785 long *l = (long *) va_arg(args,long *); 786 *l = simple_strtol(str,&next,base); 787 } else { 788 unsigned long *l = (unsigned long*) va_arg(args,unsigned long*); 789 *l = simple_strtoul(str,&next,base); 790 } 791 break; 792 case 'L': 793 if (is_sign) { 794 long long *l = (long long*) va_arg(args,long long *); 795 *l = simple_strtoll(str,&next,base); 796 } else { 797 unsigned long long *l = (unsigned long long*) va_arg(args,unsigned long long*); 798 *l = simple_strtoull(str,&next,base); 799 } 800 break; 801 case 'Z': 802 case 'z': 803 { 804 size_t *s = (size_t*) va_arg(args,size_t*); 805 *s = (size_t) simple_strtoul(str,&next,base); 806 } 807 break; 808 default: 809 if (is_sign) { 810 int *i = (int *) va_arg(args, int*); 811 *i = (int) simple_strtol(str,&next,base); 812 } else { 813 unsigned int *i = (unsigned int*) va_arg(args, unsigned int*); 814 *i = (unsigned int) simple_strtoul(str,&next,base); 815 } 816 break; 817 } 818 num++; 819 820 if (!next) 821 break; 822 str = next; 823 } 824 return num; 825 } 826 827 EXPORT_SYMBOL(vsscanf); 828 829 /** 830 * sscanf - Unformat a buffer into a list of arguments 831 * @buf: input buffer 832 * @fmt: formatting of buffer 833 * @...: resulting arguments 834 */ 835 int sscanf(const char * buf, const char * fmt, ...) 836 { 837 va_list args; 838 int i; 839 840 va_start(args,fmt); 841 i = vsscanf(buf,fmt,args); 842 va_end(args); 843 return i; 844 } 845 846 EXPORT_SYMBOL(sscanf); 847