blob: bb3d4b6993c408321da2268b07b1eeefe57cd854 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 <ioe@informatik.tu-chemnitz.de>
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 <jason@topic.com.au>,
18 * Matthew Hawkins <matt@mh.dropbear.id.au>
19 * - Kissed strtok() goodbye
20 */
21
22#include <linux/types.h>
23#include <linux/string.h>
24#include <linux/ctype.h>
Paul Gortmaker8bc3bcc2011-11-16 21:29:17 -050025#include <linux/kernel.h>
26#include <linux/export.h>
Paul Gortmaker50af5ea2012-01-20 18:35:53 -050027#include <linux/bug.h>
Paul Gortmaker8bc3bcc2011-11-16 21:29:17 -050028#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Rasmus Villemoescd514e72014-10-13 15:54:25 -070030#ifndef __HAVE_ARCH_STRNCASECMP
Linus Torvalds1da177e2005-04-16 15:20:36 -070031/**
Rasmus Villemoescd514e72014-10-13 15:54:25 -070032 * strncasecmp - Case insensitive, length-limited string comparison
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 * @s1: One string
34 * @s2: The other string
35 * @len: the maximum number of characters to compare
36 */
Rasmus Villemoescd514e72014-10-13 15:54:25 -070037int strncasecmp(const char *s1, const char *s2, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -070038{
39 /* Yes, Virginia, it had better be unsigned */
40 unsigned char c1, c2;
41
André Goddard Rosaa11d2b62010-03-05 13:43:11 -080042 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 return (int)c1 - (int)c2;
58}
Rasmus Villemoescd514e72014-10-13 15:54:25 -070059EXPORT_SYMBOL(strncasecmp);
60#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
David S. Millerded220b2007-03-29 01:18:42 -070062#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
Linus Torvalds1da177e2005-04-16 15:20:36 -070076#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 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -070082#undef strcpy
Jesper Juhl51a0f0f2005-10-30 15:02:11 -080083char *strcpy(char *dest, const char *src)
Linus Torvalds1da177e2005-04-16 15:20:36 -070084{
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/**
Dan Carpenter0046dd92014-06-04 16:11:47 -070096 * strncpy - Copy a length-limited, C-string
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 * @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.
walter harms25279522005-05-05 16:16:20 -0700103 *
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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800108char *strncpy(char *dest, const char *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
110 char *tmp = dest;
111
112 while (count) {
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800113 if ((*tmp = *src) != 0)
114 src++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 tmp++;
116 count--;
117 }
118 return dest;
119}
120EXPORT_SYMBOL(strncpy);
121#endif
122
123#ifndef __HAVE_ARCH_STRLCPY
124/**
Dan Carpenter0046dd92014-06-04 16:11:47 -0700125 * strlcpy - Copy a C-string into a sized buffer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 * @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) {
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800140 size_t len = (ret >= size) ? size - 1 : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 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 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -0700155#undef strcat
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800156char *strcat(char *dest, const char *src)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
158 char *tmp = dest;
159
160 while (*dest)
161 dest++;
162 while ((*dest++ = *src++) != '\0')
163 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 return tmp;
165}
166EXPORT_SYMBOL(strcat);
167#endif
168
169#ifndef __HAVE_ARCH_STRNCAT
170/**
Dan Carpenter0046dd92014-06-04 16:11:47 -0700171 * strncat - Append a length-limited, C-string to another
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 * @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 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800176 * Note that in contrast to strncpy(), strncat() ensures the result is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 * terminated.
178 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800179char *strncat(char *dest, const char *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180{
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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 return tmp;
194}
195EXPORT_SYMBOL(strncat);
196#endif
197
198#ifndef __HAVE_ARCH_STRLCAT
199/**
Dan Carpenter0046dd92014-06-04 16:11:47 -0700200 * strlcat - Append a length-limited, C-string to another
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 * @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 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -0700231#undef strcmp
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800232int strcmp(const char *cs, const char *ct)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233{
Linus Torvaldsa414f012009-11-18 22:31:52 +0100234 unsigned char c1, c2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
236 while (1) {
Linus Torvaldsa414f012009-11-18 22:31:52 +0100237 c1 = *cs++;
238 c2 = *ct++;
239 if (c1 != c2)
240 return c1 < c2 ? -1 : 1;
241 if (!c1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 break;
243 }
Linus Torvaldsa414f012009-11-18 22:31:52 +0100244 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245}
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 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800256int strncmp(const char *cs, const char *ct, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257{
Linus Torvaldsa414f012009-11-18 22:31:52 +0100258 unsigned char c1, c2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
260 while (count) {
Linus Torvaldsa414f012009-11-18 22:31:52 +0100261 c1 = *cs++;
262 c2 = *ct++;
263 if (c1 != c2)
264 return c1 < c2 ? -1 : 1;
265 if (!c1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 break;
267 count--;
268 }
Linus Torvaldsa414f012009-11-18 22:31:52 +0100269 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270}
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 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800280char *strchr(const char *s, int c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281{
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800282 for (; *s != (char)c; ++s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 if (*s == '\0')
284 return NULL;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800285 return (char *)s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286}
287EXPORT_SYMBOL(strchr);
288#endif
289
Grant Likely11d200e2014-03-14 17:00:14 +0000290#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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308#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 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800314char *strrchr(const char *s, int c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
Rasmus Villemoes8da53d42015-02-13 14:36:44 -0800316 const char *last = NULL;
317 do {
318 if (*s == (char)c)
319 last = s;
320 } while (*s++);
321 return (char *)last;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322}
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)
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800336 if (*s == (char)c)
337 return (char *)s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 return NULL;
339}
340EXPORT_SYMBOL(strnchr);
341#endif
342
Pekka Enberg481fad42006-06-23 02:05:44 -0700343/**
Randy Dunlapa6cd13f2009-12-21 14:37:22 -0800344 * skip_spaces - Removes leading whitespace from @str.
345 * @str: The string to be stripped.
André Goddard Rosaf6533982009-12-14 18:01:04 -0800346 *
Randy Dunlapa6cd13f2009-12-21 14:37:22 -0800347 * Returns a pointer to the first non-whitespace character in @str.
André Goddard Rosaf6533982009-12-14 18:01:04 -0800348 */
349char *skip_spaces(const char *str)
350{
351 while (isspace(*str))
352 ++str;
353 return (char *)str;
354}
355EXPORT_SYMBOL(skip_spaces);
356
357/**
KOSAKI Motohiroca54cb82009-12-14 18:01:15 -0800358 * strim - Removes leading and trailing whitespace from @s.
Pekka Enberg481fad42006-06-23 02:05:44 -0700359 * @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 */
KOSAKI Motohiroca54cb82009-12-14 18:01:15 -0800365char *strim(char *s)
Pekka Enberg481fad42006-06-23 02:05:44 -0700366{
367 size_t size;
368 char *end;
369
370 size = strlen(s);
Pekka Enberg481fad42006-06-23 02:05:44 -0700371 if (!size)
372 return s;
373
374 end = s + size - 1;
Michael Holzheu6e6d9fa2006-10-28 10:38:47 -0700375 while (end >= s && isspace(*end))
Pekka Enberg481fad42006-06-23 02:05:44 -0700376 end--;
377 *(end + 1) = '\0';
378
Michael Holzheu66f69582011-10-31 17:12:37 -0700379 return skip_spaces(s);
Pekka Enberg481fad42006-06-23 02:05:44 -0700380}
KOSAKI Motohiroca54cb82009-12-14 18:01:15 -0800381EXPORT_SYMBOL(strim);
Pekka Enberg481fad42006-06-23 02:05:44 -0700382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383#ifndef __HAVE_ARCH_STRLEN
384/**
385 * strlen - Find the length of a string
386 * @s: The string to be sized
387 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800388size_t strlen(const char *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389{
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 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800405size_t strnlen(const char *s, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
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/**
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800418 * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 * @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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 return count;
438}
439
440EXPORT_SYMBOL(strspn);
441#endif
442
Kyle McMartin8833d322006-04-10 22:53:57 -0700443#ifndef __HAVE_ARCH_STRCSPN
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444/**
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800445 * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 * @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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 return count;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800463}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464EXPORT_SYMBOL(strcspn);
Kyle McMartin8833d322006-04-10 22:53:57 -0700465#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
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 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800473char *strpbrk(const char *cs, const char *ct)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474{
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800475 const char *sc1, *sc2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800477 for (sc1 = cs; *sc1 != '\0'; ++sc1) {
478 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 if (*sc1 == *sc2)
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800480 return (char *)sc1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 }
482 }
483 return NULL;
484}
Kyle McMartin894b5772006-04-10 22:53:56 -0700485EXPORT_SYMBOL(strpbrk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486#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 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800500char *strsep(char **s, const char *ct)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501{
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800502 char *sbegin = *s;
503 char *end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
505 if (sbegin == NULL)
506 return NULL;
507
508 end = strpbrk(sbegin, ct);
509 if (end)
510 *end++ = '\0';
511 *s = end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 return sbegin;
513}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514EXPORT_SYMBOL(strsep);
515#endif
516
David Brownell34990cf2008-05-01 04:34:42 -0700517/**
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
Jonathan Camerond0f1fed2011-04-19 12:43:45 +0100544/**
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573#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 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800582void *memset(void *s, int c, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583{
Jesper Juhl850b9242005-10-30 15:02:13 -0800584 char *xs = s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
586 while (count--)
587 *xs++ = c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 return s;
589}
590EXPORT_SYMBOL(memset);
591#endif
592
Daniel Borkmannd4c5efd2014-08-26 23:16:35 -0400593/**
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 *
Daniel Borkmann81553302015-01-06 00:27:45 +0100599 * 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 *
Daniel Borkmannd4c5efd2014-08-26 23:16:35 -0400604 * 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);
Daniel Borkmann7829fb02015-04-30 04:13:52 +0200610 barrier_data(s);
Daniel Borkmannd4c5efd2014-08-26 23:16:35 -0400611}
612EXPORT_SYMBOL(memzero_explicit);
613
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614#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 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800624void *memcpy(void *dest, const void *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625{
Jesper Juhl850b9242005-10-30 15:02:13 -0800626 char *tmp = dest;
Jan-Benedict Glaw4c416ab2006-04-10 22:54:09 -0700627 const char *s = src;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
629 while (count--)
630 *tmp++ = *s++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 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 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800645void *memmove(void *dest, const void *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646{
Paul Jackson82da2c32005-10-30 15:03:19 -0800647 char *tmp;
648 const char *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
650 if (dest <= src) {
Jesper Juhl850b9242005-10-30 15:02:13 -0800651 tmp = dest;
652 s = src;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 while (count--)
654 *tmp++ = *s++;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800655 } else {
Jesper Juhl850b9242005-10-30 15:02:13 -0800656 tmp = dest;
657 tmp += count;
658 s = src;
659 s += count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 while (count--)
661 *--tmp = *--s;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800662 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 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 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -0700675#undef memcmp
Andi Kleena7330c92014-02-08 08:52:06 +0100676__visible int memcmp(const void *cs, const void *ct, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677{
678 const unsigned char *su1, *su2;
679 int res = 0;
680
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800681 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 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 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800699void *memscan(void *addr, int c, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
Jesper Juhl850b9242005-10-30 15:02:13 -0800701 unsigned char *p = addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
703 while (size) {
704 if (*p == c)
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800705 return (void *)p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 p++;
707 size--;
708 }
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800709 return (void *)p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710}
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 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800720char *strstr(const char *s1, const char *s2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721{
Li Zefand5f1fb52010-01-14 10:53:55 +0800722 size_t l1, l2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724 l2 = strlen(s2);
725 if (!l2)
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800726 return (char *)s1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 l1 = strlen(s1);
728 while (l1 >= l2) {
729 l1--;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800730 if (!memcmp(s1, s2, l2))
731 return (char *)s1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 s1++;
733 }
734 return NULL;
735}
736EXPORT_SYMBOL(strstr);
737#endif
738
Li Zefand5f1fb52010-01-14 10:53:55 +0800739#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{
André Goddard Rosad6a2eed2010-03-05 13:43:12 -0800748 size_t l2;
Li Zefand5f1fb52010-01-14 10:53:55 +0800749
750 l2 = strlen(s2);
751 if (!l2)
752 return (char *)s1;
André Goddard Rosad6a2eed2010-03-05 13:43:12 -0800753 while (len >= l2) {
754 len--;
Li Zefand5f1fb52010-01-14 10:53:55 +0800755 if (!memcmp(s1, s2, l2))
756 return (char *)s1;
757 s1++;
758 }
759 return NULL;
760}
761EXPORT_SYMBOL(strnstr);
762#endif
763
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764#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++) {
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800779 return (void *)(p - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 }
781 }
782 return NULL;
783}
784EXPORT_SYMBOL(memchr);
785#endif
Akinobu Mita798248202011-10-31 17:08:07 -0700786
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
Akinobu Mitaf43804b2012-03-23 15:02:14 -0700816 value64 = value;
Linus Torvalds72d93102014-09-13 11:14:53 -0700817#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
Akinobu Mitaf43804b2012-03-23 15:02:14 -0700818 value64 *= 0x0101010101010101;
Linus Torvalds72d93102014-09-13 11:14:53 -0700819#elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
Akinobu Mitaf43804b2012-03-23 15:02:14 -0700820 value64 *= 0x01010101;
821 value64 |= value64 << 32;
822#else
823 value64 |= value64 << 8;
824 value64 |= value64 << 16;
825 value64 |= value64 << 32;
826#endif
Akinobu Mita798248202011-10-31 17:08:07 -0700827
Akinobu Mitaf43804b2012-03-23 15:02:14 -0700828 prefix = (unsigned long)start % 8;
Akinobu Mita798248202011-10-31 17:08:07 -0700829 if (prefix) {
Akinobu Mitaf43804b2012-03-23 15:02:14 -0700830 u8 *r;
831
832 prefix = 8 - prefix;
833 r = check_bytes8(start, value, prefix);
Akinobu Mita798248202011-10-31 17:08:07 -0700834 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);