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 c1 = c2 = 0; 40 if (len) { 41 do { 42 c1 = *s1; 43 c2 = *s2; 44 s1++; 45 s2++; 46 if (!c1) 47 break; 48 if (!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 } 58 return (int)c1 - (int)c2; 59 } 60 EXPORT_SYMBOL(strnicmp); 61 #endif 62 63 #ifndef __HAVE_ARCH_STRCPY 64 /** 65 * strcpy - Copy a %NUL terminated string 66 * @dest: Where to copy the string to 67 * @src: Where to copy the string from 68 */ 69 #undef strcpy 70 char *strcpy(char *dest, const char *src) 71 { 72 char *tmp = dest; 73 74 while ((*dest++ = *src++) != '\0') 75 /* nothing */; 76 return tmp; 77 } 78 EXPORT_SYMBOL(strcpy); 79 #endif 80 81 #ifndef __HAVE_ARCH_STRNCPY 82 /** 83 * strncpy - Copy a length-limited, %NUL-terminated string 84 * @dest: Where to copy the string to 85 * @src: Where to copy the string from 86 * @count: The maximum number of bytes to copy 87 * 88 * The result is not %NUL-terminated if the source exceeds 89 * @count bytes. 90 * 91 * In the case where the length of @src is less than that of 92 * count, the remainder of @dest will be padded with %NUL. 93 * 94 */ 95 char *strncpy(char *dest, const char *src, size_t count) 96 { 97 char *tmp = dest; 98 99 while (count) { 100 if ((*tmp = *src) != 0) 101 src++; 102 tmp++; 103 count--; 104 } 105 return dest; 106 } 107 EXPORT_SYMBOL(strncpy); 108 #endif 109 110 #ifndef __HAVE_ARCH_STRLCPY 111 /** 112 * strlcpy - Copy a %NUL terminated string into a sized buffer 113 * @dest: Where to copy the string to 114 * @src: Where to copy the string from 115 * @size: size of destination buffer 116 * 117 * Compatible with *BSD: the result is always a valid 118 * NUL-terminated string that fits in the buffer (unless, 119 * of course, the buffer size is zero). It does not pad 120 * out the result like strncpy() does. 121 */ 122 size_t strlcpy(char *dest, const char *src, size_t size) 123 { 124 size_t ret = strlen(src); 125 126 if (size) { 127 size_t len = (ret >= size) ? size - 1 : ret; 128 memcpy(dest, src, len); 129 dest[len] = '\0'; 130 } 131 return ret; 132 } 133 EXPORT_SYMBOL(strlcpy); 134 #endif 135 136 #ifndef __HAVE_ARCH_STRCAT 137 /** 138 * strcat - Append one %NUL-terminated string to another 139 * @dest: The string to be appended to 140 * @src: The string to append to it 141 */ 142 #undef strcat 143 char *strcat(char *dest, const char *src) 144 { 145 char *tmp = dest; 146 147 while (*dest) 148 dest++; 149 while ((*dest++ = *src++) != '\0') 150 ; 151 return tmp; 152 } 153 EXPORT_SYMBOL(strcat); 154 #endif 155 156 #ifndef __HAVE_ARCH_STRNCAT 157 /** 158 * strncat - Append a length-limited, %NUL-terminated string to another 159 * @dest: The string to be appended to 160 * @src: The string to append to it 161 * @count: The maximum numbers of bytes to copy 162 * 163 * Note that in contrast to strncpy, strncat ensures the result is 164 * terminated. 165 */ 166 char *strncat(char *dest, const char *src, size_t count) 167 { 168 char *tmp = dest; 169 170 if (count) { 171 while (*dest) 172 dest++; 173 while ((*dest++ = *src++) != 0) { 174 if (--count == 0) { 175 *dest = '\0'; 176 break; 177 } 178 } 179 } 180 return tmp; 181 } 182 EXPORT_SYMBOL(strncat); 183 #endif 184 185 #ifndef __HAVE_ARCH_STRLCAT 186 /** 187 * strlcat - Append a length-limited, %NUL-terminated string to another 188 * @dest: The string to be appended to 189 * @src: The string to append to it 190 * @count: The size of the destination buffer. 191 */ 192 size_t strlcat(char *dest, const char *src, size_t count) 193 { 194 size_t dsize = strlen(dest); 195 size_t len = strlen(src); 196 size_t res = dsize + len; 197 198 /* This would be a bug */ 199 BUG_ON(dsize >= count); 200 201 dest += dsize; 202 count -= dsize; 203 if (len >= count) 204 len = count-1; 205 memcpy(dest, src, len); 206 dest[len] = 0; 207 return res; 208 } 209 EXPORT_SYMBOL(strlcat); 210 #endif 211 212 #ifndef __HAVE_ARCH_STRCMP 213 /** 214 * strcmp - Compare two strings 215 * @cs: One string 216 * @ct: Another string 217 */ 218 #undef strcmp 219 int strcmp(const char *cs, const char *ct) 220 { 221 signed char __res; 222 223 while (1) { 224 if ((__res = *cs - *ct++) != 0 || !*cs++) 225 break; 226 } 227 return __res; 228 } 229 EXPORT_SYMBOL(strcmp); 230 #endif 231 232 #ifndef __HAVE_ARCH_STRNCMP 233 /** 234 * strncmp - Compare two length-limited strings 235 * @cs: One string 236 * @ct: Another string 237 * @count: The maximum number of bytes to compare 238 */ 239 int strncmp(const char *cs, const char *ct, size_t count) 240 { 241 signed char __res = 0; 242 243 while (count) { 244 if ((__res = *cs - *ct++) != 0 || !*cs++) 245 break; 246 count--; 247 } 248 return __res; 249 } 250 EXPORT_SYMBOL(strncmp); 251 #endif 252 253 #ifndef __HAVE_ARCH_STRCHR 254 /** 255 * strchr - Find the first occurrence of a character in a string 256 * @s: The string to be searched 257 * @c: The character to search for 258 */ 259 char *strchr(const char *s, int c) 260 { 261 for (; *s != (char)c; ++s) 262 if (*s == '\0') 263 return NULL; 264 return (char *)s; 265 } 266 EXPORT_SYMBOL(strchr); 267 #endif 268 269 #ifndef __HAVE_ARCH_STRRCHR 270 /** 271 * strrchr - Find the last occurrence of a character in a string 272 * @s: The string to be searched 273 * @c: The character to search for 274 */ 275 char *strrchr(const char *s, int c) 276 { 277 const char *p = s + strlen(s); 278 do { 279 if (*p == (char)c) 280 return (char *)p; 281 } while (--p >= s); 282 return NULL; 283 } 284 EXPORT_SYMBOL(strrchr); 285 #endif 286 287 #ifndef __HAVE_ARCH_STRNCHR 288 /** 289 * strnchr - Find a character in a length limited string 290 * @s: The string to be searched 291 * @count: The number of characters to be searched 292 * @c: The character to search for 293 */ 294 char *strnchr(const char *s, size_t count, int c) 295 { 296 for (; count-- && *s != '\0'; ++s) 297 if (*s == (char)c) 298 return (char *)s; 299 return NULL; 300 } 301 EXPORT_SYMBOL(strnchr); 302 #endif 303 304 /** 305 * strstrip - Removes leading and trailing whitespace from @s. 306 * @s: The string to be stripped. 307 * 308 * Note that the first trailing whitespace is replaced with a %NUL-terminator 309 * in the given string @s. Returns a pointer to the first non-whitespace 310 * character in @s. 311 */ 312 char *strstrip(char *s) 313 { 314 size_t size; 315 char *end; 316 317 size = strlen(s); 318 319 if (!size) 320 return s; 321 322 end = s + size - 1; 323 while (end >= s && isspace(*end)) 324 end--; 325 *(end + 1) = '\0'; 326 327 while (*s && isspace(*s)) 328 s++; 329 330 return s; 331 } 332 EXPORT_SYMBOL(strstrip); 333 334 #ifndef __HAVE_ARCH_STRLEN 335 /** 336 * strlen - Find the length of a string 337 * @s: The string to be sized 338 */ 339 size_t strlen(const char *s) 340 { 341 const char *sc; 342 343 for (sc = s; *sc != '\0'; ++sc) 344 /* nothing */; 345 return sc - s; 346 } 347 EXPORT_SYMBOL(strlen); 348 #endif 349 350 #ifndef __HAVE_ARCH_STRNLEN 351 /** 352 * strnlen - Find the length of a length-limited string 353 * @s: The string to be sized 354 * @count: The maximum number of bytes to search 355 */ 356 size_t strnlen(const char *s, size_t count) 357 { 358 const char *sc; 359 360 for (sc = s; count-- && *sc != '\0'; ++sc) 361 /* nothing */; 362 return sc - s; 363 } 364 EXPORT_SYMBOL(strnlen); 365 #endif 366 367 #ifndef __HAVE_ARCH_STRSPN 368 /** 369 * strspn - Calculate the length of the initial substring of @s which only 370 * contain letters in @accept 371 * @s: The string to be searched 372 * @accept: The string to search for 373 */ 374 size_t strspn(const char *s, const char *accept) 375 { 376 const char *p; 377 const char *a; 378 size_t count = 0; 379 380 for (p = s; *p != '\0'; ++p) { 381 for (a = accept; *a != '\0'; ++a) { 382 if (*p == *a) 383 break; 384 } 385 if (*a == '\0') 386 return count; 387 ++count; 388 } 389 return count; 390 } 391 392 EXPORT_SYMBOL(strspn); 393 #endif 394 395 #ifndef __HAVE_ARCH_STRCSPN 396 /** 397 * strcspn - Calculate the length of the initial substring of @s which does 398 * not contain letters in @reject 399 * @s: The string to be searched 400 * @reject: The string to avoid 401 */ 402 size_t strcspn(const char *s, const char *reject) 403 { 404 const char *p; 405 const char *r; 406 size_t count = 0; 407 408 for (p = s; *p != '\0'; ++p) { 409 for (r = reject; *r != '\0'; ++r) { 410 if (*p == *r) 411 return count; 412 } 413 ++count; 414 } 415 return count; 416 } 417 EXPORT_SYMBOL(strcspn); 418 #endif 419 420 #ifndef __HAVE_ARCH_STRPBRK 421 /** 422 * strpbrk - Find the first occurrence of a set of characters 423 * @cs: The string to be searched 424 * @ct: The characters to search for 425 */ 426 char *strpbrk(const char *cs, const char *ct) 427 { 428 const char *sc1, *sc2; 429 430 for (sc1 = cs; *sc1 != '\0'; ++sc1) { 431 for (sc2 = ct; *sc2 != '\0'; ++sc2) { 432 if (*sc1 == *sc2) 433 return (char *)sc1; 434 } 435 } 436 return NULL; 437 } 438 EXPORT_SYMBOL(strpbrk); 439 #endif 440 441 #ifndef __HAVE_ARCH_STRSEP 442 /** 443 * strsep - Split a string into tokens 444 * @s: The string to be searched 445 * @ct: The characters to search for 446 * 447 * strsep() updates @s to point after the token, ready for the next call. 448 * 449 * It returns empty tokens, too, behaving exactly like the libc function 450 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied. 451 * Same semantics, slimmer shape. ;) 452 */ 453 char *strsep(char **s, const char *ct) 454 { 455 char *sbegin = *s; 456 char *end; 457 458 if (sbegin == NULL) 459 return NULL; 460 461 end = strpbrk(sbegin, ct); 462 if (end) 463 *end++ = '\0'; 464 *s = end; 465 return sbegin; 466 } 467 EXPORT_SYMBOL(strsep); 468 #endif 469 470 #ifndef __HAVE_ARCH_MEMSET 471 /** 472 * memset - Fill a region of memory with the given value 473 * @s: Pointer to the start of the area. 474 * @c: The byte to fill the area with 475 * @count: The size of the area. 476 * 477 * Do not use memset() to access IO space, use memset_io() instead. 478 */ 479 void *memset(void *s, int c, size_t count) 480 { 481 char *xs = s; 482 483 while (count--) 484 *xs++ = c; 485 return s; 486 } 487 EXPORT_SYMBOL(memset); 488 #endif 489 490 #ifndef __HAVE_ARCH_MEMCPY 491 /** 492 * memcpy - Copy one area of memory to another 493 * @dest: Where to copy to 494 * @src: Where to copy from 495 * @count: The size of the area. 496 * 497 * You should not use this function to access IO space, use memcpy_toio() 498 * or memcpy_fromio() instead. 499 */ 500 void *memcpy(void *dest, const void *src, size_t count) 501 { 502 char *tmp = dest; 503 const char *s = src; 504 505 while (count--) 506 *tmp++ = *s++; 507 return dest; 508 } 509 EXPORT_SYMBOL(memcpy); 510 #endif 511 512 #ifndef __HAVE_ARCH_MEMMOVE 513 /** 514 * memmove - Copy one area of memory to another 515 * @dest: Where to copy to 516 * @src: Where to copy from 517 * @count: The size of the area. 518 * 519 * Unlike memcpy(), memmove() copes with overlapping areas. 520 */ 521 void *memmove(void *dest, const void *src, size_t count) 522 { 523 char *tmp; 524 const char *s; 525 526 if (dest <= src) { 527 tmp = dest; 528 s = src; 529 while (count--) 530 *tmp++ = *s++; 531 } else { 532 tmp = dest; 533 tmp += count; 534 s = src; 535 s += count; 536 while (count--) 537 *--tmp = *--s; 538 } 539 return dest; 540 } 541 EXPORT_SYMBOL(memmove); 542 #endif 543 544 #ifndef __HAVE_ARCH_MEMCMP 545 /** 546 * memcmp - Compare two areas of memory 547 * @cs: One area of memory 548 * @ct: Another area of memory 549 * @count: The size of the area. 550 */ 551 #undef memcmp 552 int memcmp(const void *cs, const void *ct, size_t count) 553 { 554 const unsigned char *su1, *su2; 555 int res = 0; 556 557 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--) 558 if ((res = *su1 - *su2) != 0) 559 break; 560 return res; 561 } 562 EXPORT_SYMBOL(memcmp); 563 #endif 564 565 #ifndef __HAVE_ARCH_MEMSCAN 566 /** 567 * memscan - Find a character in an area of memory. 568 * @addr: The memory area 569 * @c: The byte to search for 570 * @size: The size of the area. 571 * 572 * returns the address of the first occurrence of @c, or 1 byte past 573 * the area if @c is not found 574 */ 575 void *memscan(void *addr, int c, size_t size) 576 { 577 unsigned char *p = addr; 578 579 while (size) { 580 if (*p == c) 581 return (void *)p; 582 p++; 583 size--; 584 } 585 return (void *)p; 586 } 587 EXPORT_SYMBOL(memscan); 588 #endif 589 590 #ifndef __HAVE_ARCH_STRSTR 591 /** 592 * strstr - Find the first substring in a %NUL terminated string 593 * @s1: The string to be searched 594 * @s2: The string to search for 595 */ 596 char *strstr(const char *s1, const char *s2) 597 { 598 int l1, l2; 599 600 l2 = strlen(s2); 601 if (!l2) 602 return (char *)s1; 603 l1 = strlen(s1); 604 while (l1 >= l2) { 605 l1--; 606 if (!memcmp(s1, s2, l2)) 607 return (char *)s1; 608 s1++; 609 } 610 return NULL; 611 } 612 EXPORT_SYMBOL(strstr); 613 #endif 614 615 #ifndef __HAVE_ARCH_MEMCHR 616 /** 617 * memchr - Find a character in an area of memory. 618 * @s: The memory area 619 * @c: The byte to search for 620 * @n: The size of the area. 621 * 622 * returns the address of the first occurrence of @c, or %NULL 623 * if @c is not found 624 */ 625 void *memchr(const void *s, int c, size_t n) 626 { 627 const unsigned char *p = s; 628 while (n-- != 0) { 629 if ((unsigned char)c == *p++) { 630 return (void *)(p - 1); 631 } 632 } 633 return NULL; 634 } 635 EXPORT_SYMBOL(memchr); 636 #endif 637