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