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