1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/lib/string.c 4 * 5 * Copyright (C) 1991, 1992 Linus Torvalds 6 */ 7 8 /* 9 * stupid library routines.. The optimized versions should generally be found 10 * as inline code in <asm-xx/string.h> 11 * 12 * These are buggy as well.. 13 * 14 * * Fri Jun 25 1999, Ingo Oeser <ioe@informatik.tu-chemnitz.de> 15 * - Added strsep() which will replace strtok() soon (because strsep() is 16 * reentrant and should be faster). Use only strsep() in new code, please. 17 * 18 * * Sat Feb 09 2002, Jason Thomas <jason@topic.com.au>, 19 * Matthew Hawkins <matt@mh.dropbear.id.au> 20 * - Kissed strtok() goodbye 21 */ 22 23 #include <linux/types.h> 24 #include <linux/string.h> 25 #include <linux/ctype.h> 26 #include <linux/kernel.h> 27 #include <linux/export.h> 28 #include <linux/bug.h> 29 #include <linux/errno.h> 30 31 #include <asm/byteorder.h> 32 #include <asm/word-at-a-time.h> 33 #include <asm/page.h> 34 35 #ifndef __HAVE_ARCH_STRNCASECMP 36 /** 37 * strncasecmp - Case insensitive, length-limited string comparison 38 * @s1: One string 39 * @s2: The other string 40 * @len: the maximum number of characters to compare 41 */ 42 int strncasecmp(const char *s1, const char *s2, size_t len) 43 { 44 /* Yes, Virginia, it had better be unsigned */ 45 unsigned char c1, c2; 46 47 if (!len) 48 return 0; 49 50 do { 51 c1 = *s1++; 52 c2 = *s2++; 53 if (!c1 || !c2) 54 break; 55 if (c1 == c2) 56 continue; 57 c1 = tolower(c1); 58 c2 = tolower(c2); 59 if (c1 != c2) 60 break; 61 } while (--len); 62 return (int)c1 - (int)c2; 63 } 64 EXPORT_SYMBOL(strncasecmp); 65 #endif 66 67 #ifndef __HAVE_ARCH_STRCASECMP 68 int strcasecmp(const char *s1, const char *s2) 69 { 70 int c1, c2; 71 72 do { 73 c1 = tolower(*s1++); 74 c2 = tolower(*s2++); 75 } while (c1 == c2 && c1 != 0); 76 return c1 - c2; 77 } 78 EXPORT_SYMBOL(strcasecmp); 79 #endif 80 81 #ifndef __HAVE_ARCH_STRCPY 82 /** 83 * strcpy - Copy a %NUL terminated string 84 * @dest: Where to copy the string to 85 * @src: Where to copy the string from 86 */ 87 #undef strcpy 88 char *strcpy(char *dest, const char *src) 89 { 90 char *tmp = dest; 91 92 while ((*dest++ = *src++) != '\0') 93 /* nothing */; 94 return tmp; 95 } 96 EXPORT_SYMBOL(strcpy); 97 #endif 98 99 #ifndef __HAVE_ARCH_STRNCPY 100 /** 101 * strncpy - Copy a length-limited, C-string 102 * @dest: Where to copy the string to 103 * @src: Where to copy the string from 104 * @count: The maximum number of bytes to copy 105 * 106 * The result is not %NUL-terminated if the source exceeds 107 * @count bytes. 108 * 109 * In the case where the length of @src is less than that of 110 * count, the remainder of @dest will be padded with %NUL. 111 * 112 */ 113 char *strncpy(char *dest, const char *src, size_t count) 114 { 115 char *tmp = dest; 116 117 while (count) { 118 if ((*tmp = *src) != 0) 119 src++; 120 tmp++; 121 count--; 122 } 123 return dest; 124 } 125 EXPORT_SYMBOL(strncpy); 126 #endif 127 128 #ifndef __HAVE_ARCH_STRLCPY 129 /** 130 * strlcpy - Copy a C-string into a sized buffer 131 * @dest: Where to copy the string to 132 * @src: Where to copy the string from 133 * @size: size of destination buffer 134 * 135 * Compatible with ``*BSD``: the result is always a valid 136 * NUL-terminated string that fits in the buffer (unless, 137 * of course, the buffer size is zero). It does not pad 138 * out the result like strncpy() does. 139 */ 140 size_t strlcpy(char *dest, const char *src, size_t size) 141 { 142 size_t ret = strlen(src); 143 144 if (size) { 145 size_t len = (ret >= size) ? size - 1 : ret; 146 memcpy(dest, src, len); 147 dest[len] = '\0'; 148 } 149 return ret; 150 } 151 EXPORT_SYMBOL(strlcpy); 152 #endif 153 154 #ifndef __HAVE_ARCH_STRSCPY 155 /** 156 * strscpy - Copy a C-string into a sized buffer 157 * @dest: Where to copy the string to 158 * @src: Where to copy the string from 159 * @count: Size of destination buffer 160 * 161 * Copy the string, or as much of it as fits, into the dest buffer. 162 * The routine returns the number of characters copied (not including 163 * the trailing NUL) or -E2BIG if the destination buffer wasn't big enough. 164 * The behavior is undefined if the string buffers overlap. 165 * The destination buffer is always NUL terminated, unless it's zero-sized. 166 * 167 * Preferred to strlcpy() since the API doesn't require reading memory 168 * from the src string beyond the specified "count" bytes, and since 169 * the return value is easier to error-check than strlcpy()'s. 170 * In addition, the implementation is robust to the string changing out 171 * from underneath it, unlike the current strlcpy() implementation. 172 * 173 * Preferred to strncpy() since it always returns a valid string, and 174 * doesn't unnecessarily force the tail of the destination buffer to be 175 * zeroed. If the zeroing is desired, it's likely cleaner to use strscpy() 176 * with an overflow test, then just memset() the tail of the dest buffer. 177 */ 178 ssize_t strscpy(char *dest, const char *src, size_t count) 179 { 180 const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS; 181 size_t max = count; 182 long res = 0; 183 184 if (count == 0) 185 return -E2BIG; 186 187 #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS 188 /* 189 * If src is unaligned, don't cross a page boundary, 190 * since we don't know if the next page is mapped. 191 */ 192 if ((long)src & (sizeof(long) - 1)) { 193 size_t limit = PAGE_SIZE - ((long)src & (PAGE_SIZE - 1)); 194 if (limit < max) 195 max = limit; 196 } 197 #else 198 /* If src or dest is unaligned, don't do word-at-a-time. */ 199 if (((long) dest | (long) src) & (sizeof(long) - 1)) 200 max = 0; 201 #endif 202 203 while (max >= sizeof(unsigned long)) { 204 unsigned long c, data; 205 206 c = read_word_at_a_time(src+res); 207 if (has_zero(c, &data, &constants)) { 208 data = prep_zero_mask(c, data, &constants); 209 data = create_zero_mask(data); 210 *(unsigned long *)(dest+res) = c & zero_bytemask(data); 211 return res + find_zero(data); 212 } 213 *(unsigned long *)(dest+res) = c; 214 res += sizeof(unsigned long); 215 count -= sizeof(unsigned long); 216 max -= sizeof(unsigned long); 217 } 218 219 while (count) { 220 char c; 221 222 c = src[res]; 223 dest[res] = c; 224 if (!c) 225 return res; 226 res++; 227 count--; 228 } 229 230 /* Hit buffer length without finding a NUL; force NUL-termination. */ 231 if (res) 232 dest[res-1] = '\0'; 233 234 return -E2BIG; 235 } 236 EXPORT_SYMBOL(strscpy); 237 #endif 238 239 #ifndef __HAVE_ARCH_STRCAT 240 /** 241 * strcat - Append one %NUL-terminated string to another 242 * @dest: The string to be appended to 243 * @src: The string to append to it 244 */ 245 #undef strcat 246 char *strcat(char *dest, const char *src) 247 { 248 char *tmp = dest; 249 250 while (*dest) 251 dest++; 252 while ((*dest++ = *src++) != '\0') 253 ; 254 return tmp; 255 } 256 EXPORT_SYMBOL(strcat); 257 #endif 258 259 #ifndef __HAVE_ARCH_STRNCAT 260 /** 261 * strncat - Append a length-limited, C-string to another 262 * @dest: The string to be appended to 263 * @src: The string to append to it 264 * @count: The maximum numbers of bytes to copy 265 * 266 * Note that in contrast to strncpy(), strncat() ensures the result is 267 * terminated. 268 */ 269 char *strncat(char *dest, const char *src, size_t count) 270 { 271 char *tmp = dest; 272 273 if (count) { 274 while (*dest) 275 dest++; 276 while ((*dest++ = *src++) != 0) { 277 if (--count == 0) { 278 *dest = '\0'; 279 break; 280 } 281 } 282 } 283 return tmp; 284 } 285 EXPORT_SYMBOL(strncat); 286 #endif 287 288 #ifndef __HAVE_ARCH_STRLCAT 289 /** 290 * strlcat - Append a length-limited, C-string to another 291 * @dest: The string to be appended to 292 * @src: The string to append to it 293 * @count: The size of the destination buffer. 294 */ 295 size_t strlcat(char *dest, const char *src, size_t count) 296 { 297 size_t dsize = strlen(dest); 298 size_t len = strlen(src); 299 size_t res = dsize + len; 300 301 /* This would be a bug */ 302 BUG_ON(dsize >= count); 303 304 dest += dsize; 305 count -= dsize; 306 if (len >= count) 307 len = count-1; 308 memcpy(dest, src, len); 309 dest[len] = 0; 310 return res; 311 } 312 EXPORT_SYMBOL(strlcat); 313 #endif 314 315 #ifndef __HAVE_ARCH_STRCMP 316 /** 317 * strcmp - Compare two strings 318 * @cs: One string 319 * @ct: Another string 320 */ 321 #undef strcmp 322 int strcmp(const char *cs, const char *ct) 323 { 324 unsigned char c1, c2; 325 326 while (1) { 327 c1 = *cs++; 328 c2 = *ct++; 329 if (c1 != c2) 330 return c1 < c2 ? -1 : 1; 331 if (!c1) 332 break; 333 } 334 return 0; 335 } 336 EXPORT_SYMBOL(strcmp); 337 #endif 338 339 #ifndef __HAVE_ARCH_STRNCMP 340 /** 341 * strncmp - Compare two length-limited strings 342 * @cs: One string 343 * @ct: Another string 344 * @count: The maximum number of bytes to compare 345 */ 346 int strncmp(const char *cs, const char *ct, size_t count) 347 { 348 unsigned char c1, c2; 349 350 while (count) { 351 c1 = *cs++; 352 c2 = *ct++; 353 if (c1 != c2) 354 return c1 < c2 ? -1 : 1; 355 if (!c1) 356 break; 357 count--; 358 } 359 return 0; 360 } 361 EXPORT_SYMBOL(strncmp); 362 #endif 363 364 #ifndef __HAVE_ARCH_STRCHR 365 /** 366 * strchr - Find the first occurrence of a character in a string 367 * @s: The string to be searched 368 * @c: The character to search for 369 */ 370 char *strchr(const char *s, int c) 371 { 372 for (; *s != (char)c; ++s) 373 if (*s == '\0') 374 return NULL; 375 return (char *)s; 376 } 377 EXPORT_SYMBOL(strchr); 378 #endif 379 380 #ifndef __HAVE_ARCH_STRCHRNUL 381 /** 382 * strchrnul - Find and return a character in a string, or end of string 383 * @s: The string to be searched 384 * @c: The character to search for 385 * 386 * Returns pointer to first occurrence of 'c' in s. If c is not found, then 387 * return a pointer to the null byte at the end of s. 388 */ 389 char *strchrnul(const char *s, int c) 390 { 391 while (*s && *s != (char)c) 392 s++; 393 return (char *)s; 394 } 395 EXPORT_SYMBOL(strchrnul); 396 #endif 397 398 #ifndef __HAVE_ARCH_STRRCHR 399 /** 400 * strrchr - Find the last occurrence of a character in a string 401 * @s: The string to be searched 402 * @c: The character to search for 403 */ 404 char *strrchr(const char *s, int c) 405 { 406 const char *last = NULL; 407 do { 408 if (*s == (char)c) 409 last = s; 410 } while (*s++); 411 return (char *)last; 412 } 413 EXPORT_SYMBOL(strrchr); 414 #endif 415 416 #ifndef __HAVE_ARCH_STRNCHR 417 /** 418 * strnchr - Find a character in a length limited string 419 * @s: The string to be searched 420 * @count: The number of characters to be searched 421 * @c: The character to search for 422 */ 423 char *strnchr(const char *s, size_t count, int c) 424 { 425 for (; count-- && *s != '\0'; ++s) 426 if (*s == (char)c) 427 return (char *)s; 428 return NULL; 429 } 430 EXPORT_SYMBOL(strnchr); 431 #endif 432 433 /** 434 * skip_spaces - Removes leading whitespace from @str. 435 * @str: The string to be stripped. 436 * 437 * Returns a pointer to the first non-whitespace character in @str. 438 */ 439 char *skip_spaces(const char *str) 440 { 441 while (isspace(*str)) 442 ++str; 443 return (char *)str; 444 } 445 EXPORT_SYMBOL(skip_spaces); 446 447 /** 448 * strim - Removes leading and trailing whitespace from @s. 449 * @s: The string to be stripped. 450 * 451 * Note that the first trailing whitespace is replaced with a %NUL-terminator 452 * in the given string @s. Returns a pointer to the first non-whitespace 453 * character in @s. 454 */ 455 char *strim(char *s) 456 { 457 size_t size; 458 char *end; 459 460 size = strlen(s); 461 if (!size) 462 return s; 463 464 end = s + size - 1; 465 while (end >= s && isspace(*end)) 466 end--; 467 *(end + 1) = '\0'; 468 469 return skip_spaces(s); 470 } 471 EXPORT_SYMBOL(strim); 472 473 #ifndef __HAVE_ARCH_STRLEN 474 /** 475 * strlen - Find the length of a string 476 * @s: The string to be sized 477 */ 478 size_t strlen(const char *s) 479 { 480 const char *sc; 481 482 for (sc = s; *sc != '\0'; ++sc) 483 /* nothing */; 484 return sc - s; 485 } 486 EXPORT_SYMBOL(strlen); 487 #endif 488 489 #ifndef __HAVE_ARCH_STRNLEN 490 /** 491 * strnlen - Find the length of a length-limited string 492 * @s: The string to be sized 493 * @count: The maximum number of bytes to search 494 */ 495 size_t strnlen(const char *s, size_t count) 496 { 497 const char *sc; 498 499 for (sc = s; count-- && *sc != '\0'; ++sc) 500 /* nothing */; 501 return sc - s; 502 } 503 EXPORT_SYMBOL(strnlen); 504 #endif 505 506 #ifndef __HAVE_ARCH_STRSPN 507 /** 508 * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept 509 * @s: The string to be searched 510 * @accept: The string to search for 511 */ 512 size_t strspn(const char *s, const char *accept) 513 { 514 const char *p; 515 const char *a; 516 size_t count = 0; 517 518 for (p = s; *p != '\0'; ++p) { 519 for (a = accept; *a != '\0'; ++a) { 520 if (*p == *a) 521 break; 522 } 523 if (*a == '\0') 524 return count; 525 ++count; 526 } 527 return count; 528 } 529 530 EXPORT_SYMBOL(strspn); 531 #endif 532 533 #ifndef __HAVE_ARCH_STRCSPN 534 /** 535 * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject 536 * @s: The string to be searched 537 * @reject: The string to avoid 538 */ 539 size_t strcspn(const char *s, const char *reject) 540 { 541 const char *p; 542 const char *r; 543 size_t count = 0; 544 545 for (p = s; *p != '\0'; ++p) { 546 for (r = reject; *r != '\0'; ++r) { 547 if (*p == *r) 548 return count; 549 } 550 ++count; 551 } 552 return count; 553 } 554 EXPORT_SYMBOL(strcspn); 555 #endif 556 557 #ifndef __HAVE_ARCH_STRPBRK 558 /** 559 * strpbrk - Find the first occurrence of a set of characters 560 * @cs: The string to be searched 561 * @ct: The characters to search for 562 */ 563 char *strpbrk(const char *cs, const char *ct) 564 { 565 const char *sc1, *sc2; 566 567 for (sc1 = cs; *sc1 != '\0'; ++sc1) { 568 for (sc2 = ct; *sc2 != '\0'; ++sc2) { 569 if (*sc1 == *sc2) 570 return (char *)sc1; 571 } 572 } 573 return NULL; 574 } 575 EXPORT_SYMBOL(strpbrk); 576 #endif 577 578 #ifndef __HAVE_ARCH_STRSEP 579 /** 580 * strsep - Split a string into tokens 581 * @s: The string to be searched 582 * @ct: The characters to search for 583 * 584 * strsep() updates @s to point after the token, ready for the next call. 585 * 586 * It returns empty tokens, too, behaving exactly like the libc function 587 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied. 588 * Same semantics, slimmer shape. ;) 589 */ 590 char *strsep(char **s, const char *ct) 591 { 592 char *sbegin = *s; 593 char *end; 594 595 if (sbegin == NULL) 596 return NULL; 597 598 end = strpbrk(sbegin, ct); 599 if (end) 600 *end++ = '\0'; 601 *s = end; 602 return sbegin; 603 } 604 EXPORT_SYMBOL(strsep); 605 #endif 606 607 /** 608 * sysfs_streq - return true if strings are equal, modulo trailing newline 609 * @s1: one string 610 * @s2: another string 611 * 612 * This routine returns true iff two strings are equal, treating both 613 * NUL and newline-then-NUL as equivalent string terminations. It's 614 * geared for use with sysfs input strings, which generally terminate 615 * with newlines but are compared against values without newlines. 616 */ 617 bool sysfs_streq(const char *s1, const char *s2) 618 { 619 while (*s1 && *s1 == *s2) { 620 s1++; 621 s2++; 622 } 623 624 if (*s1 == *s2) 625 return true; 626 if (!*s1 && *s2 == '\n' && !s2[1]) 627 return true; 628 if (*s1 == '\n' && !s1[1] && !*s2) 629 return true; 630 return false; 631 } 632 EXPORT_SYMBOL(sysfs_streq); 633 634 /** 635 * match_string - matches given string in an array 636 * @array: array of strings 637 * @n: number of strings in the array or -1 for NULL terminated arrays 638 * @string: string to match with 639 * 640 * Return: 641 * index of a @string in the @array if matches, or %-EINVAL otherwise. 642 */ 643 int match_string(const char * const *array, size_t n, const char *string) 644 { 645 int index; 646 const char *item; 647 648 for (index = 0; index < n; index++) { 649 item = array[index]; 650 if (!item) 651 break; 652 if (!strcmp(item, string)) 653 return index; 654 } 655 656 return -EINVAL; 657 } 658 EXPORT_SYMBOL(match_string); 659 660 /** 661 * __sysfs_match_string - matches given string in an array 662 * @array: array of strings 663 * @n: number of strings in the array or -1 for NULL terminated arrays 664 * @str: string to match with 665 * 666 * Returns index of @str in the @array or -EINVAL, just like match_string(). 667 * Uses sysfs_streq instead of strcmp for matching. 668 */ 669 int __sysfs_match_string(const char * const *array, size_t n, const char *str) 670 { 671 const char *item; 672 int index; 673 674 for (index = 0; index < n; index++) { 675 item = array[index]; 676 if (!item) 677 break; 678 if (sysfs_streq(item, str)) 679 return index; 680 } 681 682 return -EINVAL; 683 } 684 EXPORT_SYMBOL(__sysfs_match_string); 685 686 #ifndef __HAVE_ARCH_MEMSET 687 /** 688 * memset - Fill a region of memory with the given value 689 * @s: Pointer to the start of the area. 690 * @c: The byte to fill the area with 691 * @count: The size of the area. 692 * 693 * Do not use memset() to access IO space, use memset_io() instead. 694 */ 695 void *memset(void *s, int c, size_t count) 696 { 697 char *xs = s; 698 699 while (count--) 700 *xs++ = c; 701 return s; 702 } 703 EXPORT_SYMBOL(memset); 704 #endif 705 706 /** 707 * memzero_explicit - Fill a region of memory (e.g. sensitive 708 * keying data) with 0s. 709 * @s: Pointer to the start of the area. 710 * @count: The size of the area. 711 * 712 * Note: usually using memset() is just fine (!), but in cases 713 * where clearing out _local_ data at the end of a scope is 714 * necessary, memzero_explicit() should be used instead in 715 * order to prevent the compiler from optimising away zeroing. 716 * 717 * memzero_explicit() doesn't need an arch-specific version as 718 * it just invokes the one of memset() implicitly. 719 */ 720 void memzero_explicit(void *s, size_t count) 721 { 722 memset(s, 0, count); 723 barrier_data(s); 724 } 725 EXPORT_SYMBOL(memzero_explicit); 726 727 #ifndef __HAVE_ARCH_MEMSET16 728 /** 729 * memset16() - Fill a memory area with a uint16_t 730 * @s: Pointer to the start of the area. 731 * @v: The value to fill the area with 732 * @count: The number of values to store 733 * 734 * Differs from memset() in that it fills with a uint16_t instead 735 * of a byte. Remember that @count is the number of uint16_ts to 736 * store, not the number of bytes. 737 */ 738 void *memset16(uint16_t *s, uint16_t v, size_t count) 739 { 740 uint16_t *xs = s; 741 742 while (count--) 743 *xs++ = v; 744 return s; 745 } 746 EXPORT_SYMBOL(memset16); 747 #endif 748 749 #ifndef __HAVE_ARCH_MEMSET32 750 /** 751 * memset32() - Fill a memory area with a uint32_t 752 * @s: Pointer to the start of the area. 753 * @v: The value to fill the area with 754 * @count: The number of values to store 755 * 756 * Differs from memset() in that it fills with a uint32_t instead 757 * of a byte. Remember that @count is the number of uint32_ts to 758 * store, not the number of bytes. 759 */ 760 void *memset32(uint32_t *s, uint32_t v, size_t count) 761 { 762 uint32_t *xs = s; 763 764 while (count--) 765 *xs++ = v; 766 return s; 767 } 768 EXPORT_SYMBOL(memset32); 769 #endif 770 771 #ifndef __HAVE_ARCH_MEMSET64 772 /** 773 * memset64() - Fill a memory area with a uint64_t 774 * @s: Pointer to the start of the area. 775 * @v: The value to fill the area with 776 * @count: The number of values to store 777 * 778 * Differs from memset() in that it fills with a uint64_t instead 779 * of a byte. Remember that @count is the number of uint64_ts to 780 * store, not the number of bytes. 781 */ 782 void *memset64(uint64_t *s, uint64_t v, size_t count) 783 { 784 uint64_t *xs = s; 785 786 while (count--) 787 *xs++ = v; 788 return s; 789 } 790 EXPORT_SYMBOL(memset64); 791 #endif 792 793 #ifndef __HAVE_ARCH_MEMCPY 794 /** 795 * memcpy - Copy one area of memory to another 796 * @dest: Where to copy to 797 * @src: Where to copy from 798 * @count: The size of the area. 799 * 800 * You should not use this function to access IO space, use memcpy_toio() 801 * or memcpy_fromio() instead. 802 */ 803 void *memcpy(void *dest, const void *src, size_t count) 804 { 805 char *tmp = dest; 806 const char *s = src; 807 808 while (count--) 809 *tmp++ = *s++; 810 return dest; 811 } 812 EXPORT_SYMBOL(memcpy); 813 #endif 814 815 #ifndef __HAVE_ARCH_MEMMOVE 816 /** 817 * memmove - Copy one area of memory to another 818 * @dest: Where to copy to 819 * @src: Where to copy from 820 * @count: The size of the area. 821 * 822 * Unlike memcpy(), memmove() copes with overlapping areas. 823 */ 824 void *memmove(void *dest, const void *src, size_t count) 825 { 826 char *tmp; 827 const char *s; 828 829 if (dest <= src) { 830 tmp = dest; 831 s = src; 832 while (count--) 833 *tmp++ = *s++; 834 } else { 835 tmp = dest; 836 tmp += count; 837 s = src; 838 s += count; 839 while (count--) 840 *--tmp = *--s; 841 } 842 return dest; 843 } 844 EXPORT_SYMBOL(memmove); 845 #endif 846 847 #ifndef __HAVE_ARCH_MEMCMP 848 /** 849 * memcmp - Compare two areas of memory 850 * @cs: One area of memory 851 * @ct: Another area of memory 852 * @count: The size of the area. 853 */ 854 #undef memcmp 855 __visible int memcmp(const void *cs, const void *ct, size_t count) 856 { 857 const unsigned char *su1, *su2; 858 int res = 0; 859 860 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--) 861 if ((res = *su1 - *su2) != 0) 862 break; 863 return res; 864 } 865 EXPORT_SYMBOL(memcmp); 866 #endif 867 868 #ifndef __HAVE_ARCH_MEMSCAN 869 /** 870 * memscan - Find a character in an area of memory. 871 * @addr: The memory area 872 * @c: The byte to search for 873 * @size: The size of the area. 874 * 875 * returns the address of the first occurrence of @c, or 1 byte past 876 * the area if @c is not found 877 */ 878 void *memscan(void *addr, int c, size_t size) 879 { 880 unsigned char *p = addr; 881 882 while (size) { 883 if (*p == c) 884 return (void *)p; 885 p++; 886 size--; 887 } 888 return (void *)p; 889 } 890 EXPORT_SYMBOL(memscan); 891 #endif 892 893 #ifndef __HAVE_ARCH_STRSTR 894 /** 895 * strstr - Find the first substring in a %NUL terminated string 896 * @s1: The string to be searched 897 * @s2: The string to search for 898 */ 899 char *strstr(const char *s1, const char *s2) 900 { 901 size_t l1, l2; 902 903 l2 = strlen(s2); 904 if (!l2) 905 return (char *)s1; 906 l1 = strlen(s1); 907 while (l1 >= l2) { 908 l1--; 909 if (!memcmp(s1, s2, l2)) 910 return (char *)s1; 911 s1++; 912 } 913 return NULL; 914 } 915 EXPORT_SYMBOL(strstr); 916 #endif 917 918 #ifndef __HAVE_ARCH_STRNSTR 919 /** 920 * strnstr - Find the first substring in a length-limited string 921 * @s1: The string to be searched 922 * @s2: The string to search for 923 * @len: the maximum number of characters to search 924 */ 925 char *strnstr(const char *s1, const char *s2, size_t len) 926 { 927 size_t l2; 928 929 l2 = strlen(s2); 930 if (!l2) 931 return (char *)s1; 932 while (len >= l2) { 933 len--; 934 if (!memcmp(s1, s2, l2)) 935 return (char *)s1; 936 s1++; 937 } 938 return NULL; 939 } 940 EXPORT_SYMBOL(strnstr); 941 #endif 942 943 #ifndef __HAVE_ARCH_MEMCHR 944 /** 945 * memchr - Find a character in an area of memory. 946 * @s: The memory area 947 * @c: The byte to search for 948 * @n: The size of the area. 949 * 950 * returns the address of the first occurrence of @c, or %NULL 951 * if @c is not found 952 */ 953 void *memchr(const void *s, int c, size_t n) 954 { 955 const unsigned char *p = s; 956 while (n-- != 0) { 957 if ((unsigned char)c == *p++) { 958 return (void *)(p - 1); 959 } 960 } 961 return NULL; 962 } 963 EXPORT_SYMBOL(memchr); 964 #endif 965 966 static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes) 967 { 968 while (bytes) { 969 if (*start != value) 970 return (void *)start; 971 start++; 972 bytes--; 973 } 974 return NULL; 975 } 976 977 /** 978 * memchr_inv - Find an unmatching character in an area of memory. 979 * @start: The memory area 980 * @c: Find a character other than c 981 * @bytes: The size of the area. 982 * 983 * returns the address of the first character other than @c, or %NULL 984 * if the whole buffer contains just @c. 985 */ 986 void *memchr_inv(const void *start, int c, size_t bytes) 987 { 988 u8 value = c; 989 u64 value64; 990 unsigned int words, prefix; 991 992 if (bytes <= 16) 993 return check_bytes8(start, value, bytes); 994 995 value64 = value; 996 #if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64 997 value64 *= 0x0101010101010101ULL; 998 #elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) 999 value64 *= 0x01010101; 1000 value64 |= value64 << 32; 1001 #else 1002 value64 |= value64 << 8; 1003 value64 |= value64 << 16; 1004 value64 |= value64 << 32; 1005 #endif 1006 1007 prefix = (unsigned long)start % 8; 1008 if (prefix) { 1009 u8 *r; 1010 1011 prefix = 8 - prefix; 1012 r = check_bytes8(start, value, prefix); 1013 if (r) 1014 return r; 1015 start += prefix; 1016 bytes -= prefix; 1017 } 1018 1019 words = bytes / 8; 1020 1021 while (words) { 1022 if (*(u64 *)start != value64) 1023 return check_bytes8(start, value, 8); 1024 start += 8; 1025 words--; 1026 } 1027 1028 return check_bytes8(start, value, bytes % 8); 1029 } 1030 EXPORT_SYMBOL(memchr_inv); 1031 1032 /** 1033 * strreplace - Replace all occurrences of character in string. 1034 * @s: The string to operate on. 1035 * @old: The character being replaced. 1036 * @new: The character @old is replaced with. 1037 * 1038 * Returns pointer to the nul byte at the end of @s. 1039 */ 1040 char *strreplace(char *s, char old, char new) 1041 { 1042 for (; *s; ++s) 1043 if (*s == old) 1044 *s = new; 1045 return s; 1046 } 1047 EXPORT_SYMBOL(strreplace); 1048 1049 void fortify_panic(const char *name) 1050 { 1051 pr_emerg("detected buffer overflow in %s\n", name); 1052 BUG(); 1053 } 1054 EXPORT_SYMBOL(fortify_panic); 1055