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