blob: 6012c385fb314d810bd8a2ff4f18b9e8a3a517db [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
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>
Paul Gortmaker8bc3bcc2011-11-16 21:29:17 -050026#include <linux/kernel.h>
27#include <linux/export.h>
Paul Gortmaker50af5ea2012-01-20 18:35:53 -050028#include <linux/bug.h>
Paul Gortmaker8bc3bcc2011-11-16 21:29:17 -050029#include <linux/errno.h>
Alexander Shishkince76d932018-10-05 15:43:05 +030030#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
Chris Metcalf30035e42015-04-29 12:52:04 -040032#include <asm/byteorder.h>
33#include <asm/word-at-a-time.h>
34#include <asm/page.h>
35
Rasmus Villemoescd514e72014-10-13 15:54:25 -070036#ifndef __HAVE_ARCH_STRNCASECMP
Linus Torvalds1da177e2005-04-16 15:20:36 -070037/**
Rasmus Villemoescd514e72014-10-13 15:54:25 -070038 * strncasecmp - Case insensitive, length-limited string comparison
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 * @s1: One string
40 * @s2: The other string
41 * @len: the maximum number of characters to compare
42 */
Rasmus Villemoescd514e72014-10-13 15:54:25 -070043int strncasecmp(const char *s1, const char *s2, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -070044{
45 /* Yes, Virginia, it had better be unsigned */
46 unsigned char c1, c2;
47
André Goddard Rosaa11d2b62010-03-05 13:43:11 -080048 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 return (int)c1 - (int)c2;
64}
Rasmus Villemoescd514e72014-10-13 15:54:25 -070065EXPORT_SYMBOL(strncasecmp);
66#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
David S. Millerded220b2007-03-29 01:18:42 -070068#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
Linus Torvalds1da177e2005-04-16 15:20:36 -070082#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 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -070088#undef strcpy
Jesper Juhl51a0f0f2005-10-30 15:02:11 -080089char *strcpy(char *dest, const char *src)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090{
91 char *tmp = dest;
92
93 while ((*dest++ = *src++) != '\0')
94 /* nothing */;
95 return tmp;
96}
97EXPORT_SYMBOL(strcpy);
98#endif
99
100#ifndef __HAVE_ARCH_STRNCPY
101/**
Dan Carpenter0046dd92014-06-04 16:11:47 -0700102 * strncpy - Copy a length-limited, C-string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 * @dest: Where to copy the string to
104 * @src: Where to copy the string from
105 * @count: The maximum number of bytes to copy
106 *
107 * The result is not %NUL-terminated if the source exceeds
108 * @count bytes.
walter harms25279522005-05-05 16:16:20 -0700109 *
110 * In the case where the length of @src is less than that of
111 * count, the remainder of @dest will be padded with %NUL.
112 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800114char *strncpy(char *dest, const char *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115{
116 char *tmp = dest;
117
118 while (count) {
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800119 if ((*tmp = *src) != 0)
120 src++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 tmp++;
122 count--;
123 }
124 return dest;
125}
126EXPORT_SYMBOL(strncpy);
127#endif
128
129#ifndef __HAVE_ARCH_STRLCPY
130/**
Dan Carpenter0046dd92014-06-04 16:11:47 -0700131 * strlcpy - Copy a C-string into a sized buffer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 * @dest: Where to copy the string to
133 * @src: Where to copy the string from
134 * @size: size of destination buffer
135 *
mchehab@s-opensource.com0e056eb2017-03-30 17:11:36 -0300136 * Compatible with ``*BSD``: the result is always a valid
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 * NUL-terminated string that fits in the buffer (unless,
138 * of course, the buffer size is zero). It does not pad
139 * out the result like strncpy() does.
140 */
141size_t strlcpy(char *dest, const char *src, size_t size)
142{
143 size_t ret = strlen(src);
144
145 if (size) {
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800146 size_t len = (ret >= size) ? size - 1 : ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 memcpy(dest, src, len);
148 dest[len] = '\0';
149 }
150 return ret;
151}
152EXPORT_SYMBOL(strlcpy);
153#endif
154
Chris Metcalf30035e42015-04-29 12:52:04 -0400155#ifndef __HAVE_ARCH_STRSCPY
156/**
157 * strscpy - Copy a C-string into a sized buffer
158 * @dest: Where to copy the string to
159 * @src: Where to copy the string from
160 * @count: Size of destination buffer
161 *
Tobin C. Harding458a3bf2019-04-05 12:58:58 +1100162 * Copy the string, or as much of it as fits, into the dest buffer. The
163 * behavior is undefined if the string buffers overlap. The destination
164 * buffer is always NUL terminated, unless it's zero-sized.
Chris Metcalf30035e42015-04-29 12:52:04 -0400165 *
166 * Preferred to strlcpy() since the API doesn't require reading memory
167 * from the src string beyond the specified "count" bytes, and since
168 * the return value is easier to error-check than strlcpy()'s.
169 * In addition, the implementation is robust to the string changing out
170 * from underneath it, unlike the current strlcpy() implementation.
171 *
172 * Preferred to strncpy() since it always returns a valid string, and
173 * doesn't unnecessarily force the tail of the destination buffer to be
Tobin C. Harding458a3bf2019-04-05 12:58:58 +1100174 * zeroed. If zeroing is desired please use strscpy_pad().
175 *
Joe Perches917cda22019-09-25 16:46:13 -0700176 * Returns:
177 * * The number of characters copied (not including the trailing %NUL)
178 * * -E2BIG if count is 0 or @src was truncated.
Chris Metcalf30035e42015-04-29 12:52:04 -0400179 */
180ssize_t strscpy(char *dest, const char *src, size_t count)
181{
182 const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
183 size_t max = count;
184 long res = 0;
185
Kees Cook9a156462019-09-25 16:46:20 -0700186 if (count == 0 || WARN_ON_ONCE(count > INT_MAX))
Chris Metcalf30035e42015-04-29 12:52:04 -0400187 return -E2BIG;
188
189#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
190 /*
191 * If src is unaligned, don't cross a page boundary,
192 * since we don't know if the next page is mapped.
193 */
194 if ((long)src & (sizeof(long) - 1)) {
195 size_t limit = PAGE_SIZE - ((long)src & (PAGE_SIZE - 1));
196 if (limit < max)
197 max = limit;
198 }
199#else
200 /* If src or dest is unaligned, don't do word-at-a-time. */
201 if (((long) dest | (long) src) & (sizeof(long) - 1))
202 max = 0;
203#endif
204
205 while (max >= sizeof(unsigned long)) {
206 unsigned long c, data;
207
Andrey Ryabinin1a3241f2018-02-01 21:00:50 +0300208 c = read_word_at_a_time(src+res);
Chris Metcalf30035e42015-04-29 12:52:04 -0400209 if (has_zero(c, &data, &constants)) {
210 data = prep_zero_mask(c, data, &constants);
211 data = create_zero_mask(data);
Chris Metcalf990486c2015-10-06 12:37:41 -0400212 *(unsigned long *)(dest+res) = c & zero_bytemask(data);
Chris Metcalf30035e42015-04-29 12:52:04 -0400213 return res + find_zero(data);
214 }
Chris Metcalf990486c2015-10-06 12:37:41 -0400215 *(unsigned long *)(dest+res) = c;
Chris Metcalf30035e42015-04-29 12:52:04 -0400216 res += sizeof(unsigned long);
217 count -= sizeof(unsigned long);
218 max -= sizeof(unsigned long);
219 }
220
221 while (count) {
222 char c;
223
224 c = src[res];
225 dest[res] = c;
226 if (!c)
227 return res;
228 res++;
229 count--;
230 }
231
232 /* Hit buffer length without finding a NUL; force NUL-termination. */
233 if (res)
234 dest[res-1] = '\0';
235
236 return -E2BIG;
237}
238EXPORT_SYMBOL(strscpy);
239#endif
240
Tobin C. Harding458a3bf2019-04-05 12:58:58 +1100241/**
242 * strscpy_pad() - Copy a C-string into a sized buffer
243 * @dest: Where to copy the string to
244 * @src: Where to copy the string from
245 * @count: Size of destination buffer
246 *
247 * Copy the string, or as much of it as fits, into the dest buffer. The
248 * behavior is undefined if the string buffers overlap. The destination
249 * buffer is always %NUL terminated, unless it's zero-sized.
250 *
251 * If the source string is shorter than the destination buffer, zeros
252 * the tail of the destination buffer.
253 *
254 * For full explanation of why you may want to consider using the
255 * 'strscpy' functions please see the function docstring for strscpy().
256 *
Joe Perches917cda22019-09-25 16:46:13 -0700257 * Returns:
258 * * The number of characters copied (not including the trailing %NUL)
259 * * -E2BIG if count is 0 or @src was truncated.
Tobin C. Harding458a3bf2019-04-05 12:58:58 +1100260 */
261ssize_t strscpy_pad(char *dest, const char *src, size_t count)
262{
263 ssize_t written;
264
265 written = strscpy(dest, src, count);
266 if (written < 0 || written == count - 1)
267 return written;
268
269 memset(dest + written + 1, 0, count - written - 1);
270
271 return written;
272}
273EXPORT_SYMBOL(strscpy_pad);
274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275#ifndef __HAVE_ARCH_STRCAT
276/**
277 * strcat - Append one %NUL-terminated string to another
278 * @dest: The string to be appended to
279 * @src: The string to append to it
280 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -0700281#undef strcat
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800282char *strcat(char *dest, const char *src)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283{
284 char *tmp = dest;
285
286 while (*dest)
287 dest++;
288 while ((*dest++ = *src++) != '\0')
289 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 return tmp;
291}
292EXPORT_SYMBOL(strcat);
293#endif
294
295#ifndef __HAVE_ARCH_STRNCAT
296/**
Dan Carpenter0046dd92014-06-04 16:11:47 -0700297 * strncat - Append a length-limited, C-string to another
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 * @dest: The string to be appended to
299 * @src: The string to append to it
300 * @count: The maximum numbers of bytes to copy
301 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800302 * Note that in contrast to strncpy(), strncat() ensures the result is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 * terminated.
304 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800305char *strncat(char *dest, const char *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306{
307 char *tmp = dest;
308
309 if (count) {
310 while (*dest)
311 dest++;
312 while ((*dest++ = *src++) != 0) {
313 if (--count == 0) {
314 *dest = '\0';
315 break;
316 }
317 }
318 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 return tmp;
320}
321EXPORT_SYMBOL(strncat);
322#endif
323
324#ifndef __HAVE_ARCH_STRLCAT
325/**
Dan Carpenter0046dd92014-06-04 16:11:47 -0700326 * strlcat - Append a length-limited, C-string to another
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 * @dest: The string to be appended to
328 * @src: The string to append to it
329 * @count: The size of the destination buffer.
330 */
331size_t strlcat(char *dest, const char *src, size_t count)
332{
333 size_t dsize = strlen(dest);
334 size_t len = strlen(src);
335 size_t res = dsize + len;
336
337 /* This would be a bug */
338 BUG_ON(dsize >= count);
339
340 dest += dsize;
341 count -= dsize;
342 if (len >= count)
343 len = count-1;
344 memcpy(dest, src, len);
345 dest[len] = 0;
346 return res;
347}
348EXPORT_SYMBOL(strlcat);
349#endif
350
351#ifndef __HAVE_ARCH_STRCMP
352/**
353 * strcmp - Compare two strings
354 * @cs: One string
355 * @ct: Another string
356 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -0700357#undef strcmp
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800358int strcmp(const char *cs, const char *ct)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
Linus Torvaldsa414f012009-11-18 22:31:52 +0100360 unsigned char c1, c2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
362 while (1) {
Linus Torvaldsa414f012009-11-18 22:31:52 +0100363 c1 = *cs++;
364 c2 = *ct++;
365 if (c1 != c2)
366 return c1 < c2 ? -1 : 1;
367 if (!c1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 break;
369 }
Linus Torvaldsa414f012009-11-18 22:31:52 +0100370 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371}
372EXPORT_SYMBOL(strcmp);
373#endif
374
375#ifndef __HAVE_ARCH_STRNCMP
376/**
377 * strncmp - Compare two length-limited strings
378 * @cs: One string
379 * @ct: Another string
380 * @count: The maximum number of bytes to compare
381 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800382int strncmp(const char *cs, const char *ct, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383{
Linus Torvaldsa414f012009-11-18 22:31:52 +0100384 unsigned char c1, c2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
386 while (count) {
Linus Torvaldsa414f012009-11-18 22:31:52 +0100387 c1 = *cs++;
388 c2 = *ct++;
389 if (c1 != c2)
390 return c1 < c2 ? -1 : 1;
391 if (!c1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 break;
393 count--;
394 }
Linus Torvaldsa414f012009-11-18 22:31:52 +0100395 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396}
397EXPORT_SYMBOL(strncmp);
398#endif
399
400#ifndef __HAVE_ARCH_STRCHR
401/**
402 * strchr - Find the first occurrence of a character in a string
403 * @s: The string to be searched
404 * @c: The character to search for
Peter Rosinb0975712019-07-16 16:27:15 -0700405 *
406 * Note that the %NUL-terminator is considered part of the string, and can
407 * be searched for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800409char *strchr(const char *s, int c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410{
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800411 for (; *s != (char)c; ++s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 if (*s == '\0')
413 return NULL;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800414 return (char *)s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415}
416EXPORT_SYMBOL(strchr);
417#endif
418
Grant Likely11d200e2014-03-14 17:00:14 +0000419#ifndef __HAVE_ARCH_STRCHRNUL
420/**
421 * strchrnul - Find and return a character in a string, or end of string
422 * @s: The string to be searched
423 * @c: The character to search for
424 *
425 * Returns pointer to first occurrence of 'c' in s. If c is not found, then
426 * return a pointer to the null byte at the end of s.
427 */
428char *strchrnul(const char *s, int c)
429{
430 while (*s && *s != (char)c)
431 s++;
432 return (char *)s;
433}
434EXPORT_SYMBOL(strchrnul);
435#endif
436
Yury Norov0bee0ce2020-02-03 17:37:20 -0800437/**
438 * strnchrnul - Find and return a character in a length limited string,
439 * or end of string
440 * @s: The string to be searched
441 * @count: The number of characters to be searched
442 * @c: The character to search for
443 *
444 * Returns pointer to the first occurrence of 'c' in s. If c is not found,
445 * then return a pointer to the last character of the string.
446 */
447char *strnchrnul(const char *s, size_t count, int c)
448{
449 while (count-- && *s && *s != (char)c)
450 s++;
451 return (char *)s;
452}
453
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454#ifndef __HAVE_ARCH_STRRCHR
455/**
456 * strrchr - Find the last occurrence of a character in a string
457 * @s: The string to be searched
458 * @c: The character to search for
459 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800460char *strrchr(const char *s, int c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461{
Rasmus Villemoes8da53d42015-02-13 14:36:44 -0800462 const char *last = NULL;
463 do {
464 if (*s == (char)c)
465 last = s;
466 } while (*s++);
467 return (char *)last;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468}
469EXPORT_SYMBOL(strrchr);
470#endif
471
472#ifndef __HAVE_ARCH_STRNCHR
473/**
474 * strnchr - Find a character in a length limited string
475 * @s: The string to be searched
476 * @count: The number of characters to be searched
477 * @c: The character to search for
Peter Rosinb0975712019-07-16 16:27:15 -0700478 *
479 * Note that the %NUL-terminator is considered part of the string, and can
480 * be searched for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 */
482char *strnchr(const char *s, size_t count, int c)
483{
Peter Rosinb0975712019-07-16 16:27:15 -0700484 while (count--) {
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800485 if (*s == (char)c)
486 return (char *)s;
Peter Rosinb0975712019-07-16 16:27:15 -0700487 if (*s++ == '\0')
488 break;
489 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 return NULL;
491}
492EXPORT_SYMBOL(strnchr);
493#endif
494
Pekka Enberg481fad42006-06-23 02:05:44 -0700495/**
Randy Dunlapa6cd13f2009-12-21 14:37:22 -0800496 * skip_spaces - Removes leading whitespace from @str.
497 * @str: The string to be stripped.
André Goddard Rosaf6533982009-12-14 18:01:04 -0800498 *
Randy Dunlapa6cd13f2009-12-21 14:37:22 -0800499 * Returns a pointer to the first non-whitespace character in @str.
André Goddard Rosaf6533982009-12-14 18:01:04 -0800500 */
501char *skip_spaces(const char *str)
502{
503 while (isspace(*str))
504 ++str;
505 return (char *)str;
506}
507EXPORT_SYMBOL(skip_spaces);
508
509/**
KOSAKI Motohiroca54cb82009-12-14 18:01:15 -0800510 * strim - Removes leading and trailing whitespace from @s.
Pekka Enberg481fad42006-06-23 02:05:44 -0700511 * @s: The string to be stripped.
512 *
513 * Note that the first trailing whitespace is replaced with a %NUL-terminator
514 * in the given string @s. Returns a pointer to the first non-whitespace
515 * character in @s.
516 */
KOSAKI Motohiroca54cb82009-12-14 18:01:15 -0800517char *strim(char *s)
Pekka Enberg481fad42006-06-23 02:05:44 -0700518{
519 size_t size;
520 char *end;
521
522 size = strlen(s);
Pekka Enberg481fad42006-06-23 02:05:44 -0700523 if (!size)
524 return s;
525
526 end = s + size - 1;
Michael Holzheu6e6d9fa2006-10-28 10:38:47 -0700527 while (end >= s && isspace(*end))
Pekka Enberg481fad42006-06-23 02:05:44 -0700528 end--;
529 *(end + 1) = '\0';
530
Michael Holzheu66f69582011-10-31 17:12:37 -0700531 return skip_spaces(s);
Pekka Enberg481fad42006-06-23 02:05:44 -0700532}
KOSAKI Motohiroca54cb82009-12-14 18:01:15 -0800533EXPORT_SYMBOL(strim);
Pekka Enberg481fad42006-06-23 02:05:44 -0700534
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535#ifndef __HAVE_ARCH_STRLEN
536/**
537 * strlen - Find the length of a string
538 * @s: The string to be sized
539 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800540size_t strlen(const char *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
542 const char *sc;
543
544 for (sc = s; *sc != '\0'; ++sc)
545 /* nothing */;
546 return sc - s;
547}
548EXPORT_SYMBOL(strlen);
549#endif
550
551#ifndef __HAVE_ARCH_STRNLEN
552/**
553 * strnlen - Find the length of a length-limited string
554 * @s: The string to be sized
555 * @count: The maximum number of bytes to search
556 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800557size_t strnlen(const char *s, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
559 const char *sc;
560
561 for (sc = s; count-- && *sc != '\0'; ++sc)
562 /* nothing */;
563 return sc - s;
564}
565EXPORT_SYMBOL(strnlen);
566#endif
567
568#ifndef __HAVE_ARCH_STRSPN
569/**
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800570 * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 * @s: The string to be searched
572 * @accept: The string to search for
573 */
574size_t strspn(const char *s, const char *accept)
575{
576 const char *p;
577 const char *a;
578 size_t count = 0;
579
580 for (p = s; *p != '\0'; ++p) {
581 for (a = accept; *a != '\0'; ++a) {
582 if (*p == *a)
583 break;
584 }
585 if (*a == '\0')
586 return count;
587 ++count;
588 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 return count;
590}
591
592EXPORT_SYMBOL(strspn);
593#endif
594
Kyle McMartin8833d322006-04-10 22:53:57 -0700595#ifndef __HAVE_ARCH_STRCSPN
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596/**
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800597 * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 * @s: The string to be searched
599 * @reject: The string to avoid
600 */
601size_t strcspn(const char *s, const char *reject)
602{
603 const char *p;
604 const char *r;
605 size_t count = 0;
606
607 for (p = s; *p != '\0'; ++p) {
608 for (r = reject; *r != '\0'; ++r) {
609 if (*p == *r)
610 return count;
611 }
612 ++count;
613 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 return count;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800615}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616EXPORT_SYMBOL(strcspn);
Kyle McMartin8833d322006-04-10 22:53:57 -0700617#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
619#ifndef __HAVE_ARCH_STRPBRK
620/**
621 * strpbrk - Find the first occurrence of a set of characters
622 * @cs: The string to be searched
623 * @ct: The characters to search for
624 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800625char *strpbrk(const char *cs, const char *ct)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626{
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800627 const char *sc1, *sc2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800629 for (sc1 = cs; *sc1 != '\0'; ++sc1) {
630 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 if (*sc1 == *sc2)
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800632 return (char *)sc1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 }
634 }
635 return NULL;
636}
Kyle McMartin894b5772006-04-10 22:53:56 -0700637EXPORT_SYMBOL(strpbrk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638#endif
639
640#ifndef __HAVE_ARCH_STRSEP
641/**
642 * strsep - Split a string into tokens
643 * @s: The string to be searched
644 * @ct: The characters to search for
645 *
646 * strsep() updates @s to point after the token, ready for the next call.
647 *
648 * It returns empty tokens, too, behaving exactly like the libc function
649 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
650 * Same semantics, slimmer shape. ;)
651 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800652char *strsep(char **s, const char *ct)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653{
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800654 char *sbegin = *s;
655 char *end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
657 if (sbegin == NULL)
658 return NULL;
659
660 end = strpbrk(sbegin, ct);
661 if (end)
662 *end++ = '\0';
663 *s = end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 return sbegin;
665}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666EXPORT_SYMBOL(strsep);
667#endif
668
David Brownell34990cf2008-05-01 04:34:42 -0700669/**
670 * sysfs_streq - return true if strings are equal, modulo trailing newline
671 * @s1: one string
672 * @s2: another string
673 *
674 * This routine returns true iff two strings are equal, treating both
675 * NUL and newline-then-NUL as equivalent string terminations. It's
676 * geared for use with sysfs input strings, which generally terminate
677 * with newlines but are compared against values without newlines.
678 */
679bool sysfs_streq(const char *s1, const char *s2)
680{
681 while (*s1 && *s1 == *s2) {
682 s1++;
683 s2++;
684 }
685
686 if (*s1 == *s2)
687 return true;
688 if (!*s1 && *s2 == '\n' && !s2[1])
689 return true;
690 if (*s1 == '\n' && !s1[1] && !*s2)
691 return true;
692 return false;
693}
694EXPORT_SYMBOL(sysfs_streq);
695
Jonathan Camerond0f1fed2011-04-19 12:43:45 +0100696/**
Andy Shevchenko56b06082016-03-17 14:22:14 -0700697 * match_string - matches given string in an array
698 * @array: array of strings
699 * @n: number of strings in the array or -1 for NULL terminated arrays
700 * @string: string to match with
701 *
Alexandru Ardeleanc11d3fa2020-02-20 20:04:21 -0800702 * This routine will look for a string in an array of strings up to the
703 * n-th element in the array or until the first NULL element.
704 *
705 * Historically the value of -1 for @n, was used to search in arrays that
706 * are NULL terminated. However, the function does not make a distinction
707 * when finishing the search: either @n elements have been compared OR
708 * the first NULL element was found.
709 *
Andy Shevchenko56b06082016-03-17 14:22:14 -0700710 * Return:
711 * index of a @string in the @array if matches, or %-EINVAL otherwise.
712 */
713int match_string(const char * const *array, size_t n, const char *string)
714{
715 int index;
716 const char *item;
717
718 for (index = 0; index < n; index++) {
719 item = array[index];
720 if (!item)
721 break;
722 if (!strcmp(item, string))
723 return index;
724 }
725
726 return -EINVAL;
727}
728EXPORT_SYMBOL(match_string);
729
Heikki Krogeruse1fe7b62017-03-21 13:56:46 +0200730/**
731 * __sysfs_match_string - matches given string in an array
732 * @array: array of strings
733 * @n: number of strings in the array or -1 for NULL terminated arrays
734 * @str: string to match with
735 *
736 * Returns index of @str in the @array or -EINVAL, just like match_string().
737 * Uses sysfs_streq instead of strcmp for matching.
Alexandru Ardeleanc11d3fa2020-02-20 20:04:21 -0800738 *
739 * This routine will look for a string in an array of strings up to the
740 * n-th element in the array or until the first NULL element.
741 *
742 * Historically the value of -1 for @n, was used to search in arrays that
743 * are NULL terminated. However, the function does not make a distinction
744 * when finishing the search: either @n elements have been compared OR
745 * the first NULL element was found.
Heikki Krogeruse1fe7b62017-03-21 13:56:46 +0200746 */
747int __sysfs_match_string(const char * const *array, size_t n, const char *str)
748{
749 const char *item;
750 int index;
751
752 for (index = 0; index < n; index++) {
753 item = array[index];
754 if (!item)
755 break;
756 if (sysfs_streq(item, str))
757 return index;
758 }
759
760 return -EINVAL;
761}
762EXPORT_SYMBOL(__sysfs_match_string);
763
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764#ifndef __HAVE_ARCH_MEMSET
765/**
766 * memset - Fill a region of memory with the given value
767 * @s: Pointer to the start of the area.
768 * @c: The byte to fill the area with
769 * @count: The size of the area.
770 *
771 * Do not use memset() to access IO space, use memset_io() instead.
772 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800773void *memset(void *s, int c, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774{
Jesper Juhl850b9242005-10-30 15:02:13 -0800775 char *xs = s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
777 while (count--)
778 *xs++ = c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 return s;
780}
781EXPORT_SYMBOL(memset);
782#endif
783
Matthew Wilcox3b3c4ba2017-09-08 16:13:48 -0700784#ifndef __HAVE_ARCH_MEMSET16
785/**
786 * memset16() - Fill a memory area with a uint16_t
787 * @s: Pointer to the start of the area.
788 * @v: The value to fill the area with
789 * @count: The number of values to store
790 *
791 * Differs from memset() in that it fills with a uint16_t instead
792 * of a byte. Remember that @count is the number of uint16_ts to
793 * store, not the number of bytes.
794 */
795void *memset16(uint16_t *s, uint16_t v, size_t count)
796{
797 uint16_t *xs = s;
798
799 while (count--)
800 *xs++ = v;
801 return s;
802}
803EXPORT_SYMBOL(memset16);
804#endif
805
806#ifndef __HAVE_ARCH_MEMSET32
807/**
808 * memset32() - Fill a memory area with a uint32_t
809 * @s: Pointer to the start of the area.
810 * @v: The value to fill the area with
811 * @count: The number of values to store
812 *
813 * Differs from memset() in that it fills with a uint32_t instead
814 * of a byte. Remember that @count is the number of uint32_ts to
815 * store, not the number of bytes.
816 */
817void *memset32(uint32_t *s, uint32_t v, size_t count)
818{
819 uint32_t *xs = s;
820
821 while (count--)
822 *xs++ = v;
823 return s;
824}
825EXPORT_SYMBOL(memset32);
826#endif
827
828#ifndef __HAVE_ARCH_MEMSET64
829/**
830 * memset64() - Fill a memory area with a uint64_t
831 * @s: Pointer to the start of the area.
832 * @v: The value to fill the area with
833 * @count: The number of values to store
834 *
835 * Differs from memset() in that it fills with a uint64_t instead
836 * of a byte. Remember that @count is the number of uint64_ts to
837 * store, not the number of bytes.
838 */
839void *memset64(uint64_t *s, uint64_t v, size_t count)
840{
841 uint64_t *xs = s;
842
843 while (count--)
844 *xs++ = v;
845 return s;
846}
847EXPORT_SYMBOL(memset64);
848#endif
849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850#ifndef __HAVE_ARCH_MEMCPY
851/**
852 * memcpy - Copy one area of memory to another
853 * @dest: Where to copy to
854 * @src: Where to copy from
855 * @count: The size of the area.
856 *
857 * You should not use this function to access IO space, use memcpy_toio()
858 * or memcpy_fromio() instead.
859 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800860void *memcpy(void *dest, const void *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861{
Jesper Juhl850b9242005-10-30 15:02:13 -0800862 char *tmp = dest;
Jan-Benedict Glaw4c416ab2006-04-10 22:54:09 -0700863 const char *s = src;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
865 while (count--)
866 *tmp++ = *s++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 return dest;
868}
869EXPORT_SYMBOL(memcpy);
870#endif
871
872#ifndef __HAVE_ARCH_MEMMOVE
873/**
874 * memmove - Copy one area of memory to another
875 * @dest: Where to copy to
876 * @src: Where to copy from
877 * @count: The size of the area.
878 *
879 * Unlike memcpy(), memmove() copes with overlapping areas.
880 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800881void *memmove(void *dest, const void *src, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882{
Paul Jackson82da2c32005-10-30 15:03:19 -0800883 char *tmp;
884 const char *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885
886 if (dest <= src) {
Jesper Juhl850b9242005-10-30 15:02:13 -0800887 tmp = dest;
888 s = src;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 while (count--)
890 *tmp++ = *s++;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800891 } else {
Jesper Juhl850b9242005-10-30 15:02:13 -0800892 tmp = dest;
893 tmp += count;
894 s = src;
895 s += count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 while (count--)
897 *--tmp = *--s;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800898 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 return dest;
900}
901EXPORT_SYMBOL(memmove);
902#endif
903
904#ifndef __HAVE_ARCH_MEMCMP
905/**
906 * memcmp - Compare two areas of memory
907 * @cs: One area of memory
908 * @ct: Another area of memory
909 * @count: The size of the area.
910 */
Paolo 'Blaisorblade' Giarrusso0c281302005-05-05 16:15:17 -0700911#undef memcmp
Andi Kleena7330c92014-02-08 08:52:06 +0100912__visible int memcmp(const void *cs, const void *ct, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913{
914 const unsigned char *su1, *su2;
915 int res = 0;
916
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800917 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 if ((res = *su1 - *su2) != 0)
919 break;
920 return res;
921}
922EXPORT_SYMBOL(memcmp);
923#endif
924
Nick Desaulniers5f074f32019-04-05 18:38:45 -0700925#ifndef __HAVE_ARCH_BCMP
926/**
927 * bcmp - returns 0 if and only if the buffers have identical contents.
928 * @a: pointer to first buffer.
929 * @b: pointer to second buffer.
930 * @len: size of buffers.
931 *
932 * The sign or magnitude of a non-zero return value has no particular
933 * meaning, and architectures may implement their own more efficient bcmp(). So
934 * while this particular implementation is a simple (tail) call to memcmp, do
935 * not rely on anything but whether the return value is zero or non-zero.
936 */
937#undef bcmp
938int bcmp(const void *a, const void *b, size_t len)
939{
940 return memcmp(a, b, len);
941}
942EXPORT_SYMBOL(bcmp);
943#endif
944
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945#ifndef __HAVE_ARCH_MEMSCAN
946/**
947 * memscan - Find a character in an area of memory.
948 * @addr: The memory area
949 * @c: The byte to search for
950 * @size: The size of the area.
951 *
952 * returns the address of the first occurrence of @c, or 1 byte past
953 * the area if @c is not found
954 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800955void *memscan(void *addr, int c, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956{
Jesper Juhl850b9242005-10-30 15:02:13 -0800957 unsigned char *p = addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
959 while (size) {
960 if (*p == c)
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800961 return (void *)p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 p++;
963 size--;
964 }
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800965 return (void *)p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966}
967EXPORT_SYMBOL(memscan);
968#endif
969
970#ifndef __HAVE_ARCH_STRSTR
971/**
972 * strstr - Find the first substring in a %NUL terminated string
973 * @s1: The string to be searched
974 * @s2: The string to search for
975 */
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800976char *strstr(const char *s1, const char *s2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977{
Li Zefand5f1fb52010-01-14 10:53:55 +0800978 size_t l1, l2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
980 l2 = strlen(s2);
981 if (!l2)
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800982 return (char *)s1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 l1 = strlen(s1);
984 while (l1 >= l2) {
985 l1--;
Jesper Juhl51a0f0f2005-10-30 15:02:11 -0800986 if (!memcmp(s1, s2, l2))
987 return (char *)s1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 s1++;
989 }
990 return NULL;
991}
992EXPORT_SYMBOL(strstr);
993#endif
994
Li Zefand5f1fb52010-01-14 10:53:55 +0800995#ifndef __HAVE_ARCH_STRNSTR
996/**
997 * strnstr - Find the first substring in a length-limited string
998 * @s1: The string to be searched
999 * @s2: The string to search for
1000 * @len: the maximum number of characters to search
1001 */
1002char *strnstr(const char *s1, const char *s2, size_t len)
1003{
André Goddard Rosad6a2eed2010-03-05 13:43:12 -08001004 size_t l2;
Li Zefand5f1fb52010-01-14 10:53:55 +08001005
1006 l2 = strlen(s2);
1007 if (!l2)
1008 return (char *)s1;
André Goddard Rosad6a2eed2010-03-05 13:43:12 -08001009 while (len >= l2) {
1010 len--;
Li Zefand5f1fb52010-01-14 10:53:55 +08001011 if (!memcmp(s1, s2, l2))
1012 return (char *)s1;
1013 s1++;
1014 }
1015 return NULL;
1016}
1017EXPORT_SYMBOL(strnstr);
1018#endif
1019
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020#ifndef __HAVE_ARCH_MEMCHR
1021/**
1022 * memchr - Find a character in an area of memory.
1023 * @s: The memory area
1024 * @c: The byte to search for
1025 * @n: The size of the area.
1026 *
1027 * returns the address of the first occurrence of @c, or %NULL
1028 * if @c is not found
1029 */
1030void *memchr(const void *s, int c, size_t n)
1031{
1032 const unsigned char *p = s;
1033 while (n-- != 0) {
1034 if ((unsigned char)c == *p++) {
Jesper Juhl51a0f0f2005-10-30 15:02:11 -08001035 return (void *)(p - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 }
1037 }
1038 return NULL;
1039}
1040EXPORT_SYMBOL(memchr);
1041#endif
Akinobu Mita798248202011-10-31 17:08:07 -07001042
1043static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
1044{
1045 while (bytes) {
1046 if (*start != value)
1047 return (void *)start;
1048 start++;
1049 bytes--;
1050 }
1051 return NULL;
1052}
1053
1054/**
1055 * memchr_inv - Find an unmatching character in an area of memory.
1056 * @start: The memory area
1057 * @c: Find a character other than c
1058 * @bytes: The size of the area.
1059 *
1060 * returns the address of the first character other than @c, or %NULL
1061 * if the whole buffer contains just @c.
1062 */
1063void *memchr_inv(const void *start, int c, size_t bytes)
1064{
1065 u8 value = c;
1066 u64 value64;
1067 unsigned int words, prefix;
1068
1069 if (bytes <= 16)
1070 return check_bytes8(start, value, bytes);
1071
Akinobu Mitaf43804b2012-03-23 15:02:14 -07001072 value64 = value;
Linus Torvalds72d93102014-09-13 11:14:53 -07001073#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
Andy Shevchenko3368e8f2015-11-10 14:45:14 -08001074 value64 *= 0x0101010101010101ULL;
Linus Torvalds72d93102014-09-13 11:14:53 -07001075#elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
Akinobu Mitaf43804b2012-03-23 15:02:14 -07001076 value64 *= 0x01010101;
1077 value64 |= value64 << 32;
1078#else
1079 value64 |= value64 << 8;
1080 value64 |= value64 << 16;
1081 value64 |= value64 << 32;
1082#endif
Akinobu Mita798248202011-10-31 17:08:07 -07001083
Akinobu Mitaf43804b2012-03-23 15:02:14 -07001084 prefix = (unsigned long)start % 8;
Akinobu Mita798248202011-10-31 17:08:07 -07001085 if (prefix) {
Akinobu Mitaf43804b2012-03-23 15:02:14 -07001086 u8 *r;
1087
1088 prefix = 8 - prefix;
1089 r = check_bytes8(start, value, prefix);
Akinobu Mita798248202011-10-31 17:08:07 -07001090 if (r)
1091 return r;
1092 start += prefix;
1093 bytes -= prefix;
1094 }
1095
1096 words = bytes / 8;
1097
1098 while (words) {
1099 if (*(u64 *)start != value64)
1100 return check_bytes8(start, value, 8);
1101 start += 8;
1102 words--;
1103 }
1104
1105 return check_bytes8(start, value, bytes % 8);
1106}
1107EXPORT_SYMBOL(memchr_inv);
Rasmus Villemoes94df2902015-06-25 15:02:22 -07001108
1109/**
1110 * strreplace - Replace all occurrences of character in string.
1111 * @s: The string to operate on.
1112 * @old: The character being replaced.
1113 * @new: The character @old is replaced with.
1114 *
1115 * Returns pointer to the nul byte at the end of @s.
1116 */
1117char *strreplace(char *s, char old, char new)
1118{
1119 for (; *s; ++s)
1120 if (*s == old)
1121 *s = new;
1122 return s;
1123}
1124EXPORT_SYMBOL(strreplace);
Daniel Micay6974f0c2017-07-12 14:36:10 -07001125
1126void fortify_panic(const char *name)
1127{
1128 pr_emerg("detected buffer overflow in %s\n", name);
1129 BUG();
1130}
1131EXPORT_SYMBOL(fortify_panic);