1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
39
40
41
42
43int strncasecmp(const char *s1, const char *s2, size_t len)
44{
45
46 unsigned char c1, c2;
47
48 if (!len)
49 return 0;
50
51 do {
52 c1 = *s1++;
53 c2 = *s2++;
54 if (!c1 || !c2)
55 break;
56 if (c1 == c2)
57 continue;
58 c1 = tolower(c1);
59 c2 = tolower(c2);
60 if (c1 != c2)
61 break;
62 } while (--len);
63 return (int)c1 - (int)c2;
64}
65EXPORT_SYMBOL(strncasecmp);
66#endif
67
68#ifndef __HAVE_ARCH_STRCASECMP
69int strcasecmp(const char *s1, const char *s2)
70{
71 int c1, c2;
72
73 do {
74 c1 = tolower(*s1++);
75 c2 = tolower(*s2++);
76 } while (c1 == c2 && c1 != 0);
77 return c1 - c2;
78}
79EXPORT_SYMBOL(strcasecmp);
80#endif
81
82#ifndef __HAVE_ARCH_STRCPY
83
84
85
86
87
88#undef strcpy
89char *strcpy(char *dest, const char *src)
90{
91 char *tmp = dest;
92
93 while ((*dest++ = *src++) != '\0')
94 ;
95 return tmp;
96}
97EXPORT_SYMBOL(strcpy);
98#endif
99
100#ifndef __HAVE_ARCH_STRNCPY
101
102
103
104
105
106
107
108
109
110
111
112
113
114char *strncpy(char *dest, const char *src, size_t count)
115{
116 char *tmp = dest;
117
118 while (count) {
119 if ((*tmp = *src) != 0)
120 src++;
121 tmp++;
122 count--;
123 }
124 return dest;
125}
126EXPORT_SYMBOL(strncpy);
127#endif
128
129#ifndef __HAVE_ARCH_STRLCPY
130
131
132
133
134
135
136
137
138
139
140
141size_t strlcpy(char *dest, const char *src, size_t size)
142{
143 size_t ret = strlen(src);
144
145 if (size) {
146 size_t len = (ret >= size) ? size - 1 : ret;
147 memcpy(dest, src, len);
148 dest[len] = '\0';
149 }
150 return ret;
151}
152EXPORT_SYMBOL(strlcpy);
153#endif
154
155#ifndef __HAVE_ARCH_STRSCPY
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179ssize_t strscpy(char *dest, const char *src, size_t count)
180{
181 const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
182 size_t max = count;
183 long res = 0;
184
185 if (count == 0)
186 return -E2BIG;
187
188#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
189
190
191
192
193 if ((long)src & (sizeof(long) - 1)) {
194 size_t limit = PAGE_SIZE - ((long)src & (PAGE_SIZE - 1));
195 if (limit < max)
196 max = limit;
197 }
198#else
199
200 if (((long) dest | (long) src) & (sizeof(long) - 1))
201 max = 0;
202#endif
203
204 while (max >= sizeof(unsigned long)) {
205 unsigned long c, data;
206
207 c = read_word_at_a_time(src+res);
208 if (has_zero(c, &data, &constants)) {
209 data = prep_zero_mask(c, data, &constants);
210 data = create_zero_mask(data);
211 *(unsigned long *)(dest+res) = c & zero_bytemask(data);
212 return res + find_zero(data);
213 }
214 *(unsigned long *)(dest+res) = c;
215 res += sizeof(unsigned long);
216 count -= sizeof(unsigned long);
217 max -= sizeof(unsigned long);
218 }
219
220 while (count) {
221 char c;
222
223 c = src[res];
224 dest[res] = c;
225 if (!c)
226 return res;
227 res++;
228 count--;
229 }
230
231
232 if (res)
233 dest[res-1] = '\0';
234
235 return -E2BIG;
236}
237EXPORT_SYMBOL(strscpy);
238#endif
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259ssize_t strscpy_pad(char *dest, const char *src, size_t count)
260{
261 ssize_t written;
262
263 written = strscpy(dest, src, count);
264 if (written < 0 || written == count - 1)
265 return written;
266
267 memset(dest + written + 1, 0, count - written - 1);
268
269 return written;
270}
271EXPORT_SYMBOL(strscpy_pad);
272
273#ifndef __HAVE_ARCH_STRCAT
274
275
276
277
278
279#undef strcat
280char *strcat(char *dest, const char *src)
281{
282 char *tmp = dest;
283
284 while (*dest)
285 dest++;
286 while ((*dest++ = *src++) != '\0')
287 ;
288 return tmp;
289}
290EXPORT_SYMBOL(strcat);
291#endif
292
293#ifndef __HAVE_ARCH_STRNCAT
294
295
296
297
298
299
300
301
302
303char *strncat(char *dest, const char *src, size_t count)
304{
305 char *tmp = dest;
306
307 if (count) {
308 while (*dest)
309 dest++;
310 while ((*dest++ = *src++) != 0) {
311 if (--count == 0) {
312 *dest = '\0';
313 break;
314 }
315 }
316 }
317 return tmp;
318}
319EXPORT_SYMBOL(strncat);
320#endif
321
322#ifndef __HAVE_ARCH_STRLCAT
323
324
325
326
327
328
329size_t strlcat(char *dest, const char *src, size_t count)
330{
331 size_t dsize = strlen(dest);
332 size_t len = strlen(src);
333 size_t res = dsize + len;
334
335
336 BUG_ON(dsize >= count);
337
338 dest += dsize;
339 count -= dsize;
340 if (len >= count)
341 len = count-1;
342 memcpy(dest, src, len);
343 dest[len] = 0;
344 return res;
345}
346EXPORT_SYMBOL(strlcat);
347#endif
348
349#ifndef __HAVE_ARCH_STRCMP
350
351
352
353
354
355#undef strcmp
356int strcmp(const char *cs, const char *ct)
357{
358 unsigned char c1, c2;
359
360 while (1) {
361 c1 = *cs++;
362 c2 = *ct++;
363 if (c1 != c2)
364 return c1 < c2 ? -1 : 1;
365 if (!c1)
366 break;
367 }
368 return 0;
369}
370EXPORT_SYMBOL(strcmp);
371#endif
372
373#ifndef __HAVE_ARCH_STRNCMP
374
375
376
377
378
379
380int strncmp(const char *cs, const char *ct, size_t count)
381{
382 unsigned char c1, c2;
383
384 while (count) {
385 c1 = *cs++;
386 c2 = *ct++;
387 if (c1 != c2)
388 return c1 < c2 ? -1 : 1;
389 if (!c1)
390 break;
391 count--;
392 }
393 return 0;
394}
395EXPORT_SYMBOL(strncmp);
396#endif
397
398#ifndef __HAVE_ARCH_STRCHR
399
400
401
402
403
404char *strchr(const char *s, int c)
405{
406 for (; *s != (char)c; ++s)
407 if (*s == '\0')
408 return NULL;
409 return (char *)s;
410}
411EXPORT_SYMBOL(strchr);
412#endif
413
414#ifndef __HAVE_ARCH_STRCHRNUL
415
416
417
418
419
420
421
422
423char *strchrnul(const char *s, int c)
424{
425 while (*s && *s != (char)c)
426 s++;
427 return (char *)s;
428}
429EXPORT_SYMBOL(strchrnul);
430#endif
431
432#ifndef __HAVE_ARCH_STRRCHR
433
434
435
436
437
438char *strrchr(const char *s, int c)
439{
440 const char *last = NULL;
441 do {
442 if (*s == (char)c)
443 last = s;
444 } while (*s++);
445 return (char *)last;
446}
447EXPORT_SYMBOL(strrchr);
448#endif
449
450#ifndef __HAVE_ARCH_STRNCHR
451
452
453
454
455
456
457char *strnchr(const char *s, size_t count, int c)
458{
459 for (; count-- && *s != '\0'; ++s)
460 if (*s == (char)c)
461 return (char *)s;
462 return NULL;
463}
464EXPORT_SYMBOL(strnchr);
465#endif
466
467
468
469
470
471
472
473char *skip_spaces(const char *str)
474{
475 while (isspace(*str))
476 ++str;
477 return (char *)str;
478}
479EXPORT_SYMBOL(skip_spaces);
480
481
482
483
484
485
486
487
488
489char *strim(char *s)
490{
491 size_t size;
492 char *end;
493
494 size = strlen(s);
495 if (!size)
496 return s;
497
498 end = s + size - 1;
499 while (end >= s && isspace(*end))
500 end--;
501 *(end + 1) = '\0';
502
503 return skip_spaces(s);
504}
505EXPORT_SYMBOL(strim);
506
507#ifndef __HAVE_ARCH_STRLEN
508
509
510
511
512size_t strlen(const char *s)
513{
514 const char *sc;
515
516 for (sc = s; *sc != '\0'; ++sc)
517 ;
518 return sc - s;
519}
520EXPORT_SYMBOL(strlen);
521#endif
522
523#ifndef __HAVE_ARCH_STRNLEN
524
525
526
527
528
529size_t strnlen(const char *s, size_t count)
530{
531 const char *sc;
532
533 for (sc = s; count-- && *sc != '\0'; ++sc)
534 ;
535 return sc - s;
536}
537EXPORT_SYMBOL(strnlen);
538#endif
539
540#ifndef __HAVE_ARCH_STRSPN
541
542
543
544
545
546size_t strspn(const char *s, const char *accept)
547{
548 const char *p;
549 const char *a;
550 size_t count = 0;
551
552 for (p = s; *p != '\0'; ++p) {
553 for (a = accept; *a != '\0'; ++a) {
554 if (*p == *a)
555 break;
556 }
557 if (*a == '\0')
558 return count;
559 ++count;
560 }
561 return count;
562}
563
564EXPORT_SYMBOL(strspn);
565#endif
566
567#ifndef __HAVE_ARCH_STRCSPN
568
569
570
571
572
573size_t strcspn(const char *s, const char *reject)
574{
575 const char *p;
576 const char *r;
577 size_t count = 0;
578
579 for (p = s; *p != '\0'; ++p) {
580 for (r = reject; *r != '\0'; ++r) {
581 if (*p == *r)
582 return count;
583 }
584 ++count;
585 }
586 return count;
587}
588EXPORT_SYMBOL(strcspn);
589#endif
590
591#ifndef __HAVE_ARCH_STRPBRK
592
593
594
595
596
597char *strpbrk(const char *cs, const char *ct)
598{
599 const char *sc1, *sc2;
600
601 for (sc1 = cs; *sc1 != '\0'; ++sc1) {
602 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
603 if (*sc1 == *sc2)
604 return (char *)sc1;
605 }
606 }
607 return NULL;
608}
609EXPORT_SYMBOL(strpbrk);
610#endif
611
612#ifndef __HAVE_ARCH_STRSEP
613
614
615
616
617
618
619
620
621
622
623
624char *strsep(char **s, const char *ct)
625{
626 char *sbegin = *s;
627 char *end;
628
629 if (sbegin == NULL)
630 return NULL;
631
632 end = strpbrk(sbegin, ct);
633 if (end)
634 *end++ = '\0';
635 *s = end;
636 return sbegin;
637}
638EXPORT_SYMBOL(strsep);
639#endif
640
641
642
643
644
645
646
647
648
649
650
651bool sysfs_streq(const char *s1, const char *s2)
652{
653 while (*s1 && *s1 == *s2) {
654 s1++;
655 s2++;
656 }
657
658 if (*s1 == *s2)
659 return true;
660 if (!*s1 && *s2 == '\n' && !s2[1])
661 return true;
662 if (*s1 == '\n' && !s1[1] && !*s2)
663 return true;
664 return false;
665}
666EXPORT_SYMBOL(sysfs_streq);
667
668
669
670
671
672
673
674
675
676
677int match_string(const char * const *array, size_t n, const char *string)
678{
679 int index;
680 const char *item;
681
682 for (index = 0; index < n; index++) {
683 item = array[index];
684 if (!item)
685 break;
686 if (!strcmp(item, string))
687 return index;
688 }
689
690 return -EINVAL;
691}
692EXPORT_SYMBOL(match_string);
693
694
695
696
697
698
699
700
701
702
703int __sysfs_match_string(const char * const *array, size_t n, const char *str)
704{
705 const char *item;
706 int index;
707
708 for (index = 0; index < n; index++) {
709 item = array[index];
710 if (!item)
711 break;
712 if (sysfs_streq(item, str))
713 return index;
714 }
715
716 return -EINVAL;
717}
718EXPORT_SYMBOL(__sysfs_match_string);
719
720#ifndef __HAVE_ARCH_MEMSET
721
722
723
724
725
726
727
728
729void *memset(void *s, int c, size_t count)
730{
731 char *xs = s;
732
733 while (count--)
734 *xs++ = c;
735 return s;
736}
737EXPORT_SYMBOL(memset);
738#endif
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754void memzero_explicit(void *s, size_t count)
755{
756 memset(s, 0, count);
757 barrier_data(s);
758}
759EXPORT_SYMBOL(memzero_explicit);
760
761#ifndef __HAVE_ARCH_MEMSET16
762
763
764
765
766
767
768
769
770
771
772void *memset16(uint16_t *s, uint16_t v, size_t count)
773{
774 uint16_t *xs = s;
775
776 while (count--)
777 *xs++ = v;
778 return s;
779}
780EXPORT_SYMBOL(memset16);
781#endif
782
783#ifndef __HAVE_ARCH_MEMSET32
784
785
786
787
788
789
790
791
792
793
794void *memset32(uint32_t *s, uint32_t v, size_t count)
795{
796 uint32_t *xs = s;
797
798 while (count--)
799 *xs++ = v;
800 return s;
801}
802EXPORT_SYMBOL(memset32);
803#endif
804
805#ifndef __HAVE_ARCH_MEMSET64
806
807
808
809
810
811
812
813
814
815
816void *memset64(uint64_t *s, uint64_t v, size_t count)
817{
818 uint64_t *xs = s;
819
820 while (count--)
821 *xs++ = v;
822 return s;
823}
824EXPORT_SYMBOL(memset64);
825#endif
826
827#ifndef __HAVE_ARCH_MEMCPY
828
829
830
831
832
833
834
835
836
837void *memcpy(void *dest, const void *src, size_t count)
838{
839 char *tmp = dest;
840 const char *s = src;
841
842 while (count--)
843 *tmp++ = *s++;
844 return dest;
845}
846EXPORT_SYMBOL(memcpy);
847#endif
848
849#ifndef __HAVE_ARCH_MEMMOVE
850
851
852
853
854
855
856
857
858void *memmove(void *dest, const void *src, size_t count)
859{
860 char *tmp;
861 const char *s;
862
863 if (dest <= src) {
864 tmp = dest;
865 s = src;
866 while (count--)
867 *tmp++ = *s++;
868 } else {
869 tmp = dest;
870 tmp += count;
871 s = src;
872 s += count;
873 while (count--)
874 *--tmp = *--s;
875 }
876 return dest;
877}
878EXPORT_SYMBOL(memmove);
879#endif
880
881#ifndef __HAVE_ARCH_MEMCMP
882
883
884
885
886
887
888#undef memcmp
889__visible int memcmp(const void *cs, const void *ct, size_t count)
890{
891 const unsigned char *su1, *su2;
892 int res = 0;
893
894 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
895 if ((res = *su1 - *su2) != 0)
896 break;
897 return res;
898}
899EXPORT_SYMBOL(memcmp);
900#endif
901
902#ifndef __HAVE_ARCH_BCMP
903
904
905
906
907
908
909
910
911
912
913
914#undef bcmp
915int bcmp(const void *a, const void *b, size_t len)
916{
917 return memcmp(a, b, len);
918}
919EXPORT_SYMBOL(bcmp);
920#endif
921
922#ifndef __HAVE_ARCH_MEMSCAN
923
924
925
926
927
928
929
930
931
932void *memscan(void *addr, int c, size_t size)
933{
934 unsigned char *p = addr;
935
936 while (size) {
937 if (*p == c)
938 return (void *)p;
939 p++;
940 size--;
941 }
942 return (void *)p;
943}
944EXPORT_SYMBOL(memscan);
945#endif
946
947#ifndef __HAVE_ARCH_STRSTR
948
949
950
951
952
953char *strstr(const char *s1, const char *s2)
954{
955 size_t l1, l2;
956
957 l2 = strlen(s2);
958 if (!l2)
959 return (char *)s1;
960 l1 = strlen(s1);
961 while (l1 >= l2) {
962 l1--;
963 if (!memcmp(s1, s2, l2))
964 return (char *)s1;
965 s1++;
966 }
967 return NULL;
968}
969EXPORT_SYMBOL(strstr);
970#endif
971
972#ifndef __HAVE_ARCH_STRNSTR
973
974
975
976
977
978
979char *strnstr(const char *s1, const char *s2, size_t len)
980{
981 size_t l2;
982
983 l2 = strlen(s2);
984 if (!l2)
985 return (char *)s1;
986 while (len >= l2) {
987 len--;
988 if (!memcmp(s1, s2, l2))
989 return (char *)s1;
990 s1++;
991 }
992 return NULL;
993}
994EXPORT_SYMBOL(strnstr);
995#endif
996
997#ifndef __HAVE_ARCH_MEMCHR
998
999
1000
1001
1002
1003
1004
1005
1006
1007void *memchr(const void *s, int c, size_t n)
1008{
1009 const unsigned char *p = s;
1010 while (n-- != 0) {
1011 if ((unsigned char)c == *p++) {
1012 return (void *)(p - 1);
1013 }
1014 }
1015 return NULL;
1016}
1017EXPORT_SYMBOL(memchr);
1018#endif
1019
1020static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
1021{
1022 while (bytes) {
1023 if (*start != value)
1024 return (void *)start;
1025 start++;
1026 bytes--;
1027 }
1028 return NULL;
1029}
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040void *memchr_inv(const void *start, int c, size_t bytes)
1041{
1042 u8 value = c;
1043 u64 value64;
1044 unsigned int words, prefix;
1045
1046 if (bytes <= 16)
1047 return check_bytes8(start, value, bytes);
1048
1049 value64 = value;
1050#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
1051 value64 *= 0x0101010101010101ULL;
1052#elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
1053 value64 *= 0x01010101;
1054 value64 |= value64 << 32;
1055#else
1056 value64 |= value64 << 8;
1057 value64 |= value64 << 16;
1058 value64 |= value64 << 32;
1059#endif
1060
1061 prefix = (unsigned long)start % 8;
1062 if (prefix) {
1063 u8 *r;
1064
1065 prefix = 8 - prefix;
1066 r = check_bytes8(start, value, prefix);
1067 if (r)
1068 return r;
1069 start += prefix;
1070 bytes -= prefix;
1071 }
1072
1073 words = bytes / 8;
1074
1075 while (words) {
1076 if (*(u64 *)start != value64)
1077 return check_bytes8(start, value, 8);
1078 start += 8;
1079 words--;
1080 }
1081
1082 return check_bytes8(start, value, bytes % 8);
1083}
1084EXPORT_SYMBOL(memchr_inv);
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094char *strreplace(char *s, char old, char new)
1095{
1096 for (; *s; ++s)
1097 if (*s == old)
1098 *s = new;
1099 return s;
1100}
1101EXPORT_SYMBOL(strreplace);
1102
1103void fortify_panic(const char *name)
1104{
1105 pr_emerg("detected buffer overflow in %s\n", name);
1106 BUG();
1107}
1108EXPORT_SYMBOL(fortify_panic);
1109