Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
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> | |
8bc3bcc9 PG |
26 | #include <linux/kernel.h> |
27 | #include <linux/export.h> | |
50af5ead | 28 | #include <linux/bug.h> |
8bc3bcc9 | 29 | #include <linux/errno.h> |
1da177e4 | 30 | |
30035e45 CM |
31 | #include <asm/byteorder.h> |
32 | #include <asm/word-at-a-time.h> | |
33 | #include <asm/page.h> | |
34 | ||
cd514e72 | 35 | #ifndef __HAVE_ARCH_STRNCASECMP |
1da177e4 | 36 | /** |
cd514e72 | 37 | * strncasecmp - Case insensitive, length-limited string comparison |
1da177e4 LT |
38 | * @s1: One string |
39 | * @s2: The other string | |
40 | * @len: the maximum number of characters to compare | |
41 | */ | |
cd514e72 | 42 | int strncasecmp(const char *s1, const char *s2, size_t len) |
1da177e4 LT |
43 | { |
44 | /* Yes, Virginia, it had better be unsigned */ | |
45 | unsigned char c1, c2; | |
46 | ||
a11d2b64 AGR |
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); | |
1da177e4 LT |
62 | return (int)c1 - (int)c2; |
63 | } | |
cd514e72 RV |
64 | EXPORT_SYMBOL(strncasecmp); |
65 | #endif | |
1da177e4 | 66 | |
ded220bd DM |
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 | ||
1da177e4 LT |
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 | */ | |
0c28130b | 87 | #undef strcpy |
51a0f0f6 | 88 | char *strcpy(char *dest, const char *src) |
1da177e4 LT |
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 | /** | |
0046dd9f | 101 | * strncpy - Copy a length-limited, C-string |
1da177e4 LT |
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. | |
25279526 | 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 | * | |
1da177e4 | 112 | */ |
51a0f0f6 | 113 | char *strncpy(char *dest, const char *src, size_t count) |
1da177e4 LT |
114 | { |
115 | char *tmp = dest; | |
116 | ||
117 | while (count) { | |
51a0f0f6 JJ |
118 | if ((*tmp = *src) != 0) |
119 | src++; | |
1da177e4 LT |
120 | tmp++; |
121 | count--; | |
122 | } | |
123 | return dest; | |
124 | } | |
125 | EXPORT_SYMBOL(strncpy); | |
126 | #endif | |
127 | ||
128 | #ifndef __HAVE_ARCH_STRLCPY | |
129 | /** | |
0046dd9f | 130 | * strlcpy - Copy a C-string into a sized buffer |
1da177e4 LT |
131 | * @dest: Where to copy the string to |
132 | * @src: Where to copy the string from | |
133 | * @size: size of destination buffer | |
134 | * | |
0e056eb5 | 135 | * Compatible with ``*BSD``: the result is always a valid |
1da177e4 LT |
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) { | |
51a0f0f6 | 145 | size_t len = (ret >= size) ? size - 1 : ret; |
1da177e4 LT |
146 | memcpy(dest, src, len); |
147 | dest[len] = '\0'; | |
148 | } | |
149 | return ret; | |
150 | } | |
151 | EXPORT_SYMBOL(strlcpy); | |
152 | #endif | |
153 | ||
30035e45 CM |
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 = *(unsigned long *)(src+res); | |
30035e45 CM |
207 | if (has_zero(c, &data, &constants)) { |
208 | data = prep_zero_mask(c, data, &constants); | |
209 | data = create_zero_mask(data); | |
990486c8 | 210 | *(unsigned long *)(dest+res) = c & zero_bytemask(data); |
30035e45 CM |
211 | return res + find_zero(data); |
212 | } | |
990486c8 | 213 | *(unsigned long *)(dest+res) = c; |
30035e45 CM |
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 | ||
1da177e4 LT |
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 | */ | |
0c28130b | 245 | #undef strcat |
51a0f0f6 | 246 | char *strcat(char *dest, const char *src) |
1da177e4 LT |
247 | { |
248 | char *tmp = dest; | |
249 | ||
250 | while (*dest) | |
251 | dest++; | |
252 | while ((*dest++ = *src++) != '\0') | |
253 | ; | |
1da177e4 LT |
254 | return tmp; |
255 | } | |
256 | EXPORT_SYMBOL(strcat); | |
257 | #endif | |
258 | ||
259 | #ifndef __HAVE_ARCH_STRNCAT | |
260 | /** | |
0046dd9f | 261 | * strncat - Append a length-limited, C-string to another |
1da177e4 LT |
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 | * | |
72fd4a35 | 266 | * Note that in contrast to strncpy(), strncat() ensures the result is |
1da177e4 LT |
267 | * terminated. |
268 | */ | |
51a0f0f6 | 269 | char *strncat(char *dest, const char *src, size_t count) |
1da177e4 LT |
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 | } | |
1da177e4 LT |
283 | return tmp; |
284 | } | |
285 | EXPORT_SYMBOL(strncat); | |
286 | #endif | |
287 | ||
288 | #ifndef __HAVE_ARCH_STRLCAT | |
289 | /** | |
0046dd9f | 290 | * strlcat - Append a length-limited, C-string to another |
1da177e4 LT |
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 | */ | |
0c28130b | 321 | #undef strcmp |
51a0f0f6 | 322 | int strcmp(const char *cs, const char *ct) |
1da177e4 | 323 | { |
a414f01a | 324 | unsigned char c1, c2; |
1da177e4 LT |
325 | |
326 | while (1) { | |
a414f01a LT |
327 | c1 = *cs++; |
328 | c2 = *ct++; | |
329 | if (c1 != c2) | |
330 | return c1 < c2 ? -1 : 1; | |
331 | if (!c1) | |
1da177e4 LT |
332 | break; |
333 | } | |
a414f01a | 334 | return 0; |
1da177e4 LT |
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 | */ | |
51a0f0f6 | 346 | int strncmp(const char *cs, const char *ct, size_t count) |
1da177e4 | 347 | { |
a414f01a | 348 | unsigned char c1, c2; |
1da177e4 LT |
349 | |
350 | while (count) { | |
a414f01a LT |
351 | c1 = *cs++; |
352 | c2 = *ct++; | |
353 | if (c1 != c2) | |
354 | return c1 < c2 ? -1 : 1; | |
355 | if (!c1) | |
1da177e4 LT |
356 | break; |
357 | count--; | |
358 | } | |
a414f01a | 359 | return 0; |
1da177e4 LT |
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 | */ | |
51a0f0f6 | 370 | char *strchr(const char *s, int c) |
1da177e4 | 371 | { |
51a0f0f6 | 372 | for (; *s != (char)c; ++s) |
1da177e4 LT |
373 | if (*s == '\0') |
374 | return NULL; | |
51a0f0f6 | 375 | return (char *)s; |
1da177e4 LT |
376 | } |
377 | EXPORT_SYMBOL(strchr); | |
378 | #endif | |
379 | ||
11d200e9 GL |
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 | ||
1da177e4 LT |
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 | */ | |
51a0f0f6 | 404 | char *strrchr(const char *s, int c) |
1da177e4 | 405 | { |
8da53d45 RV |
406 | const char *last = NULL; |
407 | do { | |
408 | if (*s == (char)c) | |
409 | last = s; | |
410 | } while (*s++); | |
411 | return (char *)last; | |
1da177e4 LT |
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) | |
51a0f0f6 JJ |
426 | if (*s == (char)c) |
427 | return (char *)s; | |
1da177e4 LT |
428 | return NULL; |
429 | } | |
430 | EXPORT_SYMBOL(strnchr); | |
431 | #endif | |
432 | ||
f653398c | 433 | /** |
a6cd13f3 RD |
434 | * skip_spaces - Removes leading whitespace from @str. |
435 | * @str: The string to be stripped. | |
f653398c | 436 | * |
a6cd13f3 | 437 | * Returns a pointer to the first non-whitespace character in @str. |
f653398c AGR |
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 | ||
481fad48 | 447 | /** |
ca54cb8c | 448 | * strim - Removes leading and trailing whitespace from @s. |
481fad48 PE |
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 | */ | |
ca54cb8c | 455 | char *strim(char *s) |
481fad48 PE |
456 | { |
457 | size_t size; | |
458 | char *end; | |
459 | ||
460 | size = strlen(s); | |
481fad48 PE |
461 | if (!size) |
462 | return s; | |
463 | ||
464 | end = s + size - 1; | |
6e6d9fa6 | 465 | while (end >= s && isspace(*end)) |
481fad48 PE |
466 | end--; |
467 | *(end + 1) = '\0'; | |
468 | ||
66f6958e | 469 | return skip_spaces(s); |
481fad48 | 470 | } |
ca54cb8c | 471 | EXPORT_SYMBOL(strim); |
481fad48 | 472 | |
1da177e4 LT |
473 | #ifndef __HAVE_ARCH_STRLEN |
474 | /** | |
475 | * strlen - Find the length of a string | |
476 | * @s: The string to be sized | |
477 | */ | |
51a0f0f6 | 478 | size_t strlen(const char *s) |
1da177e4 LT |
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 | */ | |
51a0f0f6 | 495 | size_t strnlen(const char *s, size_t count) |
1da177e4 LT |
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 | /** | |
72fd4a35 | 508 | * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept |
1da177e4 LT |
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 | } | |
1da177e4 LT |
527 | return count; |
528 | } | |
529 | ||
530 | EXPORT_SYMBOL(strspn); | |
531 | #endif | |
532 | ||
8833d328 | 533 | #ifndef __HAVE_ARCH_STRCSPN |
1da177e4 | 534 | /** |
72fd4a35 | 535 | * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject |
1da177e4 LT |
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 | } | |
1da177e4 | 552 | return count; |
51a0f0f6 | 553 | } |
1da177e4 | 554 | EXPORT_SYMBOL(strcspn); |
8833d328 | 555 | #endif |
1da177e4 LT |
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 | */ | |
51a0f0f6 | 563 | char *strpbrk(const char *cs, const char *ct) |
1da177e4 | 564 | { |
51a0f0f6 | 565 | const char *sc1, *sc2; |
1da177e4 | 566 | |
51a0f0f6 JJ |
567 | for (sc1 = cs; *sc1 != '\0'; ++sc1) { |
568 | for (sc2 = ct; *sc2 != '\0'; ++sc2) { | |
1da177e4 | 569 | if (*sc1 == *sc2) |
51a0f0f6 | 570 | return (char *)sc1; |
1da177e4 LT |
571 | } |
572 | } | |
573 | return NULL; | |
574 | } | |
894b5779 | 575 | EXPORT_SYMBOL(strpbrk); |
1da177e4 LT |
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 | */ | |
51a0f0f6 | 590 | char *strsep(char **s, const char *ct) |
1da177e4 | 591 | { |
51a0f0f6 JJ |
592 | char *sbegin = *s; |
593 | char *end; | |
1da177e4 LT |
594 | |
595 | if (sbegin == NULL) | |
596 | return NULL; | |
597 | ||
598 | end = strpbrk(sbegin, ct); | |
599 | if (end) | |
600 | *end++ = '\0'; | |
601 | *s = end; | |
1da177e4 LT |
602 | return sbegin; |
603 | } | |
1da177e4 LT |
604 | EXPORT_SYMBOL(strsep); |
605 | #endif | |
606 | ||
34990cf7 DB |
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 | ||
56b06081 AS |
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 | ||
e1fe7b6a HK |
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 | ||
1da177e4 LT |
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 | */ | |
51a0f0f6 | 695 | void *memset(void *s, int c, size_t count) |
1da177e4 | 696 | { |
850b9247 | 697 | char *xs = s; |
1da177e4 LT |
698 | |
699 | while (count--) | |
700 | *xs++ = c; | |
1da177e4 LT |
701 | return s; |
702 | } | |
703 | EXPORT_SYMBOL(memset); | |
704 | #endif | |
705 | ||
d4c5efdb DB |
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 | * | |
8155330a DB |
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 | * | |
d4c5efdb DB |
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); | |
7829fb09 | 723 | barrier_data(s); |
d4c5efdb DB |
724 | } |
725 | EXPORT_SYMBOL(memzero_explicit); | |
726 | ||
3b3c4bab MW |
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 | ||
1da177e4 LT |
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 | */ | |
51a0f0f6 | 803 | void *memcpy(void *dest, const void *src, size_t count) |
1da177e4 | 804 | { |
850b9247 | 805 | char *tmp = dest; |
4c416ab7 | 806 | const char *s = src; |
1da177e4 LT |
807 | |
808 | while (count--) | |
809 | *tmp++ = *s++; | |
1da177e4 LT |
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 | */ | |
51a0f0f6 | 824 | void *memmove(void *dest, const void *src, size_t count) |
1da177e4 | 825 | { |
82da2c37 PJ |
826 | char *tmp; |
827 | const char *s; | |
1da177e4 LT |
828 | |
829 | if (dest <= src) { | |
850b9247 JJ |
830 | tmp = dest; |
831 | s = src; | |
1da177e4 LT |
832 | while (count--) |
833 | *tmp++ = *s++; | |
51a0f0f6 | 834 | } else { |
850b9247 JJ |
835 | tmp = dest; |
836 | tmp += count; | |
837 | s = src; | |
838 | s += count; | |
1da177e4 LT |
839 | while (count--) |
840 | *--tmp = *--s; | |
51a0f0f6 | 841 | } |
1da177e4 LT |
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 | */ | |
0c28130b | 854 | #undef memcmp |
a7330c99 | 855 | __visible int memcmp(const void *cs, const void *ct, size_t count) |
1da177e4 LT |
856 | { |
857 | const unsigned char *su1, *su2; | |
858 | int res = 0; | |
859 | ||
51a0f0f6 | 860 | for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--) |
1da177e4 LT |
861 | if ((res = *su1 - *su2) != 0) |
862 | break; | |
863 | return res; | |
864 | } | |
865 | EXPORT_SYMBOL(memcmp); | |
866 | #endif | |
867 | ||
56dbdae0 ND |
868 | #ifndef __HAVE_ARCH_BCMP |
869 | /** | |
870 | * bcmp - returns 0 if and only if the buffers have identical contents. | |
871 | * @a: pointer to first buffer. | |
872 | * @b: pointer to second buffer. | |
873 | * @len: size of buffers. | |
874 | * | |
875 | * The sign or magnitude of a non-zero return value has no particular | |
876 | * meaning, and architectures may implement their own more efficient bcmp(). So | |
877 | * while this particular implementation is a simple (tail) call to memcmp, do | |
878 | * not rely on anything but whether the return value is zero or non-zero. | |
879 | */ | |
880 | #undef bcmp | |
881 | int bcmp(const void *a, const void *b, size_t len) | |
882 | { | |
883 | return memcmp(a, b, len); | |
884 | } | |
885 | EXPORT_SYMBOL(bcmp); | |
886 | #endif | |
887 | ||
1da177e4 LT |
888 | #ifndef __HAVE_ARCH_MEMSCAN |
889 | /** | |
890 | * memscan - Find a character in an area of memory. | |
891 | * @addr: The memory area | |
892 | * @c: The byte to search for | |
893 | * @size: The size of the area. | |
894 | * | |
895 | * returns the address of the first occurrence of @c, or 1 byte past | |
896 | * the area if @c is not found | |
897 | */ | |
51a0f0f6 | 898 | void *memscan(void *addr, int c, size_t size) |
1da177e4 | 899 | { |
850b9247 | 900 | unsigned char *p = addr; |
1da177e4 LT |
901 | |
902 | while (size) { | |
903 | if (*p == c) | |
51a0f0f6 | 904 | return (void *)p; |
1da177e4 LT |
905 | p++; |
906 | size--; | |
907 | } | |
51a0f0f6 | 908 | return (void *)p; |
1da177e4 LT |
909 | } |
910 | EXPORT_SYMBOL(memscan); | |
911 | #endif | |
912 | ||
913 | #ifndef __HAVE_ARCH_STRSTR | |
914 | /** | |
915 | * strstr - Find the first substring in a %NUL terminated string | |
916 | * @s1: The string to be searched | |
917 | * @s2: The string to search for | |
918 | */ | |
51a0f0f6 | 919 | char *strstr(const char *s1, const char *s2) |
1da177e4 | 920 | { |
d5f1fb53 | 921 | size_t l1, l2; |
1da177e4 LT |
922 | |
923 | l2 = strlen(s2); | |
924 | if (!l2) | |
51a0f0f6 | 925 | return (char *)s1; |
1da177e4 LT |
926 | l1 = strlen(s1); |
927 | while (l1 >= l2) { | |
928 | l1--; | |
51a0f0f6 JJ |
929 | if (!memcmp(s1, s2, l2)) |
930 | return (char *)s1; | |
1da177e4 LT |
931 | s1++; |
932 | } | |
933 | return NULL; | |
934 | } | |
935 | EXPORT_SYMBOL(strstr); | |
936 | #endif | |
937 | ||
d5f1fb53 LZ |
938 | #ifndef __HAVE_ARCH_STRNSTR |
939 | /** | |
940 | * strnstr - Find the first substring in a length-limited string | |
941 | * @s1: The string to be searched | |
942 | * @s2: The string to search for | |
943 | * @len: the maximum number of characters to search | |
944 | */ | |
945 | char *strnstr(const char *s1, const char *s2, size_t len) | |
946 | { | |
d6a2eedf | 947 | size_t l2; |
d5f1fb53 LZ |
948 | |
949 | l2 = strlen(s2); | |
950 | if (!l2) | |
951 | return (char *)s1; | |
d6a2eedf AGR |
952 | while (len >= l2) { |
953 | len--; | |
d5f1fb53 LZ |
954 | if (!memcmp(s1, s2, l2)) |
955 | return (char *)s1; | |
956 | s1++; | |
957 | } | |
958 | return NULL; | |
959 | } | |
960 | EXPORT_SYMBOL(strnstr); | |
961 | #endif | |
962 | ||
1da177e4 LT |
963 | #ifndef __HAVE_ARCH_MEMCHR |
964 | /** | |
965 | * memchr - Find a character in an area of memory. | |
966 | * @s: The memory area | |
967 | * @c: The byte to search for | |
968 | * @n: The size of the area. | |
969 | * | |
970 | * returns the address of the first occurrence of @c, or %NULL | |
971 | * if @c is not found | |
972 | */ | |
973 | void *memchr(const void *s, int c, size_t n) | |
974 | { | |
975 | const unsigned char *p = s; | |
976 | while (n-- != 0) { | |
977 | if ((unsigned char)c == *p++) { | |
51a0f0f6 | 978 | return (void *)(p - 1); |
1da177e4 LT |
979 | } |
980 | } | |
981 | return NULL; | |
982 | } | |
983 | EXPORT_SYMBOL(memchr); | |
984 | #endif | |
79824820 AM |
985 | |
986 | static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes) | |
987 | { | |
988 | while (bytes) { | |
989 | if (*start != value) | |
990 | return (void *)start; | |
991 | start++; | |
992 | bytes--; | |
993 | } | |
994 | return NULL; | |
995 | } | |
996 | ||
997 | /** | |
998 | * memchr_inv - Find an unmatching character in an area of memory. | |
999 | * @start: The memory area | |
1000 | * @c: Find a character other than c | |
1001 | * @bytes: The size of the area. | |
1002 | * | |
1003 | * returns the address of the first character other than @c, or %NULL | |
1004 | * if the whole buffer contains just @c. | |
1005 | */ | |
1006 | void *memchr_inv(const void *start, int c, size_t bytes) | |
1007 | { | |
1008 | u8 value = c; | |
1009 | u64 value64; | |
1010 | unsigned int words, prefix; | |
1011 | ||
1012 | if (bytes <= 16) | |
1013 | return check_bytes8(start, value, bytes); | |
1014 | ||
f43804bf | 1015 | value64 = value; |
72d93104 | 1016 | #if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64 |
3368e8fb | 1017 | value64 *= 0x0101010101010101ULL; |
72d93104 | 1018 | #elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) |
f43804bf AM |
1019 | value64 *= 0x01010101; |
1020 | value64 |= value64 << 32; | |
1021 | #else | |
1022 | value64 |= value64 << 8; | |
1023 | value64 |= value64 << 16; | |
1024 | value64 |= value64 << 32; | |
1025 | #endif | |
79824820 | 1026 | |
f43804bf | 1027 | prefix = (unsigned long)start % 8; |
79824820 | 1028 | if (prefix) { |
f43804bf AM |
1029 | u8 *r; |
1030 | ||
1031 | prefix = 8 - prefix; | |
1032 | r = check_bytes8(start, value, prefix); | |
79824820 AM |
1033 | if (r) |
1034 | return r; | |
1035 | start += prefix; | |
1036 | bytes -= prefix; | |
1037 | } | |
1038 | ||
1039 | words = bytes / 8; | |
1040 | ||
1041 | while (words) { | |
1042 | if (*(u64 *)start != value64) | |
1043 | return check_bytes8(start, value, 8); | |
1044 | start += 8; | |
1045 | words--; | |
1046 | } | |
1047 | ||
1048 | return check_bytes8(start, value, bytes % 8); | |
1049 | } | |
1050 | EXPORT_SYMBOL(memchr_inv); | |
94df2904 RV |
1051 | |
1052 | /** | |
1053 | * strreplace - Replace all occurrences of character in string. | |
1054 | * @s: The string to operate on. | |
1055 | * @old: The character being replaced. | |
1056 | * @new: The character @old is replaced with. | |
1057 | * | |
1058 | * Returns pointer to the nul byte at the end of @s. | |
1059 | */ | |
1060 | char *strreplace(char *s, char old, char new) | |
1061 | { | |
1062 | for (; *s; ++s) | |
1063 | if (*s == old) | |
1064 | *s = new; | |
1065 | return s; | |
1066 | } | |
1067 | EXPORT_SYMBOL(strreplace); | |
6974f0c4 DM |
1068 | |
1069 | void fortify_panic(const char *name) | |
1070 | { | |
1071 | pr_emerg("detected buffer overflow in %s\n", name); | |
1072 | BUG(); | |
1073 | } | |
1074 | EXPORT_SYMBOL(fortify_panic); | |
03270c13 MW |
1075 | |
1076 | #ifdef CONFIG_STRING_SELFTEST | |
1077 | #include <linux/slab.h> | |
1078 | #include <linux/module.h> | |
1079 | ||
1080 | static __init int memset16_selftest(void) | |
1081 | { | |
1082 | unsigned i, j, k; | |
da436528 DC |
1083 | u16 v, *p; |
1084 | ||
1085 | p = kmalloc(256 * 2 * 2, GFP_KERNEL); | |
1086 | if (!p) | |
1087 | return -1; | |
03270c13 MW |
1088 | |
1089 | for (i = 0; i < 256; i++) { | |
1090 | for (j = 0; j < 256; j++) { | |
1091 | memset(p, 0xa1, 256 * 2 * sizeof(v)); | |
1092 | memset16(p + i, 0xb1b2, j); | |
1093 | for (k = 0; k < 512; k++) { | |
1094 | v = p[k]; | |
1095 | if (k < i) { | |
1096 | if (v != 0xa1a1) | |
1097 | goto fail; | |
1098 | } else if (k < i + j) { | |
1099 | if (v != 0xb1b2) | |
1100 | goto fail; | |
1101 | } else { | |
1102 | if (v != 0xa1a1) | |
1103 | goto fail; | |
1104 | } | |
1105 | } | |
1106 | } | |
1107 | } | |
1108 | ||
1109 | fail: | |
1110 | kfree(p); | |
1111 | if (i < 256) | |
1112 | return (i << 24) | (j << 16) | k; | |
1113 | return 0; | |
1114 | } | |
1115 | ||
1116 | static __init int memset32_selftest(void) | |
1117 | { | |
1118 | unsigned i, j, k; | |
da436528 DC |
1119 | u32 v, *p; |
1120 | ||
1121 | p = kmalloc(256 * 2 * 4, GFP_KERNEL); | |
1122 | if (!p) | |
1123 | return -1; | |
03270c13 MW |
1124 | |
1125 | for (i = 0; i < 256; i++) { | |
1126 | for (j = 0; j < 256; j++) { | |
1127 | memset(p, 0xa1, 256 * 2 * sizeof(v)); | |
1128 | memset32(p + i, 0xb1b2b3b4, j); | |
1129 | for (k = 0; k < 512; k++) { | |
1130 | v = p[k]; | |
1131 | if (k < i) { | |
1132 | if (v != 0xa1a1a1a1) | |
1133 | goto fail; | |
1134 | } else if (k < i + j) { | |
1135 | if (v != 0xb1b2b3b4) | |
1136 | goto fail; | |
1137 | } else { | |
1138 | if (v != 0xa1a1a1a1) | |
1139 | goto fail; | |
1140 | } | |
1141 | } | |
1142 | } | |
1143 | } | |
1144 | ||
1145 | fail: | |
1146 | kfree(p); | |
1147 | if (i < 256) | |
1148 | return (i << 24) | (j << 16) | k; | |
1149 | return 0; | |
1150 | } | |
1151 | ||
1152 | static __init int memset64_selftest(void) | |
1153 | { | |
1154 | unsigned i, j, k; | |
da436528 DC |
1155 | u64 v, *p; |
1156 | ||
1157 | p = kmalloc(256 * 2 * 8, GFP_KERNEL); | |
1158 | if (!p) | |
1159 | return -1; | |
03270c13 MW |
1160 | |
1161 | for (i = 0; i < 256; i++) { | |
1162 | for (j = 0; j < 256; j++) { | |
1163 | memset(p, 0xa1, 256 * 2 * sizeof(v)); | |
1164 | memset64(p + i, 0xb1b2b3b4b5b6b7b8ULL, j); | |
1165 | for (k = 0; k < 512; k++) { | |
1166 | v = p[k]; | |
1167 | if (k < i) { | |
1168 | if (v != 0xa1a1a1a1a1a1a1a1ULL) | |
1169 | goto fail; | |
1170 | } else if (k < i + j) { | |
1171 | if (v != 0xb1b2b3b4b5b6b7b8ULL) | |
1172 | goto fail; | |
1173 | } else { | |
1174 | if (v != 0xa1a1a1a1a1a1a1a1ULL) | |
1175 | goto fail; | |
1176 | } | |
1177 | } | |
1178 | } | |
1179 | } | |
1180 | ||
1181 | fail: | |
1182 | kfree(p); | |
1183 | if (i < 256) | |
1184 | return (i << 24) | (j << 16) | k; | |
1185 | return 0; | |
1186 | } | |
1187 | ||
1188 | static __init int string_selftest_init(void) | |
1189 | { | |
1190 | int test, subtest; | |
1191 | ||
1192 | test = 1; | |
1193 | subtest = memset16_selftest(); | |
1194 | if (subtest) | |
1195 | goto fail; | |
1196 | ||
1197 | test = 2; | |
1198 | subtest = memset32_selftest(); | |
1199 | if (subtest) | |
1200 | goto fail; | |
1201 | ||
1202 | test = 3; | |
1203 | subtest = memset64_selftest(); | |
1204 | if (subtest) | |
1205 | goto fail; | |
1206 | ||
1207 | pr_info("String selftests succeeded\n"); | |
1208 | return 0; | |
1209 | fail: | |
1210 | pr_crit("String selftest failure %d.%08x\n", test, subtest); | |
1211 | return 0; | |
1212 | } | |
1213 | ||
1214 | module_init(string_selftest_init); | |
1215 | #endif /* CONFIG_STRING_SELFTEST */ |