projects/linux·blob v4.2-rc8 · refs

868 lines · 17.4 KiB

1/*
2 * linux/lib/string.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7/*
8 * stupid library routines.. The optimized versions should generally be found
9 * as inline code in <asm-xx/string.h>
10 *
11 * These are buggy as well..
12 *
13 * * Fri Jun 25 1999, Ingo Oeser <[email protected]>
14 * - Added strsep() which will replace strtok() soon (because strsep() is
15 * reentrant and should be faster). Use only strsep() in new code, please.
16 *
17 * * Sat Feb 09 2002, Jason Thomas <[email protected]>,
18 * Matthew Hawkins <[email protected]>
19 * - Kissed strtok() goodbye
20 */
21
22#include <linux/types.h>
23#include <linux/string.h>
24#include <linux/ctype.h>
25#include <linux/kernel.h>
26#include <linux/export.h>
27#include <linux/bug.h>
28#include <linux/errno.h>
29
30#ifndef __HAVE_ARCH_STRNCASECMP
31/**
32 * strncasecmp - Case insensitive, length-limited string comparison
33 * @s1: One string
34 * @s2: The other string
35 * @len: the maximum number of characters to compare
36 */
37int strncasecmp(const char *s1, const char *s2, size_t len)
38{
39 /* Yes, Virginia, it had better be unsigned */
40 unsigned char c1, c2;
41
42 if (!len)
43 return 0;
44
45 do {
46 c1 = *s1++;
47 c2 = *s2++;
48 if (!c1 || !c2)
49 break;
50 if (c1 == c2)
51 continue;
52 c1 = tolower(c1);
53 c2 = tolower(c2);
54 if (c1 != c2)
55 break;
56 } while (--len);
57 return (int)c1 - (int)c2;
58}
59EXPORT_SYMBOL(strncasecmp);
60#endif
61
62#ifndef __HAVE_ARCH_STRCASECMP
63int strcasecmp(const char *s1, const char *s2)
64{
65 int c1, c2;
66
67 do {
68 c1 = tolower(*s1++);
69 c2 = tolower(*s2++);
70 } while (c1 == c2 && c1 != 0);
71 return c1 - c2;
72}
73EXPORT_SYMBOL(strcasecmp);
74#endif
75
76#ifndef __HAVE_ARCH_STRCPY
77/**
78 * strcpy - Copy a %NUL terminated string
79 * @dest: Where to copy the string to
80 * @src: Where to copy the string from
81 */
82#undef strcpy
83char *strcpy(char *dest, const char *src)
84{
85 char *tmp = dest;
86
87 while ((*dest++ = *src++) != '\0')
88 /* nothing */;
89 return tmp;
90}
91EXPORT_SYMBOL(strcpy);
92#endif
93
94#ifndef __HAVE_ARCH_STRNCPY
95/**
96 * strncpy - Copy a length-limited, C-string
97 * @dest: Where to copy the string to
98 * @src: Where to copy the string from
99 * @count: The maximum number of bytes to copy
100 *
101 * The result is not %NUL-terminated if the source exceeds
102 * @count bytes.
103 *
104 * In the case where the length of @src is less than that of
105 * count, the remainder of @dest will be padded with %NUL.
106 *
107 */
108char *strncpy(char *dest, const char *src, size_t count)
109{
110 char *tmp = dest;
111
112 while (count) {
113 if ((*tmp = *src) != 0)
114 src++;
115 tmp++;
116 count--;
117 }
118 return dest;
119}
120EXPORT_SYMBOL(strncpy);
121#endif
122
123#ifndef __HAVE_ARCH_STRLCPY
124/**
125 * strlcpy - Copy a C-string into a sized buffer
126 * @dest: Where to copy the string to
127 * @src: Where to copy the string from
128 * @size: size of destination buffer
129 *
130 * Compatible with *BSD: the result is always a valid
131 * NUL-terminated string that fits in the buffer (unless,
132 * of course, the buffer size is zero). It does not pad
133 * out the result like strncpy() does.
134 */
135size_t strlcpy(char *dest, const char *src, size_t size)
136{
137 size_t ret = strlen(src);
138
139 if (size) {
140 size_t len = (ret >= size) ? size - 1 : ret;
141 memcpy(dest, src, len);
142 dest[len] = '\0';
143 }
144 return ret;
145}
146EXPORT_SYMBOL(strlcpy);
147#endif
148
149#ifndef __HAVE_ARCH_STRCAT
150/**
151 * strcat - Append one %NUL-terminated string to another
152 * @dest: The string to be appended to
153 * @src: The string to append to it
154 */
155#undef strcat
156char *strcat(char *dest, const char *src)
157{
158 char *tmp = dest;
159
160 while (*dest)
161 dest++;
162 while ((*dest++ = *src++) != '\0')
163 ;
164 return tmp;
165}
166EXPORT_SYMBOL(strcat);
167#endif
168
169#ifndef __HAVE_ARCH_STRNCAT
170/**
171 * strncat - Append a length-limited, C-string to another
172 * @dest: The string to be appended to
173 * @src: The string to append to it
174 * @count: The maximum numbers of bytes to copy
175 *
176 * Note that in contrast to strncpy(), strncat() ensures the result is
177 * terminated.
178 */
179char *strncat(char *dest, const char *src, size_t count)
180{
181 char *tmp = dest;
182
183 if (count) {
184 while (*dest)
185 dest++;
186 while ((*dest++ = *src++) != 0) {
187 if (--count == 0) {
188 *dest = '\0';
189 break;
190 }
191 }
192 }
193 return tmp;
194}
195EXPORT_SYMBOL(strncat);
196#endif
197
198#ifndef __HAVE_ARCH_STRLCAT
199/**
200 * strlcat - Append a length-limited, C-string to another
201 * @dest: The string to be appended to
202 * @src: The string to append to it
203 * @count: The size of the destination buffer.
204 */
205size_t strlcat(char *dest, const char *src, size_t count)
206{
207 size_t dsize = strlen(dest);
208 size_t len = strlen(src);
209 size_t res = dsize + len;
210
211 /* This would be a bug */
212 BUG_ON(dsize >= count);
213
214 dest += dsize;
215 count -= dsize;
216 if (len >= count)
217 len = count-1;
218 memcpy(dest, src, len);
219 dest[len] = 0;
220 return res;
221}
222EXPORT_SYMBOL(strlcat);
223#endif
224
225#ifndef __HAVE_ARCH_STRCMP
226/**
227 * strcmp - Compare two strings
228 * @cs: One string
229 * @ct: Another string
230 */
231#undef strcmp
232int strcmp(const char *cs, const char *ct)
233{
234 unsigned char c1, c2;
235
236 while (1) {
237 c1 = *cs++;
238 c2 = *ct++;
239 if (c1 != c2)
240 return c1 < c2 ? -1 : 1;
241 if (!c1)
242 break;
243 }
244 return 0;
245}
246EXPORT_SYMBOL(strcmp);
247#endif
248
249#ifndef __HAVE_ARCH_STRNCMP
250/**
251 * strncmp - Compare two length-limited strings
252 * @cs: One string
253 * @ct: Another string
254 * @count: The maximum number of bytes to compare
255 */
256int strncmp(const char *cs, const char *ct, size_t count)
257{
258 unsigned char c1, c2;
259
260 while (count) {
261 c1 = *cs++;
262 c2 = *ct++;
263 if (c1 != c2)
264 return c1 < c2 ? -1 : 1;
265 if (!c1)
266 break;
267 count--;
268 }
269 return 0;
270}
271EXPORT_SYMBOL(strncmp);
272#endif
273
274#ifndef __HAVE_ARCH_STRCHR
275/**
276 * strchr - Find the first occurrence of a character in a string
277 * @s: The string to be searched
278 * @c: The character to search for
279 */
280char *strchr(const char *s, int c)
281{
282 for (; *s != (char)c; ++s)
283 if (*s == '\0')
284 return NULL;
285 return (char *)s;
286}
287EXPORT_SYMBOL(strchr);
288#endif
289
290#ifndef __HAVE_ARCH_STRCHRNUL
291/**
292 * strchrnul - Find and return a character in a string, or end of string
293 * @s: The string to be searched
294 * @c: The character to search for
295 *
296 * Returns pointer to first occurrence of 'c' in s. If c is not found, then
297 * return a pointer to the null byte at the end of s.
298 */
299char *strchrnul(const char *s, int c)
300{
301 while (*s && *s != (char)c)
302 s++;
303 return (char *)s;
304}
305EXPORT_SYMBOL(strchrnul);
306#endif
307
308#ifndef __HAVE_ARCH_STRRCHR
309/**
310 * strrchr - Find the last occurrence of a character in a string
311 * @s: The string to be searched
312 * @c: The character to search for
313 */
314char *strrchr(const char *s, int c)
315{
316 const char *last = NULL;
317 do {
318 if (*s == (char)c)
319 last = s;
320 } while (*s++);
321 return (char *)last;
322}
323EXPORT_SYMBOL(strrchr);
324#endif
325
326#ifndef __HAVE_ARCH_STRNCHR
327/**
328 * strnchr - Find a character in a length limited string
329 * @s: The string to be searched
330 * @count: The number of characters to be searched
331 * @c: The character to search for
332 */
333char *strnchr(const char *s, size_t count, int c)
334{
335 for (; count-- && *s != '\0'; ++s)
336 if (*s == (char)c)
337 return (char *)s;
338 return NULL;
339}
340EXPORT_SYMBOL(strnchr);
341#endif
342
343/**
344 * skip_spaces - Removes leading whitespace from @str.
345 * @str: The string to be stripped.
346 *
347 * Returns a pointer to the first non-whitespace character in @str.
348 */
349char *skip_spaces(const char *str)
350{
351 while (isspace(*str))
352 ++str;
353 return (char *)str;
354}
355EXPORT_SYMBOL(skip_spaces);
356
357/**
358 * strim - Removes leading and trailing whitespace from @s.
359 * @s: The string to be stripped.
360 *
361 * Note that the first trailing whitespace is replaced with a %NUL-terminator
362 * in the given string @s. Returns a pointer to the first non-whitespace
363 * character in @s.
364 */
365char *strim(char *s)
366{
367 size_t size;
368 char *end;
369
370 size = strlen(s);
371 if (!size)
372 return s;
373
374 end = s + size - 1;
375 while (end >= s && isspace(*end))
376 end--;
377 *(end + 1) = '\0';
378
379 return skip_spaces(s);
380}
381EXPORT_SYMBOL(strim);
382
383#ifndef __HAVE_ARCH_STRLEN
384/**
385 * strlen - Find the length of a string
386 * @s: The string to be sized
387 */
388size_t strlen(const char *s)
389{
390 const char *sc;
391
392 for (sc = s; *sc != '\0'; ++sc)
393 /* nothing */;
394 return sc - s;
395}
396EXPORT_SYMBOL(strlen);
397#endif
398
399#ifndef __HAVE_ARCH_STRNLEN
400/**
401 * strnlen - Find the length of a length-limited string
402 * @s: The string to be sized
403 * @count: The maximum number of bytes to search
404 */
405size_t strnlen(const char *s, size_t count)
406{
407 const char *sc;
408
409 for (sc = s; count-- && *sc != '\0'; ++sc)
410 /* nothing */;
411 return sc - s;
412}
413EXPORT_SYMBOL(strnlen);
414#endif
415
416#ifndef __HAVE_ARCH_STRSPN
417/**
418 * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept
419 * @s: The string to be searched
420 * @accept: The string to search for
421 */
422size_t strspn(const char *s, const char *accept)
423{
424 const char *p;
425 const char *a;
426 size_t count = 0;
427
428 for (p = s; *p != '\0'; ++p) {
429 for (a = accept; *a != '\0'; ++a) {
430 if (*p == *a)
431 break;
432 }
433 if (*a == '\0')
434 return count;
435 ++count;
436 }
437 return count;
438}
439
440EXPORT_SYMBOL(strspn);
441#endif
442
443#ifndef __HAVE_ARCH_STRCSPN
444/**
445 * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject
446 * @s: The string to be searched
447 * @reject: The string to avoid
448 */
449size_t strcspn(const char *s, const char *reject)
450{
451 const char *p;
452 const char *r;
453 size_t count = 0;
454
455 for (p = s; *p != '\0'; ++p) {
456 for (r = reject; *r != '\0'; ++r) {
457 if (*p == *r)
458 return count;
459 }
460 ++count;
461 }
462 return count;
463}
464EXPORT_SYMBOL(strcspn);
465#endif
466
467#ifndef __HAVE_ARCH_STRPBRK
468/**
469 * strpbrk - Find the first occurrence of a set of characters
470 * @cs: The string to be searched
471 * @ct: The characters to search for
472 */
473char *strpbrk(const char *cs, const char *ct)
474{
475 const char *sc1, *sc2;
476
477 for (sc1 = cs; *sc1 != '\0'; ++sc1) {
478 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
479 if (*sc1 == *sc2)
480 return (char *)sc1;
481 }
482 }
483 return NULL;
484}
485EXPORT_SYMBOL(strpbrk);
486#endif
487
488#ifndef __HAVE_ARCH_STRSEP
489/**
490 * strsep - Split a string into tokens
491 * @s: The string to be searched
492 * @ct: The characters to search for
493 *
494 * strsep() updates @s to point after the token, ready for the next call.
495 *
496 * It returns empty tokens, too, behaving exactly like the libc function
497 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
498 * Same semantics, slimmer shape. ;)
499 */
500char *strsep(char **s, const char *ct)
501{
502 char *sbegin = *s;
503 char *end;
504
505 if (sbegin == NULL)
506 return NULL;
507
508 end = strpbrk(sbegin, ct);
509 if (end)
510 *end++ = '\0';
511 *s = end;
512 return sbegin;
513}
514EXPORT_SYMBOL(strsep);
515#endif
516
517/**
518 * sysfs_streq - return true if strings are equal, modulo trailing newline
519 * @s1: one string
520 * @s2: another string
521 *
522 * This routine returns true iff two strings are equal, treating both
523 * NUL and newline-then-NUL as equivalent string terminations. It's
524 * geared for use with sysfs input strings, which generally terminate
525 * with newlines but are compared against values without newlines.
526 */
527bool sysfs_streq(const char *s1, const char *s2)
528{
529 while (*s1 && *s1 == *s2) {
530 s1++;
531 s2++;
532 }
533
534 if (*s1 == *s2)
535 return true;
536 if (!*s1 && *s2 == '\n' && !s2[1])
537 return true;
538 if (*s1 == '\n' && !s1[1] && !*s2)
539 return true;
540 return false;
541}
542EXPORT_SYMBOL(sysfs_streq);
543
544/**
545 * strtobool - convert common user inputs into boolean values
546 * @s: input string
547 * @res: result
548 *
549 * This routine returns 0 iff the first character is one of 'Yy1Nn0'.
550 * Otherwise it will return -EINVAL. Value pointed to by res is
551 * updated upon finding a match.
552 */
553int strtobool(const char *s, bool *res)
554{
555 switch (s[0]) {
556 case 'y':
557 case 'Y':
558 case '1':
559 *res = true;
560 break;
561 case 'n':
562 case 'N':
563 case '0':
564 *res = false;
565 break;
566 default:
567 return -EINVAL;
568 }
569 return 0;
570}
571EXPORT_SYMBOL(strtobool);
572
573#ifndef __HAVE_ARCH_MEMSET
574/**
575 * memset - Fill a region of memory with the given value
576 * @s: Pointer to the start of the area.
577 * @c: The byte to fill the area with
578 * @count: The size of the area.
579 *
580 * Do not use memset() to access IO space, use memset_io() instead.
581 */
582void *memset(void *s, int c, size_t count)
583{
584 char *xs = s;
585
586 while (count--)
587 *xs++ = c;
588 return s;
589}
590EXPORT_SYMBOL(memset);
591#endif
592
593/**
594 * memzero_explicit - Fill a region of memory (e.g. sensitive
595 * keying data) with 0s.
596 * @s: Pointer to the start of the area.
597 * @count: The size of the area.
598 *
599 * Note: usually using memset() is just fine (!), but in cases
600 * where clearing out _local_ data at the end of a scope is
601 * necessary, memzero_explicit() should be used instead in
602 * order to prevent the compiler from optimising away zeroing.
603 *
604 * memzero_explicit() doesn't need an arch-specific version as
605 * it just invokes the one of memset() implicitly.
606 */
607void memzero_explicit(void *s, size_t count)
608{
609 memset(s, 0, count);
610 barrier_data(s);
611}
612EXPORT_SYMBOL(memzero_explicit);
613
614#ifndef __HAVE_ARCH_MEMCPY
615/**
616 * memcpy - Copy one area of memory to another
617 * @dest: Where to copy to
618 * @src: Where to copy from
619 * @count: The size of the area.
620 *
621 * You should not use this function to access IO space, use memcpy_toio()
622 * or memcpy_fromio() instead.
623 */
624void *memcpy(void *dest, const void *src, size_t count)
625{
626 char *tmp = dest;
627 const char *s = src;
628
629 while (count--)
630 *tmp++ = *s++;
631 return dest;
632}
633EXPORT_SYMBOL(memcpy);
634#endif
635
636#ifndef __HAVE_ARCH_MEMMOVE
637/**
638 * memmove - Copy one area of memory to another
639 * @dest: Where to copy to
640 * @src: Where to copy from
641 * @count: The size of the area.
642 *
643 * Unlike memcpy(), memmove() copes with overlapping areas.
644 */
645void *memmove(void *dest, const void *src, size_t count)
646{
647 char *tmp;
648 const char *s;
649
650 if (dest <= src) {
651 tmp = dest;
652 s = src;
653 while (count--)
654 *tmp++ = *s++;
655 } else {
656 tmp = dest;
657 tmp += count;
658 s = src;
659 s += count;
660 while (count--)
661 *--tmp = *--s;
662 }
663 return dest;
664}
665EXPORT_SYMBOL(memmove);
666#endif
667
668#ifndef __HAVE_ARCH_MEMCMP
669/**
670 * memcmp - Compare two areas of memory
671 * @cs: One area of memory
672 * @ct: Another area of memory
673 * @count: The size of the area.
674 */
675#undef memcmp
676__visible int memcmp(const void *cs, const void *ct, size_t count)
677{
678 const unsigned char *su1, *su2;
679 int res = 0;
680
681 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
682 if ((res = *su1 - *su2) != 0)
683 break;
684 return res;
685}
686EXPORT_SYMBOL(memcmp);
687#endif
688
689#ifndef __HAVE_ARCH_MEMSCAN
690/**
691 * memscan - Find a character in an area of memory.
692 * @addr: The memory area
693 * @c: The byte to search for
694 * @size: The size of the area.
695 *
696 * returns the address of the first occurrence of @c, or 1 byte past
697 * the area if @c is not found
698 */
699void *memscan(void *addr, int c, size_t size)
700{
701 unsigned char *p = addr;
702
703 while (size) {
704 if (*p == c)
705 return (void *)p;
706 p++;
707 size--;
708 }
709 return (void *)p;
710}
711EXPORT_SYMBOL(memscan);
712#endif
713
714#ifndef __HAVE_ARCH_STRSTR
715/**
716 * strstr - Find the first substring in a %NUL terminated string
717 * @s1: The string to be searched
718 * @s2: The string to search for
719 */
720char *strstr(const char *s1, const char *s2)
721{
722 size_t l1, l2;
723
724 l2 = strlen(s2);
725 if (!l2)
726 return (char *)s1;
727 l1 = strlen(s1);
728 while (l1 >= l2) {
729 l1--;
730 if (!memcmp(s1, s2, l2))
731 return (char *)s1;
732 s1++;
733 }
734 return NULL;
735}
736EXPORT_SYMBOL(strstr);
737#endif
738
739#ifndef __HAVE_ARCH_STRNSTR
740/**
741 * strnstr - Find the first substring in a length-limited string
742 * @s1: The string to be searched
743 * @s2: The string to search for
744 * @len: the maximum number of characters to search
745 */
746char *strnstr(const char *s1, const char *s2, size_t len)
747{
748 size_t l2;
749
750 l2 = strlen(s2);
751 if (!l2)
752 return (char *)s1;
753 while (len >= l2) {
754 len--;
755 if (!memcmp(s1, s2, l2))
756 return (char *)s1;
757 s1++;
758 }
759 return NULL;
760}
761EXPORT_SYMBOL(strnstr);
762#endif
763
764#ifndef __HAVE_ARCH_MEMCHR
765/**
766 * memchr - Find a character in an area of memory.
767 * @s: The memory area
768 * @c: The byte to search for
769 * @n: The size of the area.
770 *
771 * returns the address of the first occurrence of @c, or %NULL
772 * if @c is not found
773 */
774void *memchr(const void *s, int c, size_t n)
775{
776 const unsigned char *p = s;
777 while (n-- != 0) {
778 if ((unsigned char)c == *p++) {
779 return (void *)(p - 1);
780 }
781 }
782 return NULL;
783}
784EXPORT_SYMBOL(memchr);
785#endif
786
787static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
788{
789 while (bytes) {
790 if (*start != value)
791 return (void *)start;
792 start++;
793 bytes--;
794 }
795 return NULL;
796}
797
798/**
799 * memchr_inv - Find an unmatching character in an area of memory.
800 * @start: The memory area
801 * @c: Find a character other than c
802 * @bytes: The size of the area.
803 *
804 * returns the address of the first character other than @c, or %NULL
805 * if the whole buffer contains just @c.
806 */
807void *memchr_inv(const void *start, int c, size_t bytes)
808{
809 u8 value = c;
810 u64 value64;
811 unsigned int words, prefix;
812
813 if (bytes <= 16)
814 return check_bytes8(start, value, bytes);
815
816 value64 = value;
817#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
818 value64 *= 0x0101010101010101;
819#elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
820 value64 *= 0x01010101;
821 value64 |= value64 << 32;
822#else
823 value64 |= value64 << 8;
824 value64 |= value64 << 16;
825 value64 |= value64 << 32;
826#endif
827
828 prefix = (unsigned long)start % 8;
829 if (prefix) {
830 u8 *r;
831
832 prefix = 8 - prefix;
833 r = check_bytes8(start, value, prefix);
834 if (r)
835 return r;
836 start += prefix;
837 bytes -= prefix;
838 }
839
840 words = bytes / 8;
841
842 while (words) {
843 if (*(u64 *)start != value64)
844 return check_bytes8(start, value, 8);
845 start += 8;
846 words--;
847 }
848
849 return check_bytes8(start, value, bytes % 8);
850}
851EXPORT_SYMBOL(memchr_inv);
852
853/**
854 * strreplace - Replace all occurrences of character in string.
855 * @s: The string to operate on.
856 * @old: The character being replaced.
857 * @new: The character @old is replaced with.
858 *
859 * Returns pointer to the nul byte at the end of @s.
860 */
861char *strreplace(char *s, char old, char new)
862{
863 for (; *s; ++s)
864 if (*s == old)
865 *s = new;
866 return s;
867}
868EXPORT_SYMBOL(strreplace);