1 /* 2 * linux/lib/string.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7 /* 8 * stupid library routines.. The optimized versions should generally be found 9 * as inline code in <asm-xx/string.h> 10 * 11 * These are buggy as well.. 12 * 13 * * Fri Jun 25 1999, Ingo Oeser <ioe@informatik.tu-chemnitz.de> 14 * - Added strsep() which will replace strtok() soon (because strsep() is 15 * reentrant and should be faster). Use only strsep() in new code, please. 16 * 17 * * Sat Feb 09 2002, Jason Thomas <jason@topic.com.au>, 18 * Matthew Hawkins <matt@mh.dropbear.id.au> 19 * - Kissed strtok() goodbye 20 */ 21 22 #include <linux/types.h> 23 #include <linux/string.h> 24 #include <linux/ctype.h> 25 #include <linux/kernel.h> 26 #include <linux/export.h> 27 #include <linux/bug.h> 28 #include <linux/errno.h> 29 30 #ifndef __HAVE_ARCH_STRNCASECMP 31 /** 32 * strncasecmp - Case insensitive, length-limited string comparison 33 * @s1: One string 34 * @s2: The other string 35 * @len: the maximum number of characters to compare 36 */ 37 int strncasecmp(const char *s1, const char *s2, size_t len) 38 { 39 /* Yes, Virginia, it had better be unsigned */ 40 unsigned char c1, c2; 41 42 if (!len) 43 return 0; 44 45 do { 46 c1 = *s1++; 47 c2 = *s2++; 48 if (!c1 || !c2) 49 break; 50 if (c1 == c2) 51 continue; 52 c1 = tolower(c1); 53 c2 = tolower(c2); 54 if (c1 != c2) 55 break; 56 } while (--len); 57 return (int)c1 - (int)c2; 58 } 59 EXPORT_SYMBOL(strncasecmp); 60 #endif 61 62 #ifndef __HAVE_ARCH_STRCASECMP 63 int strcasecmp(const char *s1, const char *s2) 64 { 65 int c1, c2; 66 67 do { 68 c1 = tolower(*s1++); 69 c2 = tolower(*s2++); 70 } while (c1 == c2 && c1 != 0); 71 return c1 - c2; 72 } 73 EXPORT_SYMBOL(strcasecmp); 74 #endif 75 76 #ifndef __HAVE_ARCH_STRCPY 77 /** 78 * strcpy - Copy a %NUL terminated string 79 * @dest: Where to copy the string to 80 * @src: Where to copy the string from 81 */ 82 #undef strcpy 83 char *strcpy(char *dest, const char *src) 84 { 85 char *tmp = dest; 86 87 while ((*dest++ = *src++) != '\0') 88 /* nothing */; 89 return tmp; 90 } 91 EXPORT_SYMBOL(strcpy); 92 #endif 93 94 #ifndef __HAVE_ARCH_STRNCPY 95 /** 96 * strncpy - Copy a length-limited, C-string 97 * @dest: Where to copy the string to 98 * @src: Where to copy the string from 99 * @count: The maximum number of bytes to copy 100 * 101 * The result is not %NUL-terminated if the source exceeds 102 * @count bytes. 103 * 104 * In the case where the length of @src is less than that of 105 * count, the remainder of @dest will be padded with %NUL. 106 * 107 */ 108 char *strncpy(char *dest, const char *src, size_t count) 109 { 110 char *tmp = dest; 111 112 while (count) { 113 if ((*tmp = *src) != 0) 114 src++; 115 tmp++; 116 count--; 117 } 118 return dest; 119 } 120 EXPORT_SYMBOL(strncpy); 121 #endif 122 123 #ifndef __HAVE_ARCH_STRLCPY 124 /** 125 * strlcpy - Copy a C-string into a sized buffer 126 * @dest: Where to copy the string to 127 * @src: Where to copy the string from 128 * @size: size of destination buffer 129 * 130 * Compatible with *BSD: the result is always a valid 131 * NUL-terminated string that fits in the buffer (unless, 132 * of course, the buffer size is zero). It does not pad 133 * out the result like strncpy() does. 134 */ 135 size_t strlcpy(char *dest, const char *src, size_t size) 136 { 137 size_t ret = strlen(src); 138 139 if (size) { 140 size_t len = (ret >= size) ? size - 1 : ret; 141 memcpy(dest, src, len); 142 dest[len] = '\0'; 143 } 144 return ret; 145 } 146 EXPORT_SYMBOL(strlcpy); 147 #endif 148 149 #ifndef __HAVE_ARCH_STRCAT 150 /** 151 * strcat - Append one %NUL-terminated string to another 152 * @dest: The string to be appended to 153 * @src: The string to append to it 154 */ 155 #undef strcat 156 char *strcat(char *dest, const char *src) 157 { 158 char *tmp = dest; 159 160 while (*dest) 161 dest++; 162 while ((*dest++ = *src++) != '\0') 163 ; 164 return tmp; 165 } 166 EXPORT_SYMBOL(strcat); 167 #endif 168 169 #ifndef __HAVE_ARCH_STRNCAT 170 /** 171 * strncat - Append a length-limited, C-string to another 172 * @dest: The string to be appended to 173 * @src: The string to append to it 174 * @count: The maximum numbers of bytes to copy 175 * 176 * Note that in contrast to strncpy(), strncat() ensures the result is 177 * terminated. 178 */ 179 char *strncat(char *dest, const char *src, size_t count) 180 { 181 char *tmp = dest; 182 183 if (count) { 184 while (*dest) 185 dest++; 186 while ((*dest++ = *src++) != 0) { 187 if (--count == 0) { 188 *dest = '\0'; 189 break; 190 } 191 } 192 } 193 return tmp; 194 } 195 EXPORT_SYMBOL(strncat); 196 #endif 197 198 #ifndef __HAVE_ARCH_STRLCAT 199 /** 200 * strlcat - Append a length-limited, C-string to another 201 * @dest: The string to be appended to 202 * @src: The string to append to it 203 * @count: The size of the destination buffer. 204 */ 205 size_t strlcat(char *dest, const char *src, size_t count) 206 { 207 size_t dsize = strlen(dest); 208 size_t len = strlen(src); 209 size_t res = dsize + len; 210 211 /* This would be a bug */ 212 BUG_ON(dsize >= count); 213 214 dest += dsize; 215 count -= dsize; 216 if (len >= count) 217 len = count-1; 218 memcpy(dest, src, len); 219 dest[len] = 0; 220 return res; 221 } 222 EXPORT_SYMBOL(strlcat); 223 #endif 224 225 #ifndef __HAVE_ARCH_STRCMP 226 /** 227 * strcmp - Compare two strings 228 * @cs: One string 229 * @ct: Another string 230 */ 231 #undef strcmp 232 int strcmp(const char *cs, const char *ct) 233 { 234 unsigned char c1, c2; 235 236 while (1) { 237 c1 = *cs++; 238 c2 = *ct++; 239 if (c1 != c2) 240 return c1 < c2 ? -1 : 1; 241 if (!c1) 242 break; 243 } 244 return 0; 245 } 246 EXPORT_SYMBOL(strcmp); 247 #endif 248 249 #ifndef __HAVE_ARCH_STRNCMP 250 /** 251 * strncmp - Compare two length-limited strings 252 * @cs: One string 253 * @ct: Another string 254 * @count: The maximum number of bytes to compare 255 */ 256 int strncmp(const char *cs, const char *ct, size_t count) 257 { 258 unsigned char c1, c2; 259 260 while (count) { 261 c1 = *cs++; 262 c2 = *ct++; 263 if (c1 != c2) 264 return c1 < c2 ? -1 : 1; 265 if (!c1) 266 break; 267 count--; 268 } 269 return 0; 270 } 271 EXPORT_SYMBOL(strncmp); 272 #endif 273 274 #ifndef __HAVE_ARCH_STRCHR 275 /** 276 * strchr - Find the first occurrence of a character in a string 277 * @s: The string to be searched 278 * @c: The character to search for 279 */ 280 char *strchr(const char *s, int c) 281 { 282 for (; *s != (char)c; ++s) 283 if (*s == '\0') 284 return NULL; 285 return (char *)s; 286 } 287 EXPORT_SYMBOL(strchr); 288 #endif 289 290 #ifndef __HAVE_ARCH_STRCHRNUL 291 /** 292 * strchrnul - Find and return a character in a string, or end of string 293 * @s: The string to be searched 294 * @c: The character to search for 295 * 296 * Returns pointer to first occurrence of 'c' in s. If c is not found, then 297 * return a pointer to the null byte at the end of s. 298 */ 299 char *strchrnul(const char *s, int c) 300 { 301 while (*s && *s != (char)c) 302 s++; 303 return (char *)s; 304 } 305 EXPORT_SYMBOL(strchrnul); 306 #endif 307 308 #ifndef __HAVE_ARCH_STRRCHR 309 /** 310 * strrchr - Find the last occurrence of a character in a string 311 * @s: The string to be searched 312 * @c: The character to search for 313 */ 314 char *strrchr(const char *s, int c) 315 { 316 const char *last = NULL; 317 do { 318 if (*s == (char)c) 319 last = s; 320 } while (*s++); 321 return (char *)last; 322 } 323 EXPORT_SYMBOL(strrchr); 324 #endif 325 326 #ifndef __HAVE_ARCH_STRNCHR 327 /** 328 * strnchr - Find a character in a length limited string 329 * @s: The string to be searched 330 * @count: The number of characters to be searched 331 * @c: The character to search for 332 */ 333 char *strnchr(const char *s, size_t count, int c) 334 { 335 for (; count-- && *s != '\0'; ++s) 336 if (*s == (char)c) 337 return (char *)s; 338 return NULL; 339 } 340 EXPORT_SYMBOL(strnchr); 341 #endif 342 343 /** 344 * skip_spaces - Removes leading whitespace from @str. 345 * @str: The string to be stripped. 346 * 347 * Returns a pointer to the first non-whitespace character in @str. 348 */ 349 char *skip_spaces(const char *str) 350 { 351 while (isspace(*str)) 352 ++str; 353 return (char *)str; 354 } 355 EXPORT_SYMBOL(skip_spaces); 356 357 /** 358 * strim - Removes leading and trailing whitespace from @s. 359 * @s: The string to be stripped. 360 * 361 * Note that the first trailing whitespace is replaced with a %NUL-terminator 362 * in the given string @s. Returns a pointer to the first non-whitespace 363 * character in @s. 364 */ 365 char *strim(char *s) 366 { 367 size_t size; 368 char *end; 369 370 size = strlen(s); 371 if (!size) 372 return s; 373 374 end = s + size - 1; 375 while (end >= s && isspace(*end)) 376 end--; 377 *(end + 1) = '\0'; 378 379 return skip_spaces(s); 380 } 381 EXPORT_SYMBOL(strim); 382 383 #ifndef __HAVE_ARCH_STRLEN 384 /** 385 * strlen - Find the length of a string 386 * @s: The string to be sized 387 */ 388 size_t strlen(const char *s) 389 { 390 const char *sc; 391 392 for (sc = s; *sc != '\0'; ++sc) 393 /* nothing */; 394 return sc - s; 395 } 396 EXPORT_SYMBOL(strlen); 397 #endif 398 399 #ifndef __HAVE_ARCH_STRNLEN 400 /** 401 * strnlen - Find the length of a length-limited string 402 * @s: The string to be sized 403 * @count: The maximum number of bytes to search 404 */ 405 size_t strnlen(const char *s, size_t count) 406 { 407 const char *sc; 408 409 for (sc = s; count-- && *sc != '\0'; ++sc) 410 /* nothing */; 411 return sc - s; 412 } 413 EXPORT_SYMBOL(strnlen); 414 #endif 415 416 #ifndef __HAVE_ARCH_STRSPN 417 /** 418 * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept 419 * @s: The string to be searched 420 * @accept: The string to search for 421 */ 422 size_t strspn(const char *s, const char *accept) 423 { 424 const char *p; 425 const char *a; 426 size_t count = 0; 427 428 for (p = s; *p != '\0'; ++p) { 429 for (a = accept; *a != '\0'; ++a) { 430 if (*p == *a) 431 break; 432 } 433 if (*a == '\0') 434 return count; 435 ++count; 436 } 437 return count; 438 } 439 440 EXPORT_SYMBOL(strspn); 441 #endif 442 443 #ifndef __HAVE_ARCH_STRCSPN 444 /** 445 * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject 446 * @s: The string to be searched 447 * @reject: The string to avoid 448 */ 449 size_t strcspn(const char *s, const char *reject) 450 { 451 const char *p; 452 const char *r; 453 size_t count = 0; 454 455 for (p = s; *p != '\0'; ++p) { 456 for (r = reject; *r != '\0'; ++r) { 457 if (*p == *r) 458 return count; 459 } 460 ++count; 461 } 462 return count; 463 } 464 EXPORT_SYMBOL(strcspn); 465 #endif 466 467 #ifndef __HAVE_ARCH_STRPBRK 468 /** 469 * strpbrk - Find the first occurrence of a set of characters 470 * @cs: The string to be searched 471 * @ct: The characters to search for 472 */ 473 char *strpbrk(const char *cs, const char *ct) 474 { 475 const char *sc1, *sc2; 476 477 for (sc1 = cs; *sc1 != '\0'; ++sc1) { 478 for (sc2 = ct; *sc2 != '\0'; ++sc2) { 479 if (*sc1 == *sc2) 480 return (char *)sc1; 481 } 482 } 483 return NULL; 484 } 485 EXPORT_SYMBOL(strpbrk); 486 #endif 487 488 #ifndef __HAVE_ARCH_STRSEP 489 /** 490 * strsep - Split a string into tokens 491 * @s: The string to be searched 492 * @ct: The characters to search for 493 * 494 * strsep() updates @s to point after the token, ready for the next call. 495 * 496 * It returns empty tokens, too, behaving exactly like the libc function 497 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied. 498 * Same semantics, slimmer shape. ;) 499 */ 500 char *strsep(char **s, const char *ct) 501 { 502 char *sbegin = *s; 503 char *end; 504 505 if (sbegin == NULL) 506 return NULL; 507 508 end = strpbrk(sbegin, ct); 509 if (end) 510 *end++ = '\0'; 511 *s = end; 512 return sbegin; 513 } 514 EXPORT_SYMBOL(strsep); 515 #endif 516 517 /** 518 * sysfs_streq - return true if strings are equal, modulo trailing newline 519 * @s1: one string 520 * @s2: another string 521 * 522 * This routine returns true iff two strings are equal, treating both 523 * NUL and newline-then-NUL as equivalent string terminations. It's 524 * geared for use with sysfs input strings, which generally terminate 525 * with newlines but are compared against values without newlines. 526 */ 527 bool sysfs_streq(const char *s1, const char *s2) 528 { 529 while (*s1 && *s1 == *s2) { 530 s1++; 531 s2++; 532 } 533 534 if (*s1 == *s2) 535 return true; 536 if (!*s1 && *s2 == '\n' && !s2[1]) 537 return true; 538 if (*s1 == '\n' && !s1[1] && !*s2) 539 return true; 540 return false; 541 } 542 EXPORT_SYMBOL(sysfs_streq); 543 544 /** 545 * strtobool - convert common user inputs into boolean values 546 * @s: input string 547 * @res: result 548 * 549 * This routine returns 0 iff the first character is one of 'Yy1Nn0'. 550 * Otherwise it will return -EINVAL. Value pointed to by res is 551 * updated upon finding a match. 552 */ 553 int strtobool(const char *s, bool *res) 554 { 555 switch (s[0]) { 556 case 'y': 557 case 'Y': 558 case '1': 559 *res = true; 560 break; 561 case 'n': 562 case 'N': 563 case '0': 564 *res = false; 565 break; 566 default: 567 return -EINVAL; 568 } 569 return 0; 570 } 571 EXPORT_SYMBOL(strtobool); 572 573 #ifndef __HAVE_ARCH_MEMSET 574 /** 575 * memset - Fill a region of memory with the given value 576 * @s: Pointer to the start of the area. 577 * @c: The byte to fill the area with 578 * @count: The size of the area. 579 * 580 * Do not use memset() to access IO space, use memset_io() instead. 581 */ 582 void *memset(void *s, int c, size_t count) 583 { 584 char *xs = s; 585 586 while (count--) 587 *xs++ = c; 588 return s; 589 } 590 EXPORT_SYMBOL(memset); 591 #endif 592 593 /** 594 * memzero_explicit - Fill a region of memory (e.g. sensitive 595 * keying data) with 0s. 596 * @s: Pointer to the start of the area. 597 * @count: The size of the area. 598 * 599 * Note: usually using memset() is just fine (!), but in cases 600 * where clearing out _local_ data at the end of a scope is 601 * necessary, memzero_explicit() should be used instead in 602 * order to prevent the compiler from optimising away zeroing. 603 * 604 * memzero_explicit() doesn't need an arch-specific version as 605 * it just invokes the one of memset() implicitly. 606 */ 607 void memzero_explicit(void *s, size_t count) 608 { 609 memset(s, 0, count); 610 OPTIMIZER_HIDE_VAR(s); 611 } 612 EXPORT_SYMBOL(memzero_explicit); 613 614 #ifndef __HAVE_ARCH_MEMCPY 615 /** 616 * memcpy - Copy one area of memory to another 617 * @dest: Where to copy to 618 * @src: Where to copy from 619 * @count: The size of the area. 620 * 621 * You should not use this function to access IO space, use memcpy_toio() 622 * or memcpy_fromio() instead. 623 */ 624 void *memcpy(void *dest, const void *src, size_t count) 625 { 626 char *tmp = dest; 627 const char *s = src; 628 629 while (count--) 630 *tmp++ = *s++; 631 return dest; 632 } 633 EXPORT_SYMBOL(memcpy); 634 #endif 635 636 #ifndef __HAVE_ARCH_MEMMOVE 637 /** 638 * memmove - Copy one area of memory to another 639 * @dest: Where to copy to 640 * @src: Where to copy from 641 * @count: The size of the area. 642 * 643 * Unlike memcpy(), memmove() copes with overlapping areas. 644 */ 645 void *memmove(void *dest, const void *src, size_t count) 646 { 647 char *tmp; 648 const char *s; 649 650 if (dest <= src) { 651 tmp = dest; 652 s = src; 653 while (count--) 654 *tmp++ = *s++; 655 } else { 656 tmp = dest; 657 tmp += count; 658 s = src; 659 s += count; 660 while (count--) 661 *--tmp = *--s; 662 } 663 return dest; 664 } 665 EXPORT_SYMBOL(memmove); 666 #endif 667 668 #ifndef __HAVE_ARCH_MEMCMP 669 /** 670 * memcmp - Compare two areas of memory 671 * @cs: One area of memory 672 * @ct: Another area of memory 673 * @count: The size of the area. 674 */ 675 #undef memcmp 676 __visible int memcmp(const void *cs, const void *ct, size_t count) 677 { 678 const unsigned char *su1, *su2; 679 int res = 0; 680 681 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--) 682 if ((res = *su1 - *su2) != 0) 683 break; 684 return res; 685 } 686 EXPORT_SYMBOL(memcmp); 687 #endif 688 689 #ifndef __HAVE_ARCH_MEMSCAN 690 /** 691 * memscan - Find a character in an area of memory. 692 * @addr: The memory area 693 * @c: The byte to search for 694 * @size: The size of the area. 695 * 696 * returns the address of the first occurrence of @c, or 1 byte past 697 * the area if @c is not found 698 */ 699 void *memscan(void *addr, int c, size_t size) 700 { 701 unsigned char *p = addr; 702 703 while (size) { 704 if (*p == c) 705 return (void *)p; 706 p++; 707 size--; 708 } 709 return (void *)p; 710 } 711 EXPORT_SYMBOL(memscan); 712 #endif 713 714 #ifndef __HAVE_ARCH_STRSTR 715 /** 716 * strstr - Find the first substring in a %NUL terminated string 717 * @s1: The string to be searched 718 * @s2: The string to search for 719 */ 720 char *strstr(const char *s1, const char *s2) 721 { 722 size_t l1, l2; 723 724 l2 = strlen(s2); 725 if (!l2) 726 return (char *)s1; 727 l1 = strlen(s1); 728 while (l1 >= l2) { 729 l1--; 730 if (!memcmp(s1, s2, l2)) 731 return (char *)s1; 732 s1++; 733 } 734 return NULL; 735 } 736 EXPORT_SYMBOL(strstr); 737 #endif 738 739 #ifndef __HAVE_ARCH_STRNSTR 740 /** 741 * strnstr - Find the first substring in a length-limited string 742 * @s1: The string to be searched 743 * @s2: The string to search for 744 * @len: the maximum number of characters to search 745 */ 746 char *strnstr(const char *s1, const char *s2, size_t len) 747 { 748 size_t l2; 749 750 l2 = strlen(s2); 751 if (!l2) 752 return (char *)s1; 753 while (len >= l2) { 754 len--; 755 if (!memcmp(s1, s2, l2)) 756 return (char *)s1; 757 s1++; 758 } 759 return NULL; 760 } 761 EXPORT_SYMBOL(strnstr); 762 #endif 763 764 #ifndef __HAVE_ARCH_MEMCHR 765 /** 766 * memchr - Find a character in an area of memory. 767 * @s: The memory area 768 * @c: The byte to search for 769 * @n: The size of the area. 770 * 771 * returns the address of the first occurrence of @c, or %NULL 772 * if @c is not found 773 */ 774 void *memchr(const void *s, int c, size_t n) 775 { 776 const unsigned char *p = s; 777 while (n-- != 0) { 778 if ((unsigned char)c == *p++) { 779 return (void *)(p - 1); 780 } 781 } 782 return NULL; 783 } 784 EXPORT_SYMBOL(memchr); 785 #endif 786 787 static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes) 788 { 789 while (bytes) { 790 if (*start != value) 791 return (void *)start; 792 start++; 793 bytes--; 794 } 795 return NULL; 796 } 797 798 /** 799 * memchr_inv - Find an unmatching character in an area of memory. 800 * @start: The memory area 801 * @c: Find a character other than c 802 * @bytes: The size of the area. 803 * 804 * returns the address of the first character other than @c, or %NULL 805 * if the whole buffer contains just @c. 806 */ 807 void *memchr_inv(const void *start, int c, size_t bytes) 808 { 809 u8 value = c; 810 u64 value64; 811 unsigned int words, prefix; 812 813 if (bytes <= 16) 814 return check_bytes8(start, value, bytes); 815 816 value64 = value; 817 #if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64 818 value64 *= 0x0101010101010101; 819 #elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) 820 value64 *= 0x01010101; 821 value64 |= value64 << 32; 822 #else 823 value64 |= value64 << 8; 824 value64 |= value64 << 16; 825 value64 |= value64 << 32; 826 #endif 827 828 prefix = (unsigned long)start % 8; 829 if (prefix) { 830 u8 *r; 831 832 prefix = 8 - prefix; 833 r = check_bytes8(start, value, prefix); 834 if (r) 835 return r; 836 start += prefix; 837 bytes -= prefix; 838 } 839 840 words = bytes / 8; 841 842 while (words) { 843 if (*(u64 *)start != value64) 844 return check_bytes8(start, value, 8); 845 start += 8; 846 words--; 847 } 848 849 return check_bytes8(start, value, bytes % 8); 850 } 851 EXPORT_SYMBOL(memchr_inv); 852