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 s = skip_spaces(s); 364 size = strlen(s); 365 if (!size) 366 return s; 367 368 end = s + size - 1; 369 while (end >= s && isspace(*end)) 370 end--; 371 *(end + 1) = '\0'; 372 373 return s; 374 } 375 EXPORT_SYMBOL(strim); 376 377 #ifndef __HAVE_ARCH_STRLEN 378 /** 379 * strlen - Find the length of a string 380 * @s: The string to be sized 381 */ 382 size_t strlen(const char *s) 383 { 384 const char *sc; 385 386 for (sc = s; *sc != '\0'; ++sc) 387 /* nothing */; 388 return sc - s; 389 } 390 EXPORT_SYMBOL(strlen); 391 #endif 392 393 #ifndef __HAVE_ARCH_STRNLEN 394 /** 395 * strnlen - Find the length of a length-limited string 396 * @s: The string to be sized 397 * @count: The maximum number of bytes to search 398 */ 399 size_t strnlen(const char *s, size_t count) 400 { 401 const char *sc; 402 403 for (sc = s; count-- && *sc != '\0'; ++sc) 404 /* nothing */; 405 return sc - s; 406 } 407 EXPORT_SYMBOL(strnlen); 408 #endif 409 410 #ifndef __HAVE_ARCH_STRSPN 411 /** 412 * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept 413 * @s: The string to be searched 414 * @accept: The string to search for 415 */ 416 size_t strspn(const char *s, const char *accept) 417 { 418 const char *p; 419 const char *a; 420 size_t count = 0; 421 422 for (p = s; *p != '\0'; ++p) { 423 for (a = accept; *a != '\0'; ++a) { 424 if (*p == *a) 425 break; 426 } 427 if (*a == '\0') 428 return count; 429 ++count; 430 } 431 return count; 432 } 433 434 EXPORT_SYMBOL(strspn); 435 #endif 436 437 #ifndef __HAVE_ARCH_STRCSPN 438 /** 439 * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject 440 * @s: The string to be searched 441 * @reject: The string to avoid 442 */ 443 size_t strcspn(const char *s, const char *reject) 444 { 445 const char *p; 446 const char *r; 447 size_t count = 0; 448 449 for (p = s; *p != '\0'; ++p) { 450 for (r = reject; *r != '\0'; ++r) { 451 if (*p == *r) 452 return count; 453 } 454 ++count; 455 } 456 return count; 457 } 458 EXPORT_SYMBOL(strcspn); 459 #endif 460 461 #ifndef __HAVE_ARCH_STRPBRK 462 /** 463 * strpbrk - Find the first occurrence of a set of characters 464 * @cs: The string to be searched 465 * @ct: The characters to search for 466 */ 467 char *strpbrk(const char *cs, const char *ct) 468 { 469 const char *sc1, *sc2; 470 471 for (sc1 = cs; *sc1 != '\0'; ++sc1) { 472 for (sc2 = ct; *sc2 != '\0'; ++sc2) { 473 if (*sc1 == *sc2) 474 return (char *)sc1; 475 } 476 } 477 return NULL; 478 } 479 EXPORT_SYMBOL(strpbrk); 480 #endif 481 482 #ifndef __HAVE_ARCH_STRSEP 483 /** 484 * strsep - Split a string into tokens 485 * @s: The string to be searched 486 * @ct: The characters to search for 487 * 488 * strsep() updates @s to point after the token, ready for the next call. 489 * 490 * It returns empty tokens, too, behaving exactly like the libc function 491 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied. 492 * Same semantics, slimmer shape. ;) 493 */ 494 char *strsep(char **s, const char *ct) 495 { 496 char *sbegin = *s; 497 char *end; 498 499 if (sbegin == NULL) 500 return NULL; 501 502 end = strpbrk(sbegin, ct); 503 if (end) 504 *end++ = '\0'; 505 *s = end; 506 return sbegin; 507 } 508 EXPORT_SYMBOL(strsep); 509 #endif 510 511 /** 512 * sysfs_streq - return true if strings are equal, modulo trailing newline 513 * @s1: one string 514 * @s2: another string 515 * 516 * This routine returns true iff two strings are equal, treating both 517 * NUL and newline-then-NUL as equivalent string terminations. It's 518 * geared for use with sysfs input strings, which generally terminate 519 * with newlines but are compared against values without newlines. 520 */ 521 bool sysfs_streq(const char *s1, const char *s2) 522 { 523 while (*s1 && *s1 == *s2) { 524 s1++; 525 s2++; 526 } 527 528 if (*s1 == *s2) 529 return true; 530 if (!*s1 && *s2 == '\n' && !s2[1]) 531 return true; 532 if (*s1 == '\n' && !s1[1] && !*s2) 533 return true; 534 return false; 535 } 536 EXPORT_SYMBOL(sysfs_streq); 537 538 #ifndef __HAVE_ARCH_MEMSET 539 /** 540 * memset - Fill a region of memory with the given value 541 * @s: Pointer to the start of the area. 542 * @c: The byte to fill the area with 543 * @count: The size of the area. 544 * 545 * Do not use memset() to access IO space, use memset_io() instead. 546 */ 547 void *memset(void *s, int c, size_t count) 548 { 549 char *xs = s; 550 551 while (count--) 552 *xs++ = c; 553 return s; 554 } 555 EXPORT_SYMBOL(memset); 556 #endif 557 558 #ifndef __HAVE_ARCH_MEMCPY 559 /** 560 * memcpy - Copy one area of memory to another 561 * @dest: Where to copy to 562 * @src: Where to copy from 563 * @count: The size of the area. 564 * 565 * You should not use this function to access IO space, use memcpy_toio() 566 * or memcpy_fromio() instead. 567 */ 568 void *memcpy(void *dest, const void *src, size_t count) 569 { 570 char *tmp = dest; 571 const char *s = src; 572 573 while (count--) 574 *tmp++ = *s++; 575 return dest; 576 } 577 EXPORT_SYMBOL(memcpy); 578 #endif 579 580 #ifndef __HAVE_ARCH_MEMMOVE 581 /** 582 * memmove - Copy one area of memory to another 583 * @dest: Where to copy to 584 * @src: Where to copy from 585 * @count: The size of the area. 586 * 587 * Unlike memcpy(), memmove() copes with overlapping areas. 588 */ 589 void *memmove(void *dest, const void *src, size_t count) 590 { 591 char *tmp; 592 const char *s; 593 594 if (dest <= src) { 595 tmp = dest; 596 s = src; 597 while (count--) 598 *tmp++ = *s++; 599 } else { 600 tmp = dest; 601 tmp += count; 602 s = src; 603 s += count; 604 while (count--) 605 *--tmp = *--s; 606 } 607 return dest; 608 } 609 EXPORT_SYMBOL(memmove); 610 #endif 611 612 #ifndef __HAVE_ARCH_MEMCMP 613 /** 614 * memcmp - Compare two areas of memory 615 * @cs: One area of memory 616 * @ct: Another area of memory 617 * @count: The size of the area. 618 */ 619 #undef memcmp 620 int memcmp(const void *cs, const void *ct, size_t count) 621 { 622 const unsigned char *su1, *su2; 623 int res = 0; 624 625 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--) 626 if ((res = *su1 - *su2) != 0) 627 break; 628 return res; 629 } 630 EXPORT_SYMBOL(memcmp); 631 #endif 632 633 #ifndef __HAVE_ARCH_MEMSCAN 634 /** 635 * memscan - Find a character in an area of memory. 636 * @addr: The memory area 637 * @c: The byte to search for 638 * @size: The size of the area. 639 * 640 * returns the address of the first occurrence of @c, or 1 byte past 641 * the area if @c is not found 642 */ 643 void *memscan(void *addr, int c, size_t size) 644 { 645 unsigned char *p = addr; 646 647 while (size) { 648 if (*p == c) 649 return (void *)p; 650 p++; 651 size--; 652 } 653 return (void *)p; 654 } 655 EXPORT_SYMBOL(memscan); 656 #endif 657 658 #ifndef __HAVE_ARCH_STRSTR 659 /** 660 * strstr - Find the first substring in a %NUL terminated string 661 * @s1: The string to be searched 662 * @s2: The string to search for 663 */ 664 char *strstr(const char *s1, const char *s2) 665 { 666 size_t l1, l2; 667 668 l2 = strlen(s2); 669 if (!l2) 670 return (char *)s1; 671 l1 = strlen(s1); 672 while (l1 >= l2) { 673 l1--; 674 if (!memcmp(s1, s2, l2)) 675 return (char *)s1; 676 s1++; 677 } 678 return NULL; 679 } 680 EXPORT_SYMBOL(strstr); 681 #endif 682 683 #ifndef __HAVE_ARCH_STRNSTR 684 /** 685 * strnstr - Find the first substring in a length-limited string 686 * @s1: The string to be searched 687 * @s2: The string to search for 688 * @len: the maximum number of characters to search 689 */ 690 char *strnstr(const char *s1, const char *s2, size_t len) 691 { 692 size_t l2; 693 694 l2 = strlen(s2); 695 if (!l2) 696 return (char *)s1; 697 while (len >= l2) { 698 len--; 699 if (!memcmp(s1, s2, l2)) 700 return (char *)s1; 701 s1++; 702 } 703 return NULL; 704 } 705 EXPORT_SYMBOL(strnstr); 706 #endif 707 708 #ifndef __HAVE_ARCH_MEMCHR 709 /** 710 * memchr - Find a character in an area of memory. 711 * @s: The memory area 712 * @c: The byte to search for 713 * @n: The size of the area. 714 * 715 * returns the address of the first occurrence of @c, or %NULL 716 * if @c is not found 717 */ 718 void *memchr(const void *s, int c, size_t n) 719 { 720 const unsigned char *p = s; 721 while (n-- != 0) { 722 if ((unsigned char)c == *p++) { 723 return (void *)(p - 1); 724 } 725 } 726 return NULL; 727 } 728 EXPORT_SYMBOL(memchr); 729 #endif 730