Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
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>
26 : #include <linux/kernel.h>
27 : #include <linux/export.h>
28 : #include <linux/bug.h>
29 : #include <linux/errno.h>
30 : #include <linux/slab.h>
31 :
32 : #include <asm/byteorder.h>
33 : #include <asm/word-at-a-time.h>
34 : #include <asm/page.h>
35 :
36 : #ifndef __HAVE_ARCH_STRNCASECMP
37 : /**
38 : * strncasecmp - Case insensitive, length-limited string comparison
39 : * @s1: One string
40 : * @s2: The other string
41 : * @len: the maximum number of characters to compare
42 : */
43 0 : int strncasecmp(const char *s1, const char *s2, size_t len)
44 : {
45 : /* Yes, Virginia, it had better be unsigned */
46 0 : unsigned char c1, c2;
47 :
48 0 : if (!len)
49 : return 0;
50 :
51 0 : do {
52 0 : c1 = *s1++;
53 0 : c2 = *s2++;
54 0 : if (!c1 || !c2)
55 : break;
56 0 : if (c1 == c2)
57 0 : continue;
58 0 : c1 = tolower(c1);
59 0 : c2 = tolower(c2);
60 0 : if (c1 != c2)
61 : break;
62 0 : } while (--len);
63 0 : return (int)c1 - (int)c2;
64 : }
65 : EXPORT_SYMBOL(strncasecmp);
66 : #endif
67 :
68 : #ifndef __HAVE_ARCH_STRCASECMP
69 0 : int strcasecmp(const char *s1, const char *s2)
70 : {
71 0 : int c1, c2;
72 :
73 0 : do {
74 0 : c1 = tolower(*s1++);
75 0 : c2 = tolower(*s2++);
76 0 : } while (c1 == c2 && c1 != 0);
77 0 : return c1 - c2;
78 : }
79 : EXPORT_SYMBOL(strcasecmp);
80 : #endif
81 :
82 : #ifndef __HAVE_ARCH_STRCPY
83 : /**
84 : * strcpy - Copy a %NUL terminated string
85 : * @dest: Where to copy the string to
86 : * @src: Where to copy the string from
87 : */
88 1088 : char *strcpy(char *dest, const char *src)
89 : {
90 1088 : char *tmp = dest;
91 :
92 1088 : while ((*dest++ = *src++) != '\0')
93 15178 : /* nothing */;
94 1088 : return tmp;
95 : }
96 : EXPORT_SYMBOL(strcpy);
97 : #endif
98 :
99 : #ifndef __HAVE_ARCH_STRNCPY
100 : /**
101 : * strncpy - Copy a length-limited, C-string
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.
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 : *
112 : */
113 1108487 : char *strncpy(char *dest, const char *src, size_t count)
114 : {
115 1108487 : char *tmp = dest;
116 :
117 18836610 : while (count) {
118 17728123 : if ((*tmp = *src) != 0)
119 6197434 : src++;
120 17728123 : tmp++;
121 17728123 : count--;
122 : }
123 1108487 : return dest;
124 : }
125 : EXPORT_SYMBOL(strncpy);
126 : #endif
127 :
128 : #ifndef __HAVE_ARCH_STRLCPY
129 : /**
130 : * strlcpy - Copy a C-string into a sized buffer
131 : * @dest: Where to copy the string to
132 : * @src: Where to copy the string from
133 : * @size: size of destination buffer
134 : *
135 : * Compatible with ``*BSD``: the result is always a valid
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 4400 : size_t strlcpy(char *dest, const char *src, size_t size)
141 : {
142 8800 : size_t ret = strlen(src);
143 :
144 4400 : if (size) {
145 4400 : size_t len = (ret >= size) ? size - 1 : ret;
146 4400 : memcpy(dest, src, len);
147 4400 : dest[len] = '\0';
148 : }
149 4400 : return ret;
150 : }
151 : EXPORT_SYMBOL(strlcpy);
152 : #endif
153 :
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. The
162 : * behavior is undefined if the string buffers overlap. The destination
163 : * buffer is always NUL terminated, unless it's zero-sized.
164 : *
165 : * Preferred to strlcpy() since the API doesn't require reading memory
166 : * from the src string beyond the specified "count" bytes, and since
167 : * the return value is easier to error-check than strlcpy()'s.
168 : * In addition, the implementation is robust to the string changing out
169 : * from underneath it, unlike the current strlcpy() implementation.
170 : *
171 : * Preferred to strncpy() since it always returns a valid string, and
172 : * doesn't unnecessarily force the tail of the destination buffer to be
173 : * zeroed. If zeroing is desired please use strscpy_pad().
174 : *
175 : * Returns:
176 : * * The number of characters copied (not including the trailing %NUL)
177 : * * -E2BIG if count is 0 or @src was truncated.
178 : */
179 4509 : ssize_t strscpy(char *dest, const char *src, size_t count)
180 : {
181 4509 : const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
182 4509 : size_t max = count;
183 4509 : long res = 0;
184 :
185 4509 : if (count == 0 || WARN_ON_ONCE(count > INT_MAX))
186 : return -E2BIG;
187 :
188 : #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
189 : /*
190 : * If src is unaligned, don't cross a page boundary,
191 : * since we don't know if the next page is mapped.
192 : */
193 4509 : if ((long)src & (sizeof(long) - 1)) {
194 0 : size_t limit = PAGE_SIZE - ((long)src & (PAGE_SIZE - 1));
195 0 : if (limit < max)
196 : max = limit;
197 : }
198 : #else
199 : /* If src or dest is unaligned, don't do word-at-a-time. */
200 : if (((long) dest | (long) src) & (sizeof(long) - 1))
201 : max = 0;
202 : #endif
203 :
204 7627 : while (max >= sizeof(unsigned long)) {
205 7627 : unsigned long c, data;
206 :
207 7627 : c = read_word_at_a_time(src+res);
208 7628 : if (has_zero(c, &data, &constants)) {
209 4510 : data = prep_zero_mask(c, data, &constants);
210 4510 : data = create_zero_mask(data);
211 4510 : *(unsigned long *)(dest+res) = c & zero_bytemask(data);
212 4510 : return res + find_zero(data);
213 : }
214 3118 : *(unsigned long *)(dest+res) = c;
215 3118 : res += sizeof(unsigned long);
216 3118 : count -= sizeof(unsigned long);
217 3118 : max -= sizeof(unsigned long);
218 : }
219 :
220 0 : while (count) {
221 0 : char c;
222 :
223 0 : c = src[res];
224 0 : dest[res] = c;
225 0 : if (!c)
226 0 : return res;
227 0 : res++;
228 0 : count--;
229 : }
230 :
231 : /* Hit buffer length without finding a NUL; force NUL-termination. */
232 0 : if (res)
233 0 : dest[res-1] = '\0';
234 :
235 : return -E2BIG;
236 : }
237 : EXPORT_SYMBOL(strscpy);
238 : #endif
239 :
240 : /**
241 : * strscpy_pad() - Copy a C-string into a sized buffer
242 : * @dest: Where to copy the string to
243 : * @src: Where to copy the string from
244 : * @count: Size of destination buffer
245 : *
246 : * Copy the string, or as much of it as fits, into the dest buffer. The
247 : * behavior is undefined if the string buffers overlap. The destination
248 : * buffer is always %NUL terminated, unless it's zero-sized.
249 : *
250 : * If the source string is shorter than the destination buffer, zeros
251 : * the tail of the destination buffer.
252 : *
253 : * For full explanation of why you may want to consider using the
254 : * 'strscpy' functions please see the function docstring for strscpy().
255 : *
256 : * Returns:
257 : * * The number of characters copied (not including the trailing %NUL)
258 : * * -E2BIG if count is 0 or @src was truncated.
259 : */
260 0 : ssize_t strscpy_pad(char *dest, const char *src, size_t count)
261 : {
262 0 : ssize_t written;
263 :
264 0 : written = strscpy(dest, src, count);
265 0 : if (written < 0 || written == count - 1)
266 : return written;
267 :
268 0 : memset(dest + written + 1, 0, count - written - 1);
269 :
270 0 : return written;
271 : }
272 : EXPORT_SYMBOL(strscpy_pad);
273 :
274 : /**
275 : * stpcpy - copy a string from src to dest returning a pointer to the new end
276 : * of dest, including src's %NUL-terminator. May overrun dest.
277 : * @dest: pointer to end of string being copied into. Must be large enough
278 : * to receive copy.
279 : * @src: pointer to the beginning of string being copied from. Must not overlap
280 : * dest.
281 : *
282 : * stpcpy differs from strcpy in a key way: the return value is a pointer
283 : * to the new %NUL-terminating character in @dest. (For strcpy, the return
284 : * value is a pointer to the start of @dest). This interface is considered
285 : * unsafe as it doesn't perform bounds checking of the inputs. As such it's
286 : * not recommended for usage. Instead, its definition is provided in case
287 : * the compiler lowers other libcalls to stpcpy.
288 : */
289 : char *stpcpy(char *__restrict__ dest, const char *__restrict__ src);
290 0 : char *stpcpy(char *__restrict__ dest, const char *__restrict__ src)
291 : {
292 0 : while ((*dest++ = *src++) != '\0')
293 0 : /* nothing */;
294 0 : return --dest;
295 : }
296 : EXPORT_SYMBOL(stpcpy);
297 :
298 : #ifndef __HAVE_ARCH_STRCAT
299 : /**
300 : * strcat - Append one %NUL-terminated string to another
301 : * @dest: The string to be appended to
302 : * @src: The string to append to it
303 : */
304 0 : char *strcat(char *dest, const char *src)
305 : {
306 0 : char *tmp = dest;
307 :
308 0 : while (*dest)
309 0 : dest++;
310 0 : while ((*dest++ = *src++) != '\0')
311 0 : ;
312 0 : return tmp;
313 : }
314 : EXPORT_SYMBOL(strcat);
315 : #endif
316 :
317 : #ifndef __HAVE_ARCH_STRNCAT
318 : /**
319 : * strncat - Append a length-limited, C-string to another
320 : * @dest: The string to be appended to
321 : * @src: The string to append to it
322 : * @count: The maximum numbers of bytes to copy
323 : *
324 : * Note that in contrast to strncpy(), strncat() ensures the result is
325 : * terminated.
326 : */
327 0 : char *strncat(char *dest, const char *src, size_t count)
328 : {
329 0 : char *tmp = dest;
330 :
331 0 : if (count) {
332 0 : while (*dest)
333 0 : dest++;
334 0 : while ((*dest++ = *src++) != 0) {
335 0 : if (--count == 0) {
336 0 : *dest = '\0';
337 0 : break;
338 : }
339 : }
340 : }
341 0 : return tmp;
342 : }
343 : EXPORT_SYMBOL(strncat);
344 : #endif
345 :
346 : #ifndef __HAVE_ARCH_STRLCAT
347 : /**
348 : * strlcat - Append a length-limited, C-string to another
349 : * @dest: The string to be appended to
350 : * @src: The string to append to it
351 : * @count: The size of the destination buffer.
352 : */
353 2 : size_t strlcat(char *dest, const char *src, size_t count)
354 : {
355 4 : size_t dsize = strlen(dest);
356 4 : size_t len = strlen(src);
357 2 : size_t res = dsize + len;
358 :
359 : /* This would be a bug */
360 0 : BUG_ON(dsize >= count);
361 :
362 2 : dest += dsize;
363 2 : count -= dsize;
364 2 : if (len >= count)
365 0 : len = count-1;
366 2 : memcpy(dest, src, len);
367 2 : dest[len] = 0;
368 2 : return res;
369 : }
370 : EXPORT_SYMBOL(strlcat);
371 : #endif
372 :
373 : #ifndef __HAVE_ARCH_STRCMP
374 : /**
375 : * strcmp - Compare two strings
376 : * @cs: One string
377 : * @ct: Another string
378 : */
379 795516 : int strcmp(const char *cs, const char *ct)
380 : {
381 20233336 : unsigned char c1, c2;
382 :
383 20233336 : while (1) {
384 20233336 : c1 = *cs++;
385 20233336 : c2 = *ct++;
386 20233336 : if (c1 != c2)
387 761814 : return c1 < c2 ? -1 : 1;
388 19471522 : if (!c1)
389 : break;
390 : }
391 : return 0;
392 : }
393 : EXPORT_SYMBOL(strcmp);
394 : #endif
395 :
396 : #ifndef __HAVE_ARCH_STRNCMP
397 : /**
398 : * strncmp - Compare two length-limited strings
399 : * @cs: One string
400 : * @ct: Another string
401 : * @count: The maximum number of bytes to compare
402 : */
403 69013 : int strncmp(const char *cs, const char *ct, size_t count)
404 : {
405 69013 : unsigned char c1, c2;
406 :
407 113115 : while (count) {
408 112071 : c1 = *cs++;
409 112071 : c2 = *ct++;
410 112071 : if (c1 != c2)
411 67969 : return c1 < c2 ? -1 : 1;
412 44102 : if (!c1)
413 : break;
414 44102 : count--;
415 : }
416 : return 0;
417 : }
418 : EXPORT_SYMBOL(strncmp);
419 : #endif
420 :
421 : #ifndef __HAVE_ARCH_STRCHR
422 : /**
423 : * strchr - Find the first occurrence of a character in a string
424 : * @s: The string to be searched
425 : * @c: The character to search for
426 : *
427 : * Note that the %NUL-terminator is considered part of the string, and can
428 : * be searched for.
429 : */
430 189139 : char *strchr(const char *s, int c)
431 : {
432 978686 : for (; *s != (char)c; ++s)
433 970026 : if (*s == '\0')
434 : return NULL;
435 : return (char *)s;
436 : }
437 : EXPORT_SYMBOL(strchr);
438 : #endif
439 :
440 : #ifndef __HAVE_ARCH_STRCHRNUL
441 : /**
442 : * strchrnul - Find and return a character in a string, or end of string
443 : * @s: The string to be searched
444 : * @c: The character to search for
445 : *
446 : * Returns pointer to first occurrence of 'c' in s. If c is not found, then
447 : * return a pointer to the null byte at the end of s.
448 : */
449 0 : char *strchrnul(const char *s, int c)
450 : {
451 0 : while (*s && *s != (char)c)
452 0 : s++;
453 0 : return (char *)s;
454 : }
455 : EXPORT_SYMBOL(strchrnul);
456 : #endif
457 :
458 : /**
459 : * strnchrnul - Find and return a character in a length limited string,
460 : * or end of string
461 : * @s: The string to be searched
462 : * @count: The number of characters to be searched
463 : * @c: The character to search for
464 : *
465 : * Returns pointer to the first occurrence of 'c' in s. If c is not found,
466 : * then return a pointer to the last character of the string.
467 : */
468 0 : char *strnchrnul(const char *s, size_t count, int c)
469 : {
470 0 : while (count-- && *s && *s != (char)c)
471 0 : s++;
472 0 : return (char *)s;
473 : }
474 :
475 : #ifndef __HAVE_ARCH_STRRCHR
476 : /**
477 : * strrchr - Find the last occurrence of a character in a string
478 : * @s: The string to be searched
479 : * @c: The character to search for
480 : */
481 4040 : char *strrchr(const char *s, int c)
482 : {
483 4040 : const char *last = NULL;
484 145860 : do {
485 145860 : if (*s == (char)c)
486 13046 : last = s;
487 145860 : } while (*s++);
488 4040 : return (char *)last;
489 : }
490 : EXPORT_SYMBOL(strrchr);
491 : #endif
492 :
493 : #ifndef __HAVE_ARCH_STRNCHR
494 : /**
495 : * strnchr - Find a character in a length limited string
496 : * @s: The string to be searched
497 : * @count: The number of characters to be searched
498 : * @c: The character to search for
499 : *
500 : * Note that the %NUL-terminator is considered part of the string, and can
501 : * be searched for.
502 : */
503 213 : char *strnchr(const char *s, size_t count, int c)
504 : {
505 1160 : while (count--) {
506 989 : if (*s == (char)c)
507 42 : return (char *)s;
508 947 : if (*s++ == '\0')
509 : break;
510 : }
511 : return NULL;
512 : }
513 : EXPORT_SYMBOL(strnchr);
514 : #endif
515 :
516 : /**
517 : * skip_spaces - Removes leading whitespace from @str.
518 : * @str: The string to be stripped.
519 : *
520 : * Returns a pointer to the first non-whitespace character in @str.
521 : */
522 307 : char *skip_spaces(const char *str)
523 : {
524 310 : while (isspace(*str))
525 3 : ++str;
526 88 : return (char *)str;
527 : }
528 : EXPORT_SYMBOL(skip_spaces);
529 :
530 : /**
531 : * strim - Removes leading and trailing whitespace from @s.
532 : * @s: The string to be stripped.
533 : *
534 : * Note that the first trailing whitespace is replaced with a %NUL-terminator
535 : * in the given string @s. Returns a pointer to the first non-whitespace
536 : * character in @s.
537 : */
538 219 : char *strim(char *s)
539 : {
540 219 : size_t size;
541 219 : char *end;
542 :
543 438 : size = strlen(s);
544 219 : if (!size)
545 : return s;
546 :
547 219 : end = s + size - 1;
548 438 : while (end >= s && isspace(*end))
549 219 : end--;
550 219 : *(end + 1) = '\0';
551 :
552 219 : return skip_spaces(s);
553 : }
554 : EXPORT_SYMBOL(strim);
555 :
556 : #ifndef __HAVE_ARCH_STRLEN
557 : /**
558 : * strlen - Find the length of a string
559 : * @s: The string to be sized
560 : */
561 108886 : size_t strlen(const char *s)
562 : {
563 108884 : const char *sc;
564 :
565 1478358 : for (sc = s; *sc != '\0'; ++sc)
566 1383548 : /* nothing */;
567 4623 : return sc - s;
568 : }
569 : EXPORT_SYMBOL(strlen);
570 : #endif
571 :
572 : #ifndef __HAVE_ARCH_STRNLEN
573 : /**
574 : * strnlen - Find the length of a length-limited string
575 : * @s: The string to be sized
576 : * @count: The maximum number of bytes to search
577 : */
578 6812 : size_t strnlen(const char *s, size_t count)
579 : {
580 6812 : const char *sc;
581 :
582 90229 : for (sc = s; count-- && *sc != '\0'; ++sc)
583 83417 : /* nothing */;
584 6812 : return sc - s;
585 : }
586 : EXPORT_SYMBOL(strnlen);
587 : #endif
588 :
589 : #ifndef __HAVE_ARCH_STRSPN
590 : /**
591 : * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept
592 : * @s: The string to be searched
593 : * @accept: The string to search for
594 : */
595 0 : size_t strspn(const char *s, const char *accept)
596 : {
597 0 : const char *p;
598 0 : const char *a;
599 0 : size_t count = 0;
600 :
601 0 : for (p = s; *p != '\0'; ++p) {
602 0 : for (a = accept; *a != '\0'; ++a) {
603 0 : if (*p == *a)
604 : break;
605 : }
606 0 : if (*a == '\0')
607 0 : return count;
608 0 : ++count;
609 : }
610 : return count;
611 : }
612 :
613 : EXPORT_SYMBOL(strspn);
614 : #endif
615 :
616 : #ifndef __HAVE_ARCH_STRCSPN
617 : /**
618 : * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject
619 : * @s: The string to be searched
620 : * @reject: The string to avoid
621 : */
622 1 : size_t strcspn(const char *s, const char *reject)
623 : {
624 1 : const char *p;
625 1 : const char *r;
626 1 : size_t count = 0;
627 :
628 4 : for (p = s; *p != '\0'; ++p) {
629 7 : for (r = reject; *r != '\0'; ++r) {
630 4 : if (*p == *r)
631 1 : return count;
632 : }
633 3 : ++count;
634 : }
635 : return count;
636 : }
637 : EXPORT_SYMBOL(strcspn);
638 : #endif
639 :
640 : #ifndef __HAVE_ARCH_STRPBRK
641 : /**
642 : * strpbrk - Find the first occurrence of a set of characters
643 : * @cs: The string to be searched
644 : * @ct: The characters to search for
645 : */
646 0 : char *strpbrk(const char *cs, const char *ct)
647 : {
648 0 : const char *sc1, *sc2;
649 :
650 109 : for (sc1 = cs; *sc1 != '\0'; ++sc1) {
651 227 : for (sc2 = ct; *sc2 != '\0'; ++sc2) {
652 118 : if (*sc1 == *sc2)
653 0 : return (char *)sc1;
654 : }
655 : }
656 : return NULL;
657 : }
658 : EXPORT_SYMBOL(strpbrk);
659 : #endif
660 :
661 : #ifndef __HAVE_ARCH_STRSEP
662 : /**
663 : * strsep - Split a string into tokens
664 : * @s: The string to be searched
665 : * @ct: The characters to search for
666 : *
667 : * strsep() updates @s to point after the token, ready for the next call.
668 : *
669 : * It returns empty tokens, too, behaving exactly like the libc function
670 : * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
671 : * Same semantics, slimmer shape. ;)
672 : */
673 29 : char *strsep(char **s, const char *ct)
674 : {
675 29 : char *sbegin = *s;
676 29 : char *end;
677 :
678 29 : if (sbegin == NULL)
679 : return NULL;
680 :
681 127 : end = strpbrk(sbegin, ct);
682 18 : if (end)
683 9 : *end++ = '\0';
684 18 : *s = end;
685 18 : return sbegin;
686 : }
687 : EXPORT_SYMBOL(strsep);
688 : #endif
689 :
690 : /**
691 : * sysfs_streq - return true if strings are equal, modulo trailing newline
692 : * @s1: one string
693 : * @s2: another string
694 : *
695 : * This routine returns true iff two strings are equal, treating both
696 : * NUL and newline-then-NUL as equivalent string terminations. It's
697 : * geared for use with sysfs input strings, which generally terminate
698 : * with newlines but are compared against values without newlines.
699 : */
700 0 : bool sysfs_streq(const char *s1, const char *s2)
701 : {
702 0 : while (*s1 && *s1 == *s2) {
703 0 : s1++;
704 0 : s2++;
705 : }
706 :
707 0 : if (*s1 == *s2)
708 : return true;
709 0 : if (!*s1 && *s2 == '\n' && !s2[1])
710 : return true;
711 0 : if (*s1 == '\n' && !s1[1] && !*s2)
712 0 : return true;
713 : return false;
714 : }
715 : EXPORT_SYMBOL(sysfs_streq);
716 :
717 : /**
718 : * match_string - matches given string in an array
719 : * @array: array of strings
720 : * @n: number of strings in the array or -1 for NULL terminated arrays
721 : * @string: string to match with
722 : *
723 : * This routine will look for a string in an array of strings up to the
724 : * n-th element in the array or until the first NULL element.
725 : *
726 : * Historically the value of -1 for @n, was used to search in arrays that
727 : * are NULL terminated. However, the function does not make a distinction
728 : * when finishing the search: either @n elements have been compared OR
729 : * the first NULL element was found.
730 : *
731 : * Return:
732 : * index of a @string in the @array if matches, or %-EINVAL otherwise.
733 : */
734 0 : int match_string(const char * const *array, size_t n, const char *string)
735 : {
736 0 : int index;
737 0 : const char *item;
738 :
739 0 : for (index = 0; index < n; index++) {
740 0 : item = array[index];
741 0 : if (!item)
742 : break;
743 0 : if (!strcmp(item, string))
744 0 : return index;
745 : }
746 :
747 : return -EINVAL;
748 : }
749 : EXPORT_SYMBOL(match_string);
750 :
751 : /**
752 : * __sysfs_match_string - matches given string in an array
753 : * @array: array of strings
754 : * @n: number of strings in the array or -1 for NULL terminated arrays
755 : * @str: string to match with
756 : *
757 : * Returns index of @str in the @array or -EINVAL, just like match_string().
758 : * Uses sysfs_streq instead of strcmp for matching.
759 : *
760 : * This routine will look for a string in an array of strings up to the
761 : * n-th element in the array or until the first NULL element.
762 : *
763 : * Historically the value of -1 for @n, was used to search in arrays that
764 : * are NULL terminated. However, the function does not make a distinction
765 : * when finishing the search: either @n elements have been compared OR
766 : * the first NULL element was found.
767 : */
768 0 : int __sysfs_match_string(const char * const *array, size_t n, const char *str)
769 : {
770 0 : const char *item;
771 0 : int index;
772 :
773 0 : for (index = 0; index < n; index++) {
774 0 : item = array[index];
775 0 : if (!item)
776 : break;
777 0 : if (sysfs_streq(item, str))
778 0 : return index;
779 : }
780 :
781 : return -EINVAL;
782 : }
783 : EXPORT_SYMBOL(__sysfs_match_string);
784 :
785 : #ifndef __HAVE_ARCH_MEMSET
786 : /**
787 : * memset - Fill a region of memory with the given value
788 : * @s: Pointer to the start of the area.
789 : * @c: The byte to fill the area with
790 : * @count: The size of the area.
791 : *
792 : * Do not use memset() to access IO space, use memset_io() instead.
793 : */
794 : void *memset(void *s, int c, size_t count)
795 : {
796 : char *xs = s;
797 :
798 : while (count--)
799 : *xs++ = c;
800 : return s;
801 : }
802 : EXPORT_SYMBOL(memset);
803 : #endif
804 :
805 : #ifndef __HAVE_ARCH_MEMSET16
806 : /**
807 : * memset16() - Fill a memory area with a uint16_t
808 : * @s: Pointer to the start of the area.
809 : * @v: The value to fill the area with
810 : * @count: The number of values to store
811 : *
812 : * Differs from memset() in that it fills with a uint16_t instead
813 : * of a byte. Remember that @count is the number of uint16_ts to
814 : * store, not the number of bytes.
815 : */
816 : void *memset16(uint16_t *s, uint16_t v, size_t count)
817 : {
818 : uint16_t *xs = s;
819 :
820 : while (count--)
821 : *xs++ = v;
822 : return s;
823 : }
824 : EXPORT_SYMBOL(memset16);
825 : #endif
826 :
827 : #ifndef __HAVE_ARCH_MEMSET32
828 : /**
829 : * memset32() - Fill a memory area with a uint32_t
830 : * @s: Pointer to the start of the area.
831 : * @v: The value to fill the area with
832 : * @count: The number of values to store
833 : *
834 : * Differs from memset() in that it fills with a uint32_t instead
835 : * of a byte. Remember that @count is the number of uint32_ts to
836 : * store, not the number of bytes.
837 : */
838 : void *memset32(uint32_t *s, uint32_t v, size_t count)
839 : {
840 : uint32_t *xs = s;
841 :
842 : while (count--)
843 : *xs++ = v;
844 : return s;
845 : }
846 : EXPORT_SYMBOL(memset32);
847 : #endif
848 :
849 : #ifndef __HAVE_ARCH_MEMSET64
850 : /**
851 : * memset64() - Fill a memory area with a uint64_t
852 : * @s: Pointer to the start of the area.
853 : * @v: The value to fill the area with
854 : * @count: The number of values to store
855 : *
856 : * Differs from memset() in that it fills with a uint64_t instead
857 : * of a byte. Remember that @count is the number of uint64_ts to
858 : * store, not the number of bytes.
859 : */
860 : void *memset64(uint64_t *s, uint64_t v, size_t count)
861 : {
862 : uint64_t *xs = s;
863 :
864 : while (count--)
865 : *xs++ = v;
866 : return s;
867 : }
868 : EXPORT_SYMBOL(memset64);
869 : #endif
870 :
871 : #ifndef __HAVE_ARCH_MEMCPY
872 : /**
873 : * memcpy - Copy one area of memory to another
874 : * @dest: Where to copy to
875 : * @src: Where to copy from
876 : * @count: The size of the area.
877 : *
878 : * You should not use this function to access IO space, use memcpy_toio()
879 : * or memcpy_fromio() instead.
880 : */
881 : void *memcpy(void *dest, const void *src, size_t count)
882 : {
883 : char *tmp = dest;
884 : const char *s = src;
885 :
886 : while (count--)
887 : *tmp++ = *s++;
888 : return dest;
889 : }
890 : EXPORT_SYMBOL(memcpy);
891 : #endif
892 :
893 : #ifndef __HAVE_ARCH_MEMMOVE
894 : /**
895 : * memmove - Copy one area of memory to another
896 : * @dest: Where to copy to
897 : * @src: Where to copy from
898 : * @count: The size of the area.
899 : *
900 : * Unlike memcpy(), memmove() copes with overlapping areas.
901 : */
902 : void *memmove(void *dest, const void *src, size_t count)
903 : {
904 : char *tmp;
905 : const char *s;
906 :
907 : if (dest <= src) {
908 : tmp = dest;
909 : s = src;
910 : while (count--)
911 : *tmp++ = *s++;
912 : } else {
913 : tmp = dest;
914 : tmp += count;
915 : s = src;
916 : s += count;
917 : while (count--)
918 : *--tmp = *--s;
919 : }
920 : return dest;
921 : }
922 : EXPORT_SYMBOL(memmove);
923 : #endif
924 :
925 : #ifndef __HAVE_ARCH_MEMCMP
926 : /**
927 : * memcmp - Compare two areas of memory
928 : * @cs: One area of memory
929 : * @ct: Another area of memory
930 : * @count: The size of the area.
931 : */
932 : #undef memcmp
933 35820 : __visible int memcmp(const void *cs, const void *ct, size_t count)
934 : {
935 35820 : const unsigned char *su1, *su2;
936 35820 : int res = 0;
937 :
938 279374 : for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
939 271478 : if ((res = *su1 - *su2) != 0)
940 : break;
941 35820 : return res;
942 : }
943 : EXPORT_SYMBOL(memcmp);
944 : #endif
945 :
946 : #ifndef __HAVE_ARCH_BCMP
947 : /**
948 : * bcmp - returns 0 if and only if the buffers have identical contents.
949 : * @a: pointer to first buffer.
950 : * @b: pointer to second buffer.
951 : * @len: size of buffers.
952 : *
953 : * The sign or magnitude of a non-zero return value has no particular
954 : * meaning, and architectures may implement their own more efficient bcmp(). So
955 : * while this particular implementation is a simple (tail) call to memcmp, do
956 : * not rely on anything but whether the return value is zero or non-zero.
957 : */
958 0 : int bcmp(const void *a, const void *b, size_t len)
959 : {
960 0 : return memcmp(a, b, len);
961 : }
962 : EXPORT_SYMBOL(bcmp);
963 : #endif
964 :
965 : #ifndef __HAVE_ARCH_MEMSCAN
966 : /**
967 : * memscan - Find a character in an area of memory.
968 : * @addr: The memory area
969 : * @c: The byte to search for
970 : * @size: The size of the area.
971 : *
972 : * returns the address of the first occurrence of @c, or 1 byte past
973 : * the area if @c is not found
974 : */
975 0 : void *memscan(void *addr, int c, size_t size)
976 : {
977 0 : unsigned char *p = addr;
978 :
979 0 : while (size) {
980 0 : if (*p == c)
981 0 : return (void *)p;
982 0 : p++;
983 0 : size--;
984 : }
985 : return (void *)p;
986 : }
987 : EXPORT_SYMBOL(memscan);
988 : #endif
989 :
990 : #ifndef __HAVE_ARCH_STRSTR
991 : /**
992 : * strstr - Find the first substring in a %NUL terminated string
993 : * @s1: The string to be searched
994 : * @s2: The string to search for
995 : */
996 1814 : char *strstr(const char *s1, const char *s2)
997 : {
998 1814 : size_t l1, l2;
999 :
1000 1814 : l2 = strlen(s2);
1001 1814 : if (!l2)
1002 : return (char *)s1;
1003 15890 : l1 = strlen(s1);
1004 4680 : while (l1 >= l2) {
1005 3016 : l1--;
1006 6032 : if (!memcmp(s1, s2, l2))
1007 150 : return (char *)s1;
1008 2866 : s1++;
1009 : }
1010 : return NULL;
1011 : }
1012 : EXPORT_SYMBOL(strstr);
1013 : #endif
1014 :
1015 : #ifndef __HAVE_ARCH_STRNSTR
1016 : /**
1017 : * strnstr - Find the first substring in a length-limited string
1018 : * @s1: The string to be searched
1019 : * @s2: The string to search for
1020 : * @len: the maximum number of characters to search
1021 : */
1022 0 : char *strnstr(const char *s1, const char *s2, size_t len)
1023 : {
1024 0 : size_t l2;
1025 :
1026 0 : l2 = strlen(s2);
1027 0 : if (!l2)
1028 : return (char *)s1;
1029 0 : while (len >= l2) {
1030 0 : len--;
1031 0 : if (!memcmp(s1, s2, l2))
1032 0 : return (char *)s1;
1033 0 : s1++;
1034 : }
1035 : return NULL;
1036 : }
1037 : EXPORT_SYMBOL(strnstr);
1038 : #endif
1039 :
1040 : #ifndef __HAVE_ARCH_MEMCHR
1041 : /**
1042 : * memchr - Find a character in an area of memory.
1043 : * @s: The memory area
1044 : * @c: The byte to search for
1045 : * @n: The size of the area.
1046 : *
1047 : * returns the address of the first occurrence of @c, or %NULL
1048 : * if @c is not found
1049 : */
1050 16279 : void *memchr(const void *s, int c, size_t n)
1051 : {
1052 16279 : const unsigned char *p = s;
1053 214209 : while (n-- != 0) {
1054 197935 : if ((unsigned char)c == *p++) {
1055 5 : return (void *)(p - 1);
1056 : }
1057 : }
1058 : return NULL;
1059 : }
1060 : EXPORT_SYMBOL(memchr);
1061 : #endif
1062 :
1063 8730 : static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
1064 : {
1065 80863 : while (bytes) {
1066 72867 : if (*start != value)
1067 : return (void *)start;
1068 72133 : start++;
1069 72133 : bytes--;
1070 : }
1071 : return NULL;
1072 : }
1073 :
1074 : /**
1075 : * memchr_inv - Find an unmatching character in an area of memory.
1076 : * @start: The memory area
1077 : * @c: Find a character other than c
1078 : * @bytes: The size of the area.
1079 : *
1080 : * returns the address of the first character other than @c, or %NULL
1081 : * if the whole buffer contains just @c.
1082 : */
1083 6739 : void *memchr_inv(const void *start, int c, size_t bytes)
1084 : {
1085 6739 : u8 value = c;
1086 6739 : u64 value64;
1087 6739 : unsigned int words, prefix;
1088 :
1089 6739 : if (bytes <= 16)
1090 9496 : return check_bytes8(start, value, bytes);
1091 :
1092 1991 : value64 = value;
1093 : #if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
1094 1991 : value64 *= 0x0101010101010101ULL;
1095 : #elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
1096 : value64 *= 0x01010101;
1097 : value64 |= value64 << 32;
1098 : #else
1099 : value64 |= value64 << 8;
1100 : value64 |= value64 << 16;
1101 : value64 |= value64 << 32;
1102 : #endif
1103 :
1104 1991 : prefix = (unsigned long)start % 8;
1105 1991 : if (prefix) {
1106 1991 : u8 *r;
1107 :
1108 1991 : prefix = 8 - prefix;
1109 1991 : r = check_bytes8(start, value, prefix);
1110 1991 : if (r)
1111 : return r;
1112 1991 : start += prefix;
1113 1991 : bytes -= prefix;
1114 : }
1115 :
1116 1991 : words = bytes / 8;
1117 :
1118 7963 : while (words) {
1119 5972 : if (*(u64 *)start != value64)
1120 0 : return check_bytes8(start, value, 8);
1121 5972 : start += 8;
1122 5972 : words--;
1123 : }
1124 :
1125 1991 : return check_bytes8(start, value, bytes % 8);
1126 : }
1127 : EXPORT_SYMBOL(memchr_inv);
1128 :
1129 : /**
1130 : * strreplace - Replace all occurrences of character in string.
1131 : * @s: The string to operate on.
1132 : * @old: The character being replaced.
1133 : * @new: The character @old is replaced with.
1134 : *
1135 : * Returns pointer to the nul byte at the end of @s.
1136 : */
1137 3 : char *strreplace(char *s, char old, char new)
1138 : {
1139 15 : for (; *s; ++s)
1140 12 : if (*s == old)
1141 0 : *s = new;
1142 3 : return s;
1143 : }
1144 : EXPORT_SYMBOL(strreplace);
1145 :
1146 0 : void fortify_panic(const char *name)
1147 : {
1148 0 : pr_emerg("detected buffer overflow in %s\n", name);
1149 0 : BUG();
1150 : }
1151 : EXPORT_SYMBOL(fortify_panic);
|
