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
88char *strcpy(char *dest, const char *src)
89{
90 char *tmp = dest;
91
92 while ((*dest++ = *src++) != '\0')
93 ;
94 return tmp;
95}
96EXPORT_SYMBOL(strcpy);
97#endif
98
99#ifndef __HAVE_ARCH_STRNCPY
100
101
102
103
104
105
106
107
108
109
110
111
112
113char *strncpy(char *dest, const char *src, size_t count)
114{
115 char *tmp = dest;
116
117 while (count) {
118 if ((*tmp = *src) != 0)
119 src++;
120 tmp++;
121 count--;
122 }
123 return dest;
124}
125EXPORT_SYMBOL(strncpy);
126#endif
127
128#ifndef __HAVE_ARCH_STRLCPY
129
130
131
132
133
134
135
136
137
138
139
140size_t strlcpy(char *dest, const char *src, size_t size)
141{
142 size_t ret = strlen(src);
143
144 if (size) {
145 size_t len = (ret >= size) ? size - 1 : ret;
146 memcpy(dest, src, len);
147 dest[len] = '\0';
148 }
149 return ret;
150}
151EXPORT_SYMBOL(strlcpy);
152#endif
153
154#ifndef __HAVE_ARCH_STRSCPY
155
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 || WARN_ON_ONCE(count > INT_MAX))
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
259
260ssize_t strscpy_pad(char *dest, const char *src, size_t count)
261{
262 ssize_t written;
263
264 written = strscpy(dest, src, count);
265 if (written < 0 || written == count - 1)
266 return written;
267
268 memset(dest + written + 1, 0, count - written - 1);
269
270 return written;
271}
272EXPORT_SYMBOL(strscpy_pad);
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289char *stpcpy(char *__restrict__ dest, const char *__restrict__ src);
290char *stpcpy(char *__restrict__ dest, const char *__restrict__ src)
291{
292 while ((*dest++ = *src++) != '\0')
293 ;
294 return --dest;
295}
296EXPORT_SYMBOL(stpcpy);
297
298#ifndef __HAVE_ARCH_STRCAT
299
300
301
302
303
304char *strcat(char *dest, const char *src)
305{
306 char *tmp = dest;
307
308 while (*dest)
309 dest++;
310 while ((*dest++ = *src++) != '\0')
311 ;
312 return tmp;
313}
314EXPORT_SYMBOL(strcat);
315#endif
316
317#ifndef __HAVE_ARCH_STRNCAT
318
319
320
321
322
323
324
325
326
327char *strncat(char *dest, const char *src, size_t count)
328{
329 char *tmp = dest;
330
331 if (count) {
332 while (*dest)
333 dest++;
334 while ((*dest++ = *src++) != 0) {
335 if (--count == 0) {
336 *dest = '\0';
337 break;
338 }
339 }
340 }
341 return tmp;
342}
343EXPORT_SYMBOL(strncat);
344#endif
345
346#ifndef __HAVE_ARCH_STRLCAT
347
348
349
350
351
352
353size_t strlcat(char *dest, const char *src, size_t count)
354{
355 size_t dsize = strlen(dest);
356 size_t len = strlen(src);
357 size_t res = dsize + len;
358
359
360 BUG_ON(dsize >= count);
361
362 dest += dsize;
363 count -= dsize;
364 if (len >= count)
365 len = count-1;
366 memcpy(dest, src, len);
367 dest[len] = 0;
368 return res;
369}
370EXPORT_SYMBOL(strlcat);
371#endif
372
373#ifndef __HAVE_ARCH_STRCMP
374
375
376
377
378
379int strcmp(const char *cs, const char *ct)
380{
381 unsigned char c1, c2;
382
383 while (1) {
384 c1 = *cs++;
385 c2 = *ct++;
386 if (c1 != c2)
387 return c1 < c2 ? -1 : 1;
388 if (!c1)
389 break;
390 }
391 return 0;
392}
393EXPORT_SYMBOL(strcmp);
394#endif
395
396#ifndef __HAVE_ARCH_STRNCMP
397
398
399
400
401
402
403int strncmp(const char *cs, const char *ct, size_t count)
404{
405 unsigned char c1, c2;
406
407 while (count) {
408 c1 = *cs++;
409 c2 = *ct++;
410 if (c1 != c2)
411 return c1 < c2 ? -1 : 1;
412 if (!c1)
413 break;
414 count--;
415 }
416 return 0;
417}
418EXPORT_SYMBOL(strncmp);
419#endif
420
421#ifndef __HAVE_ARCH_STRCHR
422
423
424
425
426
427
428
429
430char *strchr(const char *s, int c)
431{
432 for (; *s != (char)c; ++s)
433 if (*s == '\0')
434 return NULL;
435 return (char *)s;
436}
437EXPORT_SYMBOL(strchr);
438#endif
439
440#ifndef __HAVE_ARCH_STRCHRNUL
441
442
443
444
445
446
447
448
449char *strchrnul(const char *s, int c)
450{
451 while (*s && *s != (char)c)
452 s++;
453 return (char *)s;
454}
455EXPORT_SYMBOL(strchrnul);
456#endif
457
458
459
460
461
462
463
464
465
466
467
468char *strnchrnul(const char *s, size_t count, int c)
469{
470 while (count-- && *s && *s != (char)c)
471 s++;
472 return (char *)s;
473}
474
475#ifndef __HAVE_ARCH_STRRCHR
476
477
478
479
480
481char *strrchr(const char *s, int c)
482{
483 const char *last = NULL;
484 do {
485 if (*s == (char)c)
486 last = s;
487 } while (*s++);
488 return (char *)last;
489}
490EXPORT_SYMBOL(strrchr);
491#endif
492
493#ifndef __HAVE_ARCH_STRNCHR
494
495
496
497
498
499
500
501
502
503char *strnchr(const char *s, size_t count, int c)
504{
505 while (count--) {
506 if (*s == (char)c)
507 return (char *)s;
508 if (*s++ == '\0')
509 break;
510 }
511 return NULL;
512}
513EXPORT_SYMBOL(strnchr);
514#endif
515
516
517
518
519
520
521
522char *skip_spaces(const char *str)
523{
524 while (isspace(*str))
525 ++str;
526 return (char *)str;
527}
528EXPORT_SYMBOL(skip_spaces);
529
530
531
532
533
534
535
536
537
538char *strim(char *s)
539{
540 size_t size;
541 char *end;
542
543 size = strlen(s);
544 if (!size)
545 return s;
546
547 end = s + size - 1;
548 while (end >= s && isspace(*end))
549 end--;
550 *(end + 1) = '\0';
551
552 return skip_spaces(s);
553}
554EXPORT_SYMBOL(strim);
555
556#ifndef __HAVE_ARCH_STRLEN
557
558
559
560
561size_t strlen(const char *s)
562{
563 const char *sc;
564
565 for (sc = s; *sc != '\0'; ++sc)
566 ;
567 return sc - s;
568}
569EXPORT_SYMBOL(strlen);
570#endif
571
572#ifndef __HAVE_ARCH_STRNLEN
573
574
575
576
577
578size_t strnlen(const char *s, size_t count)
579{
580 const char *sc;
581
582 for (sc = s; count-- && *sc != '\0'; ++sc)
583 ;
584 return sc - s;
585}
586EXPORT_SYMBOL(strnlen);
587#endif
588
589#ifndef __HAVE_ARCH_STRSPN
590
591
592
593
594
595size_t strspn(const char *s, const char *accept)
596{
597 const char *p;
598 const char *a;
599 size_t count = 0;
600
601 for (p = s; *p != '\0'; ++p) {
602 for (a = accept; *a != '\0'; ++a) {
603 if (*p == *a)
604 break;
605 }
606 if (*a == '\0')
607 return count;
608 ++count;
609 }
610 return count;
611}
612
613EXPORT_SYMBOL(strspn);
614#endif
615
616#ifndef __HAVE_ARCH_STRCSPN
617
618
619
620
621
622size_t strcspn(const char *s, const char *reject)
623{
624 const char *p;
625 const char *r;
626 size_t count = 0;
627
628 for (p = s; *p != '\0'; ++p) {
629 for (r = reject; *r != '\0'; ++r) {
630 if (*p == *r)
631 return count;
632 }
633 ++count;
634 }
635 return count;
636}
637EXPORT_SYMBOL(strcspn);
638#endif
639
640#ifndef __HAVE_ARCH_STRPBRK
641
642
643
644
645
646char *strpbrk(const char *cs, const char *ct)
647{
648 const char *sc1, *sc2;
649
650 for (sc1 = cs; *sc1 != '\0'; ++sc1) {
651 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
652 if (*sc1 == *sc2)
653 return (char *)sc1;
654 }
655 }
656 return NULL;
657}
658EXPORT_SYMBOL(strpbrk);
659#endif
660
661#ifndef __HAVE_ARCH_STRSEP
662
663
664
665
666
667
668
669
670
671
672
673char *strsep(char **s, const char *ct)
674{
675 char *sbegin = *s;
676 char *end;
677
678 if (sbegin == NULL)
679 return NULL;
680
681 end = strpbrk(sbegin, ct);
682 if (end)
683 *end++ = '\0';
684 *s = end;
685 return sbegin;
686}
687EXPORT_SYMBOL(strsep);
688#endif
689
690
691
692
693
694
695
696
697
698
699
700bool sysfs_streq(const char *s1, const char *s2)
701{
702 while (*s1 && *s1 == *s2) {
703 s1++;
704 s2++;
705 }
706
707 if (*s1 == *s2)
708 return true;
709 if (!*s1 && *s2 == '\n' && !s2[1])
710 return true;
711 if (*s1 == '\n' && !s1[1] && !*s2)
712 return true;
713 return false;
714}
715EXPORT_SYMBOL(sysfs_streq);
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734int match_string(const char * const *array, size_t n, const char *string)
735{
736 int index;
737 const char *item;
738
739 for (index = 0; index < n; index++) {
740 item = array[index];
741 if (!item)
742 break;
743 if (!strcmp(item, string))
744 return index;
745 }
746
747 return -EINVAL;
748}
749EXPORT_SYMBOL(match_string);
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768int __sysfs_match_string(const char * const *array, size_t n, const char *str)
769{
770 const char *item;
771 int index;
772
773 for (index = 0; index < n; index++) {
774 item = array[index];
775 if (!item)
776 break;
777 if (sysfs_streq(item, str))
778 return index;
779 }
780
781 return -EINVAL;
782}
783EXPORT_SYMBOL(__sysfs_match_string);
784
785#ifndef __HAVE_ARCH_MEMSET
786
787
788
789
790
791
792
793
794void *memset(void *s, int c, size_t count)
795{
796 char *xs = s;
797
798 while (count--)
799 *xs++ = c;
800 return s;
801}
802EXPORT_SYMBOL(memset);
803#endif
804
805#ifndef __HAVE_ARCH_MEMSET16
806
807
808
809
810
811
812
813
814
815
816void *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}
824EXPORT_SYMBOL(memset16);
825#endif
826
827#ifndef __HAVE_ARCH_MEMSET32
828
829
830
831
832
833
834
835
836
837
838void *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}
846EXPORT_SYMBOL(memset32);
847#endif
848
849#ifndef __HAVE_ARCH_MEMSET64
850
851
852
853
854
855
856
857
858
859
860void *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}
868EXPORT_SYMBOL(memset64);
869#endif
870
871#ifndef __HAVE_ARCH_MEMCPY
872
873
874
875
876
877
878
879
880
881void *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}
890EXPORT_SYMBOL(memcpy);
891#endif
892
893#ifndef __HAVE_ARCH_MEMMOVE
894
895
896
897
898
899
900
901
902void *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}
922EXPORT_SYMBOL(memmove);
923#endif
924
925#ifndef __HAVE_ARCH_MEMCMP
926
927
928
929
930
931
932#undef memcmp
933__visible int memcmp(const void *cs, const void *ct, size_t count)
934{
935 const unsigned char *su1, *su2;
936 int res = 0;
937
938 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
939 if ((res = *su1 - *su2) != 0)
940 break;
941 return res;
942}
943EXPORT_SYMBOL(memcmp);
944#endif
945
946#ifndef __HAVE_ARCH_BCMP
947
948
949
950
951
952
953
954
955
956
957
958int bcmp(const void *a, const void *b, size_t len)
959{
960 return memcmp(a, b, len);
961}
962EXPORT_SYMBOL(bcmp);
963#endif
964
965#ifndef __HAVE_ARCH_MEMSCAN
966
967
968
969
970
971
972
973
974
975void *memscan(void *addr, int c, size_t size)
976{
977 unsigned char *p = addr;
978
979 while (size) {
980 if (*p == (unsigned char)c)
981 return (void *)p;
982 p++;
983 size--;
984 }
985 return (void *)p;
986}
987EXPORT_SYMBOL(memscan);
988#endif
989
990#ifndef __HAVE_ARCH_STRSTR
991
992
993
994
995
996char *strstr(const char *s1, const char *s2)
997{
998 size_t l1, l2;
999
1000 l2 = strlen(s2);
1001 if (!l2)
1002 return (char *)s1;
1003 l1 = strlen(s1);
1004 while (l1 >= l2) {
1005 l1--;
1006 if (!memcmp(s1, s2, l2))
1007 return (char *)s1;
1008 s1++;
1009 }
1010 return NULL;
1011}
1012EXPORT_SYMBOL(strstr);
1013#endif
1014
1015#ifndef __HAVE_ARCH_STRNSTR
1016
1017
1018
1019
1020
1021
1022char *strnstr(const char *s1, const char *s2, size_t len)
1023{
1024 size_t l2;
1025
1026 l2 = strlen(s2);
1027 if (!l2)
1028 return (char *)s1;
1029 while (len >= l2) {
1030 len--;
1031 if (!memcmp(s1, s2, l2))
1032 return (char *)s1;
1033 s1++;
1034 }
1035 return NULL;
1036}
1037EXPORT_SYMBOL(strnstr);
1038#endif
1039
1040#ifndef __HAVE_ARCH_MEMCHR
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050void *memchr(const void *s, int c, size_t n)
1051{
1052 const unsigned char *p = s;
1053 while (n-- != 0) {
1054 if ((unsigned char)c == *p++) {
1055 return (void *)(p - 1);
1056 }
1057 }
1058 return NULL;
1059}
1060EXPORT_SYMBOL(memchr);
1061#endif
1062
1063static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
1064{
1065 while (bytes) {
1066 if (*start != value)
1067 return (void *)start;
1068 start++;
1069 bytes--;
1070 }
1071 return NULL;
1072}
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083void *memchr_inv(const void *start, int c, size_t bytes)
1084{
1085 u8 value = c;
1086 u64 value64;
1087 unsigned int words, prefix;
1088
1089 if (bytes <= 16)
1090 return check_bytes8(start, value, bytes);
1091
1092 value64 = value;
1093#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
1094 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 prefix = (unsigned long)start % 8;
1105 if (prefix) {
1106 u8 *r;
1107
1108 prefix = 8 - prefix;
1109 r = check_bytes8(start, value, prefix);
1110 if (r)
1111 return r;
1112 start += prefix;
1113 bytes -= prefix;
1114 }
1115
1116 words = bytes / 8;
1117
1118 while (words) {
1119 if (*(u64 *)start != value64)
1120 return check_bytes8(start, value, 8);
1121 start += 8;
1122 words--;
1123 }
1124
1125 return check_bytes8(start, value, bytes % 8);
1126}
1127EXPORT_SYMBOL(memchr_inv);
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137char *strreplace(char *s, char old, char new)
1138{
1139 for (; *s; ++s)
1140 if (*s == old)
1141 *s = new;
1142 return s;
1143}
1144EXPORT_SYMBOL(strreplace);
1145
1146void fortify_panic(const char *name)
1147{
1148 pr_emerg("detected buffer overflow in %s\n", name);
1149 BUG();
1150}
1151EXPORT_SYMBOL(fortify_panic);
1152